SqlAlchemy 2.0 中文文档（五）（5）-阿里云开发者社区

SqlAlchemy 2.0 中文文档（五）（4）https://developer.aliyun.com/article/1563095

自定义类型映射

Python 类型到 SQLAlchemy TypeEngine类型的映射在前一节中描述的默认为sqlalchemy.sql.sqltypes模块中的硬编码字典。然而，协调 Declarative 映射过程的registry对象将首先查阅一个本地的、用户定义的类型字典，该字典可以在构建registry时作为registry.type_annotation_map参数传递，当首次使用时可能与DeclarativeBase超类相关联。

举例来说，如果我们希望使用BIGINT数据类型来表示int，使用带有timezone=True的TIMESTAMP数据类型来表示datetime.datetime，然后仅在 Microsoft SQL Server 上使用NVARCHAR数据类型来表示 Python 的str，则可以配置注册表和 Declarative 基类如下：

import datetime
from sqlalchemy import BIGINT, Integer, NVARCHAR, String, TIMESTAMP
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped, mapped_column, registry
class Base(DeclarativeBase):
    type_annotation_map = {
        int: BIGINT,
        datetime.datetime: TIMESTAMP(timezone=True),
        str: String().with_variant(NVARCHAR, "mssql"),
    }
class SomeClass(Base):
    __tablename__ = "some_table"
    id: Mapped[int] = mapped_column(primary_key=True)
    date: Mapped[datetime.datetime]
    status: Mapped[str]

下面展示了为上述映射生成的 CREATE TABLE 语句，在 Microsoft SQL Server 后端首先展示了NVARCHAR数据类型：

>>> from sqlalchemy.schema import CreateTable
>>> from sqlalchemy.dialects import mssql, postgresql
>>> print(CreateTable(SomeClass.__table__).compile(dialect=mssql.dialect()))
CREATE  TABLE  some_table  (
  id  BIGINT  NOT  NULL  IDENTITY,
  date  TIMESTAMP  NOT  NULL,
  status  NVARCHAR(max)  NOT  NULL,
  PRIMARY  KEY  (id)
)

然后在 PostgreSQL 后端，展示了TIMESTAMP WITH TIME ZONE：

>>> print(CreateTable(SomeClass.__table__).compile(dialect=postgresql.dialect()))
CREATE  TABLE  some_table  (
  id  BIGSERIAL  NOT  NULL,
  date  TIMESTAMP  WITH  TIME  ZONE  NOT  NULL,
  status  VARCHAR  NOT  NULL,
  PRIMARY  KEY  (id)
)

通过使用诸如TypeEngine.with_variant()之类的方法，我们能够构建一个针对不同后端定制的类型映射，同时仍然能够使用简洁的仅注释的mapped_column()配置。在此之上还有两个级别的 Python 类型可配置性，将在接下来的两个部分中描述。

将多种类型配置映射到 Python 类型

由于个别 Python 类型可以通过使用TypeEngine配置的任何类型与registry.type_annotation_map参数相关联，另一个功能是能够将单个 Python 类型与基于附加类型限定符的 SQL 类型的不同变体关联起来。一个典型的例子是将 Python 的str数据类型映射到不同长度的VARCHAR SQL 类型。另一个是将不同种类的decimal.Decimal映射到不同大小的NUMERIC列。

Python 的类型系统提供了一种很好的方式来为 Python 类型添加额外的元数据，即使用PEP 593 Annotated泛型类型，它允许将附加信息与 Python 类型捆绑在一起。mapped_column()构造将正确解释Annotated对象的身份，当在registry.type_annotation_map中解析它时，就像下面的示例中声明两个String和Numeric变体一样：

from decimal import Decimal
from typing_extensions import Annotated
from sqlalchemy import Numeric
from sqlalchemy import String
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import registry
str_30 = Annotated[str, 30]
str_50 = Annotated[str, 50]
num_12_4 = Annotated[Decimal, 12]
num_6_2 = Annotated[Decimal, 6]
class Base(DeclarativeBase):
    registry = registry(
        type_annotation_map={
            str_30: String(30),
            str_50: String(50),
            num_12_4: Numeric(12, 4),
            num_6_2: Numeric(6, 2),
        }
    )

在上述示例中传递给Annotated容器的 Python 类型，例如str和Decimal类型，仅对于类型工具的好处是重要的；就mapped_column()构造而言，在这个特定的上下文中，它只需要在registry.type_annotation_map字典中查找每个类型对象，而不实际查看Annotated对象的内部。类似地，传递给Annotated的参数超出底层 Python 类型本身也不重要，只是必须至少存在一个参数，以使Annotated构造有效。然后，我们可以直接在我们的映射中使用这些增强类型，它们将与更具体的类型构造相匹配，就像以下示例中一样：

class SomeClass(Base):
    __tablename__ = "some_table"
    short_name: Mapped[str_30] = mapped_column(primary_key=True)
    long_name: Mapped[str_50]
    num_value: Mapped[num_12_4]
    short_num_value: Mapped[num_6_2]

上述映射的 CREATE TABLE 将说明我们配置的不同变体的VARCHAR和NUMERIC，并且看起来像是：

>>> from sqlalchemy.schema import CreateTable
>>> print(CreateTable(SomeClass.__table__))
CREATE  TABLE  some_table  (
  short_name  VARCHAR(30)  NOT  NULL,
  long_name  VARCHAR(50)  NOT  NULL,
  num_value  NUMERIC(12,  4)  NOT  NULL,
  short_num_value  NUMERIC(6,  2)  NOT  NULL,
  PRIMARY  KEY  (short_name)
)

虽然将Annotated类型与不同的 SQL 类型链接的多样性为我们提供了广泛的灵活性，但下一节说明了一种使用Annotated与 Declarative 结合使用的第二种更加开放的方式。

将整个列声明映射到 Python 类型

前面的章节说明了使用PEP 593 Annotated类型实例作为registry.type_annotation_map字典中的键。在这种形式中，mapped_column()构造实际上并不查看Annotated对象本身，而是仅用作字典键。然而，Declarative 还具有直接从Annotated对象中提取整个预先建立的mapped_column()构造的能力。使用这种形式，我们不仅可以定义与 Python 类型相关联的不同种类的 SQL 数据类型，而且还可以以可重用的方式设置任意数量的参数，例如可为空性、列默认值和约束。

一组 ORM 模型通常会有一种对所有映射类都通用的主键样式。还可能有常见的列配置，例如具有默认值的时间戳和其他预先确定大小和配置的字段。我们可以将这些配置组合成mapped_column()实例，然后直接捆绑到Annotated的实例中，然后在任意数量的类声明中重复使用。当以这种方式提供时，声明性将解开Annotated对象，跳过任何不适用于 SQLAlchemy 的其他指令，并仅搜索 SQLAlchemy ORM 构造。

下面的示例说明了以这种方式使用的各种预配置字段类型，其中我们定义了intpk代表一个整型主键列，timestamp代表一个日期时间类型，它将使用CURRENT_TIMESTAMP作为 DDL 级别的列默认值，并且required_name是一个长度为 30 的字符串，它是NOT NULL的：

import datetime
from typing_extensions import Annotated
from sqlalchemy import func
from sqlalchemy import String
from sqlalchemy.orm import mapped_column
intpk = Annotated[int, mapped_column(primary_key=True)]
timestamp = Annotated[
    datetime.datetime,
    mapped_column(nullable=False, server_default=func.CURRENT_TIMESTAMP()),
]
required_name = Annotated[str, mapped_column(String(30), nullable=False)]

上述的Annotated对象然后可以直接在Mapped中使用，预配置的mapped_column()构造将被提取并复制到一个新实例中，该实例将针对每个属性具体：

class Base(DeclarativeBase):
    pass
class SomeClass(Base):
    __tablename__ = "some_table"
    id: Mapped[intpk]
    name: Mapped[required_name]
    created_at: Mapped[timestamp]

我们上面的映射的CREATE TABLE如下所示：

>>> from sqlalchemy.schema import CreateTable
>>> print(CreateTable(SomeClass.__table__))
CREATE  TABLE  some_table  (
  id  INTEGER  NOT  NULL,
  name  VARCHAR(30)  NOT  NULL,
  created_at  DATETIME  DEFAULT  CURRENT_TIMESTAMP  NOT  NULL,
  PRIMARY  KEY  (id)
)

当以这种方式使用Annotated类型时，类型的配置也可能会受到每个属性基础的影响。对于上面示例中显式使用了mapped_column.nullable的类型，我们可以对我们的任何类型应用Optional[]泛型修饰符，以便在 Python 级别该字段是可选的还是不可选的，这将独立于数据库中发生的NULL / NOT NULL设置：

from typing_extensions import Annotated
import datetime
from typing import Optional
from sqlalchemy.orm import DeclarativeBase
timestamp = Annotated[
    datetime.datetime,
    mapped_column(nullable=False),
]
class Base(DeclarativeBase):
    pass
class SomeClass(Base):
    # ...
    # pep-484 type will be Optional, but column will be
    # NOT NULL
    created_at: Mapped[Optional[timestamp]]

mapped_column()构造还与显式传递的mapped_column()构造协调一致，其参数将优先于Annotated构造的参数。下面我们向我们的整型主键添加了一个外键约束，并且还为created_at列使用了备用服务器默认值：

import datetime
from typing_extensions import Annotated
from sqlalchemy import ForeignKey
from sqlalchemy import func
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.schema import CreateTable
intpk = Annotated[int, mapped_column(primary_key=True)]
timestamp = Annotated[
    datetime.datetime,
    mapped_column(nullable=False, server_default=func.CURRENT_TIMESTAMP()),
]
class Base(DeclarativeBase):
    pass
class Parent(Base):
    __tablename__ = "parent"
    id: Mapped[intpk]
class SomeClass(Base):
    __tablename__ = "some_table"
    # add ForeignKey to mapped_column(Integer, primary_key=True)
    id: Mapped[intpk] = mapped_column(ForeignKey("parent.id"))
    # change server default from CURRENT_TIMESTAMP to UTC_TIMESTAMP
    created_at: Mapped[timestamp] = mapped_column(server_default=func.UTC_TIMESTAMP())

CREATE TABLE语句说明了这些每个属性的设置，添加了FOREIGN KEY约束，并且将UTC_TIMESTAMP替换为CURRENT_TIMESTAMP：

>>> from sqlalchemy.schema import CreateTable
>>> print(CreateTable(SomeClass.__table__))
CREATE  TABLE  some_table  (
  id  INTEGER  NOT  NULL,
  created_at  DATETIME  DEFAULT  UTC_TIMESTAMP()  NOT  NULL,
  PRIMARY  KEY  (id),
  FOREIGN  KEY(id)  REFERENCES  parent  (id)
)

注意

刚刚描述的 mapped_column() 特性，其中可以使用 PEP 593 Annotated 对象指示一组完全构造的列参数，这些列参数包含一个“模板” mapped_column() 对象，将被复制到属性中，目前尚未实现为其他 ORM 构造（如 relationship() 和 composite()）。虽然理论上可能存在这种功能，但目前尝试使用 Annotated 来指示 relationship() 等的进一步参数将在运行时引发 NotImplementedError 异常，但可能会在将来的版本中实现。

在类型映射中使用 Python `Enum` 或 pep-586 `Literal` 类型

新版本 2.0.0b4 中新增：- 添加了 Enum 支持

新版本 2.0.1 中新增：- 添加了 Literal 支持

当在 ORM 声明性映射中使用用户定义的 Python 类型时，这些类型派生自 Python 内置的 enum.Enum 类以及 typing.Literal 类时，它们会自动链接到 SQLAlchemy Enum 数据类型。下面的示例在 Mapped[] 构造函数中使用了自定义的 enum.Enum：

import enum
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
class Base(DeclarativeBase):
    pass
class Status(enum.Enum):
    PENDING = "pending"
    RECEIVED = "received"
    COMPLETED = "completed"
class SomeClass(Base):
    __tablename__ = "some_table"
    id: Mapped[int] = mapped_column(primary_key=True)
    status: Mapped[Status]

在上面的示例中，映射的属性 SomeClass.status 将链接到一个 Column，其数据类型为 Enum(Status)。我们可以在 PostgreSQL 数据库的 CREATE TABLE 输出中看到这一点：

CREATE  TYPE  status  AS  ENUM  ('PENDING',  'RECEIVED',  'COMPLETED')
CREATE  TABLE  some_table  (
  id  SERIAL  NOT  NULL,
  status  status  NOT  NULL,
  PRIMARY  KEY  (id)
)

类似地，也可以使用 typing.Literal，使用包含所有字符串的 typing.Literal：

from typing import Literal
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
class Base(DeclarativeBase):
    pass
Status = Literal["pending", "received", "completed"]
class SomeClass(Base):
    __tablename__ = "some_table"
    id: Mapped[int] = mapped_column(primary_key=True)
    status: Mapped[Status]

在 registry.type_annotation_map 中使用的条目将基本的 enum.Enum Python 类型以及 typing.Literal 类型链接到 SQLAlchemy Enum SQL 类型，使用特殊形式来指示 Enum 数据类型应自动配置自己以针对任意枚举类型。默认情况下，此配置是隐式的，但可以显式指示为：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    type_annotation_map = {
        enum.Enum: sqlalchemy.Enum(enum.Enum),
        typing.Literal: sqlalchemy.Enum(enum.Enum),
    }

在 Declarative 内部的解析逻辑能够解析enum.Enum的子类以及typing.Literal的实例，以匹配registry.type_annotation_map字典中的enum.Enum或typing.Literal条目。然后，Enum SQL 类型知道如何生成具有适当设置的已配置版本，包括默认字符串长度。如果传递的typing.Literal不仅由字符串值组成，则会引发信息性错误。

本地枚举和命名

Enum.native_enum参数是指Enum数据类型是否应创建所谓的“本地”枚举，在 MySQL/MariaDB 上是ENUM数据类型，在 PostgreSQL 上是通过CREATE TYPE创建的新TYPE对象，或者是“非本地”枚举，这意味着将使用VARCHAR创建数据类型。对于 MySQL/MariaDB 或 PostgreSQL 以外的后端，在所有情况下都使用VARCHAR（第三方方言可能具有自己的行为）。

因为 PostgreSQL 的CREATE TYPE要求为要创建的类型指定显式名称，所以在处理未显式指定显式Enum数据类型的情况下，特殊的后备逻辑存在于隐式生成的Enum时：

如果Enum链接到一个enum.Enum对象，则Enum.native_enum参数默认为True，并且枚举的名称将取自enum.Enum数据类型的名称。 PostgreSQL 后端将假定使用此名称创建CREATE TYPE。
如果Enum链接到一个typing.Literal对象，则Enum.native_enum参数默认为False；不会生成名称，并且假定为VARCHAR。

要在 PostgreSQL 的CREATE TYPE类型中使用typing.Literal，必须使用显式的Enum，要么在类型映射中：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
Status = Literal["pending", "received", "completed"]
class Base(DeclarativeBase):
    type_annotation_map = {
        Status: sqlalchemy.Enum("pending", "received", "completed", name="status_enum"),
    }

或者在 mapped_column() 内部：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
Status = Literal["pending", "received", "completed"]
class Base(DeclarativeBase):
    pass
class SomeClass(Base):
    __tablename__ = "some_table"
    id: Mapped[int] = mapped_column(primary_key=True)
    status: Mapped[Status] = mapped_column(
        sqlalchemy.Enum("pending", "received", "completed", name="status_enum")
    )

修改默认枚举的配置

为了修改隐式生成的Enum数据类型的固定配置，指定在registry.type_annotation_map中添加新条目，表示额外参数。例如，要无条件使用“非原生枚举”，可以为所有类型设置Enum.native_enum参数为 False：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    type_annotation_map = {
        enum.Enum: sqlalchemy.Enum(enum.Enum, native_enum=False),
        typing.Literal: sqlalchemy.Enum(enum.Enum, native_enum=False),
    }

从 2.0.1 版本开始更改：实现了在建立registry.type_annotation_map时覆盖参数的支持，例如Enum.native_enum参数。以前，此功能未能正常工作。

要为特定的enum.Enum子类型使用特定的配置，例如在使用示例Status数据类型时将字符串长度设置为 50：

import enum
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
class Status(enum.Enum):
    PENDING = "pending"
    RECEIVED = "received"
    COMPLETED = "completed"
class Base(DeclarativeBase):
    type_annotation_map = {
        Status: sqlalchemy.Enum(Status, length=50, native_enum=False)
    }

默认情况下，自动生成的Enum不与由Base使用的MetaData实例关联，因此，如果元数据定义了模式，它将不会自动与枚举关联。要将枚举自动与元数据或表中的模式关联起来，可以设置Enum.inherit_schema：

from enum import Enum
import sqlalchemy as sa
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    metadata = sa.MetaData(schema="my_schema")
    type_annotation_map = {Enum: sa.Enum(Enum, inherit_schema=True)}

将特定的`enum.Enum`或`typing.Literal`链接到其他数据类型

以上示例展示了一个Enum自动配置自身到一个enum.Enum或typing.Literal类型对象上存在的参数/属性的情况。对于应用场景，特定类型的enum.Enum或typing.Literal应链接到其他类型的情况，这些特定类型也可以放置在类型映射中。在下面的示例中，一个包含非字符串类型的Literal[]条目被链接到JSON数据类型：

from typing import Literal
from sqlalchemy import JSON
from sqlalchemy.orm import DeclarativeBase
my_literal = Literal[0, 1, True, False, "true", "false"]
class Base(DeclarativeBase):
    type_annotation_map = {my_literal: JSON}

在上述配置中，my_literal数据类型将解析为一个JSON实例。其他Literal变体将继续解析为Enum数据类型。

原生枚举和命名

Enum.native_enum 参数指的是 Enum 数据类型是否应该创建所谓的“本地”枚举，在 MySQL/MariaDB 中是 ENUM 数据类型，在 PostgreSQL 中是由 CREATE TYPE 创建的新 TYPE 对象，或者是“非本地”枚举，这意味着将使用 VARCHAR 来创建数据类型。对于不是 MySQL/MariaDB 或 PostgreSQL 的后端，VARCHAR 在所有情况下都会被使用（第三方方言可能具有自己的行为）。

因为 PostgreSQL 的 CREATE TYPE 要求有一个明确的类型名称要被创建，所以在使用隐式生成的 Enum 时，当没有指定显式的 Enum 数据类型时，存在特殊的回退逻辑：

如果 Enum 与 enum.Enum 对象关联，则 Enum.native_enum 参数默认为 True，并且枚举的名称将从 enum.Enum 数据类型的名称中获取。PostgreSQL 后端将假定使用此名称创建 CREATE TYPE。
如果 Enum 与 typing.Literal 对象关联，则 Enum.native_enum 参数默认为 False；不会生成名称，假定为 VARCHAR。

要在 PostgreSQL 的 CREATE TYPE 类型中使用 typing.Literal，必须使用显式的 Enum，要么在类型映射中：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
Status = Literal["pending", "received", "completed"]
class Base(DeclarativeBase):
    type_annotation_map = {
        Status: sqlalchemy.Enum("pending", "received", "completed", name="status_enum"),
    }

或者在 mapped_column() 中：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
Status = Literal["pending", "received", "completed"]
class Base(DeclarativeBase):
    pass
class SomeClass(Base):
    __tablename__ = "some_table"
    id: Mapped[int] = mapped_column(primary_key=True)
    status: Mapped[Status] = mapped_column(
        sqlalchemy.Enum("pending", "received", "completed", name="status_enum")
    )

修改默认枚举的配置

为了修改隐式生成的 Enum 数据类型的固定配置，可以在 registry.type_annotation_map 中指定新的条目，指示额外的参数。例如，要无条件地使用“非本地枚举”，可以为所有类型将 Enum.native_enum 参数设置为 False：

import enum
import typing
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    type_annotation_map = {
        enum.Enum: sqlalchemy.Enum(enum.Enum, native_enum=False),
        typing.Literal: sqlalchemy.Enum(enum.Enum, native_enum=False),
    }

在 2.0.1 版本中更改：实现了在建立 registry.type_annotation_map 时重写参数的支持，例如 Enum.native_enum 中的参数。之前，此功能未正常工作。

若要针对特定的 enum.Enum 子类型使用特定配置，例如在使用示例 Status 数据类型时将字符串长度设置为 50：

import enum
import sqlalchemy
from sqlalchemy.orm import DeclarativeBase
class Status(enum.Enum):
    PENDING = "pending"
    RECEIVED = "received"
    COMPLETED = "completed"
class Base(DeclarativeBase):
    type_annotation_map = {
        Status: sqlalchemy.Enum(Status, length=50, native_enum=False)
    }

默认情况下，自动生成的 Enum 与 Base 使用的 MetaData 实例不关联，因此如果元数据定义了模式，则不会自动将其与枚举关联起来。要将枚举自动关联到元数据或表中的模式，可以设置 Enum.inherit_schema：

from enum import Enum
import sqlalchemy as sa
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    metadata = sa.MetaData(schema="my_schema")
    type_annotation_map = {Enum: sa.Enum(Enum, inherit_schema=True)}

将特定的 `enum.Enum` 或 `typing.Literal` 链接到其他数据类型

上述示例展示了自动将 Enum 配置到 enum.Enum 或 typing.Literal 类型对象上的用法。对于应该与其他类型链接的特定种类的 enum.Enum 或 typing.Literal 的用例，也可以将这些特定类型放入类型映射中。在下面的示例中，包含非字符串类型的 Literal[] 条目被链接到 JSON 数据类型：

from typing import Literal
from sqlalchemy import JSON
from sqlalchemy.orm import DeclarativeBase
my_literal = Literal[0, 1, True, False, "true", "false"]
class Base(DeclarativeBase):
    type_annotation_map = {my_literal: JSON}

在上述配置中，my_literal 数据类型将解析为 JSON 实例。其他 Literal 变体将继续解析为 Enum 数据类型。

`mapped_column()` 中的数据类特性

mapped_column() 构造与 SQLAlchemy 的“原生数据类”功能集成，该功能在声明式数据类映射中讨论。请参阅该部分了解关于 mapped_column() 支持的其他指令的当前背景。

访问表和元数据

声明式映射的类将始终包括一个名为 __table__ 的属性；当使用 __tablename__ 进行上述配置时，声明过程通过 __table__ 属性使 Table 可用：

# access the Table
user_table = User.__table__

上述表最终与Mapper.local_table属性相同，我们可以通过运行时检查系统来查看它：

from sqlalchemy import inspect
user_table = inspect(User).local_table

与声明式registry以及基类关联的MetaData集合通常是必要的，以便执行诸如 CREATE 之类的 DDL 操作，以及与诸如 Alembic 之类的迁移工具一起使用。该对象可通过registry以及声明式基类的.metadata属性获得。下面，对于一个小脚本，我们可能希望针对 SQLite 数据库发出所有表的 CREATE：

engine = create_engine("sqlite://")
Base.metadata.create_all(engine)

声明式表配置

在使用具有__tablename__声明类属性的声明式表配置时，应该使用__table_args__声明类属性提供额外的参数供Table构造函数使用。

此属性同时适用于通常发送到Table构造函数的位置参数和关键字参数。该属性可以以两种形式之一指定。一种是作为字典：

class MyClass(Base):
    __tablename__ = "sometable"
    __table_args__ = {"mysql_engine": "InnoDB"}

另一种是元组，其中每个参数都是位置参数（通常是约束）：

class MyClass(Base):
    __tablename__ = "sometable"
    __table_args__ = (
        ForeignKeyConstraint(["id"], ["remote_table.id"]),
        UniqueConstraint("foo"),
    )

关键字参数可以通过指定最后一个参数为字典的形式来指定：

class MyClass(Base):
    __tablename__ = "sometable"
    __table_args__ = (
        ForeignKeyConstraint(["id"], ["remote_table.id"]),
        UniqueConstraint("foo"),
        {"autoload": True},
    )

类还可以使用declared_attr()方法装饰器以动态方式指定__table_args__声明属性以及__tablename__属性。有关背景信息，请参阅使用混合组合映射层次结构。

SqlAlchemy 2.0 中文文档（五）（5）

自定义类型映射

将多种类型配置映射到 Python 类型

将整个列声明映射到 Python 类型

在类型映射中使用 Python `Enum` 或 pep-586 `Literal` 类型

本地枚举和命名

修改默认枚举的配置

将特定的`enum.Enum`或`typing.Literal`链接到其他数据类型

原生枚举和命名

修改默认枚举的配置

将特定的 `enum.Enum` 或 `typing.Literal` 链接到其他数据类型

`mapped_column()` 中的数据类特性

访问表和元数据

声明式表配置

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

SqlAlchemy 2.0 中文文档（五）（5）

自定义类型映射

将多种类型配置映射到 Python 类型

将整个列声明映射到 Python 类型

在类型映射中使用 Python Enum 或 pep-586 Literal 类型

本地枚举和命名

修改默认枚举的配置

将特定的enum.Enum或typing.Literal链接到其他数据类型

原生枚举和命名

修改默认枚举的配置

将特定的 enum.Enum 或 typing.Literal 链接到其他数据类型

mapped_column() 中的数据类特性

访问表和元数据

声明式表配置

热门文章

最新文章

相关电子书

在类型映射中使用 Python `Enum` 或 pep-586 `Literal` 类型

将特定的`enum.Enum`或`typing.Literal`链接到其他数据类型

将特定的 `enum.Enum` 或 `typing.Literal` 链接到其他数据类型

`mapped_column()` 中的数据类特性