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

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'>
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            "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}
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'>, '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'>, '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'>, '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.REPLACE: 'REPLACE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.FETCH: 'FETCH'>}
class MySQL.Parser(sqlglot.parser.Parser):
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            TokenType.DPIPE: exp.Or,
284        }
285
286        TABLE_ALIAS_TOKENS = (
287            parser.Parser.TABLE_ALIAS_TOKENS - parser.Parser.TABLE_INDEX_HINT_TOKENS
288        )
289
290        RANGE_PARSERS = {
291            **parser.Parser.RANGE_PARSERS,
292            TokenType.MEMBER_OF: lambda self, this: self.expression(
293                exp.JSONArrayContains,
294                this=this,
295                expression=self._parse_wrapped(self._parse_expression),
296            ),
297        }
298
299        FUNCTIONS = {
300            **parser.Parser.FUNCTIONS,
301            "DATE": lambda args: exp.TsOrDsToDate(this=seq_get(args, 0)),
302            "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
303            "DATE_FORMAT": build_formatted_time(exp.TimeToStr, "mysql"),
304            "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
305            "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
306            "DAYOFMONTH": lambda args: exp.DayOfMonth(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
307            "DAYOFWEEK": lambda args: exp.DayOfWeek(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
308            "DAYOFYEAR": lambda args: exp.DayOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
309            "INSTR": lambda args: exp.StrPosition(substr=seq_get(args, 1), this=seq_get(args, 0)),
310            "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime, "mysql"),
311            "ISNULL": isnull_to_is_null,
312            "LOCATE": locate_to_strposition,
313            "MAKETIME": exp.TimeFromParts.from_arg_list,
314            "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
315            "MONTHNAME": lambda args: exp.TimeToStr(
316                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
317                format=exp.Literal.string("%B"),
318            ),
319            "STR_TO_DATE": _str_to_date,
320            "TIMESTAMPDIFF": build_date_delta(exp.TimestampDiff),
321            "TO_DAYS": lambda args: exp.paren(
322                exp.DateDiff(
323                    this=exp.TsOrDsToDate(this=seq_get(args, 0)),
324                    expression=exp.TsOrDsToDate(this=exp.Literal.string("0000-01-01")),
325                    unit=exp.var("DAY"),
326                )
327                + 1
328            ),
329            "WEEK": lambda args: exp.Week(
330                this=exp.TsOrDsToDate(this=seq_get(args, 0)), mode=seq_get(args, 1)
331            ),
332            "WEEKOFYEAR": lambda args: exp.WeekOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
333            "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
334        }
335
336        FUNCTION_PARSERS = {
337            **parser.Parser.FUNCTION_PARSERS,
338            "CHAR": lambda self: self._parse_chr(),
339            "GROUP_CONCAT": lambda self: self._parse_group_concat(),
340            # https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
341            "VALUES": lambda self: self.expression(
342                exp.Anonymous, this="VALUES", expressions=[self._parse_id_var()]
343            ),
344        }
345
346        STATEMENT_PARSERS = {
347            **parser.Parser.STATEMENT_PARSERS,
348            TokenType.SHOW: lambda self: self._parse_show(),
349        }
350
351        SHOW_PARSERS = {
352            "BINARY LOGS": _show_parser("BINARY LOGS"),
353            "MASTER LOGS": _show_parser("BINARY LOGS"),
354            "BINLOG EVENTS": _show_parser("BINLOG EVENTS"),
355            "CHARACTER SET": _show_parser("CHARACTER SET"),
356            "CHARSET": _show_parser("CHARACTER SET"),
357            "COLLATION": _show_parser("COLLATION"),
358            "FULL COLUMNS": _show_parser("COLUMNS", target="FROM", full=True),
359            "COLUMNS": _show_parser("COLUMNS", target="FROM"),
360            "CREATE DATABASE": _show_parser("CREATE DATABASE", target=True),
361            "CREATE EVENT": _show_parser("CREATE EVENT", target=True),
362            "CREATE FUNCTION": _show_parser("CREATE FUNCTION", target=True),
363            "CREATE PROCEDURE": _show_parser("CREATE PROCEDURE", target=True),
364            "CREATE TABLE": _show_parser("CREATE TABLE", target=True),
365            "CREATE TRIGGER": _show_parser("CREATE TRIGGER", target=True),
366            "CREATE VIEW": _show_parser("CREATE VIEW", target=True),
367            "DATABASES": _show_parser("DATABASES"),
368            "SCHEMAS": _show_parser("DATABASES"),
369            "ENGINE": _show_parser("ENGINE", target=True),
370            "STORAGE ENGINES": _show_parser("ENGINES"),
371            "ENGINES": _show_parser("ENGINES"),
372            "ERRORS": _show_parser("ERRORS"),
373            "EVENTS": _show_parser("EVENTS"),
374            "FUNCTION CODE": _show_parser("FUNCTION CODE", target=True),
375            "FUNCTION STATUS": _show_parser("FUNCTION STATUS"),
376            "GRANTS": _show_parser("GRANTS", target="FOR"),
377            "INDEX": _show_parser("INDEX", target="FROM"),
378            "MASTER STATUS": _show_parser("MASTER STATUS"),
379            "OPEN TABLES": _show_parser("OPEN TABLES"),
380            "PLUGINS": _show_parser("PLUGINS"),
381            "PROCEDURE CODE": _show_parser("PROCEDURE CODE", target=True),
382            "PROCEDURE STATUS": _show_parser("PROCEDURE STATUS"),
383            "PRIVILEGES": _show_parser("PRIVILEGES"),
384            "FULL PROCESSLIST": _show_parser("PROCESSLIST", full=True),
385            "PROCESSLIST": _show_parser("PROCESSLIST"),
386            "PROFILE": _show_parser("PROFILE"),
387            "PROFILES": _show_parser("PROFILES"),
388            "RELAYLOG EVENTS": _show_parser("RELAYLOG EVENTS"),
389            "REPLICAS": _show_parser("REPLICAS"),
390            "SLAVE HOSTS": _show_parser("REPLICAS"),
391            "REPLICA STATUS": _show_parser("REPLICA STATUS"),
392            "SLAVE STATUS": _show_parser("REPLICA STATUS"),
393            "GLOBAL STATUS": _show_parser("STATUS", global_=True),
394            "SESSION STATUS": _show_parser("STATUS"),
395            "STATUS": _show_parser("STATUS"),
396            "TABLE STATUS": _show_parser("TABLE STATUS"),
397            "FULL TABLES": _show_parser("TABLES", full=True),
398            "TABLES": _show_parser("TABLES"),
399            "TRIGGERS": _show_parser("TRIGGERS"),
400            "GLOBAL VARIABLES": _show_parser("VARIABLES", global_=True),
401            "SESSION VARIABLES": _show_parser("VARIABLES"),
402            "VARIABLES": _show_parser("VARIABLES"),
403            "WARNINGS": _show_parser("WARNINGS"),
404        }
405
406        PROPERTY_PARSERS = {
407            **parser.Parser.PROPERTY_PARSERS,
408            "LOCK": lambda self: self._parse_property_assignment(exp.LockProperty),
409        }
410
411        SET_PARSERS = {
412            **parser.Parser.SET_PARSERS,
413            "PERSIST": lambda self: self._parse_set_item_assignment("PERSIST"),
414            "PERSIST_ONLY": lambda self: self._parse_set_item_assignment("PERSIST_ONLY"),
415            "CHARACTER SET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
416            "CHARSET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
417            "NAMES": lambda self: self._parse_set_item_names(),
418        }
419
420        CONSTRAINT_PARSERS = {
421            **parser.Parser.CONSTRAINT_PARSERS,
422            "FULLTEXT": lambda self: self._parse_index_constraint(kind="FULLTEXT"),
423            "INDEX": lambda self: self._parse_index_constraint(),
424            "KEY": lambda self: self._parse_index_constraint(),
425            "SPATIAL": lambda self: self._parse_index_constraint(kind="SPATIAL"),
426        }
427
428        ALTER_PARSERS = {
429            **parser.Parser.ALTER_PARSERS,
430            "MODIFY": lambda self: self._parse_alter_table_alter(),
431        }
432
433        SCHEMA_UNNAMED_CONSTRAINTS = {
434            *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
435            "FULLTEXT",
436            "INDEX",
437            "KEY",
438            "SPATIAL",
439        }
440
441        PROFILE_TYPES: parser.OPTIONS_TYPE = {
442            **dict.fromkeys(("ALL", "CPU", "IPC", "MEMORY", "SOURCE", "SWAPS"), tuple()),
443            "BLOCK": ("IO",),
444            "CONTEXT": ("SWITCHES",),
445            "PAGE": ("FAULTS",),
446        }
447
448        TYPE_TOKENS = {
449            *parser.Parser.TYPE_TOKENS,
450            TokenType.SET,
451        }
452
453        ENUM_TYPE_TOKENS = {
454            *parser.Parser.ENUM_TYPE_TOKENS,
455            TokenType.SET,
456        }
457
458        LOG_DEFAULTS_TO_LN = True
459        STRING_ALIASES = True
460        VALUES_FOLLOWED_BY_PAREN = False
461        SUPPORTS_PARTITION_SELECTION = True
462
463        def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
464            this = self._parse_id_var()
465            if not self._match(TokenType.L_PAREN):
466                return this
467
468            expression = self._parse_number()
469            self._match_r_paren()
470            return self.expression(exp.ColumnPrefix, this=this, expression=expression)
471
472        def _parse_index_constraint(
473            self, kind: t.Optional[str] = None
474        ) -> exp.IndexColumnConstraint:
475            if kind:
476                self._match_texts(("INDEX", "KEY"))
477
478            this = self._parse_id_var(any_token=False)
479            index_type = self._match(TokenType.USING) and self._advance_any() and self._prev.text
480            expressions = self._parse_wrapped_csv(self._parse_ordered)
481
482            options = []
483            while True:
484                if self._match_text_seq("KEY_BLOCK_SIZE"):
485                    self._match(TokenType.EQ)
486                    opt = exp.IndexConstraintOption(key_block_size=self._parse_number())
487                elif self._match(TokenType.USING):
488                    opt = exp.IndexConstraintOption(using=self._advance_any() and self._prev.text)
489                elif self._match_text_seq("WITH", "PARSER"):
490                    opt = exp.IndexConstraintOption(parser=self._parse_var(any_token=True))
491                elif self._match(TokenType.COMMENT):
492                    opt = exp.IndexConstraintOption(comment=self._parse_string())
493                elif self._match_text_seq("VISIBLE"):
494                    opt = exp.IndexConstraintOption(visible=True)
495                elif self._match_text_seq("INVISIBLE"):
496                    opt = exp.IndexConstraintOption(visible=False)
497                elif self._match_text_seq("ENGINE_ATTRIBUTE"):
498                    self._match(TokenType.EQ)
499                    opt = exp.IndexConstraintOption(engine_attr=self._parse_string())
500                elif self._match_text_seq("SECONDARY_ENGINE_ATTRIBUTE"):
501                    self._match(TokenType.EQ)
502                    opt = exp.IndexConstraintOption(secondary_engine_attr=self._parse_string())
503                else:
504                    opt = None
505
506                if not opt:
507                    break
508
509                options.append(opt)
510
511            return self.expression(
512                exp.IndexColumnConstraint,
513                this=this,
514                expressions=expressions,
515                kind=kind,
516                index_type=index_type,
517                options=options,
518            )
519
520        def _parse_show_mysql(
521            self,
522            this: str,
523            target: bool | str = False,
524            full: t.Optional[bool] = None,
525            global_: t.Optional[bool] = None,
526        ) -> exp.Show:
527            if target:
528                if isinstance(target, str):
529                    self._match_text_seq(target)
530                target_id = self._parse_id_var()
531            else:
532                target_id = None
533
534            log = self._parse_string() if self._match_text_seq("IN") else None
535
536            if this in ("BINLOG EVENTS", "RELAYLOG EVENTS"):
537                position = self._parse_number() if self._match_text_seq("FROM") else None
538                db = None
539            else:
540                position = None
541                db = None
542
543                if self._match(TokenType.FROM):
544                    db = self._parse_id_var()
545                elif self._match(TokenType.DOT):
546                    db = target_id
547                    target_id = self._parse_id_var()
548
549            channel = self._parse_id_var() if self._match_text_seq("FOR", "CHANNEL") else None
550
551            like = self._parse_string() if self._match_text_seq("LIKE") else None
552            where = self._parse_where()
553
554            if this == "PROFILE":
555                types = self._parse_csv(lambda: self._parse_var_from_options(self.PROFILE_TYPES))
556                query = self._parse_number() if self._match_text_seq("FOR", "QUERY") else None
557                offset = self._parse_number() if self._match_text_seq("OFFSET") else None
558                limit = self._parse_number() if self._match_text_seq("LIMIT") else None
559            else:
560                types, query = None, None
561                offset, limit = self._parse_oldstyle_limit()
562
563            mutex = True if self._match_text_seq("MUTEX") else None
564            mutex = False if self._match_text_seq("STATUS") else mutex
565
566            return self.expression(
567                exp.Show,
568                this=this,
569                target=target_id,
570                full=full,
571                log=log,
572                position=position,
573                db=db,
574                channel=channel,
575                like=like,
576                where=where,
577                types=types,
578                query=query,
579                offset=offset,
580                limit=limit,
581                mutex=mutex,
582                **{"global": global_},  # type: ignore
583            )
584
585        def _parse_oldstyle_limit(
586            self,
587        ) -> t.Tuple[t.Optional[exp.Expression], t.Optional[exp.Expression]]:
588            limit = None
589            offset = None
590            if self._match_text_seq("LIMIT"):
591                parts = self._parse_csv(self._parse_number)
592                if len(parts) == 1:
593                    limit = parts[0]
594                elif len(parts) == 2:
595                    limit = parts[1]
596                    offset = parts[0]
597
598            return offset, limit
599
600        def _parse_set_item_charset(self, kind: str) -> exp.Expression:
601            this = self._parse_string() or self._parse_unquoted_field()
602            return self.expression(exp.SetItem, this=this, kind=kind)
603
604        def _parse_set_item_names(self) -> exp.Expression:
605            charset = self._parse_string() or self._parse_unquoted_field()
606            if self._match_text_seq("COLLATE"):
607                collate = self._parse_string() or self._parse_unquoted_field()
608            else:
609                collate = None
610
611            return self.expression(exp.SetItem, this=charset, collate=collate, kind="NAMES")
612
613        def _parse_type(
614            self, parse_interval: bool = True, fallback_to_identifier: bool = False
615        ) -> t.Optional[exp.Expression]:
616            # mysql binary is special and can work anywhere, even in order by operations
617            # it operates like a no paren func
618            if self._match(TokenType.BINARY, advance=False):
619                data_type = self._parse_types(check_func=True, allow_identifiers=False)
620
621                if isinstance(data_type, exp.DataType):
622                    return self.expression(exp.Cast, this=self._parse_column(), to=data_type)
623
624            return super()._parse_type(
625                parse_interval=parse_interval, fallback_to_identifier=fallback_to_identifier
626            )
627
628        def _parse_chr(self) -> t.Optional[exp.Expression]:
629            expressions = self._parse_csv(self._parse_conjunction)
630            kwargs: t.Dict[str, t.Any] = {"this": seq_get(expressions, 0)}
631
632            if len(expressions) > 1:
633                kwargs["expressions"] = expressions[1:]
634
635            if self._match(TokenType.USING):
636                kwargs["charset"] = self._parse_var()
637
638            return self.expression(exp.Chr, **kwargs)
639
640        def _parse_group_concat(self) -> t.Optional[exp.Expression]:
641            def concat_exprs(
642                node: t.Optional[exp.Expression], exprs: t.List[exp.Expression]
643            ) -> exp.Expression:
644                if isinstance(node, exp.Distinct) and len(node.expressions) > 1:
645                    concat_exprs = [
646                        self.expression(exp.Concat, expressions=node.expressions, safe=True)
647                    ]
648                    node.set("expressions", concat_exprs)
649                    return node
650                if len(exprs) == 1:
651                    return exprs[0]
652                return self.expression(exp.Concat, expressions=args, safe=True)
653
654            args = self._parse_csv(self._parse_lambda)
655
656            if args:
657                order = args[-1] if isinstance(args[-1], exp.Order) else None
658
659                if order:
660                    # Order By is the last (or only) expression in the list and has consumed the 'expr' before it,
661                    # remove 'expr' from exp.Order and add it back to args
662                    args[-1] = order.this
663                    order.set("this", concat_exprs(order.this, args))
664
665                this = order or concat_exprs(args[0], args)
666            else:
667                this = None
668
669            separator = self._parse_field() if self._match(TokenType.SEPARATOR) else None
670
671            return self.expression(exp.GroupConcat, this=this, separator=separator)

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.DATETIME64: 'DATETIME64'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.ANY: 'ANY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.SUPER: 'SUPER'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.FIRST: 'FIRST'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.NESTED: 'NESTED'>, <TokenType.UINT: 'UINT'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.GLOB: 'GLOB'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.TABLE: 'TABLE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.XML: 'XML'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.MAP: 'MAP'>, <TokenType.INT256: 'INT256'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.INSERT: 'INSERT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.BIT: 'BIT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.XOR: 'XOR'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.ALL: 'ALL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.INT128: 'INT128'>, <TokenType.YEAR: 'YEAR'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.ROW: 'ROW'>, <TokenType.UINT256: 'UINT256'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TEXT: 'TEXT'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.MERGE: 'MERGE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.NULL: 'NULL'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.VALUES: 'VALUES'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT128: 'UINT128'>, <TokenType.LIKE: 'LIKE'>, <TokenType.NAME: 'NAME'>, <TokenType.INT: 'INT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.DATE: 'DATE'>, <TokenType.SOME: 'SOME'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TIME: 'TIME'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.VAR: 'VAR'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.LEFT: 'LEFT'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INET: 'INET'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INT4RANGE: 'INT4RANGE'>}
CONJUNCTION = {<TokenType.AND: 'AND'>: <class 'sqlglot.expressions.And'>, <TokenType.OR: 'OR'>: <class 'sqlglot.expressions.Or'>, <TokenType.DAMP: 'DAMP'>: <class 'sqlglot.expressions.And'>, <TokenType.XOR: 'XOR'>: <class 'sqlglot.expressions.Xor'>, <TokenType.DPIPE: 'DPIPE'>: <class 'sqlglot.expressions.Or'>}
TABLE_ALIAS_TOKENS = {<TokenType.DATETIME64: 'DATETIME64'>, <TokenType.CASE: 'CASE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.FILTER: 'FILTER'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.ANY: 'ANY'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.IS: 'IS'>, <TokenType.SUPER: 'SUPER'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.FIRST: 'FIRST'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.NESTED: 'NESTED'>, <TokenType.DESC: 'DESC'>, <TokenType.UINT: 'UINT'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.SHOW: 'SHOW'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.TABLE: 'TABLE'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.XML: 'XML'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.MAP: 'MAP'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.INT256: 'INT256'>, <TokenType.VIEW: 'VIEW'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.COPY: 'COPY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TOP: 'TOP'>, <TokenType.LOAD: 'LOAD'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.BIT: 'BIT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.ALL: 'ALL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.INT128: 'INT128'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.YEAR: 'YEAR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.ROW: 'ROW'>, <TokenType.UINT256: 'UINT256'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.MODEL: 'MODEL'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TRUE: 'TRUE'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.CHAR: 'CHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.TAG: 'TAG'>, <TokenType.WAREHOUSE: 'WAREHOUSE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.SET: 'SET'>, <TokenType.ROWS: 'ROWS'>, <TokenType.TEXT: 'TEXT'>, <TokenType.SEMI: 'SEMI'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.FINAL: 'FINAL'>, <TokenType.STREAMLIT: 'STREAMLIT'>, <TokenType.END: 'END'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.MERGE: 'MERGE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.FALSE: 'FALSE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.NULL: 'NULL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.ROLLUP: 'ROLLUP'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT128: 'UINT128'>, <TokenType.NAME: 'NAME'>, <TokenType.ASC: 'ASC'>, <TokenType.INT: 'INT'>, <TokenType.KEEP: 'KEEP'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.KILL: 'KILL'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.DATE: 'DATE'>, <TokenType.SOME: 'SOME'>, <TokenType.DELETE: 'DELETE'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.DIV: 'DIV'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TIME: 'TIME'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPV6: 'IPV6'>, <TokenType.VAR: 'VAR'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.ANTI: 'ANTI'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INET: 'INET'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.CACHE: 'CACHE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.INT4RANGE: 'INT4RANGE'>}
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_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'>>, '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_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'>>, '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_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'>>, '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>>, '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>>, '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 = {'EXCLUDE', 'INDEX', 'LIKE', 'CHECK', 'FOREIGN KEY', 'UNIQUE', 'SPATIAL', 'PRIMARY KEY', 'FULLTEXT', 'KEY', 'PERIOD'}
PROFILE_TYPES: Dict[str, Sequence[Union[Sequence[str], str]]] = {'ALL': (), 'CPU': (), 'IPC': (), 'MEMORY': (), 'SOURCE': (), 'SWAPS': (), 'BLOCK': ('IO',), 'CONTEXT': ('SWITCHES',), 'PAGE': ('FAULTS',)}
TYPE_TOKENS = {<TokenType.DATETIME64: 'DATETIME64'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.CHAR: 'CHAR'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.SUPER: 'SUPER'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.NESTED: 'NESTED'>, <TokenType.UINT: 'UINT'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.IPV4: 'IPV4'>, <TokenType.MONEY: 'MONEY'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.SET: 'SET'>, <TokenType.TEXT: 'TEXT'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.MAP: 'MAP'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.INT256: 'INT256'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.JSON: 'JSON'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.NULL: 'NULL'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.TDIGEST: 'TDIGEST'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.BIT: 'BIT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.BINARY: 'BINARY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.NAME: 'NAME'>, <TokenType.DATE32: 'DATE32'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.INT: 'INT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.DATE: 'DATE'>, <TokenType.INT128: 'INT128'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.TIME: 'TIME'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UINT256: 'UINT256'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.JSONB: 'JSONB'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.INET: 'INET'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INT4RANGE: 'INT4RANGE'>}
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
COMMENT_TABLE_ALIAS_TOKENS
UPDATE_ALIAS_TOKENS
TRIM_TYPES
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_CONVERTER
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
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_UNION
UNION_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):
 673    class Generator(generator.Generator):
 674        INTERVAL_ALLOWS_PLURAL_FORM = False
 675        LOCKING_READS_SUPPORTED = True
 676        NULL_ORDERING_SUPPORTED = None
 677        JOIN_HINTS = False
 678        TABLE_HINTS = True
 679        DUPLICATE_KEY_UPDATE_WITH_SET = False
 680        QUERY_HINT_SEP = " "
 681        VALUES_AS_TABLE = False
 682        NVL2_SUPPORTED = False
 683        LAST_DAY_SUPPORTS_DATE_PART = False
 684        JSON_TYPE_REQUIRED_FOR_EXTRACTION = True
 685        JSON_PATH_BRACKETED_KEY_SUPPORTED = False
 686        JSON_KEY_VALUE_PAIR_SEP = ","
 687        SUPPORTS_TO_NUMBER = False
 688
 689        TRANSFORMS = {
 690            **generator.Generator.TRANSFORMS,
 691            exp.ArrayAgg: rename_func("GROUP_CONCAT"),
 692            exp.CurrentDate: no_paren_current_date_sql,
 693            exp.DateDiff: _remove_ts_or_ds_to_date(
 694                lambda self, e: self.func("DATEDIFF", e.this, e.expression), ("this", "expression")
 695            ),
 696            exp.DateAdd: _remove_ts_or_ds_to_date(date_add_sql("ADD")),
 697            exp.DateStrToDate: datestrtodate_sql,
 698            exp.DateSub: _remove_ts_or_ds_to_date(date_add_sql("SUB")),
 699            exp.DateTrunc: _date_trunc_sql,
 700            exp.Day: _remove_ts_or_ds_to_date(),
 701            exp.DayOfMonth: _remove_ts_or_ds_to_date(rename_func("DAYOFMONTH")),
 702            exp.DayOfWeek: _remove_ts_or_ds_to_date(rename_func("DAYOFWEEK")),
 703            exp.DayOfYear: _remove_ts_or_ds_to_date(rename_func("DAYOFYEAR")),
 704            exp.GroupConcat: lambda self,
 705            e: f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})""",
 706            exp.ILike: no_ilike_sql,
 707            exp.JSONExtractScalar: arrow_json_extract_sql,
 708            exp.Max: max_or_greatest,
 709            exp.Min: min_or_least,
 710            exp.Month: _remove_ts_or_ds_to_date(),
 711            exp.NullSafeEQ: lambda self, e: self.binary(e, "<=>"),
 712            exp.NullSafeNEQ: lambda self, e: f"NOT {self.binary(e, '<=>')}",
 713            exp.ParseJSON: lambda self, e: self.sql(e, "this"),
 714            exp.Pivot: no_pivot_sql,
 715            exp.Select: transforms.preprocess(
 716                [
 717                    transforms.eliminate_distinct_on,
 718                    transforms.eliminate_semi_and_anti_joins,
 719                    transforms.eliminate_qualify,
 720                    transforms.eliminate_full_outer_join,
 721                ]
 722            ),
 723            exp.StrPosition: strposition_to_locate_sql,
 724            exp.StrToDate: _str_to_date_sql,
 725            exp.StrToTime: _str_to_date_sql,
 726            exp.Stuff: rename_func("INSERT"),
 727            exp.TableSample: no_tablesample_sql,
 728            exp.TimeFromParts: rename_func("MAKETIME"),
 729            exp.TimestampAdd: date_add_interval_sql("DATE", "ADD"),
 730            exp.TimestampDiff: lambda self, e: self.func(
 731                "TIMESTAMPDIFF", unit_to_var(e), e.expression, e.this
 732            ),
 733            exp.TimestampSub: date_add_interval_sql("DATE", "SUB"),
 734            exp.TimeStrToUnix: rename_func("UNIX_TIMESTAMP"),
 735            exp.TimeStrToTime: lambda self, e: self.sql(
 736                exp.cast(e.this, exp.DataType.Type.DATETIME, copy=True)
 737            ),
 738            exp.TimeToStr: _remove_ts_or_ds_to_date(
 739                lambda self, e: self.func("DATE_FORMAT", e.this, self.format_time(e))
 740            ),
 741            exp.Trim: _trim_sql,
 742            exp.TryCast: no_trycast_sql,
 743            exp.TsOrDsAdd: date_add_sql("ADD"),
 744            exp.TsOrDsDiff: lambda self, e: self.func("DATEDIFF", e.this, e.expression),
 745            exp.TsOrDsToDate: _ts_or_ds_to_date_sql,
 746            exp.UnixToTime: _unix_to_time_sql,
 747            exp.Week: _remove_ts_or_ds_to_date(),
 748            exp.WeekOfYear: _remove_ts_or_ds_to_date(rename_func("WEEKOFYEAR")),
 749            exp.Year: _remove_ts_or_ds_to_date(),
 750        }
 751
 752        UNSIGNED_TYPE_MAPPING = {
 753            exp.DataType.Type.UBIGINT: "BIGINT",
 754            exp.DataType.Type.UINT: "INT",
 755            exp.DataType.Type.UMEDIUMINT: "MEDIUMINT",
 756            exp.DataType.Type.USMALLINT: "SMALLINT",
 757            exp.DataType.Type.UTINYINT: "TINYINT",
 758            exp.DataType.Type.UDECIMAL: "DECIMAL",
 759        }
 760
 761        TIMESTAMP_TYPE_MAPPING = {
 762            exp.DataType.Type.TIMESTAMP: "DATETIME",
 763            exp.DataType.Type.TIMESTAMPTZ: "TIMESTAMP",
 764            exp.DataType.Type.TIMESTAMPLTZ: "TIMESTAMP",
 765        }
 766
 767        TYPE_MAPPING = {
 768            **generator.Generator.TYPE_MAPPING,
 769            **UNSIGNED_TYPE_MAPPING,
 770            **TIMESTAMP_TYPE_MAPPING,
 771        }
 772
 773        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMTEXT)
 774        TYPE_MAPPING.pop(exp.DataType.Type.LONGTEXT)
 775        TYPE_MAPPING.pop(exp.DataType.Type.TINYTEXT)
 776        TYPE_MAPPING.pop(exp.DataType.Type.MEDIUMBLOB)
 777        TYPE_MAPPING.pop(exp.DataType.Type.LONGBLOB)
 778        TYPE_MAPPING.pop(exp.DataType.Type.TINYBLOB)
 779
 780        PROPERTIES_LOCATION = {
 781            **generator.Generator.PROPERTIES_LOCATION,
 782            exp.TransientProperty: exp.Properties.Location.UNSUPPORTED,
 783            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 784        }
 785
 786        LIMIT_FETCH = "LIMIT"
 787
 788        LIMIT_ONLY_LITERALS = True
 789
 790        CHAR_CAST_MAPPING = dict.fromkeys(
 791            (
 792                exp.DataType.Type.LONGTEXT,
 793                exp.DataType.Type.LONGBLOB,
 794                exp.DataType.Type.MEDIUMBLOB,
 795                exp.DataType.Type.MEDIUMTEXT,
 796                exp.DataType.Type.TEXT,
 797                exp.DataType.Type.TINYBLOB,
 798                exp.DataType.Type.TINYTEXT,
 799                exp.DataType.Type.VARCHAR,
 800            ),
 801            "CHAR",
 802        )
 803        SIGNED_CAST_MAPPING = dict.fromkeys(
 804            (
 805                exp.DataType.Type.BIGINT,
 806                exp.DataType.Type.BOOLEAN,
 807                exp.DataType.Type.INT,
 808                exp.DataType.Type.SMALLINT,
 809                exp.DataType.Type.TINYINT,
 810                exp.DataType.Type.MEDIUMINT,
 811            ),
 812            "SIGNED",
 813        )
 814
 815        # MySQL doesn't support many datatypes in cast.
 816        # https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_cast
 817        CAST_MAPPING = {
 818            **CHAR_CAST_MAPPING,
 819            **SIGNED_CAST_MAPPING,
 820            exp.DataType.Type.UBIGINT: "UNSIGNED",
 821        }
 822
 823        TIMESTAMP_FUNC_TYPES = {
 824            exp.DataType.Type.TIMESTAMPTZ,
 825            exp.DataType.Type.TIMESTAMPLTZ,
 826        }
 827
 828        # https://dev.mysql.com/doc/refman/8.0/en/keywords.html
 829        RESERVED_KEYWORDS = {
 830            "accessible",
 831            "add",
 832            "all",
 833            "alter",
 834            "analyze",
 835            "and",
 836            "as",
 837            "asc",
 838            "asensitive",
 839            "before",
 840            "between",
 841            "bigint",
 842            "binary",
 843            "blob",
 844            "both",
 845            "by",
 846            "call",
 847            "cascade",
 848            "case",
 849            "change",
 850            "char",
 851            "character",
 852            "check",
 853            "collate",
 854            "column",
 855            "condition",
 856            "constraint",
 857            "continue",
 858            "convert",
 859            "create",
 860            "cross",
 861            "cube",
 862            "cume_dist",
 863            "current_date",
 864            "current_time",
 865            "current_timestamp",
 866            "current_user",
 867            "cursor",
 868            "database",
 869            "databases",
 870            "day_hour",
 871            "day_microsecond",
 872            "day_minute",
 873            "day_second",
 874            "dec",
 875            "decimal",
 876            "declare",
 877            "default",
 878            "delayed",
 879            "delete",
 880            "dense_rank",
 881            "desc",
 882            "describe",
 883            "deterministic",
 884            "distinct",
 885            "distinctrow",
 886            "div",
 887            "double",
 888            "drop",
 889            "dual",
 890            "each",
 891            "else",
 892            "elseif",
 893            "empty",
 894            "enclosed",
 895            "escaped",
 896            "except",
 897            "exists",
 898            "exit",
 899            "explain",
 900            "false",
 901            "fetch",
 902            "first_value",
 903            "float",
 904            "float4",
 905            "float8",
 906            "for",
 907            "force",
 908            "foreign",
 909            "from",
 910            "fulltext",
 911            "function",
 912            "generated",
 913            "get",
 914            "grant",
 915            "group",
 916            "grouping",
 917            "groups",
 918            "having",
 919            "high_priority",
 920            "hour_microsecond",
 921            "hour_minute",
 922            "hour_second",
 923            "if",
 924            "ignore",
 925            "in",
 926            "index",
 927            "infile",
 928            "inner",
 929            "inout",
 930            "insensitive",
 931            "insert",
 932            "int",
 933            "int1",
 934            "int2",
 935            "int3",
 936            "int4",
 937            "int8",
 938            "integer",
 939            "intersect",
 940            "interval",
 941            "into",
 942            "io_after_gtids",
 943            "io_before_gtids",
 944            "is",
 945            "iterate",
 946            "join",
 947            "json_table",
 948            "key",
 949            "keys",
 950            "kill",
 951            "lag",
 952            "last_value",
 953            "lateral",
 954            "lead",
 955            "leading",
 956            "leave",
 957            "left",
 958            "like",
 959            "limit",
 960            "linear",
 961            "lines",
 962            "load",
 963            "localtime",
 964            "localtimestamp",
 965            "lock",
 966            "long",
 967            "longblob",
 968            "longtext",
 969            "loop",
 970            "low_priority",
 971            "master_bind",
 972            "master_ssl_verify_server_cert",
 973            "match",
 974            "maxvalue",
 975            "mediumblob",
 976            "mediumint",
 977            "mediumtext",
 978            "middleint",
 979            "minute_microsecond",
 980            "minute_second",
 981            "mod",
 982            "modifies",
 983            "natural",
 984            "not",
 985            "no_write_to_binlog",
 986            "nth_value",
 987            "ntile",
 988            "null",
 989            "numeric",
 990            "of",
 991            "on",
 992            "optimize",
 993            "optimizer_costs",
 994            "option",
 995            "optionally",
 996            "or",
 997            "order",
 998            "out",
 999            "outer",
1000            "outfile",
1001            "over",
1002            "partition",
1003            "percent_rank",
1004            "precision",
1005            "primary",
1006            "procedure",
1007            "purge",
1008            "range",
1009            "rank",
1010            "read",
1011            "reads",
1012            "read_write",
1013            "real",
1014            "recursive",
1015            "references",
1016            "regexp",
1017            "release",
1018            "rename",
1019            "repeat",
1020            "replace",
1021            "require",
1022            "resignal",
1023            "restrict",
1024            "return",
1025            "revoke",
1026            "right",
1027            "rlike",
1028            "row",
1029            "rows",
1030            "row_number",
1031            "schema",
1032            "schemas",
1033            "second_microsecond",
1034            "select",
1035            "sensitive",
1036            "separator",
1037            "set",
1038            "show",
1039            "signal",
1040            "smallint",
1041            "spatial",
1042            "specific",
1043            "sql",
1044            "sqlexception",
1045            "sqlstate",
1046            "sqlwarning",
1047            "sql_big_result",
1048            "sql_calc_found_rows",
1049            "sql_small_result",
1050            "ssl",
1051            "starting",
1052            "stored",
1053            "straight_join",
1054            "system",
1055            "table",
1056            "terminated",
1057            "then",
1058            "tinyblob",
1059            "tinyint",
1060            "tinytext",
1061            "to",
1062            "trailing",
1063            "trigger",
1064            "true",
1065            "undo",
1066            "union",
1067            "unique",
1068            "unlock",
1069            "unsigned",
1070            "update",
1071            "usage",
1072            "use",
1073            "using",
1074            "utc_date",
1075            "utc_time",
1076            "utc_timestamp",
1077            "values",
1078            "varbinary",
1079            "varchar",
1080            "varcharacter",
1081            "varying",
1082            "virtual",
1083            "when",
1084            "where",
1085            "while",
1086            "window",
1087            "with",
1088            "write",
1089            "xor",
1090            "year_month",
1091            "zerofill",
1092            "cume_dist",
1093            "dense_rank",
1094            "empty",
1095            "except",
1096            "first_value",
1097            "grouping",
1098            "groups",
1099            "intersect",
1100            "json_table",
1101            "lag",
1102            "last_value",
1103            "lateral",
1104            "lead",
1105            "nth_value",
1106            "ntile",
1107            "of",
1108            "over",
1109            "percent_rank",
1110            "rank",
1111            "recursive",
1112            "row_number",
1113            "system",
1114            "window",
1115        }
1116
1117        def array_sql(self, expression: exp.Array) -> str:
1118            self.unsupported("Arrays are not supported by MySQL")
1119            return self.function_fallback_sql(expression)
1120
1121        def arraycontainsall_sql(self, expression: exp.ArrayContainsAll) -> str:
1122            self.unsupported("Array operations are not supported by MySQL")
1123            return self.function_fallback_sql(expression)
1124
1125        def dpipe_sql(self, expression: exp.DPipe) -> str:
1126            return self.func("CONCAT", *expression.flatten())
1127
1128        def extract_sql(self, expression: exp.Extract) -> str:
1129            unit = expression.name
1130            if unit and unit.lower() == "epoch":
1131                return self.func("UNIX_TIMESTAMP", expression.expression)
1132
1133            return super().extract_sql(expression)
1134
1135        def datatype_sql(self, expression: exp.DataType) -> str:
1136            # https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
1137            result = super().datatype_sql(expression)
1138            if expression.this in self.UNSIGNED_TYPE_MAPPING:
1139                result = f"{result} UNSIGNED"
1140            return result
1141
1142        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
1143            return f"{self.sql(expression, 'this')} MEMBER OF({self.sql(expression, 'expression')})"
1144
1145        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1146            if expression.to.this in self.TIMESTAMP_FUNC_TYPES:
1147                return self.func("TIMESTAMP", expression.this)
1148
1149            to = self.CAST_MAPPING.get(expression.to.this)
1150
1151            if to:
1152                expression.to.set("this", to)
1153            return super().cast_sql(expression)
1154
1155        def show_sql(self, expression: exp.Show) -> str:
1156            this = f" {expression.name}"
1157            full = " FULL" if expression.args.get("full") else ""
1158            global_ = " GLOBAL" if expression.args.get("global") else ""
1159
1160            target = self.sql(expression, "target")
1161            target = f" {target}" if target else ""
1162            if expression.name in ("COLUMNS", "INDEX"):
1163                target = f" FROM{target}"
1164            elif expression.name == "GRANTS":
1165                target = f" FOR{target}"
1166
1167            db = self._prefixed_sql("FROM", expression, "db")
1168
1169            like = self._prefixed_sql("LIKE", expression, "like")
1170            where = self.sql(expression, "where")
1171
1172            types = self.expressions(expression, key="types")
1173            types = f" {types}" if types else types
1174            query = self._prefixed_sql("FOR QUERY", expression, "query")
1175
1176            if expression.name == "PROFILE":
1177                offset = self._prefixed_sql("OFFSET", expression, "offset")
1178                limit = self._prefixed_sql("LIMIT", expression, "limit")
1179            else:
1180                offset = ""
1181                limit = self._oldstyle_limit_sql(expression)
1182
1183            log = self._prefixed_sql("IN", expression, "log")
1184            position = self._prefixed_sql("FROM", expression, "position")
1185
1186            channel = self._prefixed_sql("FOR CHANNEL", expression, "channel")
1187
1188            if expression.name == "ENGINE":
1189                mutex_or_status = " MUTEX" if expression.args.get("mutex") else " STATUS"
1190            else:
1191                mutex_or_status = ""
1192
1193            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
1194
1195        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
1196            dtype = self.sql(expression, "dtype")
1197            if not dtype:
1198                return super().altercolumn_sql(expression)
1199
1200            this = self.sql(expression, "this")
1201            return f"MODIFY COLUMN {this} {dtype}"
1202
1203        def _prefixed_sql(self, prefix: str, expression: exp.Expression, arg: str) -> str:
1204            sql = self.sql(expression, arg)
1205            return f" {prefix} {sql}" if sql else ""
1206
1207        def _oldstyle_limit_sql(self, expression: exp.Show) -> str:
1208            limit = self.sql(expression, "limit")
1209            offset = self.sql(expression, "offset")
1210            if limit:
1211                limit_offset = f"{offset}, {limit}" if offset else limit
1212                return f" LIMIT {limit_offset}"
1213            return ""
1214
1215        def chr_sql(self, expression: exp.Chr) -> str:
1216            this = self.expressions(sqls=[expression.this] + expression.expressions)
1217            charset = expression.args.get("charset")
1218            using = f" USING {self.sql(charset)}" if charset else ""
1219            return f"CHAR({this}{using})"
1220
1221        def timestamptrunc_sql(self, expression: exp.TimestampTrunc) -> str:
1222            unit = expression.args.get("unit")
1223
1224            # Pick an old-enough date to avoid negative timestamp diffs
1225            start_ts = "'0000-01-01 00:00:00'"
1226
1227            # Source: https://stackoverflow.com/a/32955740
1228            timestamp_diff = build_date_delta(exp.TimestampDiff)([unit, start_ts, expression.this])
1229            interval = exp.Interval(this=timestamp_diff, unit=unit)
1230            dateadd = build_date_delta_with_interval(exp.DateAdd)([start_ts, interval])
1231
1232            return self.sql(dateadd)

Generator converts a given syntax tree to the corresponding SQL string.

Arguments:
  • pretty: Whether to format the produced SQL string. Default: False.
  • identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
  • normalize: Whether to normalize identifiers to lowercase. Default: False.
  • pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
  • indent: The indentation size in a formatted string. For example, this affects the indentation of subqueries and filters under a WHERE clause. Default: 2.
  • normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
  • unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
  • max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
  • leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
  • max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
  • comments: Whether to preserve comments in the output SQL code. Default: True
INTERVAL_ALLOWS_PLURAL_FORM = False
LOCKING_READS_SUPPORTED = True
NULL_ORDERING_SUPPORTED = None
JOIN_HINTS = False
TABLE_HINTS = True
DUPLICATE_KEY_UPDATE_WITH_SET = False
QUERY_HINT_SEP = ' '
VALUES_AS_TABLE = False
NVL2_SUPPORTED = False
LAST_DAY_SUPPORTS_DATE_PART = False
JSON_TYPE_REQUIRED_FOR_EXTRACTION = True
JSON_PATH_BRACKETED_KEY_SUPPORTED = False
JSON_KEY_VALUE_PAIR_SEP = ','
SUPPORTS_TO_NUMBER = False
TRANSFORMS = {<class 'sqlglot.expressions.JSONPathFilter'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathKey'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRecursive'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathRoot'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathScript'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSelector'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSlice'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathUnion'>: <function <lambda>>, <class 'sqlglot.expressions.JSONPathWildcard'>: <function <lambda>>, <class 'sqlglot.expressions.AllowedValuesProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EphemeralColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function arrow_json_extract_sql>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ProjectionPolicyColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StrictProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TagColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Timestamp'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ArrayAgg'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CurrentDate'>: <function no_paren_current_date_sql>, <class 'sqlglot.expressions.DateDiff'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DateAdd'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DateStrToDate'>: <function datestrtodate_sql>, <class 'sqlglot.expressions.DateSub'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DateTrunc'>: <function _date_trunc_sql>, <class 'sqlglot.expressions.Day'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DayOfMonth'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DayOfWeek'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.DayOfYear'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.GroupConcat'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.ILike'>: <function no_ilike_sql>, <class 'sqlglot.expressions.Max'>: <function max_or_greatest>, <class 'sqlglot.expressions.Min'>: <function min_or_least>, <class 'sqlglot.expressions.Month'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.NullSafeEQ'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.NullSafeNEQ'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.ParseJSON'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.Pivot'>: <function no_pivot_sql>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.StrPosition'>: <function strposition_to_locate_sql>, <class 'sqlglot.expressions.StrToDate'>: <function _str_to_date_sql>, <class 'sqlglot.expressions.StrToTime'>: <function _str_to_date_sql>, <class 'sqlglot.expressions.Stuff'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TableSample'>: <function no_tablesample_sql>, <class 'sqlglot.expressions.TimeFromParts'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimestampAdd'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimestampDiff'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.TimestampSub'>: <function date_add_interval_sql.<locals>.func>, <class 'sqlglot.expressions.TimeStrToUnix'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.TimeStrToTime'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.TimeToStr'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.Trim'>: <function _trim_sql>, <class 'sqlglot.expressions.TryCast'>: <function no_trycast_sql>, <class 'sqlglot.expressions.TsOrDsAdd'>: <function date_add_sql.<locals>.func>, <class 'sqlglot.expressions.TsOrDsDiff'>: <function MySQL.Generator.<lambda>>, <class 'sqlglot.expressions.TsOrDsToDate'>: <function _ts_or_ds_to_date_sql>, <class 'sqlglot.expressions.UnixToTime'>: <function _unix_to_time_sql>, <class 'sqlglot.expressions.Week'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.WeekOfYear'>: <function _remove_ts_or_ds_to_date.<locals>.func>, <class 'sqlglot.expressions.Year'>: <function _remove_ts_or_ds_to_date.<locals>.func>}
UNSIGNED_TYPE_MAPPING = {<Type.UBIGINT: 'UBIGINT'>: 'BIGINT', <Type.UINT: 'UINT'>: 'INT', <Type.UMEDIUMINT: 'UMEDIUMINT'>: 'MEDIUMINT', <Type.USMALLINT: 'USMALLINT'>: 'SMALLINT', <Type.UTINYINT: 'UTINYINT'>: 'TINYINT', <Type.UDECIMAL: 'UDECIMAL'>: 'DECIMAL'}
TIMESTAMP_TYPE_MAPPING = {<Type.TIMESTAMP: 'TIMESTAMP'>: 'DATETIME', <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'TIMESTAMP', <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>: 'TIMESTAMP'}
TYPE_MAPPING = {<Type.NCHAR: 'NCHAR'>: 'CHAR', <Type.NVARCHAR: 'NVARCHAR'>: 'VARCHAR', <Type.INET: 'INET'>: 'INET', <Type.ROWVERSION: 'ROWVERSION'>: 'VARBINARY', <Type.UBIGINT: 'UBIGINT'>: 'BIGINT', <Type.UINT: 'UINT'>: 'INT', <Type.UMEDIUMINT: 'UMEDIUMINT'>: 'MEDIUMINT', <Type.USMALLINT: 'USMALLINT'>: 'SMALLINT', <Type.UTINYINT: 'UTINYINT'>: 'TINYINT', <Type.UDECIMAL: 'UDECIMAL'>: 'DECIMAL', <Type.TIMESTAMP: 'TIMESTAMP'>: 'DATETIME', <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>: 'TIMESTAMP', <Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>: 'TIMESTAMP'}
PROPERTIES_LOCATION = {<class 'sqlglot.expressions.AllowedValuesProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.DataDeletionProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DefinerProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DictRange'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EngineProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExternalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.FallbackProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.FileFormatProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.FreespaceProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.GlobalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IcebergProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.InputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IsolatedLoadingProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.JournalProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.LanguageProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LikeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LocationProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockingProperty'>: <Location.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.LogProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.MaterializedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.MergeBlockRatioProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.OnProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCommitProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.Order'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OutputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedByProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.PartitionedOfProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PrimaryKey'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Property'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ReturnsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatDelimitedProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatSerdeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SampleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SerdeProperties'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Set'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SettingsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SetProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SetConfigProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SharingProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SequenceProperties'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SortKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StabilityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.StrictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TemporaryProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ToTableProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TransientProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.TransformModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.MergeTreeTTL'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.UnloggedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.VolatileProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithDataProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>}
LIMIT_FETCH = 'LIMIT'
LIMIT_ONLY_LITERALS = True
CHAR_CAST_MAPPING = {<Type.LONGTEXT: 'LONGTEXT'>: 'CHAR', <Type.LONGBLOB: 'LONGBLOB'>: 'CHAR', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'CHAR', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'CHAR', <Type.TEXT: 'TEXT'>: 'CHAR', <Type.TINYBLOB: 'TINYBLOB'>: 'CHAR', <Type.TINYTEXT: 'TINYTEXT'>: 'CHAR', <Type.VARCHAR: 'VARCHAR'>: 'CHAR'}
SIGNED_CAST_MAPPING = {<Type.BIGINT: 'BIGINT'>: 'SIGNED', <Type.BOOLEAN: 'BOOLEAN'>: 'SIGNED', <Type.INT: 'INT'>: 'SIGNED', <Type.SMALLINT: 'SMALLINT'>: 'SIGNED', <Type.TINYINT: 'TINYINT'>: 'SIGNED', <Type.MEDIUMINT: 'MEDIUMINT'>: 'SIGNED'}
CAST_MAPPING = {<Type.LONGTEXT: 'LONGTEXT'>: 'CHAR', <Type.LONGBLOB: 'LONGBLOB'>: 'CHAR', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'CHAR', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'CHAR', <Type.TEXT: 'TEXT'>: 'CHAR', <Type.TINYBLOB: 'TINYBLOB'>: 'CHAR', <Type.TINYTEXT: 'TINYTEXT'>: 'CHAR', <Type.VARCHAR: 'VARCHAR'>: 'CHAR', <Type.BIGINT: 'BIGINT'>: 'SIGNED', <Type.BOOLEAN: 'BOOLEAN'>: 'SIGNED', <Type.INT: 'INT'>: 'SIGNED', <Type.SMALLINT: 'SMALLINT'>: 'SIGNED', <Type.TINYINT: 'TINYINT'>: 'SIGNED', <Type.MEDIUMINT: 'MEDIUMINT'>: 'SIGNED', <Type.UBIGINT: 'UBIGINT'>: 'UNSIGNED'}
TIMESTAMP_FUNC_TYPES = {<Type.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <Type.TIMESTAMPTZ: 'TIMESTAMPTZ'>}
RESERVED_KEYWORDS = {'terminated', 'utc_timestamp', 'tinyint', 'infile', 'middleint', 'call', 'div', 'percent_rank', 'replace', 'databases', 'order', 'while', 'real', 'int2', 'first_value', 'as', 'then', 'read', 'where', 'check', 'on', 'mediumtext', 'fetch', 'sql_big_result', 'case', 'signal', 'when', 'between', 'is', 'join', 'both', 'reads', 'write', 'escaped', 'kill', 'master_ssl_verify_server_cert', 'in', 'release', 'current_date', 'default', 'day_hour', 'read_write', 'outfile', 'revoke', 'return', 'dec', 'enclosed', 'modifies', 'int4', 'day_minute', 'rlike', 'change', 'current_user', 'exists', 'limit', 'tinytext', 'maxvalue', 'schema', 'values', 'row', 'of', 'explain', 'having', 'collate', 'unique', 'day_second', 'system', 'select', 'over', 'loop', 'unsigned', 'continue', 'outer', 'match', 'separator', 'distinctrow', 'sensitive', 'undo', 'master_bind', 'asc', 'cube', 'double', 'current_timestamp', 'leading', 'like', 'require', 'regexp', 'natural', 'sqlstate', 'lead', 'all', 'each', 'integer', 'sqlwarning', 'int', 'inout', 'stored', 'lag', 'null', 'leave', 'insert', 'elseif', 'localtime', 'procedure', 'long', 'except', 'alter', 'varcharacter', 'primary', 'function', 'interval', 'precision', 'rename', 'rows', 'row_number', 'for', 'declare', 'mediumint', 'false', 'right', 'restrict', 'blob', 'inner', 'sql', 'mod', 'utc_date', 'delete', 'starting', 'analyze', 'true', 'varying', 'dense_rank', 'column', 'get', 'create', 'hour_minute', 'last_value', 'union', 'io_after_gtids', 'sqlexception', 'float4', 'tinyblob', 'purge', 'from', 'intersect', 'window', 'convert', 'force', 'cume_dist', 'binary', 'table', 'into', 'dual', 'cascade', 'asensitive', 'desc', 'zerofill', 'show', 'index', 'constraint', 'database', 'trigger', 'generated', 'specific', 'grouping', 'mediumblob', 'references', 'load', 'spatial', 'using', 'longtext', 'utc_time', 'virtual', 'exit', 'fulltext', 'high_priority', 'io_before_gtids', 'smallint', 'float8', 'numeric', 'out', 'with', 'no_write_to_binlog', 'set', 'foreign', 'minute_microsecond', 'iterate', 'bigint', 'and', 'use', 'float', 'else', 'character', 'describe', 'rank', 'if', 'nth_value', 'range', 'xor', 'recursive', 'unlock', 'usage', 'cross', 'deterministic', 'varchar', 'optimizer_costs', 'optimize', 'decimal', 'hour_microsecond', 'grant', 'groups', 'keys', 'low_priority', 'to', 'group', 'lines', 'linear', 'key', 'ntile', 'update', 'int3', 'drop', 'by', 'accessible', 'condition', 'resignal', 'sql_calc_found_rows', 'minute_second', 'longblob', 'current_time', 'day_microsecond', 'json_table', 'cursor', 'hour_second', 'not', 'or', 'ssl', 'repeat', 'lock', 'varbinary', 'straight_join', 'sql_small_result', 'int1', 'int8', 'schemas', 'year_month', 'lateral', 'trailing', 'insensitive', 'option', 'delayed', 'distinct', 'partition', 'add', 'ignore', 'optionally', 'before', 'char', 'empty', 'second_microsecond', 'localtimestamp', 'left'}
def array_sql(self, expression: sqlglot.expressions.Array) -> str:
1117        def array_sql(self, expression: exp.Array) -> str:
1118            self.unsupported("Arrays are not supported by MySQL")
1119            return self.function_fallback_sql(expression)
def arraycontainsall_sql(self, expression: sqlglot.expressions.ArrayContainsAll) -> str:
1121        def arraycontainsall_sql(self, expression: exp.ArrayContainsAll) -> str:
1122            self.unsupported("Array operations are not supported by MySQL")
1123            return self.function_fallback_sql(expression)
def dpipe_sql(self, expression: sqlglot.expressions.DPipe) -> str:
1125        def dpipe_sql(self, expression: exp.DPipe) -> str:
1126            return self.func("CONCAT", *expression.flatten())
def extract_sql(self, expression: sqlglot.expressions.Extract) -> str:
1128        def extract_sql(self, expression: exp.Extract) -> str:
1129            unit = expression.name
1130            if unit and unit.lower() == "epoch":
1131                return self.func("UNIX_TIMESTAMP", expression.expression)
1132
1133            return super().extract_sql(expression)
def datatype_sql(self, expression: sqlglot.expressions.DataType) -> str:
1135        def datatype_sql(self, expression: exp.DataType) -> str:
1136            # https://dev.mysql.com/doc/refman/8.0/en/numeric-type-syntax.html
1137            result = super().datatype_sql(expression)
1138            if expression.this in self.UNSIGNED_TYPE_MAPPING:
1139                result = f"{result} UNSIGNED"
1140            return result
def jsonarraycontains_sql(self, expression: sqlglot.expressions.JSONArrayContains) -> str:
1142        def jsonarraycontains_sql(self, expression: exp.JSONArrayContains) -> str:
1143            return f"{self.sql(expression, 'this')} MEMBER OF({self.sql(expression, 'expression')})"
def cast_sql( self, expression: sqlglot.expressions.Cast, safe_prefix: Optional[str] = None) -> str:
1145        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1146            if expression.to.this in self.TIMESTAMP_FUNC_TYPES:
1147                return self.func("TIMESTAMP", expression.this)
1148
1149            to = self.CAST_MAPPING.get(expression.to.this)
1150
1151            if to:
1152                expression.to.set("this", to)
1153            return super().cast_sql(expression)
def show_sql(self, expression: sqlglot.expressions.Show) -> str:
1155        def show_sql(self, expression: exp.Show) -> str:
1156            this = f" {expression.name}"
1157            full = " FULL" if expression.args.get("full") else ""
1158            global_ = " GLOBAL" if expression.args.get("global") else ""
1159
1160            target = self.sql(expression, "target")
1161            target = f" {target}" if target else ""
1162            if expression.name in ("COLUMNS", "INDEX"):
1163                target = f" FROM{target}"
1164            elif expression.name == "GRANTS":
1165                target = f" FOR{target}"
1166
1167            db = self._prefixed_sql("FROM", expression, "db")
1168
1169            like = self._prefixed_sql("LIKE", expression, "like")
1170            where = self.sql(expression, "where")
1171
1172            types = self.expressions(expression, key="types")
1173            types = f" {types}" if types else types
1174            query = self._prefixed_sql("FOR QUERY", expression, "query")
1175
1176            if expression.name == "PROFILE":
1177                offset = self._prefixed_sql("OFFSET", expression, "offset")
1178                limit = self._prefixed_sql("LIMIT", expression, "limit")
1179            else:
1180                offset = ""
1181                limit = self._oldstyle_limit_sql(expression)
1182
1183            log = self._prefixed_sql("IN", expression, "log")
1184            position = self._prefixed_sql("FROM", expression, "position")
1185
1186            channel = self._prefixed_sql("FOR CHANNEL", expression, "channel")
1187
1188            if expression.name == "ENGINE":
1189                mutex_or_status = " MUTEX" if expression.args.get("mutex") else " STATUS"
1190            else:
1191                mutex_or_status = ""
1192
1193            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
def altercolumn_sql(self, expression: sqlglot.expressions.AlterColumn) -> str:
1195        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
1196            dtype = self.sql(expression, "dtype")
1197            if not dtype:
1198                return super().altercolumn_sql(expression)
1199
1200            this = self.sql(expression, "this")
1201            return f"MODIFY COLUMN {this} {dtype}"
def chr_sql(self, expression: sqlglot.expressions.Chr) -> str:
1215        def chr_sql(self, expression: exp.Chr) -> str:
1216            this = self.expressions(sqls=[expression.this] + expression.expressions)
1217            charset = expression.args.get("charset")
1218            using = f" USING {self.sql(charset)}" if charset else ""
1219            return f"CHAR({this}{using})"
def timestamptrunc_sql(self, expression: sqlglot.expressions.TimestampTrunc) -> str:
1221        def timestamptrunc_sql(self, expression: exp.TimestampTrunc) -> str:
1222            unit = expression.args.get("unit")
1223
1224            # Pick an old-enough date to avoid negative timestamp diffs
1225            start_ts = "'0000-01-01 00:00:00'"
1226
1227            # Source: https://stackoverflow.com/a/32955740
1228            timestamp_diff = build_date_delta(exp.TimestampDiff)([unit, start_ts, expression.this])
1229            interval = exp.Interval(this=timestamp_diff, unit=unit)
1230            dateadd = build_date_delta_with_interval(exp.DateAdd)([start_ts, interval])
1231
1232            return self.sql(dateadd)
SELECT_KINDS: Tuple[str, ...] = ()
TRY_SUPPORTED = False
AFTER_HAVING_MODIFIER_TRANSFORMS = {'qualify': <function Generator.<lambda>>, 'windows': <function Generator.<lambda>>}
Inherited Members
sqlglot.generator.Generator
Generator
IGNORE_NULLS_IN_FUNC
EXPLICIT_UNION
WRAP_DERIVED_VALUES
CREATE_FUNCTION_RETURN_AS
MATCHED_BY_SOURCE
SINGLE_STRING_INTERVAL
RENAME_TABLE_WITH_DB
GROUPINGS_SEP
INDEX_ON
QUERY_HINTS
IS_BOOL_ALLOWED
LIMIT_IS_TOP
RETURNING_END
COLUMN_JOIN_MARKS_SUPPORTED
EXTRACT_ALLOWS_QUOTES
TZ_TO_WITH_TIME_ZONE
ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
UNNEST_WITH_ORDINALITY
AGGREGATE_FILTER_SUPPORTED
SEMI_ANTI_JOIN_WITH_SIDE
COMPUTED_COLUMN_WITH_TYPE
SUPPORTS_TABLE_COPY
TABLESAMPLE_REQUIRES_PARENS
TABLESAMPLE_SIZE_IS_ROWS
TABLESAMPLE_KEYWORDS
TABLESAMPLE_WITH_METHOD
TABLESAMPLE_SEED_KEYWORD
COLLATE_IS_FUNC
DATA_TYPE_SPECIFIERS_ALLOWED
ENSURE_BOOLS
CTE_RECURSIVE_KEYWORD_REQUIRED
SUPPORTS_SINGLE_ARG_CONCAT
SUPPORTS_TABLE_ALIAS_COLUMNS
UNPIVOT_ALIASES_ARE_IDENTIFIERS
INSERT_OVERWRITE
SUPPORTS_SELECT_INTO
SUPPORTS_UNLOGGED_TABLES
SUPPORTS_CREATE_TABLE_LIKE
LIKE_PROPERTY_INSIDE_SCHEMA
MULTI_ARG_DISTINCT
JSON_PATH_SINGLE_QUOTE_ESCAPE
SUPPORTED_JSON_PATH_PARTS
CAN_IMPLEMENT_ARRAY_ANY
OUTER_UNION_MODIFIERS
COPY_PARAMS_ARE_WRAPPED
COPY_PARAMS_EQ_REQUIRED
COPY_HAS_INTO_KEYWORD
STAR_EXCEPT
HEX_FUNC
WITH_PROPERTIES_PREFIX
TIME_PART_SINGULARS
TOKEN_MAPPING
STRUCT_DELIMITER
PARAMETER_TOKEN
NAMED_PLACEHOLDER_TOKEN
WITH_SEPARATED_COMMENTS
EXCLUDE_COMMENTS
UNWRAPPED_INTERVAL_VALUES
PARAMETERIZABLE_TEXT_TYPES
EXPRESSIONS_WITHOUT_NESTED_CTES
SENTINEL_LINE_BREAK
pretty
identify
normalize
pad
unsupported_level
max_unsupported
leading_comma
max_text_width
comments
dialect
normalize_functions
unsupported_messages
generate
preprocess
unsupported
sep
seg
pad_comment
maybe_comment
wrap
no_identify
normalize_func
indent
sql
uncache_sql
cache_sql
characterset_sql
column_parts
column_sql
columnposition_sql
columndef_sql
columnconstraint_sql
computedcolumnconstraint_sql
autoincrementcolumnconstraint_sql
compresscolumnconstraint_sql
generatedasidentitycolumnconstraint_sql
generatedasrowcolumnconstraint_sql
periodforsystemtimeconstraint_sql
notnullcolumnconstraint_sql
transformcolumnconstraint_sql
primarykeycolumnconstraint_sql
uniquecolumnconstraint_sql
createable_sql
create_sql
sequenceproperties_sql
clone_sql
describe_sql
heredoc_sql
prepend_ctes
with_sql
cte_sql
tablealias_sql
bitstring_sql
hexstring_sql
bytestring_sql
unicodestring_sql
rawstring_sql
datatypeparam_sql
directory_sql
delete_sql
drop_sql
except_sql
except_op
fetch_sql
filter_sql
hint_sql
indexparameters_sql
index_sql
identifier_sql
hex_sql
lowerhex_sql
inputoutputformat_sql
national_sql
partition_sql
properties_sql
root_properties
properties
with_properties
locate_properties
property_name
property_sql
likeproperty_sql
fallbackproperty_sql
journalproperty_sql
freespaceproperty_sql
checksumproperty_sql
mergeblockratioproperty_sql
datablocksizeproperty_sql
blockcompressionproperty_sql
isolatedloadingproperty_sql
partitionboundspec_sql
partitionedofproperty_sql
lockingproperty_sql
withdataproperty_sql
withsystemversioningproperty_sql
insert_sql
intersect_sql
intersect_op
introducer_sql
kill_sql
pseudotype_sql
objectidentifier_sql
onconflict_sql
returning_sql
rowformatdelimitedproperty_sql
withtablehint_sql
indextablehint_sql
historicaldata_sql
table_parts
table_sql
tablesample_sql
pivot_sql
version_sql
tuple_sql
update_sql
values_sql
var_sql
into_sql
from_sql
group_sql
having_sql
connect_sql
prior_sql
join_sql
lambda_sql
lateral_op
lateral_sql
limit_sql
offset_sql
setitem_sql
set_sql
pragma_sql
lock_sql
literal_sql
escape_str
loaddata_sql
null_sql
boolean_sql
order_sql
withfill_sql
cluster_sql
distribute_sql
sort_sql
ordered_sql
matchrecognizemeasure_sql
matchrecognize_sql
query_modifiers
queryoption_sql
offset_limit_modifiers
after_limit_modifiers
select_sql
schema_sql
schema_columns_sql
star_sql
parameter_sql
sessionparameter_sql
placeholder_sql
subquery_sql
qualify_sql
set_operations
union_sql
union_op
unnest_sql
prewhere_sql
where_sql
window_sql
partition_by_sql
windowspec_sql
withingroup_sql
between_sql
bracket_offset_expressions
bracket_sql
all_sql
any_sql
exists_sql
case_sql
constraint_sql
nextvaluefor_sql
trim_sql
convert_concat_args
concat_sql
concatws_sql
check_sql
foreignkey_sql
primarykey_sql
if_sql
matchagainst_sql
jsonkeyvalue_sql
jsonpath_sql
json_path_part
formatjson_sql
jsonobject_sql
jsonobjectagg_sql
jsonarray_sql
jsonarrayagg_sql
jsoncolumndef_sql
jsonschema_sql
jsontable_sql
openjsoncolumndef_sql
openjson_sql
in_sql
in_unnest_op
interval_sql
return_sql
reference_sql
anonymous_sql
paren_sql
neg_sql
not_sql
alias_sql
pivotalias_sql
aliases_sql
atindex_sql
attimezone_sql
fromtimezone_sql
add_sql
and_sql
or_sql
xor_sql
connector_sql
bitwiseand_sql
bitwiseleftshift_sql
bitwisenot_sql
bitwiseor_sql
bitwiserightshift_sql
bitwisexor_sql
currentdate_sql
currenttimestamp_sql
collate_sql
command_sql
comment_sql
mergetreettlaction_sql
mergetreettl_sql
transaction_sql
commit_sql
rollback_sql
alterdiststyle_sql
altersortkey_sql
renametable_sql
renamecolumn_sql
alterset_sql
altertable_sql
add_column_sql
droppartition_sql
addconstraint_sql
distinct_sql
ignorenulls_sql
respectnulls_sql
havingmax_sql
intdiv_sql
div_sql
overlaps_sql
distance_sql
dot_sql
eq_sql
propertyeq_sql
escape_sql
glob_sql
gt_sql
gte_sql
ilike_sql
ilikeany_sql
is_sql
like_sql
likeany_sql
similarto_sql
lt_sql
lte_sql
mod_sql
mul_sql
neq_sql
nullsafeeq_sql
nullsafeneq_sql
slice_sql
sub_sql
trycast_sql
try_sql
log_sql
use_sql
binary
function_fallback_sql
func
format_args
too_wide
format_time
expressions
op_expressions
naked_property
tag_sql
token_sql
userdefinedfunction_sql
joinhint_sql
kwarg_sql
when_sql
merge_sql
tochar_sql
tonumber_sql
dictproperty_sql
dictrange_sql
dictsubproperty_sql
oncluster_sql
clusteredbyproperty_sql
anyvalue_sql
querytransform_sql
indexconstraintoption_sql
checkcolumnconstraint_sql
indexcolumnconstraint_sql
nvl2_sql
comprehension_sql
columnprefix_sql
opclass_sql
predict_sql
forin_sql
refresh_sql
operator_sql
toarray_sql
tsordstotime_sql
tsordstotimestamp_sql
tsordstodate_sql
unixdate_sql
lastday_sql
dateadd_sql
arrayany_sql
generateseries_sql
struct_sql
partitionrange_sql
truncatetable_sql
convert_sql
copyparameter_sql
credentials_sql
copy_sql
semicolon_sql
datadeletionproperty_sql
maskingpolicycolumnconstraint_sql