Edit on GitHub

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

Whether an unquoted identifier can start with a digit.

NORMALIZATION_STRATEGY = <NormalizationStrategy.CASE_SENSITIVE: 'CASE_SENSITIVE'>

Specifies the strategy according to which identifiers should be normalized.

TIME_FORMAT = "'%Y-%m-%d %T'"
DPIPE_IS_STRING_CONCAT = False

Whether the DPIPE token (||) is a string concatenation operator.

SUPPORTS_USER_DEFINED_TYPES = False

Whether user-defined data types are supported.

SUPPORTS_SEMI_ANTI_JOIN = False

Whether SEMI or ANTI joins are supported.

SAFE_DIVISION = True

Whether division by zero throws an error (False) or returns NULL (True).

TIME_MAPPING: Dict[str, str] = {'%M': '%B', '%c': '%-m', '%e': '%-d', '%h': '%I', '%i': '%M', '%s': '%S', '%u': '%W', '%k': '%-H', '%l': '%-I', '%T': '%H:%M:%S', '%W': '%a'}

Associates this dialect's time formats with their equivalent Python strftime formats.

SUPPORTS_COLUMN_JOIN_MARKS = False

Whether the old-style outer join (+) syntax is supported.

UNESCAPED_SEQUENCES: Dict[str, str] = {'\\a': '\x07', '\\b': '\x08', '\\f': '\x0c', '\\n': '\n', '\\r': '\r', '\\t': '\t', '\\v': '\x0b', '\\\\': '\\'}

Mapping of an escaped sequence (\n) to its unescaped version ( ).

tokenizer_class = <class 'MySQL.Tokenizer'>
jsonpath_tokenizer_class = <class 'sqlglot.tokens.JSONPathTokenizer'>
parser_class = <class 'MySQL.Parser'>
generator_class = <class 'MySQL.Generator'>
TIME_TRIE: Dict = {'%': {'M': {0: True}, 'c': {0: True}, 'e': {0: True}, 'h': {0: True}, 'i': {0: True}, 's': {0: True}, 'u': {0: True}, 'k': {0: True}, 'l': {0: True}, 'T': {0: True}, 'W': {0: True}}}
FORMAT_TRIE: Dict = {'%': {'M': {0: True}, 'c': {0: True}, 'e': {0: True}, 'h': {0: True}, 'i': {0: True}, 's': {0: True}, 'u': {0: True}, 'k': {0: True}, 'l': {0: True}, 'T': {0: True}, 'W': {0: True}}}
INVERSE_TIME_MAPPING: Dict[str, str] = {'%B': '%M', '%-m': '%c', '%-d': '%e', '%I': '%h', '%M': '%i', '%S': '%s', '%W': '%u', '%-H': '%k', '%-I': '%l', '%H:%M:%S': '%T', '%a': '%W'}
INVERSE_TIME_TRIE: Dict = {'%': {'B': {0: True}, '-': {'m': {0: True}, 'd': {0: True}, 'H': {0: True}, 'I': {0: True}}, 'I': {0: True}, 'M': {0: True}, 'S': {0: True}, 'W': {0: True}, 'H': {':': {'%': {'M': {':': {'%': {'S': {0: True}}}}}}}, 'a': {0: True}}}
ESCAPED_SEQUENCES: Dict[str, str] = {'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\'}
QUOTE_START = "'"
QUOTE_END = "'"
IDENTIFIER_START = '`'
IDENTIFIER_END = '`'
BIT_START: Optional[str] = "b'"
BIT_END: Optional[str] = "'"
HEX_START: Optional[str] = "x'"
HEX_END: Optional[str] = "'"
BYTE_START: Optional[str] = None
BYTE_END: Optional[str] = None
UNICODE_START: Optional[str] = None
UNICODE_END: Optional[str] = None
class MySQL.Tokenizer(sqlglot.tokens.Tokenizer):
193    class Tokenizer(tokens.Tokenizer):
194        QUOTES = ["'", '"']
195        COMMENTS = ["--", "#", ("/*", "*/")]
196        IDENTIFIERS = ["`"]
197        STRING_ESCAPES = ["'", '"', "\\"]
198        BIT_STRINGS = [("b'", "'"), ("B'", "'"), ("0b", "")]
199        HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", "")]
200
201        KEYWORDS = {
202            **tokens.Tokenizer.KEYWORDS,
203            "CHARSET": TokenType.CHARACTER_SET,
204            "FORCE": TokenType.FORCE,
205            "IGNORE": TokenType.IGNORE,
206            "KEY": TokenType.KEY,
207            "LOCK TABLES": TokenType.COMMAND,
208            "LONGBLOB": TokenType.LONGBLOB,
209            "LONGTEXT": TokenType.LONGTEXT,
210            "MEDIUMBLOB": TokenType.MEDIUMBLOB,
211            "TINYBLOB": TokenType.TINYBLOB,
212            "TINYTEXT": TokenType.TINYTEXT,
213            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
214            "MEDIUMINT": TokenType.MEDIUMINT,
215            "MEMBER OF": TokenType.MEMBER_OF,
216            "SEPARATOR": TokenType.SEPARATOR,
217            "START": TokenType.BEGIN,
218            "SIGNED": TokenType.BIGINT,
219            "SIGNED INTEGER": TokenType.BIGINT,
220            "UNLOCK TABLES": TokenType.COMMAND,
221            "UNSIGNED": TokenType.UBIGINT,
222            "UNSIGNED INTEGER": TokenType.UBIGINT,
223            "YEAR": TokenType.YEAR,
224            "_ARMSCII8": TokenType.INTRODUCER,
225            "_ASCII": TokenType.INTRODUCER,
226            "_BIG5": TokenType.INTRODUCER,
227            "_BINARY": TokenType.INTRODUCER,
228            "_CP1250": TokenType.INTRODUCER,
229            "_CP1251": TokenType.INTRODUCER,
230            "_CP1256": TokenType.INTRODUCER,
231            "_CP1257": TokenType.INTRODUCER,
232            "_CP850": TokenType.INTRODUCER,
233            "_CP852": TokenType.INTRODUCER,
234            "_CP866": TokenType.INTRODUCER,
235            "_CP932": TokenType.INTRODUCER,
236            "_DEC8": TokenType.INTRODUCER,
237            "_EUCJPMS": TokenType.INTRODUCER,
238            "_EUCKR": TokenType.INTRODUCER,
239            "_GB18030": TokenType.INTRODUCER,
240            "_GB2312": TokenType.INTRODUCER,
241            "_GBK": TokenType.INTRODUCER,
242            "_GEOSTD8": TokenType.INTRODUCER,
243            "_GREEK": TokenType.INTRODUCER,
244            "_HEBREW": TokenType.INTRODUCER,
245            "_HP8": TokenType.INTRODUCER,
246            "_KEYBCS2": TokenType.INTRODUCER,
247            "_KOI8R": TokenType.INTRODUCER,
248            "_KOI8U": TokenType.INTRODUCER,
249            "_LATIN1": TokenType.INTRODUCER,
250            "_LATIN2": TokenType.INTRODUCER,
251            "_LATIN5": TokenType.INTRODUCER,
252            "_LATIN7": TokenType.INTRODUCER,
253            "_MACCE": TokenType.INTRODUCER,
254            "_MACROMAN": TokenType.INTRODUCER,
255            "_SJIS": TokenType.INTRODUCER,
256            "_SWE7": TokenType.INTRODUCER,
257            "_TIS620": TokenType.INTRODUCER,
258            "_UCS2": TokenType.INTRODUCER,
259            "_UJIS": TokenType.INTRODUCER,
260            # https://dev.mysql.com/doc/refman/8.0/en/string-literals.html
261            "_UTF8": TokenType.INTRODUCER,
262            "_UTF16": TokenType.INTRODUCER,
263            "_UTF16LE": TokenType.INTRODUCER,
264            "_UTF32": TokenType.INTRODUCER,
265            "_UTF8MB3": TokenType.INTRODUCER,
266            "_UTF8MB4": TokenType.INTRODUCER,
267            "@@": TokenType.SESSION_PARAMETER,
268        }
269
270        COMMANDS = {*tokens.Tokenizer.COMMANDS, TokenType.REPLACE} - {TokenType.SHOW}
QUOTES = ["'", '"']
COMMENTS = ['--', '#', ('/*', '*/')]
IDENTIFIERS = ['`']
STRING_ESCAPES = ["'", '"', '\\']
BIT_STRINGS = [("b'", "'"), ("B'", "'"), ('0b', '')]
HEX_STRINGS = [("x'", "'"), ("X'", "'"), ('0x', '')]
KEYWORDS = {'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '/*+': <TokenType.HINT: 'HINT'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.BEGIN: 'BEGIN'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'COPY': <TokenType.COPY: 'COPY'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DIV': <TokenType.DIV: 'DIV'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'STRAIGHT_JOIN': <TokenType.STRAIGHT_JOIN: 'STRAIGHT_JOIN'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VALUES': <TokenType.VALUES: 'VALUES'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'LIST': <TokenType.LIST: 'LIST'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'JSONB': <TokenType.JSONB: 'JSONB'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMP_LTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'TIMESTAMPNTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'TIMESTAMP_NTZ': <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.COMMAND: 'COMMAND'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.COMMAND: 'COMMAND'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'CHARSET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'FORCE': <TokenType.FORCE: 'FORCE'>, 'IGNORE': <TokenType.IGNORE: 'IGNORE'>, 'KEY': <TokenType.KEY: 'KEY'>, 'LOCK TABLES': <TokenType.COMMAND: 'COMMAND'>, 'MEMBER OF': <TokenType.MEMBER_OF: 'MEMBER_OF'>, 'SEPARATOR': <TokenType.SEPARATOR: 'SEPARATOR'>, 'START': <TokenType.BEGIN: 'BEGIN'>, 'SIGNED': <TokenType.BIGINT: 'BIGINT'>, 'SIGNED INTEGER': <TokenType.BIGINT: 'BIGINT'>, 'UNLOCK TABLES': <TokenType.COMMAND: 'COMMAND'>, 'UNSIGNED': <TokenType.UBIGINT: 'UBIGINT'>, 'UNSIGNED INTEGER': <TokenType.UBIGINT: 'UBIGINT'>, 'YEAR': <TokenType.YEAR: 'YEAR'>, '_ARMSCII8': <TokenType.INTRODUCER: 'INTRODUCER'>, '_ASCII': <TokenType.INTRODUCER: 'INTRODUCER'>, '_BIG5': <TokenType.INTRODUCER: 'INTRODUCER'>, '_BINARY': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP1250': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP1251': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP1256': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP1257': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP850': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP852': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP866': <TokenType.INTRODUCER: 'INTRODUCER'>, '_CP932': <TokenType.INTRODUCER: 'INTRODUCER'>, '_DEC8': <TokenType.INTRODUCER: 'INTRODUCER'>, '_EUCJPMS': <TokenType.INTRODUCER: 'INTRODUCER'>, '_EUCKR': <TokenType.INTRODUCER: 'INTRODUCER'>, '_GB18030': <TokenType.INTRODUCER: 'INTRODUCER'>, '_GB2312': <TokenType.INTRODUCER: 'INTRODUCER'>, '_GBK': <TokenType.INTRODUCER: 'INTRODUCER'>, '_GEOSTD8': <TokenType.INTRODUCER: 'INTRODUCER'>, '_GREEK': <TokenType.INTRODUCER: 'INTRODUCER'>, '_HEBREW': <TokenType.INTRODUCER: 'INTRODUCER'>, '_HP8': <TokenType.INTRODUCER: 'INTRODUCER'>, '_KEYBCS2': <TokenType.INTRODUCER: 'INTRODUCER'>, '_KOI8R': <TokenType.INTRODUCER: 'INTRODUCER'>, '_KOI8U': <TokenType.INTRODUCER: 'INTRODUCER'>, '_LATIN1': <TokenType.INTRODUCER: 'INTRODUCER'>, '_LATIN2': <TokenType.INTRODUCER: 'INTRODUCER'>, '_LATIN5': <TokenType.INTRODUCER: 'INTRODUCER'>, '_LATIN7': <TokenType.INTRODUCER: 'INTRODUCER'>, '_MACCE': <TokenType.INTRODUCER: 'INTRODUCER'>, '_MACROMAN': <TokenType.INTRODUCER: 'INTRODUCER'>, '_SJIS': <TokenType.INTRODUCER: 'INTRODUCER'>, '_SWE7': <TokenType.INTRODUCER: 'INTRODUCER'>, '_TIS620': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UCS2': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UJIS': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UTF8': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UTF16': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UTF16LE': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UTF32': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UTF8MB3': <TokenType.INTRODUCER: 'INTRODUCER'>, '_UTF8MB4': <TokenType.INTRODUCER: 'INTRODUCER'>, '@@': <TokenType.SESSION_PARAMETER: 'SESSION_PARAMETER'>}
COMMANDS = {<TokenType.EXECUTE: 'EXECUTE'>, <TokenType.FETCH: 'FETCH'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.REPLACE: 'REPLACE'>}
class MySQL.Parser(sqlglot.parser.Parser):
272    class Parser(parser.Parser):
273        FUNC_TOKENS = {
274            *parser.Parser.FUNC_TOKENS,
275            TokenType.DATABASE,
276            TokenType.SCHEMA,
277            TokenType.VALUES,
278        }
279
280        CONJUNCTION = {
281            **parser.Parser.CONJUNCTION,
282            TokenType.DAMP: exp.And,
283            TokenType.XOR: exp.Xor,
284        }
285
286        DISJUNCTION = {
287            **parser.Parser.DISJUNCTION,
288            TokenType.DPIPE: exp.Or,
289        }
290
291        TABLE_ALIAS_TOKENS = (
292            parser.Parser.TABLE_ALIAS_TOKENS - parser.Parser.TABLE_INDEX_HINT_TOKENS
293        )
294
295        RANGE_PARSERS = {
296            **parser.Parser.RANGE_PARSERS,
297            TokenType.MEMBER_OF: lambda self, this: self.expression(
298                exp.JSONArrayContains,
299                this=this,
300                expression=self._parse_wrapped(self._parse_expression),
301            ),
302        }
303
304        FUNCTIONS = {
305            **parser.Parser.FUNCTIONS,
306            "DATE": lambda args: exp.TsOrDsToDate(this=seq_get(args, 0)),
307            "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
308            "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "mysql"),
309            "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
310            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
311            "DAYOFMONTH": lambda args: exp.DayOfMonth(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
312            "DAYOFWEEK": lambda args: exp.DayOfWeek(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
313            "DAYOFYEAR": lambda args: exp.DayOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
314            "INSTR": lambda args: exp.StrPosition(substr=seq_get(args, 1), this=seq_get(args, 0)),
315            "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime, "mysql"),
316            "ISNULL": isnull_to_is_null,
317            "LOCATE": locate_to_strposition,
318            "MAKETIME": exp.TimeFromParts.from_arg_list,
319            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
320            "MONTHNAME": lambda args: exp.TimeToStr(
321                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
322                format=exp.Literal.string("%B"),
323            ),
324            "STR_TO_DATE": _str_to_date,
325            "TIMESTAMPDIFF": build_date_delta(exp.TimestampDiff),
326            "TO_DAYS": lambda args: exp.paren(
327                exp.DateDiff(
328                    this=exp.TsOrDsToDate(this=seq_get(args, 0)),
329                    expression=exp.TsOrDsToDate(this=exp.Literal.string("0000-01-01")),
330                    unit=exp.var("DAY"),
331                )
332                + 1
333            ),
334            "WEEK": lambda args: exp.Week(
335                this=exp.TsOrDsToDate(this=seq_get(args, 0)), mode=seq_get(args, 1)
336            ),
337            "WEEKOFYEAR": lambda args: exp.WeekOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
338            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
339        }
340
341        FUNCTION_PARSERS = {
342            **parser.Parser.FUNCTION_PARSERS,
343            "CHAR": lambda self: self._parse_chr(),
344            "GROUP_CONCAT": lambda self: self._parse_group_concat(),
345            # https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
346            "VALUES": lambda self: self.expression(
347                exp.Anonymous, this="VALUES", expressions=[self._parse_id_var()]
348            ),
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        LOG_DEFAULTS_TO_LN = True
464        STRING_ALIASES = True
465        VALUES_FOLLOWED_BY_PAREN = False
466        SUPPORTS_PARTITION_SELECTION = True
467
468        def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
469            this = self._parse_id_var()
470            if not self._match(TokenType.L_PAREN):
471                return this
472
473            expression = self._parse_number()
474            self._match_r_paren()
475            return self.expression(exp.ColumnPrefix, this=this, expression=expression)
476
477        def _parse_index_constraint(
478            self, kind: t.Optional[str] = None
479        ) -> exp.IndexColumnConstraint:
480            if kind:
481                self._match_texts(("INDEX", "KEY"))
482
483            this = self._parse_id_var(any_token=False)
484            index_type = self._match(TokenType.USING) and self._advance_any() and self._prev.text
485            expressions = self._parse_wrapped_csv(self._parse_ordered)
486
487            options = []
488            while True:
489                if self._match_text_seq("KEY_BLOCK_SIZE"):
490                    self._match(TokenType.EQ)
491                    opt = exp.IndexConstraintOption(key_block_size=self._parse_number())
492                elif self._match(TokenType.USING):
493                    opt = exp.IndexConstraintOption(using=self._advance_any() and self._prev.text)
494                elif self._match_text_seq("WITH", "PARSER"):
495                    opt = exp.IndexConstraintOption(parser=self._parse_var(any_token=True))
496                elif self._match(TokenType.COMMENT):
497                    opt = exp.IndexConstraintOption(comment=self._parse_string())
498                elif self._match_text_seq("VISIBLE"):
499                    opt = exp.IndexConstraintOption(visible=True)
500                elif self._match_text_seq("INVISIBLE"):
501                    opt = exp.IndexConstraintOption(visible=False)
502                elif self._match_text_seq("ENGINE_ATTRIBUTE"):
503                    self._match(TokenType.EQ)
504                    opt = exp.IndexConstraintOption(engine_attr=self._parse_string())
505                elif self._match_text_seq("SECONDARY_ENGINE_ATTRIBUTE"):
506                    self._match(TokenType.EQ)
507                    opt = exp.IndexConstraintOption(secondary_engine_attr=self._parse_string())
508                else:
509                    opt = None
510
511                if not opt:
512                    break
513
514                options.append(opt)
515
516            return self.expression(
517                exp.IndexColumnConstraint,
518                this=this,
519                expressions=expressions,
520                kind=kind,
521                index_type=index_type,
522                options=options,
523            )
524
525        def _parse_show_mysql(
526            self,
527            this: str,
528            target: bool | str = False,
529            full: t.Optional[bool] = None,
530            global_: t.Optional[bool] = None,
531        ) -> exp.Show:
532            if target:
533                if isinstance(target, str):
534                    self._match_text_seq(target)
535                target_id = self._parse_id_var()
536            else:
537                target_id = None
538
539            log = self._parse_string() if self._match_text_seq("IN") else None
540
541            if this in ("BINLOG EVENTS", "RELAYLOG EVENTS"):
542                position = self._parse_number() if self._match_text_seq("FROM") else None
543                db = None
544            else:
545                position = None
546                db = None
547
548                if self._match(TokenType.FROM):
549                    db = self._parse_id_var()
550                elif self._match(TokenType.DOT):
551                    db = target_id
552                    target_id = self._parse_id_var()
553
554            channel = self._parse_id_var() if self._match_text_seq("FOR", "CHANNEL") else None
555
556            like = self._parse_string() if self._match_text_seq("LIKE") else None
557            where = self._parse_where()
558
559            if this == "PROFILE":
560                types = self._parse_csv(lambda: self._parse_var_from_options(self.PROFILE_TYPES))
561                query = self._parse_number() if self._match_text_seq("FOR", "QUERY") else None
562                offset = self._parse_number() if self._match_text_seq("OFFSET") else None
563                limit = self._parse_number() if self._match_text_seq("LIMIT") else None
564            else:
565                types, query = None, None
566                offset, limit = self._parse_oldstyle_limit()
567
568            mutex = True if self._match_text_seq("MUTEX") else None
569            mutex = False if self._match_text_seq("STATUS") else mutex
570
571            return self.expression(
572                exp.Show,
573                this=this,
574                target=target_id,
575                full=full,
576                log=log,
577                position=position,
578                db=db,
579                channel=channel,
580                like=like,
581                where=where,
582                types=types,
583                query=query,
584                offset=offset,
585                limit=limit,
586                mutex=mutex,
587                **{"global": global_},  # type: ignore
588            )
589
590        def _parse_oldstyle_limit(
591            self,
592        ) -> t.Tuple[t.Optional[exp.Expression], t.Optional[exp.Expression]]:
593            limit = None
594            offset = None
595            if self._match_text_seq("LIMIT"):
596                parts = self._parse_csv(self._parse_number)
597                if len(parts) == 1:
598                    limit = parts[0]
599                elif len(parts) == 2:
600                    limit = parts[1]
601                    offset = parts[0]
602
603            return offset, limit
604
605        def _parse_set_item_charset(self, kind: str) -> exp.Expression:
606            this = self._parse_string() or self._parse_unquoted_field()
607            return self.expression(exp.SetItem, this=this, kind=kind)
608
609        def _parse_set_item_names(self) -> exp.Expression:
610            charset = self._parse_string() or self._parse_unquoted_field()
611            if self._match_text_seq("COLLATE"):
612                collate = self._parse_string() or self._parse_unquoted_field()
613            else:
614                collate = None
615
616            return self.expression(exp.SetItem, this=charset, collate=collate, kind="NAMES")
617
618        def _parse_type(
619            self, parse_interval: bool = True, fallback_to_identifier: bool = False
620        ) -> t.Optional[exp.Expression]:
621            # mysql binary is special and can work anywhere, even in order by operations
622            # it operates like a no paren func
623            if self._match(TokenType.BINARY, advance=False):
624                data_type = self._parse_types(check_func=True, allow_identifiers=False)
625
626                if isinstance(data_type, exp.DataType):
627                    return self.expression(exp.Cast, this=self._parse_column(), to=data_type)
628
629            return super()._parse_type(
630                parse_interval=parse_interval, fallback_to_identifier=fallback_to_identifier
631            )
632
633        def _parse_chr(self) -> t.Optional[exp.Expression]:
634            expressions = self._parse_csv(self._parse_assignment)
635            kwargs: t.Dict[str, t.Any] = {"this": seq_get(expressions, 0)}
636
637            if len(expressions) > 1:
638                kwargs["expressions"] = expressions[1:]
639
640            if self._match(TokenType.USING):
641                kwargs["charset"] = self._parse_var()
642
643            return self.expression(exp.Chr, **kwargs)
644
645        def _parse_group_concat(self) -> t.Optional[exp.Expression]:
646            def concat_exprs(
647                node: t.Optional[exp.Expression], exprs: t.List[exp.Expression]
648            ) -> exp.Expression:
649                if isinstance(node, exp.Distinct) and len(node.expressions) > 1:
650                    concat_exprs = [
651                        self.expression(exp.Concat, expressions=node.expressions, safe=True)
652                    ]
653                    node.set("expressions", concat_exprs)
654                    return node
655                if len(exprs) == 1:
656                    return exprs[0]
657                return self.expression(exp.Concat, expressions=args, safe=True)
658
659            args = self._parse_csv(self._parse_lambda)
660
661            if args:
662                order = args[-1] if isinstance(args[-1], exp.Order) else None
663
664                if order:
665                    # Order By is the last (or only) expression in the list and has consumed the 'expr' before it,
666                    # remove 'expr' from exp.Order and add it back to args
667                    args[-1] = order.this
668                    order.set("this", concat_exprs(order.this, args))
669
670                this = order or concat_exprs(args[0], args)
671            else:
672                this = None
673
674            separator = self._parse_field() if self._match(TokenType.SEPARATOR) else None
675
676            return self.expression(exp.GroupConcat, this=this, separator=separator)

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

Arguments:
  • error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
  • error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
  • max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
FUNC_TOKENS = {<TokenType.SERIAL: 'SERIAL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MAP: 'MAP'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.NESTED: 'NESTED'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TABLE: 'TABLE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.LIKE: 'LIKE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.BIT: 'BIT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DATE32: 'DATE32'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.TIME: 'TIME'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.SUPER: 'SUPER'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.JSONB: 'JSONB'>, <TokenType.VALUES: 'VALUES'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.NULL: 'NULL'>, <TokenType.UINT: 'UINT'>, <TokenType.INET: 'INET'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.FILTER: 'FILTER'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.INT: 'INT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.VAR: 'VAR'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.TEXT: 'TEXT'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ROW: 'ROW'>, <TokenType.NAME: 'NAME'>, <TokenType.UINT128: 'UINT128'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.ALL: 'ALL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.XML: 'XML'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.ANY: 'ANY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.LIST: 'LIST'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.INT256: 'INT256'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.XOR: 'XOR'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.INT128: 'INT128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.SOME: 'SOME'>, <TokenType.INSERT: 'INSERT'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.BINARY: 'BINARY'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GLOB: 'GLOB'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.LEFT: 'LEFT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.DATE: 'DATE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>}
CONJUNCTION = {<TokenType.AND: 'AND'>: <class 'sqlglot.expressions.And'>, <TokenType.DAMP: 'DAMP'>: <class 'sqlglot.expressions.And'>, <TokenType.XOR: 'XOR'>: <class 'sqlglot.expressions.Xor'>}
DISJUNCTION = {<TokenType.OR: 'OR'>: <class 'sqlglot.expressions.Or'>, <TokenType.DPIPE: 'DPIPE'>: <class 'sqlglot.expressions.Or'>}
TABLE_ALIAS_TOKENS = {<TokenType.SERIAL: 'SERIAL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MAP: 'MAP'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TABLE: 'TABLE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.BIT: 'BIT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DATE32: 'DATE32'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.TIME: 'TIME'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.SUPER: 'SUPER'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.CACHE: 'CACHE'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FALSE: 'FALSE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.FIRST: 'FIRST'>, <TokenType.NULL: 'NULL'>, <TokenType.UINT: 'UINT'>, <TokenType.INET: 'INET'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.INT: 'INT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.CASE: 'CASE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.DESC: 'DESC'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.KILL: 'KILL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.FINAL: 'FINAL'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.DELETE: 'DELETE'>, <TokenType.VAR: 'VAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.TEXT: 'TEXT'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ROW: 'ROW'>, <TokenType.NAME: 'NAME'>, <TokenType.UINT128: 'UINT128'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.TRUE: 'TRUE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ALL: 'ALL'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.ROWS: 'ROWS'>, <TokenType.XML: 'XML'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.ANY: 'ANY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.LIST: 'LIST'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.DATE: 'DATE'>, <TokenType.INT256: 'INT256'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TOP: 'TOP'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.ENUM: 'ENUM'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.ANTI: 'ANTI'>, <TokenType.COPY: 'COPY'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DIV: 'DIV'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.RANGE: 'RANGE'>, <TokenType.INT128: 'INT128'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.ASC: 'ASC'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.SEMI: 'SEMI'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.KEEP: 'KEEP'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.TAG: 'TAG'>, <TokenType.SOME: 'SOME'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.MODEL: 'MODEL'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.BINARY: 'BINARY'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.SHOW: 'SHOW'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.SET: 'SET'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.END: 'END'>, <TokenType.CHAR: 'CHAR'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.INDEX: 'INDEX'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.UUID: 'UUID'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.IS: 'IS'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>}
RANGE_PARSERS = {<TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.OVERLAPS: 'OVERLAPS'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>._parse_binary_range>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.MEMBER_OF: 'MEMBER_OF'>: <function MySQL.Parser.<lambda>>}
FUNCTIONS = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Array'>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONSTRUCT_COMPACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConstructCompact'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_HAS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'ARRAY_CONTAINS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'ARRAY_HAS_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContainsAll'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <function MySQL.Parser.<lambda>>, 'DATE_ADD': <function build_date_delta_with_interval.<locals>._builder>, 'DATEDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <function build_date_delta_with_interval.<locals>._builder>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateTrunc'>>, 'DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Datetime'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <function MySQL.Parser.<lambda>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <function MySQL.Parser.<lambda>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <function MySQL.Parser.<lambda>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <function MySQL.Parser.<lambda>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GAP_FILL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GapFill'>>, 'GENERATE_DATE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateDateArray'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <function build_hex>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LIST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.List'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <function build_lower>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LOWER_HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LowerHex'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Map'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <function MySQL.Parser.<lambda>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'QUARTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quarter'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtract'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Split'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <function _str_to_date>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRING_TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'SPLIT_BY_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StringToArray'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Time'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampAdd'>>, 'TIMESTAMPDIFF': <function build_date_delta.<locals>._builder>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <function MySQL.Parser.<lambda>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Try'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UNNEST': <function Parser.<lambda>>, 'UPPER': <function build_upper>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <function MySQL.Parser.<lambda>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <function MySQL.Parser.<lambda>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Xor'>>, 'YEAR': <function MySQL.Parser.<lambda>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'MOD': <function build_mod>, 'TO_HEX': <function build_hex>, 'DATE_FORMAT': <function build_formatted_time.<locals>._builder>, 'INSTR': <function MySQL.Parser.<lambda>>, 'FROM_UNIXTIME': <function build_formatted_time.<locals>._builder>, 'ISNULL': <function isnull_to_is_null>, 'LOCATE': <function locate_to_strposition>, 'MAKETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'MONTHNAME': <function MySQL.Parser.<lambda>>}
FUNCTION_PARSERS = {'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'GAP_FILL': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'CHAR': <function MySQL.Parser.<lambda>>, 'GROUP_CONCAT': <function MySQL.Parser.<lambda>>, 'VALUES': <function MySQL.Parser.<lambda>>}
STATEMENT_PARSERS = {<TokenType.ALTER: 'ALTER'>: <function Parser.<lambda>>, <TokenType.BEGIN: 'BEGIN'>: <function Parser.<lambda>>, <TokenType.CACHE: 'CACHE'>: <function Parser.<lambda>>, <TokenType.COMMENT: 'COMMENT'>: <function Parser.<lambda>>, <TokenType.COMMIT: 'COMMIT'>: <function Parser.<lambda>>, <TokenType.COPY: 'COPY'>: <function Parser.<lambda>>, <TokenType.CREATE: 'CREATE'>: <function Parser.<lambda>>, <TokenType.DELETE: 'DELETE'>: <function Parser.<lambda>>, <TokenType.DESC: 'DESC'>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 'DESCRIBE'>: <function Parser.<lambda>>, <TokenType.DROP: 'DROP'>: <function Parser.<lambda>>, <TokenType.INSERT: 'INSERT'>: <function Parser.<lambda>>, <TokenType.KILL: 'KILL'>: <function Parser.<lambda>>, <TokenType.LOAD: 'LOAD'>: <function Parser.<lambda>>, <TokenType.MERGE: 'MERGE'>: <function Parser.<lambda>>, <TokenType.PIVOT: 'PIVOT'>: <function Parser.<lambda>>, <TokenType.PRAGMA: 'PRAGMA'>: <function Parser.<lambda>>, <TokenType.REFRESH: 'REFRESH'>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 'ROLLBACK'>: <function Parser.<lambda>>, <TokenType.SET: 'SET'>: <function Parser.<lambda>>, <TokenType.TRUNCATE: 'TRUNCATE'>: <function Parser.<lambda>>, <TokenType.UNCACHE: 'UNCACHE'>: <function Parser.<lambda>>, <TokenType.UPDATE: 'UPDATE'>: <function Parser.<lambda>>, <TokenType.USE: 'USE'>: <function Parser.<lambda>>, <TokenType.SEMICOLON: 'SEMICOLON'>: <function Parser.<lambda>>, <TokenType.SHOW: 'SHOW'>: <function MySQL.Parser.<lambda>>}
SHOW_PARSERS = {'BINARY LOGS': <function _show_parser.<locals>._parse>, 'MASTER LOGS': <function _show_parser.<locals>._parse>, 'BINLOG EVENTS': <function _show_parser.<locals>._parse>, 'CHARACTER SET': <function _show_parser.<locals>._parse>, 'CHARSET': <function _show_parser.<locals>._parse>, 'COLLATION': <function _show_parser.<locals>._parse>, 'FULL COLUMNS': <function _show_parser.<locals>._parse>, 'COLUMNS': <function _show_parser.<locals>._parse>, 'CREATE DATABASE': <function _show_parser.<locals>._parse>, 'CREATE EVENT': <function _show_parser.<locals>._parse>, 'CREATE FUNCTION': <function _show_parser.<locals>._parse>, 'CREATE PROCEDURE': <function _show_parser.<locals>._parse>, 'CREATE TABLE': <function _show_parser.<locals>._parse>, 'CREATE TRIGGER': <function _show_parser.<locals>._parse>, 'CREATE VIEW': <function _show_parser.<locals>._parse>, 'DATABASES': <function _show_parser.<locals>._parse>, 'SCHEMAS': <function _show_parser.<locals>._parse>, 'ENGINE': <function _show_parser.<locals>._parse>, 'STORAGE ENGINES': <function _show_parser.<locals>._parse>, 'ENGINES': <function _show_parser.<locals>._parse>, 'ERRORS': <function _show_parser.<locals>._parse>, 'EVENTS': <function _show_parser.<locals>._parse>, 'FUNCTION CODE': <function _show_parser.<locals>._parse>, 'FUNCTION STATUS': <function _show_parser.<locals>._parse>, 'GRANTS': <function _show_parser.<locals>._parse>, 'INDEX': <function _show_parser.<locals>._parse>, 'MASTER STATUS': <function _show_parser.<locals>._parse>, 'OPEN TABLES': <function _show_parser.<locals>._parse>, 'PLUGINS': <function _show_parser.<locals>._parse>, 'PROCEDURE CODE': <function _show_parser.<locals>._parse>, 'PROCEDURE STATUS': <function _show_parser.<locals>._parse>, 'PRIVILEGES': <function _show_parser.<locals>._parse>, 'FULL PROCESSLIST': <function _show_parser.<locals>._parse>, 'PROCESSLIST': <function _show_parser.<locals>._parse>, 'PROFILE': <function _show_parser.<locals>._parse>, 'PROFILES': <function _show_parser.<locals>._parse>, 'RELAYLOG EVENTS': <function _show_parser.<locals>._parse>, 'REPLICAS': <function _show_parser.<locals>._parse>, 'SLAVE HOSTS': <function _show_parser.<locals>._parse>, 'REPLICA STATUS': <function _show_parser.<locals>._parse>, 'SLAVE STATUS': <function _show_parser.<locals>._parse>, 'GLOBAL STATUS': <function _show_parser.<locals>._parse>, 'SESSION STATUS': <function _show_parser.<locals>._parse>, 'STATUS': <function _show_parser.<locals>._parse>, 'TABLE STATUS': <function _show_parser.<locals>._parse>, 'FULL TABLES': <function _show_parser.<locals>._parse>, 'TABLES': <function _show_parser.<locals>._parse>, 'TRIGGERS': <function _show_parser.<locals>._parse>, 'GLOBAL VARIABLES': <function _show_parser.<locals>._parse>, 'SESSION VARIABLES': <function _show_parser.<locals>._parse>, 'VARIABLES': <function _show_parser.<locals>._parse>, 'WARNINGS': <function _show_parser.<locals>._parse>}
PROPERTY_PARSERS = {'ALLOWED_VALUES': <function Parser.<lambda>>, 'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'BACKUP': <function Parser.<lambda>>, 'BLOCKCOMPRESSION': <function Parser.<lambda>>, 'CHARSET': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECKSUM': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'CONTAINS': <function Parser.<lambda>>, 'COPY': <function Parser.<lambda>>, 'DATABLOCKSIZE': <function Parser.<lambda>>, 'DATA_DELETION': <function Parser.<lambda>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'ENGINE': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'GLOBAL': <function Parser.<lambda>>, 'HEAP': <function Parser.<lambda>>, 'ICEBERG': <function Parser.<lambda>>, 'IMMUTABLE': <function Parser.<lambda>>, 'INHERITS': <function Parser.<lambda>>, 'INPUT': <function Parser.<lambda>>, 'JOURNAL': <function Parser.<lambda>>, 'LANGUAGE': <function Parser.<lambda>>, 'LAYOUT': <function Parser.<lambda>>, 'LIFETIME': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'LOCATION': <function Parser.<lambda>>, 'LOCK': <function MySQL.Parser.<lambda>>, 'LOCKING': <function Parser.<lambda>>, 'LOG': <function Parser.<lambda>>, 'MATERIALIZED': <function Parser.<lambda>>, 'MERGEBLOCKRATIO': <function Parser.<lambda>>, 'MODIFIES': <function Parser.<lambda>>, 'MULTISET': <function Parser.<lambda>>, 'NO': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'ORDER BY': <function Parser.<lambda>>, 'OUTPUT': <function Parser.<lambda>>, 'PARTITION': <function Parser.<lambda>>, 'PARTITION BY': <function Parser.<lambda>>, 'PARTITIONED BY': <function Parser.<lambda>>, 'PARTITIONED_BY': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'RANGE': <function Parser.<lambda>>, 'READS': <function Parser.<lambda>>, 'REMOTE': <function Parser.<lambda>>, 'RETURNS': <function Parser.<lambda>>, 'STRICT': <function Parser.<lambda>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SECURE': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <function Parser.<lambda>>, 'SHARING': <function Parser.<lambda>>, 'SORTKEY': <function Parser.<lambda>>, 'SOURCE': <function Parser.<lambda>>, 'STABLE': <function Parser.<lambda>>, 'STORED': <function Parser.<lambda>>, 'SYSTEM_VERSIONING': <function Parser.<lambda>>, 'TBLPROPERTIES': <function Parser.<lambda>>, 'TEMP': <function Parser.<lambda>>, 'TEMPORARY': <function Parser.<lambda>>, 'TO': <function Parser.<lambda>>, 'TRANSIENT': <function Parser.<lambda>>, 'TRANSFORM': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'USING': <function Parser.<lambda>>, 'UNLOGGED': <function Parser.<lambda>>, 'VOLATILE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>}
SET_PARSERS = {'GLOBAL': <function Parser.<lambda>>, 'LOCAL': <function Parser.<lambda>>, 'SESSION': <function Parser.<lambda>>, 'TRANSACTION': <function Parser.<lambda>>, 'PERSIST': <function MySQL.Parser.<lambda>>, 'PERSIST_ONLY': <function MySQL.Parser.<lambda>>, 'CHARACTER SET': <function MySQL.Parser.<lambda>>, 'CHARSET': <function MySQL.Parser.<lambda>>, 'NAMES': <function MySQL.Parser.<lambda>>}
CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EPHEMERAL': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'FULLTEXT': <function MySQL.Parser.<lambda>>, 'INDEX': <function MySQL.Parser.<lambda>>, 'KEY': <function MySQL.Parser.<lambda>>, 'SPATIAL': <function MySQL.Parser.<lambda>>}
ALTER_PARSERS = {'ADD': <function Parser.<lambda>>, 'ALTER': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'DELETE': <function Parser.<lambda>>, 'DROP': <function Parser.<lambda>>, 'RENAME': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'MODIFY': <function MySQL.Parser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'CHECK', 'EXCLUDE', 'KEY', 'INDEX', 'FOREIGN KEY', 'LIKE', 'FULLTEXT', 'UNIQUE', 'PRIMARY KEY', 'PERIOD', 'SPATIAL'}
PROFILE_TYPES: Dict[str, Sequence[Union[Sequence[str], str]]] = {'ALL': (), 'CPU': (), 'IPC': (), 'MEMORY': (), 'SOURCE': (), 'SWAPS': (), 'BLOCK': ('IO',), 'CONTEXT': ('SWITCHES',), 'PAGE': ('FAULTS',)}
TYPE_TOKENS = {<TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.MAP: 'MAP'>, <TokenType.MONEY: 'MONEY'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.NESTED: 'NESTED'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.LIST: 'LIST'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.INT256: 'INT256'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.BIT: 'BIT'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIME: 'TIME'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.ENUM: 'ENUM'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.SUPER: 'SUPER'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.INT128: 'INT128'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NULL: 'NULL'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.UINT: 'UINT'>, <TokenType.INET: 'INET'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.INT: 'INT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.BINARY: 'BINARY'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.TEXT: 'TEXT'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.NAME: 'NAME'>, <TokenType.SET: 'SET'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.CHAR: 'CHAR'>, <TokenType.UINT128: 'UINT128'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.XML: 'XML'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.DATE: 'DATE'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>}
ENUM_TYPE_TOKENS = {<TokenType.ENUM16: 'ENUM16'>, <TokenType.ENUM: 'ENUM'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.SET: 'SET'>}
LOG_DEFAULTS_TO_LN = True
STRING_ALIASES = True
VALUES_FOLLOWED_BY_PAREN = False
SUPPORTS_PARTITION_SELECTION = True
SHOW_TRIE: Dict = {'BINARY': {'LOGS': {0: True}}, 'MASTER': {'LOGS': {0: True}, 'STATUS': {0: True}}, 'BINLOG': {'EVENTS': {0: True}}, 'CHARACTER': {'SET': {0: True}}, 'CHARSET': {0: True}, 'COLLATION': {0: True}, 'FULL': {'COLUMNS': {0: True}, 'PROCESSLIST': {0: True}, 'TABLES': {0: True}}, 'COLUMNS': {0: True}, 'CREATE': {'DATABASE': {0: True}, 'EVENT': {0: True}, 'FUNCTION': {0: True}, 'PROCEDURE': {0: True}, 'TABLE': {0: True}, 'TRIGGER': {0: True}, 'VIEW': {0: True}}, 'DATABASES': {0: True}, 'SCHEMAS': {0: True}, 'ENGINE': {0: True}, 'STORAGE': {'ENGINES': {0: True}}, 'ENGINES': {0: True}, 'ERRORS': {0: True}, 'EVENTS': {0: True}, 'FUNCTION': {'CODE': {0: True}, 'STATUS': {0: True}}, 'GRANTS': {0: True}, 'INDEX': {0: True}, 'OPEN': {'TABLES': {0: True}}, 'PLUGINS': {0: True}, 'PROCEDURE': {'CODE': {0: True}, 'STATUS': {0: True}}, 'PRIVILEGES': {0: True}, 'PROCESSLIST': {0: True}, 'PROFILE': {0: True}, 'PROFILES': {0: True}, 'RELAYLOG': {'EVENTS': {0: True}}, 'REPLICAS': {0: True}, 'SLAVE': {'HOSTS': {0: True}, 'STATUS': {0: True}}, 'REPLICA': {'STATUS': {0: True}}, 'GLOBAL': {'STATUS': {0: True}, 'VARIABLES': {0: True}}, 'SESSION': {'STATUS': {0: True}, 'VARIABLES': {0: True}}, 'STATUS': {0: True}, 'TABLE': {'STATUS': {0: True}}, 'TABLES': {0: True}, 'TRIGGERS': {0: True}, 'VARIABLES': {0: True}, 'WARNINGS': {0: True}}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}, 'PERSIST': {0: True}, 'PERSIST_ONLY': {0: True}, 'CHARACTER': {'SET': {0: True}}, 'CHARSET': {0: True}, 'NAMES': {0: True}}
Inherited Members
sqlglot.parser.Parser
Parser
NO_PAREN_FUNCTIONS
STRUCT_TYPE_TOKENS
NESTED_TYPE_TOKENS
AGGREGATE_TYPE_TOKENS
SIGNED_TO_UNSIGNED_TYPE_TOKEN
SUBQUERY_PREDICATES
RESERVED_TOKENS
DB_CREATABLES
CREATABLES
ID_VAR_TOKENS
INTERVAL_VARS
ALIAS_TOKENS
ARRAY_CONSTRUCTORS
COMMENT_TABLE_ALIAS_TOKENS
UPDATE_ALIAS_TOKENS
TRIM_TYPES
ASSIGNMENT
EQUALITY
COMPARISON
BITWISE
TERM
FACTOR
EXPONENT
TIMES
TIMESTAMPS
SET_OPERATIONS
JOIN_METHODS
JOIN_SIDES
JOIN_KINDS
JOIN_HINTS
LAMBDAS
COLUMN_OPERATORS
EXPRESSION_PARSERS
UNARY_PARSERS
STRING_PARSERS
NUMERIC_PARSERS
PRIMARY_PARSERS
PLACEHOLDER_PARSERS
ALTER_ALTER_PARSERS
NO_PAREN_FUNCTION_PARSERS
INVALID_FUNC_NAME_TOKENS
FUNCTIONS_WITH_ALIASED_ARGS
KEY_VALUE_DEFINITIONS
QUERY_MODIFIER_PARSERS
TYPE_LITERAL_PARSERS
TYPE_CONVERTERS
DDL_SELECT_TOKENS
PRE_VOLATILE_TOKENS
TRANSACTION_KIND
TRANSACTION_CHARACTERISTICS
CONFLICT_ACTIONS
CREATE_SEQUENCE
ISOLATED_LOADING_OPTIONS
USABLES
CAST_ACTIONS
INSERT_ALTERNATIVES
CLONE_KEYWORDS
HISTORICAL_DATA_KIND
OPCLASS_FOLLOW_KEYWORDS
OPTYPE_FOLLOW_TOKENS
TABLE_INDEX_HINT_TOKENS
VIEW_ATTRIBUTES
WINDOW_ALIAS_TOKENS
WINDOW_BEFORE_PAREN_TOKENS
WINDOW_SIDES
JSON_KEY_VALUE_SEPARATOR_TOKENS
FETCH_TOKENS
ADD_CONSTRAINT_TOKENS
DISTINCT_TOKENS
NULL_TOKENS
UNNEST_OFFSET_ALIAS_TOKENS
SELECT_START_TOKENS
COPY_INTO_VARLEN_OPTIONS
STRICT_CAST
PREFIXED_PIVOT_COLUMNS
IDENTIFY_PIVOT_STRINGS
ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
TABLESAMPLE_CSV
DEFAULT_SAMPLING_METHOD
SET_REQUIRES_ASSIGNMENT_DELIMITER
TRIM_PATTERN_FIRST
MODIFIERS_ATTACHED_TO_SET_OP
SET_OP_MODIFIERS
NO_PAREN_IF_COMMANDS
JSON_ARROWS_REQUIRE_JSON_TYPE
COLON_IS_JSON_EXTRACT
SUPPORTS_IMPLICIT_UNNEST
INTERVAL_SPANS
error_level
error_message_context
max_errors
dialect
reset
parse
parse_into
check_errors
raise_error
expression
validate_expression
errors
sql
class MySQL.Generator(sqlglot.generator.Generator):
 678    class Generator(generator.Generator):
 679        INTERVAL_ALLOWS_PLURAL_FORM = False
 680        LOCKING_READS_SUPPORTED = True
 681        NULL_ORDERING_SUPPORTED = None
 682        JOIN_HINTS = False
 683        TABLE_HINTS = True
 684        DUPLICATE_KEY_UPDATE_WITH_SET = False
 685        QUERY_HINT_SEP = " "
 686        VALUES_AS_TABLE = False
 687        NVL2_SUPPORTED = False
 688        LAST_DAY_SUPPORTS_DATE_PART = False
 689        JSON_TYPE_REQUIRED_FOR_EXTRACTION = True
 690        JSON_PATH_BRACKETED_KEY_SUPPORTED = False
 691        JSON_KEY_VALUE_PAIR_SEP = ","
 692        SUPPORTS_TO_NUMBER = False
 693
 694        TRANSFORMS = {
 695            **generator.Generator.TRANSFORMS,
 696            exp.ArrayAgg: rename_func("GROUP_CONCAT"),
 697            exp.CurrentDate: no_paren_current_date_sql,
 698            exp.DateDiff: _remove_ts_or_ds_to_date(
 699                lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
 700            ),
 701            exp.DateAdd: _remove_ts_or_ds_to_date(date_add_sql("ADD")),
 702            exp.DateStrToDate: datestrtodate_sql,
 703            exp.DateSub: _remove_ts_or_ds_to_date(date_add_sql("SUB")),
 704            exp.DateTrunc: _date_trunc_sql,
 705            exp.Day: _remove_ts_or_ds_to_date(),
 706            exp.DayOfMonth: _remove_ts_or_ds_to_date(rename_func("DAYOFMONTH")),
 707            exp.DayOfWeek: _remove_ts_or_ds_to_date(rename_func("DAYOFWEEK")),
 708            exp.DayOfYear: _remove_ts_or_ds_to_date(rename_func("DAYOFYEAR")),
 709            exp.GroupConcat: lambda self,
 710            e: f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})""",
 711            exp.ILike: no_ilike_sql,
 712            exp.JSONExtractScalar: arrow_json_extract_sql,
 713            exp.Max: max_or_greatest,
 714            exp.Min: min_or_least,
 715            exp.Month: _remove_ts_or_ds_to_date(),
 716            exp.NullSafeEQ: lambda self, e: self.binary(e, "<=>"),
 717            exp.NullSafeNEQ: lambda self, e: f"NOT {self.binary(e, '<=>')}",
 718            exp.ParseJSON: lambda self, e: self.sql(e, "this"),
 719            exp.Pivot: no_pivot_sql,
 720            exp.Select: transforms.preprocess(
 721                [
 722                    transforms.eliminate_distinct_on,
 723                    transforms.eliminate_semi_and_anti_joins,
 724                    transforms.eliminate_qualify,
 725                    transforms.eliminate_full_outer_join,
 726                ]
 727            ),
 728            exp.StrPosition: strposition_to_locate_sql,
 729            exp.StrToDate: _str_to_date_sql,
 730            exp.StrToTime: _str_to_date_sql,
 731            exp.Stuff: rename_func("INSERT"),
 732            exp.TableSample: no_tablesample_sql,
 733            exp.TimeFromParts: rename_func("MAKETIME"),
 734            exp.TimestampAdd: date_add_interval_sql("DATE", "ADD"),
 735            exp.TimestampDiff: lambda self, e: self.func(
 736                "TIMESTAMPDIFF", unit_to_var(e), e.expression, e.this
 737            ),
 738            exp.TimestampSub: date_add_interval_sql("DATE", "SUB"),
 739            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
 740            exp.TimeStrToTime: lambda self, e: self.sql(
 741                exp.cast(e.this, exp.DataType.Type.DATETIME, copy=True)
 742            ),
 743            exp.TimeToStr: _remove_ts_or_ds_to_date(
 744                lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e))
 745            ),
 746            exp.Trim: _trim_sql,
 747            exp.TryCast: no_trycast_sql,
 748            exp.TsOrDsAdd: date_add_sql("ADD"),
 749            exp.TsOrDsDiff: lambda self, e: self.func("DATEDIFF", e.this, e.expression),
 750            exp.TsOrDsToDate: _ts_or_ds_to_date_sql,
 751            exp.UnixToTime: _unix_to_time_sql,
 752            exp.Week: _remove_ts_or_ds_to_date(),
 753            exp.WeekOfYear: _remove_ts_or_ds_to_date(rename_func("WEEKOFYEAR")),
 754            exp.Year: _remove_ts_or_ds_to_date(),
 755        }
 756
 757        UNSIGNED_TYPE_MAPPING = {
 758            exp.DataType.Type.UBIGINT: "BIGINT",
 759            exp.DataType.Type.UINT: "INT",
 760            exp.DataType.Type.UMEDIUMINT: "MEDIUMINT",
 761            exp.DataType.Type.USMALLINT: "SMALLINT",
 762            exp.DataType.Type.UTINYINT: "TINYINT",
 763            exp.DataType.Type.UDECIMAL: "DECIMAL",
 764        }
 765
 766        TIMESTAMP_TYPE_MAPPING = {
 767            exp.DataType.Type.TIMESTAMP: "DATETIME",
 768            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
 769            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
 770        }
 771
 772        TYPE_MAPPING = {
 773            **generator.Generator.TYPE_MAPPING,
 774            **UNSIGNED_TYPE_MAPPING,
 775            **TIMESTAMP_TYPE_MAPPING,
 776        }
 777
 778        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMTEXT)
 779        TYPE_MAPPING.pop(exp.DataType.Type.LONGTEXT)
 780        TYPE_MAPPING.pop(exp.DataType.Type.TINYTEXT)
 781        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMBLOB)
 782        TYPE_MAPPING.pop(exp.DataType.Type.LONGBLOB)
 783        TYPE_MAPPING.pop(exp.DataType.Type.TINYBLOB)
 784
 785        PROPERTIES_LOCATION = {
 786            **generator.Generator.PROPERTIES_LOCATION,
 787            exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
 788            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 789        }
 790
 791        LIMIT_FETCH = "LIMIT"
 792
 793        LIMIT_ONLY_LITERALS = True
 794
 795        CHAR_CAST_MAPPING = dict.fromkeys(
 796            (
 797                exp.DataType.Type.LONGTEXT,
 798                exp.DataType.Type.LONGBLOB,
 799                exp.DataType.Type.MEDIUMBLOB,
 800                exp.DataType.Type.MEDIUMTEXT,
 801                exp.DataType.Type.TEXT,
 802                exp.DataType.Type.TINYBLOB,
 803                exp.DataType.Type.TINYTEXT,
 804                exp.DataType.Type.VARCHAR,
 805            ),
 806            "CHAR",
 807        )
 808        SIGNED_CAST_MAPPING = dict.fromkeys(
 809            (
 810                exp.DataType.Type.BIGINT,
 811                exp.DataType.Type.BOOLEAN,
 812                exp.DataType.Type.INT,
 813                exp.DataType.Type.SMALLINT,
 814                exp.DataType.Type.TINYINT,
 815                exp.DataType.Type.MEDIUMINT,
 816            ),
 817            "SIGNED",
 818        )
 819
 820        # MySQL doesn't support many datatypes in cast.
 821        # https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_cast
 822        CAST_MAPPING = {
 823            **CHAR_CAST_MAPPING,
 824            **SIGNED_CAST_MAPPING,
 825            exp.DataType.Type.UBIGINT: "UNSIGNED",
 826        }
 827
 828        TIMESTAMP_FUNC_TYPES = {
 829            exp.DataType.Type.TIMESTAMPTZ,
 830            exp.DataType.Type.TIMESTAMPLTZ,
 831        }
 832
 833        # https://dev.mysql.com/doc/refman/8.0/en/keywords.html
 834        RESERVED_KEYWORDS = {
 835            "accessible",
 836            "add",
 837            "all",
 838            "alter",
 839            "analyze",
 840            "and",
 841            "as",
 842            "asc",
 843            "asensitive",
 844            "before",
 845            "between",
 846            "bigint",
 847            "binary",
 848            "blob",
 849            "both",
 850            "by",
 851            "call",
 852            "cascade",
 853            "case",
 854            "change",
 855            "char",
 856            "character",
 857            "check",
 858            "collate",
 859            "column",
 860            "condition",
 861            "constraint",
 862            "continue",
 863            "convert",
 864            "create",
 865            "cross",
 866            "cube",
 867            "cume_dist",
 868            "current_date",
 869            "current_time",
 870            "current_timestamp",
 871            "current_user",
 872            "cursor",
 873            "database",
 874            "databases",
 875            "day_hour",
 876            "day_microsecond",
 877            "day_minute",
 878            "day_second",
 879            "dec",
 880            "decimal",
 881            "declare",
 882            "default",
 883            "delayed",
 884            "delete",
 885            "dense_rank",
 886            "desc",
 887            "describe",
 888            "deterministic",
 889            "distinct",
 890            "distinctrow",
 891            "div",
 892            "double",
 893            "drop",
 894            "dual",
 895            "each",
 896            "else",
 897            "elseif",
 898            "empty",
 899            "enclosed",
 900            "escaped",
 901            "except",
 902            "exists",
 903            "exit",
 904            "explain",
 905            "false",
 906            "fetch",
 907            "first_value",
 908            "float",
 909            "float4",
 910            "float8",
 911            "for",
 912            "force",
 913            "foreign",
 914            "from",
 915            "fulltext",
 916            "function",
 917            "generated",
 918            "get",
 919            "grant",
 920            "group",
 921            "grouping",
 922            "groups",
 923            "having",
 924            "high_priority",
 925            "hour_microsecond",
 926            "hour_minute",
 927            "hour_second",
 928            "if",
 929            "ignore",
 930            "in",
 931            "index",
 932            "infile",
 933            "inner",
 934            "inout",
 935            "insensitive",
 936            "insert",
 937            "int",
 938            "int1",
 939            "int2",
 940            "int3",
 941            "int4",
 942            "int8",
 943            "integer",
 944            "intersect",
 945            "interval",
 946            "into",
 947            "io_after_gtids",
 948            "io_before_gtids",
 949            "is",
 950            "iterate",
 951            "join",
 952            "json_table",
 953            "key",
 954            "keys",
 955            "kill",
 956            "lag",
 957            "last_value",
 958            "lateral",
 959            "lead",
 960            "leading",
 961            "leave",
 962            "left",
 963            "like",
 964            "limit",
 965            "linear",
 966            "lines",
 967            "load",
 968            "localtime",
 969            "localtimestamp",
 970            "lock",
 971            "long",
 972            "longblob",
 973            "longtext",
 974            "loop",
 975            "low_priority",
 976            "master_bind",
 977            "master_ssl_verify_server_cert",
 978            "match",
 979            "maxvalue",
 980            "mediumblob",
 981            "mediumint",
 982            "mediumtext",
 983            "middleint",
 984            "minute_microsecond",
 985            "minute_second",
 986            "mod",
 987            "modifies",
 988            "natural",
 989            "not",
 990            "no_write_to_binlog",
 991            "nth_value",
 992            "ntile",
 993            "null",
 994            "numeric",
 995            "of",
 996            "on",
 997            "optimize",
 998            "optimizer_costs",
 999            "option",
1000            "optionally",
1001            "or",
1002            "order",
1003            "out",
1004            "outer",
1005            "outfile",
1006            "over",
1007            "partition",
1008            "percent_rank",
1009            "precision",
1010            "primary",
1011            "procedure",
1012            "purge",
1013            "range",
1014            "rank",
1015            "read",
1016            "reads",
1017            "read_write",
1018            "real",
1019            "recursive",
1020            "references",
1021            "regexp",
1022            "release",
1023            "rename",
1024            "repeat",
1025            "replace",
1026            "require",
1027            "resignal",
1028            "restrict",
1029            "return",
1030            "revoke",
1031            "right",
1032            "rlike",
1033            "row",
1034            "rows",
1035            "row_number",
1036            "schema",
1037            "schemas",
1038            "second_microsecond",
1039            "select",
1040            "sensitive",
1041            "separator",
1042            "set",
1043            "show",
1044            "signal",
1045            "smallint",
1046            "spatial",
1047            "specific",
1048            "sql",
1049            "sqlexception",
1050            "sqlstate",
1051            "sqlwarning",
1052            "sql_big_result",
1053            "sql_calc_found_rows",
1054            "sql_small_result",
1055            "ssl",
1056            "starting",
1057            "stored",
1058            "straight_join",
1059            "system",
1060            "table",
1061            "terminated",
1062            "then",
1063            "tinyblob",
1064            "tinyint",
1065            "tinytext",
1066            "to",
1067            "trailing",
1068            "trigger",
1069            "true",
1070            "undo",
1071            "union",
1072            "unique",
1073            "unlock",
1074            "unsigned",
1075            "update",
1076            "usage",
1077            "use",
1078            "using",
1079            "utc_date",
1080            "utc_time",
1081            "utc_timestamp",
1082            "values",
1083            "varbinary",
1084            "varchar",
1085            "varcharacter",
1086            "varying",
1087            "virtual",
1088            "when",
1089            "where",
1090            "while",
1091            "window",
1092            "with",
1093            "write",
1094            "xor",
1095            "year_month",
1096            "zerofill",
1097        }
1098
1099        def array_sql(self, expression: exp.Array) -> str:
1100            self.unsupported("Arrays are not supported by MySQL")
1101            return self.function_fallback_sql(expression)
1102
1103        def arraycontainsall_sql(self, expression: exp.ArrayContainsAll) -> str:
1104            self.unsupported("Array operations are not supported by MySQL")
1105            return self.function_fallback_sql(expression)
1106
1107        def dpipe_sql(self, expression: exp.DPipe) -> str:
1108            return self.func("CONCAT", *expression.flatten())
1109
1110        def extract_sql(self, expression: exp.Extract) -> str:
1111            unit = expression.name
1112            if unit and unit.lower() == "epoch":
1113                return self.func("UNIX_TIMESTAMP", expression.expression)
1114
1115            return super().extract_sql(expression)
1116
1117        def datatype_sql(self, expression: exp.DataType) -> str:
1118            # https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
1119            result = super().datatype_sql(expression)
1120            if expression.this in self.UNSIGNED_TYPE_MAPPING:
1121                result = f"{result} UNSIGNED"
1122            return result
1123
1124        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
1125            return f"{self.sql(expression, 'this')} MEMBER OF({self.sql(expression, 'expression')})"
1126
1127        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1128            if expression.to.this in self.TIMESTAMP_FUNC_TYPES:
1129                return self.func("TIMESTAMP", expression.this)
1130
1131            to = self.CAST_MAPPING.get(expression.to.this)
1132
1133            if to:
1134                expression.to.set("this", to)
1135            return super().cast_sql(expression)
1136
1137        def show_sql(self, expression: exp.Show) -> str:
1138            this = f" {expression.