SqlAlchemy 2.0 中文文档（四十一）（2）

SqlAlchemy 2.0 中文文档（四十一）（1）https://developer.aliyun.com/article/1563080

控制约束和索引的 DDL 生成

新版本 2.0 中新增功能。

虽然之前提到的 ExecutableDDLElement.execute_if() 方法对于需要有条件地调用的自定义 DDL 类很有用，但通常还有一个常见的需求，即通常与特定 Table 相关的元素，如约束和索引，也要受到“条件”规则的约束，比如一个包含特定于特定后端（如 PostgreSQL 或 SQL Server）的特性的索引。对于这种用例，可以针对诸如 CheckConstraint、UniqueConstraint 和 Index 这样的构造使用 Constraint.ddl_if() 和 Index.ddl_if() 方法，接受与 ExecutableDDLElement.execute_if() 方法相同的参数，以控制它们的 DDL 是否将以其父 Table 对象的形式发出。在创建 Table 的定义时（或类似地，在使用 ORM 声明性映射的 __table_args__ 集合时），可以内联使用这些方法，例如：

from sqlalchemy import CheckConstraint, Index
from sqlalchemy import MetaData, Table, Column
from sqlalchemy import Integer, String
meta = MetaData()
my_table = Table(
    "my_table",
    meta,
    Column("id", Integer, primary_key=True),
    Column("num", Integer),
    Column("data", String),
    Index("my_pg_index", "data").ddl_if(dialect="postgresql"),
    CheckConstraint("num > 5").ddl_if(dialect="postgresql"),
)

在上面的示例中，Table 构造同时指代 Index 和 CheckConstraint 构造，均表明 .ddl_if(dialect="postgresql")，这表示这些元素仅针对 PostgreSQL 方言将包括在 CREATE TABLE 序列中。例如，如果我们针对 SQLite 方言运行 meta.create_all()，则不会包括任何构造：

>>> from sqlalchemy import create_engine
>>> sqlite_engine = create_engine("sqlite+pysqlite://", echo=True)
>>> meta.create_all(sqlite_engine)
BEGIN  (implicit)
PRAGMA  main.table_info("my_table")
[raw  sql]  ()
PRAGMA  temp.table_info("my_table")
[raw  sql]  ()
CREATE  TABLE  my_table  (
  id  INTEGER  NOT  NULL,
  num  INTEGER,
  data  VARCHAR,
  PRIMARY  KEY  (id)
) 

但是，如果我们对 PostgreSQL 数据库运行相同的命令，我们将看到内联的 DDL 用于 CHECK 约束，以及为索引发出的单独的 CREATE 语句：

>>> from sqlalchemy import create_engine
>>> postgresql_engine = create_engine(
...     "postgresql+psycopg2://scott:tiger@localhost/test", echo=True
... )
>>> meta.create_all(postgresql_engine)
BEGIN  (implicit)
select  relname  from  pg_class  c  join  pg_namespace  n  on  n.oid=c.relnamespace  where  pg_catalog.pg_table_is_visible(c.oid)  and  relname=%(name)s
[generated  in  0.00009s]  {'name':  'my_table'}
CREATE  TABLE  my_table  (
  id  SERIAL  NOT  NULL,
  num  INTEGER,
  data  VARCHAR,
  PRIMARY  KEY  (id),
  CHECK  (num  >  5)
)
[no  key  0.00007s]  {}
CREATE  INDEX  my_pg_index  ON  my_table  (data)
[no  key  0.00013s]  {}
COMMIT 

Constraint.ddl_if() 和 Index.ddl_if() 方法创建一个事件挂钩，该挂钩不仅可以在 DDL 执行时查询，如 ExecutableDDLElement.execute_if() 的行为，而且还可以在 CreateTable 对象的 SQL 编译阶段内查询，该阶段负责在 CREATE TABLE 语句中内联渲染 CHECK (num > 5) DDL。因此，通过 ddl_if.callable_() 参数接收到的事件挂钩具有更丰富的参数集，包括传递的 dialect 关键字参数，以及通过 compiler 关键字参数传递的 DDLCompiler 的实例，用于序列的“内联渲染”部分。当事件在 DDLCompiler 序列内触发时，bind 参数 不存在，因此，希望检查数据库版本信息的现代事件挂钩最好使用给定的 Dialect 对象，例如测试 PostgreSQL 版本：

def only_pg_14(ddl_element, target, bind, dialect, **kw):
    return dialect.name == "postgresql" and dialect.server_version_info >= (14,)
my_table = Table(
    "my_table",
    meta,
    Column("id", Integer, primary_key=True),
    Column("num", Integer),
    Column("data", String),
    Index("my_pg_index", "data").ddl_if(callable_=only_pg_14),
)

另请参阅

Constraint.ddl_if()

Index.ddl_if()

DDL 表达式构造 API

function sqlalchemy.schema.sort_tables(tables: Iterable[TableClause], skip_fn: Callable[[ForeignKeyConstraint], bool] | None = None, extra_dependencies: typing_Sequence[Tuple[TableClause, TableClause]] | None = None) → List[Table]

根据依赖关系对一组Table对象进行排序。

这是一个依赖排序，将发出Table对象，以便它们将遵循其依赖的Table对象。表依赖于另一个表，根据ForeignKeyConstraint对象的存在以及由Table.add_is_dependent_on()添加的显式依赖关系。 |

警告

sort_tables()函数本身无法自动解决表之间的依赖循环，这些循环通常是由相互依赖的外键约束引起的。当检测到这些循环时，这些表的外键将被从排序考虑中省略。当出现此条件时会发出警告，在未来的版本中将引发异常。不属于循环的表仍将按照依赖顺序返回。

为了解决这些循环，可以将ForeignKeyConstraint.use_alter参数应用于创建循环的约束。另外，当检测到循环时，sort_tables_and_constraints()函数将自动将外键约束返回到一个单独的集合中，以便可以单独应用到模式中。

在版本 1.3.17 中更改：当sort_tables()由于循环依赖而无法执行适当排序时，会发出警告。这将在未来的版本中成为异常。此外，排序将继续返回其他未涉及循环的表以依赖顺序，而这在以前的情况下并非如此。

参数：

• tables – 一系列Table对象。
  
• skip_fn – 可选的可调用对象，将传递一个ForeignKeyConstraint对象；如果返回 True，则不会考虑此约束作为依赖项。请注意，这与sort_tables_and_constraints()中相同参数的不同之处，该参数将传递给拥有的ForeignKeyConstraint对象。
  
• extra_dependencies – 一个包含表之间互相依赖的 2 元组序列。
  

另请参阅

sort_tables_and_constraints()函数用于排序表和约束。

MetaData.sorted_tables - 使用此函数进行排序。

function sqlalchemy.schema.sort_tables_and_constraints(tables, filter_fn=None, extra_dependencies=None, _warn_for_cycles=False)

对一组Table / ForeignKeyConstraint对象进行排序。

这是一个依赖顺序排序，将发出(Table, [ForeignKeyConstraint, ...])元组，以便每个Table都跟随其依赖的Table对象。由于排序未满足的依赖规则而分开的其余ForeignKeyConstraint对象将作为(None, [ForeignKeyConstraint ...])之后发出。

表依赖于另一个表，基于存在的ForeignKeyConstraint对象，由Table.add_is_dependent_on()添加的显式依赖关系，以及在此处使用sort_tables_and_constraints.skip_fn和/或sort_tables_and_constraints.extra_dependencies参数声明的依赖关系。

参数:

• tables – 一个包含Table对象的序列。
  
• filter_fn – 可选的可调用对象，将传递一个ForeignKeyConstraint对象，并根据此约束是否应明确包含或排除为内联约束返回一个值，或者两者都不是。如果返回 False，则该约束将明确包含为不能受 ALTER 影响的依赖项；如果为 True，则它将仅作为最终的 ALTER 结果包含。返回 None 意味着该约束将包含在基于表的结果中，除非它被检测为依赖循环的一部分。
  
• extra_dependencies – 一个包含两个表的 2 元组序列，这两个表也将被视为相互依赖。
  

另请参阅

sort_tables()

class sqlalchemy.schema.BaseDDLElement

DDL 构造的根，包括那些作为“create table”和其他过程中的子元素的构造。

版本 2.0 中的新功能。

类签名

类sqlalchemy.schema.BaseDDLElement（sqlalchemy.sql.expression.ClauseElement）。

class sqlalchemy.schema.ExecutableDDLElement

独立可执行的 DDL 表达式构造的基类。

此类是通用目的 DDL 类的基类，以及各种创建/删除子句构造，例如 CreateTable、DropTable、AddConstraint 等等。

从版本 2.0 起更改：ExecutableDDLElement 从 DDLElement 重命名，DDLElement 仍然存在以保持向后兼容性。

ExecutableDDLElement 与 SQLAlchemy 事件密切集成，介绍在 Events 中。一个实例本身就是一个事件接收器：

event.listen(
    users,
    'after_create',
    AddConstraint(constraint).execute_if(dialect='postgresql')
)

另请参见

DDL

DDLEvents

Events

控制 DDL 序列

成员

call(), against(), execute_if()

类签名

类 sqlalchemy.schema.ExecutableDDLElement (sqlalchemy.sql.roles.DDLRole, sqlalchemy.sql.expression.Executable, sqlalchemy.schema.BaseDDLElement)

method __call__(target, bind, **kw)

将 DDL 作为 ddl_listener 执行。

method against(target: SchemaItem) → Self

返回此 ExecutableDDLElement 的副本，其中将包含给定的目标。

这实质上将给定项应用于返回的 ExecutableDDLElement 对象的 .target 属性。然后可以由事件处理程序和编译例程使用此目标，以提供诸如基于特定 Table 的 DDL 字符串的标记化之类的服务。

当将ExecutableDDLElement对象作为DDLEvents.before_create()或DDLEvents.after_create()事件的事件处理程序进行建立，并且事件随后发生在诸如Constraint或Table之类的给定目标上时，使用此方法使用ExecutableDDLElement对象的副本来为该目标建立，然后进入ExecutableDDLElement.execute()方法以调用实际的 DDL 指令。

参数：

target – 一个SchemaItem，将成为 DDL 操作的主体。

返回：

此ExecutableDDLElement的副本，其.target属性分配给给定的SchemaItem。

另请参阅

DDL - 对处理 DDL 字符串时针对“target”进行标记化。

method execute_if(dialect: str | None = None, callable_: DDLIfCallable | None = None, state: Any | None = None) → Self

返回一个可调用对象，该对象将在事件处理程序中有条件地执行此ExecutableDDLElement。

用于提供事件监听的包装器：

event.listen(
            metadata,
            'before_create',
            DDL("my_ddl").execute_if(dialect='postgresql')
        )

参数：

• dialect –
  可以是字符串或字符串元组。如果是字符串，则将其与执行数据库方言的名称进行比较：

DDL('something').execute_if(dialect='postgresql')

• 如果是元组，则指定多个方言名称：

DDL('something').execute_if(dialect=('postgresql', 'mysql'))

• callable_ –
  一个可调用对象，将使用三个位置参数以及可选的关键字参数进行调用：

ddl：

此 DDL 元素。

target：

此事件的目标Table或MetaData对象。如果 DDL 是显式执行的，则可以为 None。

bind：

用于执行 DDL 的Connection。如果此构造是在表内创建的，则可以为 None，在这种情况下将存在compiler。

tables：

可选关键字参数 - 一个 Table 对象列表，这些对象将在 MetaData.create_all() 或 drop_all() 方法调用时被创建/删除。

dialect：

关键字参数，但始终存在 - 涉及操作的Dialect。

compiler：

关键字参数。对于引擎级别的 DDL 调用，将为None，但如果此 DDL 元素在表内联中创建，则将引用DDLCompiler。

state:

可选关键字参数 - 将作为此函数传递的state参数。

checkfirst：

关键字参数，在调用create()、create_all()、drop()、drop_all()时，如果设置了checkfirst标志，则为 True。

• 如果可调用函数返回 True 值，则将执行 DDL 语句。
• state - 任何将作为state关键字参数传递给可调用函数的值。
  

另请参阅

SchemaItem.ddl_if()

DDLEvents

Events

class sqlalchemy.schema.DDL

字面 DDL 语句。

指定要由数据库执行的字面 SQL DDL。DDL 对象充当 DDL 事件侦听器，并可以订阅DDLEvents中列出的事件，使用Table或MetaData对象作为目标。基本的模板支持允许单个 DDL 实例处理多个表的重复任务。

示例：

from sqlalchemy import event, DDL
tbl = Table('users', metadata, Column('uid', Integer))
event.listen(tbl, 'before_create', DDL('DROP TRIGGER users_trigger'))
spow = DDL('ALTER TABLE %(table)s SET secretpowers TRUE')
event.listen(tbl, 'after_create', spow.execute_if(dialect='somedb'))
drop_spow = DDL('ALTER TABLE users SET secretpowers FALSE')
connection.execute(drop_spow)

在操作表事件时，以下statement字符串替换可用：

%(table)s  - the Table name, with any required quoting applied
%(schema)s - the schema name, with any required quoting applied
%(fullname)s - the Table name including schema, quoted if needed

DDL 的“上下文”，如果有的话，将与上述标准替换组合。上下文中存在的键将覆盖标准替换。

成员

init()

类签名

类sqlalchemy.schema.DDL（sqlalchemy.schema.ExecutableDDLElement）

method __init__(statement, context=None)

创建 DDL 语句。

参数：

• statement -
  要执行的字符串或 Unicode 字符串。语句将使用 Python 的字符串格式化运算符处理，使用一组固定的字符串替换，以及可选的DDL.context参数提供的其他替换。
  语句中的字面‘%’必须转义为‘%%’。
  DDL 语句中不可用 SQL 绑定参数。
  
• context - 可选字典，默认为 None。这些值将可用于 DDL 语句中的字符串替换。
  

另请参阅

DDLEvents

Events

class sqlalchemy.schema._CreateDropBase

用于表示 CREATE 和 DROP 或等效操作的 DDL 构造的基类。

_CreateDropBase 的共同主题是一个element属性，指向要创建或删除的元素。

类签名

类sqlalchemy.schema._CreateDropBase（sqlalchemy.schema.ExecutableDDLElement）

class sqlalchemy.schema.CreateTable

表示 CREATE TABLE 语句。

成员

init()

类签名

类sqlalchemy.schema.CreateTable（sqlalchemy.schema._CreateBase）

method __init__(element: Table, include_foreign_key_constraints: typing_Sequence[ForeignKeyConstraint] | None = None, if_not_exists: bool = False)

创建一个CreateTable构造。

参数：

• element – 是创建的主题Table。
  
• on – 请参阅DDL中关于on的描述。
  
• include_foreign_key_constraints – 将作为内联包含在 CREATE 构造中的可选的ForeignKeyConstraint对象序列；如果省略，则包括所有未指定 use_alter=True 的外键约束。
  
• if_not_exists –
  如果为 True，则将应用 IF NOT EXISTS 操作符到构造中。
  新版本 1.4.0b2 中新增。
  

class sqlalchemy.schema.DropTable

表示 DROP TABLE 语句。

成员

init()

类签名

类sqlalchemy.schema.DropTable（sqlalchemy.schema._DropBase）

method __init__(element: Table, if_exists: bool = False)

创建一个DropTable构造。

参数：

• element – 是 DROP 的主题Table。
  
• on – 请参阅DDL中关于on的描述。
  
• if_exists –
  如果为 True，则将应用 IF EXISTS 操作符到构造中。
  新版本 1.4.0b2 中新增。
  

class sqlalchemy.schema.CreateColumn

将Column表示为通过CreateTable构造在 CREATE TABLE 语句中呈现的形式。

这是为了支持在生成 CREATE TABLE 语句时使用 Custom SQL Constructs and Compilation Extension 中记录的编译器扩展来扩展CreateColumn以支持自定义列 DDL 而提供的。

典型的集成是检查传入的Column对象，并且在找到特定标志或条件时重定向编译：

from sqlalchemy import schema
from sqlalchemy.ext.compiler import compiles
@compiles(schema.CreateColumn)
def compile(element, compiler, **kw):
    column = element.element
    if "special" not in column.info:
        return compiler.visit_create_column(element, **kw)
    text = "%s SPECIAL DIRECTIVE %s" % (
            column.name,
            compiler.type_compiler.process(column.type)
        )
    default = compiler.get_column_default_string(column)
    if default is not None:
        text += " DEFAULT " + default
    if not column.nullable:
        text += " NOT NULL"
    if column.constraints:
        text += " ".join(
                    compiler.process(const)
                    for const in column.constraints)
    return text

上述构造可以应用于Table如下：

from sqlalchemy import Table, Metadata, Column, Integer, String
from sqlalchemy import schema
metadata = MetaData()
table = Table('mytable', MetaData(),
        Column('x', Integer, info={"special":True}, primary_key=True),
        Column('y', String(50)),
        Column('z', String(20), info={"special":True})
    )
metadata.create_all(conn)

以上，我们添加到Column.info集合中的指令将被我们自定义的编译方案检测到：

CREATE TABLE mytable (
        x SPECIAL DIRECTIVE INTEGER NOT NULL,
        y VARCHAR(50),
        z SPECIAL DIRECTIVE VARCHAR(20),
    PRIMARY KEY (x)
)

CreateColumn构造也可以用于在生成CREATE TABLE时跳过某些列。这是通过创建一个有条件返回None的编译规则来实现的。这实质上就是如何产生与在Column上使用system=True参数相同的效果，该参数将列标记为隐含的“系统”列。

例如，假设我们希望生成一个Table，在 PostgreSQL 后端跳过渲染 PostgreSQL xmin列，但在其他后端进行渲染，以预期触发规则。一个条件编译规则可以仅在 PostgreSQL 上跳过此名称：

from sqlalchemy.schema import CreateColumn
@compiles(CreateColumn, "postgresql")
def skip_xmin(element, compiler, **kw):
    if element.element.name == 'xmin':
        return None
    else:
        return compiler.visit_create_column(element, **kw)
my_table = Table('mytable', metadata,
            Column('id', Integer, primary_key=True),
            Column('xmin', Integer)
        )

上面，一个CreateTable结构将仅在字符串中包含id列；xmin列将被省略，但仅针对 PostgreSQL 后端。

类签名

类sqlalchemy.schema.CreateColumn（sqlalchemy.schema.BaseDDLElement）

class sqlalchemy.schema.CreateSequence

表示一个 CREATE SEQUENCE 语句。

类签名

类sqlalchemy.schema.CreateSequence（sqlalchemy.schema._CreateBase）

class sqlalchemy.schema.DropSequence

表示一个 DROP SEQUENCE 语句。

类签名

类sqlalchemy.schema.DropSequence（sqlalchemy.schema._DropBase）

class sqlalchemy.schema.CreateIndex

表示一个 CREATE INDEX 语句。

成员

init()

类签名

类sqlalchemy.schema.CreateIndex（sqlalchemy.schema._CreateBase）

method __init__(element, if_not_exists=False)

创建一个Createindex结构。

参数：

• element – 一个Index，是 CREATE 的主题。
  
• if_not_exists –
  如果为 True，则将 IF NOT EXISTS 运算符应用于该结构。
  新版本 1.4.0b2 中新增。
  

class sqlalchemy.schema.DropIndex

表示一个 DROP INDEX 语句。

成员

init()

类签名

类sqlalchemy.schema.DropIndex（sqlalchemy.schema._DropBase）

method __init__(element, if_exists=False)

创建一个DropIndex结构。

参数：

• element – 一个Index，是 DROP 的主题。
  
• if_exists –
  如果为 True，则将 IF EXISTS 运算符应用于该结构。
  新版本 1.4.0b2 中新增。
  

class sqlalchemy.schema.AddConstraint

表示一个 ALTER TABLE ADD CONSTRAINT 语句。

类签名

类 sqlalchemy.schema.AddConstraint (sqlalchemy.schema._CreateBase)

class sqlalchemy.schema.DropConstraint

表示一个 ALTER TABLE DROP CONSTRAINT 语句。

类签名

类 sqlalchemy.schema.DropConstraint (sqlalchemy.schema._DropBase)

class sqlalchemy.schema.CreateSchema

表示一个 CREATE SCHEMA 语句。

这里的参数是模式的字符串名称。

成员

init()

类签名

类 sqlalchemy.schema.CreateSchema (sqlalchemy.schema._CreateBase)

method __init__(name, if_not_exists=False)

创建一个新的 CreateSchema 构造。

class sqlalchemy.schema.DropSchema

表示一个 DROP SCHEMA 语句。

这里的参数是模式的字符串名称。

成员

init()

类签名

类 sqlalchemy.schema.DropSchema (sqlalchemy.schema._DropBase)

method __init__(name, cascade=False, if_exists=False)

创建一个新的 DropSchema 构造。

SQL 数据类型对象

原文：docs.sqlalchemy.org/en/20/core/types.html

• 类型层次结构

• “驼峰式”数据类型
  
• “大写”数据类型
  
• 特定后端的“大写”数据类型
  
• 在多个后端使用“大写”和特定后端类型
  
• 通用“驼峰式”类型

• BigInteger
  
• Boolean
  
• Date
  
• DateTime
  
• Enum
  
• Double
  
• Float
  
• Integer
  
• Interval
  
• LargeBinary
  
• MatchType
  
• Numeric
  
• PickleType
  
• SchemaType
  
• SmallInteger
  
• String
  
• Text
  
• Time
  
• Unicode
  
• UnicodeText
  
• Uuid
  

• SQL 标准和多厂商“大写”类型

• ARRAY
  
• BIGINT
  
• BINARY
  
• BLOB
  
• BOOLEAN
  
• CHAR
  
• CLOB
  
• DATE
  
• DATETIME
  
• DECIMAL
  
• DOUBLE
  
• DOUBLE_PRECISION
  
• FLOAT
  
• INT
  
• JSON
  
• INTEGER
  
• NCHAR
  
• NVARCHAR
  
• NUMERIC
  
• REAL
  
• SMALLINT
  
• TEXT
  
• TIME
  
• TIMESTAMP
  
• UUID
  
• VARBINARY
  
• VARCHAR
  

• 自定义类型

• 覆盖类型编译
  
• 增强现有类型

• TypeDecorator

• 类型修饰器示例

• 将编码字符串强制转换为 Unicode
  
• 数值四舍五入
  
• 将时区感知时间戳存储为时区无关的 UTC
  
• 与后端无关的 GUID 类型
  
• 编组 JSON 字符串
  

• 应用 SQL 级别的绑定/结果处理
  
• 重新定义和创建新操作符
  
• 创建新类型

• UserDefinedType

• 使用自定义类型和反射
  

• 基础类型 API

• TypeEngine

• TypeEngine.Comparator
  
• TypeEngine.adapt()
  
• TypeEngine.as_generic()
  
• TypeEngine.bind_expression()
  
• TypeEngine.bind_processor()
  
• TypeEngine.coerce_compared_value()
  
• TypeEngine.column_expression()
  
• TypeEngine.comparator_factory
  
• TypeEngine.compare_values()
  
• TypeEngine.compile()
  
• TypeEngine.dialect_impl()
  
• TypeEngine.evaluates_none()
  
• TypeEngine.get_dbapi_type()
  
• TypeEngine.hashable
  
• TypeEngine.literal_processor()
  
• TypeEngine.python_type
  
• TypeEngine.render_bind_cast
  
• TypeEngine.render_literal_cast
  
• TypeEngine.result_processor()
  
• TypeEngine.should_evaluate_none
  
• TypeEngine.sort_key_function
  
• TypeEngine.with_variant()
  

• Concatenable

• Concatenable.Comparator
  
• Concatenable.comparator_factory
  

• Indexable

• Indexable.Comparator
  
• Indexable.comparator_factory
  

• NullType
  
• ExternalType

• ExternalType.cache_ok

• Variant

• Variant.with_variant()

类型层次结构

原文：docs.sqlalchemy.org/en/20/core/type_basics.html

SQLAlchemy 提供了对大多数常见数据库数据类型的抽象，以及多种自定义数据类型的技术。

数据库类型使用 Python 类表示，所有这些类最终都是从名为TypeEngine的基本类型类扩展而来。有两种一般类别的数据类型，它们在类型层次结构中以不同的方式表达自己。根据两种不同的命名约定，即“驼峰命名法”和“大写字母”，可以识别个别数据类型类使用的类别。

另请参见

使用表对象设置 MetaData - 在 SQLAlchemy Unified Tutorial 中。以教程形式演示了使用TypeEngine类型对象定义Table元数据并介绍了类型对象的概念的最基本用法。

“驼峰命名法”数据类型

初级类型的命名采用“驼峰命名法”，如String、Numeric、Integer和DateTime。所有TypeEngine的直接子类都是“驼峰命名法”类型。尽可能“驼峰命名法”类型是与数据库无关的，这意味着它们可以在任何数据库后端上使用，在这些后端上，它们将以适合该后端的方式行事，以产生所需的行为。

简单的“驼峰命名法”数据类型示例是String。在大多数后端上，将此数据类型用于 table specification 将对应于在目标后端上使用VARCHAR数据库类型，从而在数据库和数据库之间传递字符串值，如下例所示：

from sqlalchemy import MetaData
from sqlalchemy import Table, Column, Integer, String
metadata_obj = MetaData()
user = Table(
    "user",
    metadata_obj,
    Column("user_name", String, primary_key=True),
    Column("email_address", String(60)),
)

在表定义或整体 SQL 表达式中使用特定的TypeEngine类时，如果不需要参数，则可以将其作为类本身传递，即不需要实例化它，例如上面的"email_address"列中的长度参数 60。如果需要参数，则可以将类型实例化。

另一个表达更具后端特定行为的“驼峰命名法”数据类型是Boolean数据类型。与String表示所有数据库都具有的字符串数据类型不同，不是每个后端都有真正的“布尔”数据类型；一些后端使用整数或比特值 0 和 1，一些具有布尔字面常量true和false，而另一些则没有。对于此数据类型，Boolean在后端（如 PostgreSQL）上可能会呈现为BOOLEAN，在 MySQL 后端上可能为BIT，在 Oracle 上可能为SMALLINT。当使用此类型发送和接收数据到数据库时，根据正在使用的方言，它可能会解释 Python 数字或布尔值。

典型的 SQLAlchemy 应用程序通常会在一般情况下主要使用“驼峰命名法”类型，因为它们通常提供最佳的基本行为，并且可以自动地在所有后端上移植。

通用“驼峰命名法”数据类型的参考资料请参见通用“驼峰命名法”类型。

SqlAlchemy 2.0 中文文档（四十一）（3）https://developer.aliyun.com/article/1563082