Method get_indexes

lib/sqlalchemy/dialects/mysql/base.py:3503–3551

(
        self,
        connection: Connection,
        table_name: str,
        schema: Optional[str] = None,
        **kw: Any,
    )

    @reflection.cache
    def get_indexes(
        self,
        connection: Connection,
        table_name: str,
        schema: Optional[str] = None,
        **kw: Any,
    ) -> list[ReflectedIndex]:
        parsed_state = self._parsed_state_or_create(
            connection, table_name, schema, **kw
        )

        indexes: list[ReflectedIndex] = []

        for spec in parsed_state.keys:
            dialect_options = {}
            unique = False
            flavor = spec["type"]
            if flavor == "PRIMARY":
                continue
            if flavor == "UNIQUE":
                unique = True
            elif flavor in ("FULLTEXT", "SPATIAL"):
                dialect_options[f"{self.name}_prefix"] = flavor
            elif flavor is not None:
                util.warn(
                    f"Converting unknown KEY type {flavor} to a plain KEY"
                )

            if spec["parser"]:
                dialect_options[f"{self.name}_with_parser"] = spec["parser"]

            index_d: ReflectedIndex = {
                "name": spec["name"],
                "column_names": [s[0] for s in spec["columns"]],
                "unique": unique,
            }

            mysql_length = {
                s[0]: s[1] for s in spec["columns"] if s[1] is not None
            }
            if mysql_length:
                dialect_options[f"{self.name}_length"] = mysql_length

            if dialect_options:
                index_d["dialect_options"] = dialect_options

            indexes.append(index_d)
        indexes.sort(key=lambda d: d["name"] or "~")  # sort None as last
        return indexes if indexes else ReflectionDefaults.indexes()

    @reflection.cache
    def get_unique_constraints(