sqlglot.parsers.mysql

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp, parser
  6from sqlglot.trie import new_trie
  7from sqlglot.dialects.dialect import (
  8    Dialect,
  9    build_date_delta,
 10    build_date_delta_with_interval,
 11    build_formatted_time,
 12    isnull_to_is_null,
 13)
 14from sqlglot.helper import seq_get
 15from sqlglot.tokens import TokenType
 16
 17
 18# All specifiers for time parts (as opposed to date parts)
 19# https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format
 20TIME_SPECIFIERS = {"f", "H", "h", "I", "i", "k", "l", "p", "r", "S", "s", "T"}
 21
 22
 23def _has_time_specifier(date_format: str) -> bool:
 24    i = 0
 25    length = len(date_format)
 26
 27    while i < length:
 28        if date_format[i] == "%":
 29            i += 1
 30            if i < length and date_format[i] in TIME_SPECIFIERS:
 31                return True
 32        i += 1
 33    return False
 34
 35
 36def _str_to_date(args: list) -> exp.StrToDate | exp.StrToTime:
 37    mysql_date_format = seq_get(args, 1)
 38    date_format = Dialect["mysql"].format_time(mysql_date_format)
 39    this = seq_get(args, 0)
 40
 41    if mysql_date_format and _has_time_specifier(mysql_date_format.name):
 42        return exp.StrToTime(this=this, format=date_format)
 43
 44    return exp.StrToDate(this=this, format=date_format)
 45
 46
 47def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[MySQLParser], exp.Show]:
 48    def _parse(self: MySQLParser) -> exp.Show:
 49        return self._parse_show_mysql(*args, **kwargs)
 50
 51    return _parse
 52
 53
 54class MySQLParser(parser.Parser):
 55    NO_PAREN_FUNCTIONS = {
 56        **parser.Parser.NO_PAREN_FUNCTIONS,
 57        TokenType.LOCALTIME: exp.Localtime,
 58        TokenType.LOCALTIMESTAMP: exp.Localtimestamp,
 59    }
 60
 61    ID_VAR_TOKENS = parser.Parser.ID_VAR_TOKENS - {TokenType.STRAIGHT_JOIN}
 62
 63    FUNC_TOKENS = {
 64        *parser.Parser.FUNC_TOKENS,
 65        TokenType.DATABASE,
 66        TokenType.MOD,
 67        TokenType.SCHEMA,
 68        TokenType.VALUES,
 69        TokenType.CHARACTER_SET,
 70    }
 71
 72    CONJUNCTION = {
 73        **parser.Parser.CONJUNCTION,
 74        TokenType.DAMP: exp.And,
 75        TokenType.XOR: exp.Xor,
 76    }
 77
 78    DISJUNCTION = {
 79        **parser.Parser.DISJUNCTION,
 80        TokenType.DPIPE: exp.Or,
 81    }
 82
 83    TABLE_ALIAS_TOKENS = (
 84        (parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.ANTI, TokenType.SEMI})
 85        - parser.Parser.TABLE_INDEX_HINT_TOKENS
 86        - {TokenType.STRAIGHT_JOIN}
 87    )
 88
 89    RANGE_PARSERS = {
 90        **parser.Parser.RANGE_PARSERS,
 91        TokenType.MEMBER_OF: lambda self, this: self.expression(
 92            exp.JSONArrayContains(this=this, expression=self._parse_wrapped(self._parse_expression))
 93        ),
 94    }
 95
 96    FUNCTIONS = {
 97        **parser.Parser.FUNCTIONS,
 98        "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
 99        "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
100        "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
101        "BIT_COUNT": exp.BitwiseCount.from_arg_list,
102        "CONVERT_TZ": lambda args: exp.ConvertTimezone(
103            source_tz=seq_get(args, 1), target_tz=seq_get(args, 2), timestamp=seq_get(args, 0)
104        ),
105        "CURDATE": exp.CurrentDate.from_arg_list,
106        "CURTIME": exp.CurrentTime.from_arg_list,
107        "DATE": lambda args: exp.TsOrDsToDate(this=seq_get(args, 0)),
108        "DATEDIFF": lambda args: exp.DateDiff(
109            this=seq_get(args, 0), expression=seq_get(args, 1), date_part_boundary=True
110        ),
111        "DATE_ADD": build_date_delta_with_interval(exp.DateAdd),
112        "DATE_FORMAT": lambda args: exp.TimeToStr(
113            this=exp.TsOrDsToTimestamp(this=seq_get(args, 0)),
114            format=Dialect["mysql"].format_time(seq_get(args, 1)),
115        ),
116        "DATE_SUB": build_date_delta_with_interval(exp.DateSub),
117        "DAY": lambda args: exp.Day(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
118        "DAYOFMONTH": lambda args: exp.DayOfMonth(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
119        "DAYOFWEEK": lambda args: exp.DayOfWeek(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
120        "DAYOFYEAR": lambda args: exp.DayOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
121        "FORMAT": exp.NumberToStr.from_arg_list,
122        "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime),
123        "ISNULL": isnull_to_is_null,
124        "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
125        "MAKETIME": exp.TimeFromParts.from_arg_list,
126        "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
127        "MONTHNAME": lambda args: exp.TimeToStr(
128            this=exp.TsOrDsToDate(this=seq_get(args, 0)),
129            format=exp.Literal.string("%B"),
130        ),
131        "SCHEMA": exp.CurrentSchema.from_arg_list,
132        "DATABASE": exp.CurrentSchema.from_arg_list,
133        "STR_TO_DATE": _str_to_date,
134        "TIMESTAMPDIFF": build_date_delta(exp.TimestampDiff),
135        "TO_DAYS": lambda args: exp.paren(
136            exp.DateDiff(
137                this=exp.TsOrDsToDate(this=seq_get(args, 0)),
138                expression=exp.TsOrDsToDate(this=exp.Literal.string("0000-01-01")),
139                unit=exp.var("DAY"),
140            )
141            + 1
142        ),
143        "VERSION": exp.CurrentVersion.from_arg_list,
144        "WEEK": lambda args: exp.Week(
145            this=exp.TsOrDsToDate(this=seq_get(args, 0)), mode=seq_get(args, 1)
146        ),
147        "WEEKOFYEAR": lambda args: exp.WeekOfYear(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
148        "YEAR": lambda args: exp.Year(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
149    }
150
151    FUNCTION_PARSERS = {
152        **parser.Parser.FUNCTION_PARSERS,
153        "GROUP_CONCAT": lambda self: self._parse_group_concat(),
154        # https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
155        "VALUES": lambda self: self.expression(
156            exp.Anonymous(this="VALUES", expressions=[self._parse_id_var()])
157        ),
158        "JSON_VALUE": lambda self: self._parse_json_value(),
159        "SUBSTR": lambda self: self._parse_substring(),
160    }
161
162    STATEMENT_PARSERS = {
163        **parser.Parser.STATEMENT_PARSERS,
164        TokenType.SHOW: lambda self: self._parse_show(),
165    }
166
167    SHOW_PARSERS = {
168        "BINARY LOGS": _show_parser("BINARY LOGS"),
169        "MASTER LOGS": _show_parser("BINARY LOGS"),
170        "BINLOG EVENTS": _show_parser("BINLOG EVENTS"),
171        "CHARACTER SET": _show_parser("CHARACTER SET"),
172        "CHARSET": _show_parser("CHARACTER SET"),
173        "COLLATION": _show_parser("COLLATION"),
174        "FULL COLUMNS": _show_parser("COLUMNS", target="FROM", full=True),
175        "COLUMNS": _show_parser("COLUMNS", target="FROM"),
176        "CREATE DATABASE": _show_parser("CREATE DATABASE", target=True),
177        "CREATE EVENT": _show_parser("CREATE EVENT", target=True),
178        "CREATE FUNCTION": _show_parser("CREATE FUNCTION", target=True),
179        "CREATE PROCEDURE": _show_parser("CREATE PROCEDURE", target=True),
180        "CREATE TABLE": _show_parser("CREATE TABLE", target=True),
181        "CREATE TRIGGER": _show_parser("CREATE TRIGGER", target=True),
182        "CREATE VIEW": _show_parser("CREATE VIEW", target=True),
183        "DATABASES": _show_parser("DATABASES"),
184        "SCHEMAS": _show_parser("DATABASES"),
185        "ENGINE": _show_parser("ENGINE", target=True),
186        "STORAGE ENGINES": _show_parser("ENGINES"),
187        "ENGINES": _show_parser("ENGINES"),
188        "ERRORS": _show_parser("ERRORS"),
189        "EVENTS": _show_parser("EVENTS"),
190        "FUNCTION CODE": _show_parser("FUNCTION CODE", target=True),
191        "FUNCTION STATUS": _show_parser("FUNCTION STATUS"),
192        "GRANTS": _show_parser("GRANTS", target="FOR"),
193        "INDEX": _show_parser("INDEX", target="FROM"),
194        "MASTER STATUS": _show_parser("MASTER STATUS"),
195        "OPEN TABLES": _show_parser("OPEN TABLES"),
196        "PLUGINS": _show_parser("PLUGINS"),
197        "PROCEDURE CODE": _show_parser("PROCEDURE CODE", target=True),
198        "PROCEDURE STATUS": _show_parser("PROCEDURE STATUS"),
199        "PRIVILEGES": _show_parser("PRIVILEGES"),
200        "FULL PROCESSLIST": _show_parser("PROCESSLIST", full=True),
201        "PROCESSLIST": _show_parser("PROCESSLIST"),
202        "PROFILE": _show_parser("PROFILE"),
203        "PROFILES": _show_parser("PROFILES"),
204        "RELAYLOG EVENTS": _show_parser("RELAYLOG EVENTS"),
205        "REPLICAS": _show_parser("REPLICAS"),
206        "SLAVE HOSTS": _show_parser("REPLICAS"),
207        "REPLICA STATUS": _show_parser("REPLICA STATUS"),
208        "SLAVE STATUS": _show_parser("REPLICA STATUS"),
209        "GLOBAL STATUS": _show_parser("STATUS", global_=True),
210        "SESSION STATUS": _show_parser("STATUS"),
211        "STATUS": _show_parser("STATUS"),
212        "TABLE STATUS": _show_parser("TABLE STATUS"),
213        "FULL TABLES": _show_parser("TABLES", full=True),
214        "TABLES": _show_parser("TABLES"),
215        "TRIGGERS": _show_parser("TRIGGERS"),
216        "GLOBAL VARIABLES": _show_parser("VARIABLES", global_=True),
217        "SESSION VARIABLES": _show_parser("VARIABLES"),
218        "VARIABLES": _show_parser("VARIABLES"),
219        "WARNINGS": _show_parser("WARNINGS"),
220    }
221
222    PROPERTY_PARSERS = {
223        **parser.Parser.PROPERTY_PARSERS,
224        "LOCK": lambda self: self._parse_property_assignment(exp.LockProperty),
225        "PARTITION BY": lambda self: self._parse_partition_property(),
226    }
227
228    SET_PARSERS = {
229        **parser.Parser.SET_PARSERS,
230        "PERSIST": lambda self: self._parse_set_item_assignment("PERSIST"),
231        "PERSIST_ONLY": lambda self: self._parse_set_item_assignment("PERSIST_ONLY"),
232        "CHARACTER SET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
233        "CHARSET": lambda self: self._parse_set_item_charset("CHARACTER SET"),
234        "NAMES": lambda self: self._parse_set_item_names(),
235    }
236
237    SHOW_TRIE = new_trie(key.split(" ") for key in SHOW_PARSERS)
238    SET_TRIE = new_trie(key.split(" ") for key in SET_PARSERS)
239
240    CONSTRAINT_PARSERS = {
241        **parser.Parser.CONSTRAINT_PARSERS,
242        "FULLTEXT": lambda self: self._parse_index_constraint(kind="FULLTEXT"),
243        "INDEX": lambda self: self._parse_index_constraint(),
244        "KEY": lambda self: self._parse_index_constraint(),
245        "SPATIAL": lambda self: self._parse_index_constraint(kind="SPATIAL"),
246        "ZEROFILL": lambda self: self.expression(exp.ZeroFillColumnConstraint()),
247        "INVISIBLE": lambda self: self.expression(exp.InvisibleColumnConstraint()),
248    }
249
250    ALTER_PARSERS = {
251        **parser.Parser.ALTER_PARSERS,
252        "CHANGE": lambda self: self._parse_alter_table_modify(rename=True),
253        "MODIFY": lambda self: self._parse_alter_table_modify(),
254        "AUTO_INCREMENT": lambda self: self._parse_property_assignment(exp.AutoIncrementProperty),
255    }
256
257    ALTER_ALTER_PARSERS = {
258        **parser.Parser.ALTER_ALTER_PARSERS,
259        "INDEX": lambda self: self._parse_alter_table_alter_index(),
260    }
261
262    SCHEMA_UNNAMED_CONSTRAINTS = {
263        *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS,
264        "FULLTEXT",
265        "INDEX",
266        "KEY",
267        "SPATIAL",
268    }
269
270    PROFILE_TYPES: parser.OPTIONS_TYPE = {
271        **dict.fromkeys(("ALL", "CPU", "IPC", "MEMORY", "SOURCE", "SWAPS"), tuple()),
272        "BLOCK": ("IO",),
273        "CONTEXT": ("SWITCHES",),
274        "PAGE": ("FAULTS",),
275    }
276
277    TYPE_TOKENS = {
278        *parser.Parser.TYPE_TOKENS,
279        TokenType.SET,
280    }
281
282    ENUM_TYPE_TOKENS = {
283        *parser.Parser.ENUM_TYPE_TOKENS,
284        TokenType.SET,
285    }
286
287    # SELECT [ ALL | DISTINCT | DISTINCTROW ] [ <OPERATION_MODIFIERS> ]
288    OPERATION_MODIFIERS = {
289        "HIGH_PRIORITY",
290        "STRAIGHT_JOIN",
291        "SQL_SMALL_RESULT",
292        "SQL_BIG_RESULT",
293        "SQL_BUFFER_RESULT",
294        "SQL_NO_CACHE",
295        "SQL_CALC_FOUND_ROWS",
296    }
297
298    LOG_DEFAULTS_TO_LN = True
299    STRING_ALIASES = True
300    VALUES_FOLLOWED_BY_PAREN = False
301    SUPPORTS_PARTITION_SELECTION = True
302
303    def _parse_range(self, this: exp.Expr | None = None) -> exp.Expr | None:
304        this = this or self._parse_bitwise()
305
306        if self._match_text_seq("SOUNDS", "LIKE"):
307            this = self.expression(
308                exp.EQ(
309                    this=self.expression(exp.Soundex(this=this)),
310                    expression=self.expression(exp.Soundex(this=self._parse_bitwise())),
311                )
312            )
313            # MySQL evaluates = and IS left to right because they have the same precedence.
314            if self._match(TokenType.IS, advance=False):
315                this = self.expression(exp.Paren(this=this))
316
317        return super()._parse_range(this)
318
319    def _parse_alter_table_rename(self):
320        if self._match_texts(("INDEX", "KEY")):
321            old = self._parse_field(any_token=True)
322            self._match_text_seq("TO")
323            new = self._parse_field(any_token=True)
324            return self.expression(exp.RenameIndex(this=old, to=new))
325        return super()._parse_alter_table_rename()
326
327    def _parse_alter_drop_action(self) -> exp.Expr | None:
328        if self._match_pair(TokenType.DROP, TokenType.PRIMARY_KEY):
329            return self.expression(exp.DropPrimaryKey())
330        return super()._parse_alter_drop_action()
331
332    def _parse_alter_table_modify(self, rename: bool = False) -> exp.Expr | None:
333        # MODIFY [COLUMN]            col_name      column_definition [FIRST | AFTER col_name]
334        # CHANGE [COLUMN] old_col_name new_col_name column_definition [FIRST | AFTER col_name]
335        self._match(TokenType.COLUMN)
336
337        column = self._parse_field(any_token=True)
338        if column is None:
339            return None
340
341        rename_from = None
342        if rename:
343            rename_from = column
344            column = self._parse_field(any_token=True)
345            if column is None:
346                return None
347
348        column_def = self._parse_column_def(column)
349        if not isinstance(column_def, exp.ColumnDef):
350            return None
351
352        return self.expression(exp.ModifyColumn(this=column_def, rename_from=rename_from))
353
354    def _parse_generated_as_identity(
355        self,
356    ) -> (
357        exp.GeneratedAsIdentityColumnConstraint
358        | exp.ComputedColumnConstraint
359        | exp.GeneratedAsRowColumnConstraint
360    ):
361        this = super()._parse_generated_as_identity()
362
363        if self._match_texts(("STORED", "VIRTUAL")):
364            persisted = self._prev.text.upper() == "STORED"
365
366            if isinstance(this, exp.ComputedColumnConstraint):
367                this.set("persisted", persisted)
368            elif isinstance(this, exp.GeneratedAsIdentityColumnConstraint):
369                this = self.expression(
370                    exp.ComputedColumnConstraint(this=this.expression, persisted=persisted)
371                )
372
373        return this
374
375    def _parse_primary_key_part(self) -> exp.Expr | None:
376        this = self._parse_id_var()
377        if not self._match(TokenType.L_PAREN):
378            return this
379
380        expression = self._parse_number()
381        self._match_r_paren()
382        return self.expression(exp.ColumnPrefix(this=this, expression=expression))
383
384    def _parse_index_constraint(self, kind: str | None = None) -> exp.IndexColumnConstraint:
385        if kind:
386            self._match_texts(("INDEX", "KEY"))
387
388        this = self._parse_id_var(any_token=False)
389        index_type = self._match(TokenType.USING) and self._advance_any() and self._prev.text
390        expressions = self._parse_wrapped_csv(self._parse_ordered)
391
392        options = []
393        while True:
394            if self._match_text_seq("KEY_BLOCK_SIZE"):
395                self._match(TokenType.EQ)
396                opt = exp.IndexConstraintOption(key_block_size=self._parse_number())
397            elif self._match(TokenType.USING):
398                opt = exp.IndexConstraintOption(using=self._advance_any() and self._prev.text)
399            elif self._match_text_seq("WITH", "PARSER"):
400                opt = exp.IndexConstraintOption(parser=self._parse_var(any_token=True))
401            elif self._match(TokenType.COMMENT):
402                opt = exp.IndexConstraintOption(comment=self._parse_string())
403            elif self._match_text_seq("VISIBLE"):
404                opt = exp.IndexConstraintOption(visible=True)
405            elif self._match_text_seq("INVISIBLE"):
406                opt = exp.IndexConstraintOption(visible=False)
407            elif self._match_text_seq("ENGINE_ATTRIBUTE"):
408                self._match(TokenType.EQ)
409                opt = exp.IndexConstraintOption(engine_attr=self._parse_string())
410            elif self._match_text_seq("SECONDARY_ENGINE_ATTRIBUTE"):
411                self._match(TokenType.EQ)
412                opt = exp.IndexConstraintOption(secondary_engine_attr=self._parse_string())
413            else:
414                opt = None
415
416            if not opt:
417                break
418
419            options.append(opt)
420
421        return self.expression(
422            exp.IndexColumnConstraint(
423                this=this,
424                expressions=expressions,
425                kind=kind,
426                index_type=index_type,
427                options=options,
428            )
429        )
430
431    def _parse_show_mysql(
432        self,
433        this: str,
434        target: bool | str = False,
435        full: bool | None = None,
436        global_: bool | None = None,
437    ) -> exp.Show:
438        json = self._match_text_seq("JSON")
439
440        if target:
441            if isinstance(target, str):
442                self._match_text_seq(*target.split(" "))
443            target_id = self._parse_id_var()
444        else:
445            target_id = None
446
447        index = self._index
448        if self._match_text_seq("IN"):
449            log = self._parse_string()
450            if log is None:
451                self._retreat(index)
452        else:
453            log = None
454
455        if this in ("BINLOG EVENTS", "RELAYLOG EVENTS"):
456            position = self._parse_number() if self._match_text_seq("FROM") else None
457            db = None
458        else:
459            position = None
460            db = None
461
462            if self._match(TokenType.FROM) or self._match_text_seq("IN"):
463                db = self._parse_id_var()
464            elif self._match(TokenType.DOT):
465                db = target_id
466                target_id = self._parse_id_var()
467
468        channel = self._parse_id_var() if self._match_text_seq("FOR", "CHANNEL") else None
469
470        like = self._parse_string() if self._match_text_seq("LIKE") else None
471        where = self._parse_where()
472
473        if this == "PROFILE":
474            types = self._parse_csv(lambda: self._parse_var_from_options(self.PROFILE_TYPES))
475            query = self._parse_number() if self._match_text_seq("FOR", "QUERY") else None
476            offset = self._parse_number() if self._match_text_seq("OFFSET") else None
477            limit = self._parse_number() if self._match_text_seq("LIMIT") else None
478        else:
479            types, query = None, None
480            offset, limit = self._parse_oldstyle_limit()
481
482        mutex = True if self._match_text_seq("MUTEX") else None
483        mutex = False if self._match_text_seq("STATUS") else mutex
484
485        for_table = self._parse_id_var() if self._match_text_seq("FOR", "TABLE") else None
486        for_group = self._parse_string() if self._match_text_seq("FOR", "GROUP") else None
487        for_user = self._parse_string() if self._match_text_seq("FOR", "USER") else None
488        for_role = self._parse_string() if self._match_text_seq("FOR", "ROLE") else None
489        into_outfile = self._parse_string() if self._match_text_seq("INTO", "OUTFILE") else None
490
491        return self.expression(
492            exp.Show(
493                this=this,
494                target=target_id,
495                full=full,
496                log=log,
497                position=position,
498                db=db,
499                channel=channel,
500                like=like,
501                where=where,
502                types=types,
503                query=query,
504                offset=offset,
505                limit=limit,
506                mutex=mutex,
507                for_table=for_table,
508                for_group=for_group,
509                for_user=for_user,
510                for_role=for_role,
511                into_outfile=into_outfile,
512                json=json,
513                global_=global_,
514            )
515        )
516
517    def _parse_oldstyle_limit(
518        self,
519    ) -> tuple[exp.Expr | None, exp.Expr | None]:
520        limit = None
521        offset = None
522        if self._match_text_seq("LIMIT"):
523            parts = self._parse_csv(self._parse_number)
524            if len(parts) == 1:
525                limit = parts[0]
526            elif len(parts) == 2:
527                limit = parts[1]
528                offset = parts[0]
529
530        return offset, limit
531
532    def _parse_set_item_charset(self, kind: str) -> exp.Expr:
533        this = self._parse_string() or self._parse_unquoted_field()
534        return self.expression(exp.SetItem(this=this, kind=kind))
535
536    def _parse_charset_name(self) -> exp.Expr | None:
537        """
538        Preserve quoting when a charset name has characters that require it (e.g. spaces, as allowed
539        for custom XML-registered charsets). Safe names unwrap to a bare Var so roundtrips remain minimal.
540        """
541        identifier = self._parse_identifier()
542        if identifier:
543            return (
544                exp.Var(this=name)
545                if exp.SAFE_IDENTIFIER_RE.match(name := identifier.name)
546                else identifier
547            )
548        return self._parse_var(tokens={TokenType.BINARY})
549
550    def _parse_set_item_names(self) -> exp.Expr:
551        charset = self._parse_string() or self._parse_unquoted_field()
552        if self._match_text_seq("COLLATE"):
553            collate = self._parse_string() or self._parse_unquoted_field()
554        else:
555            collate = None
556
557        return self.expression(exp.SetItem(this=charset, collate=collate, kind="NAMES"))
558
559    def _parse_type(
560        self, parse_interval: bool = True, fallback_to_identifier: bool = False
561    ) -> exp.Expr | None:
562        # mysql binary is special and can work anywhere, even in order by operations
563        # it operates like a no paren func
564        if self._match(TokenType.BINARY, advance=False):
565            data_type = self._parse_types(check_func=True, allow_identifiers=False)
566
567            if isinstance(data_type, exp.DataType):
568                return self.expression(exp.Cast(this=self._parse_column(), to=data_type))
569
570        return super()._parse_type(
571            parse_interval=parse_interval, fallback_to_identifier=fallback_to_identifier
572        )
573
574    def _parse_alter_table_alter_index(self) -> exp.AlterIndex:
575        index = self._parse_field(any_token=True)
576
577        if self._match_text_seq("VISIBLE"):
578            visible = True
579        elif self._match_text_seq("INVISIBLE"):
580            visible = False
581        else:
582            visible = None
583
584        return self.expression(exp.AlterIndex(this=index, visible=visible))
585
586    def _parse_partition_property(
587        self,
588    ) -> exp.Expr | None | list[exp.Expr]:
589        partition_cls: type[exp.Expr] | None = None
590        value_parser = None
591
592        if self._match_text_seq("RANGE"):
593            partition_cls = exp.PartitionByRangeProperty
594            value_parser = self._parse_partition_range_value
595        elif self._match_text_seq("LIST"):
596            partition_cls = exp.PartitionByListProperty
597            value_parser = self._parse_partition_list_value
598
599        if not partition_cls or not value_parser:
600            return None
601
602        partition_expressions = self._parse_wrapped_csv(self._parse_assignment)
603
604        # For Doris and Starrocks
605        if not self._match_text_seq("(", "PARTITION", advance=False):
606            return partition_expressions
607
608        create_expressions = self._parse_wrapped_csv(value_parser)
609
610        return self.expression(
611            partition_cls(
612                partition_expressions=partition_expressions, create_expressions=create_expressions
613            )
614        )
615
616    def _parse_partition_range_value(self) -> exp.Expr | None:
617        self._match_text_seq("PARTITION")
618        name = self._parse_id_var()
619
620        if not self._match_text_seq("VALUES", "LESS", "THAN"):
621            return name
622
623        values = self._parse_wrapped_csv(self._parse_expression)
624
625        if (
626            len(values) == 1
627            and isinstance(values[0], exp.Column)
628            and values[0].name.upper() == "MAXVALUE"
629        ):
630            values = [exp.var("MAXVALUE")]
631
632        part_range = self.expression(exp.PartitionRange(this=name, expressions=values))
633        return self.expression(exp.Partition(expressions=[part_range]))
634
635    def _parse_partition_list_value(self) -> exp.Partition:
636        self._match_text_seq("PARTITION")
637        name = self._parse_id_var()
638        self._match_text_seq("VALUES", "IN")
639        values = self._parse_wrapped_csv(self._parse_expression)
640        part_list = self.expression(exp.PartitionList(this=name, expressions=values))
641        return self.expression(exp.Partition(expressions=[part_list]))
642
643    def _parse_primary_key(
644        self,
645        wrapped_optional: bool = False,
646        in_props: bool = False,
647        named_primary_key: bool = False,
648    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
649        return super()._parse_primary_key(
650            wrapped_optional=wrapped_optional, in_props=in_props, named_primary_key=True
651        )