How do I rename my SQLModel class from table name "AppUser" to "app_user" by not changing Class name?

[tinc0709]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the SQLModel documentation, with the integrated search.
• I already searched in Google "How to X in SQLModel" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to SQLModel but to Pydantic.
• I already checked if it is not related to SQLModel but to SQLAlchemy.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from datetime import datetime
from typing import Optional
from pydantic import EmailStr, ValidationError
from sqlmodel import Field, Session, SQLModel, create_engine, select

class AppUserModel(SQLModel, table=True): # this class, I need to rename it to "app_user" when generated into mysql
    id: Optional[int] = Field(default=None, primary_key=True)
    openid: str = Field(default=None, index=True)
    pkg_name: str = Field(default=None, index=True)
    unionid: str = Field(default=None, nullable=True, index=True)
    platform: str = Field(default='weapp', index=True)
    username : str = None
    password : str = None
    email : Optional[EmailStr] = None
    phone : str = None
    realname : str = None
    avatar : str = None
    user_desc : str = None
    is_enabled : bool = True
    login_time : int = None
    session_key: str = None
    created_at: datetime = Field(default=datetime.utcnow())
    updated_at: datetime = Field(default_factory=datetime.utcnow)

Description

Wiki was wrote it about rename table name in advance, but no way to rename

Operating System

macOS

Operating System Details

No response

SQLModel Version

0.0.8

Python Version

3.10

Additional Context

No response

[FISHMANPET]

Set a property __tablename__ in your model and set its value to app_user.

class AppUserModel(SQLModel, table=True):
    __tablename__ = "app_user"
    ...

[msftcangoblowm]

Same as #159

From main.py

    @declared_attr  # type: ignore
    def __tablename__(cls) -> str:
        return cls.__name__.lower()

should be

from sqlalchemy.orm import declared_attr
from pydantic.alias_generators import to_snake

    @declared_attr.directive  # type: ignore[misc]
    @classmethod
    def __tablename__(cls) -> str:
        return to_snake(cls.__name__)

Do not reinvent wheel to convert to snake case.

static typing

[msftcangoblowm]

This issue is particularly difficult. Here is a minimalist implementation. Code comments highlight shortcomings

from collections.abc import Callable
from typing import ClassVar, Optional

from sqlalchemy import registry
from sqlalchemy.orm import declared_attr
from pydantic import create_model
from pydantic.alias_generators import to_snake
from sqlmodel import Field, SQLModel, create_engine

# The default_registry is **never** a desirable implementation
registry_bad_implementation = registry()


class Base(SQLModel, registry=registry_bad_implementation):
    """This is the base. One per database. This implementation should
    be dynamic. This static class doesn't scale past one database
    """


def tablename_algo() -> Callable[[str], str]:
    """Patch. For overriding default algo. `unittest.mock.patch` is your friend.

    :returns: Class name to table names conversion function
    :rtype: collections.abc.Callable[[str], str]
    """
    ret = to_snake

    return ret


class ApplyTableName:
    """This mixin overrides the __tablename__ from SQLModel's metaclass which
    is applied upon call to __new__.
    """

    @declared_attr.directive
    @classmethod
    def __tablename__(cls) -> str:
        """Override classmethod SQLModel.__tablename__"""
        fcn_ = tablename_algo()
        ret = fcn_(cls._tablename)
        return ret


# Have ApplyTableName mixin be applied **AFTER** SQLModel.__new__
t_bases = (ApplyTableName, Base)

clsname = "AppUser12345"
clsname_short = "AppUser"
field_definitions = {
    "id": (Optional[int], Field(default=None, primary_key=True)),
    "name": (str, ...),
    "secret_name": (str, ...),
    "age": (Optional[int], None),
    "_tablename": (ClassVar[str], clsname_short),
}

AppUserModel = create_model(
    clsname,
    # __qualname__: "necessary and obviously missing",
    __module__="mypackage.subpackage.mymodule",
    __base__=t_bases,
    __cls_kwargs__={"table": True},
    **field_definitions,
)

engine_a_uri = '''sqlite:////tmp/a.db'''
engine_a = create_engine(engine_a_uri, echo=True)
# creates and saves sqlite database! Produces table `app_user`
Base.metadata.create_all(engine_a)

aum = AppUserModel(name="bob", secret_name="mustache guy", age=13)
assert aum.__tablename__ == to_snake(cls_name_short)

Multiple database support is always necessary. Every database will have an alembic_version table.

For multiple databases to have table, alembic_version, the class names couldn't both be AlembicVersion.

Example class names: Base12345, Base12346, AlembicVersion12345, AlembicVersion12346