标量缺省值¶

最简单的默认类型是用作列默认值的标量值：：

Table("mytable", metadata_obj,
    Column("somecolumn", Integer, default=12)
)

上面，如果没有提供其他值，则值“12”将在插入期间绑定为列值。

标量值也可能与update语句关联，尽管这并不常见（因为update语句通常寻找动态默认值）：：

Table("mytable", metadata_obj,
    Column("somecolumn", Integer, onupdate=25)
)

python执行的函数¶

这个 Column.default 和 Column.onupdate 关键字参数也接受python函数。如果没有为该列提供其他值，则在插入或更新时调用这些函数，返回的值将用于该列的值。下面演示了一个将递增计数器分配给主键列的原始“序列”：

# a function which counts upwards
i = 0
def mydefault():
    global i
    i += 1
    return i

t = Table("mytable", metadata_obj,
    Column('id', Integer, primary_key=True, default=mydefault),
)

应该注意的是，对于真正的“递增序列”行为，通常应该使用数据库的内置功能，其中可能包括序列对象或其他自动递增功能。对于主键列，SQLAlchemy在大多数情况下会自动使用这些功能。参见API文档 Column 包括 Column.autoincrement 标志，以及上的节 Sequence 本章稍后将介绍标准主键生成技术的背景。

为了说明OnUpdate，我们分配了python datetime 功能 now 到 Column.onupdate 属性：

import datetime

t = Table("mytable", metadata_obj,
    Column('id', Integer, primary_key=True),

    # define 'last_updated' to be populated with datetime.now()
    Column('last_updated', DateTime, onupdate=datetime.datetime.now),
)

当执行UPDATE语句并且没有为其传递值时 last_updated , the datetime.datetime.now() 执行python函数，其返回值用作 last_updated . 注意，我们提供 now 作为函数本身而不调用它（即后面没有括号），SQLAlchemy将在语句执行时执行函数。

def mydefault(context):
    return context.get_current_parameters()['counter'] + 12

t = Table('mytable', metadata_obj,
    Column('counter', Integer),
    Column('counter_plus_twelve', Integer, default=mydefault, onupdate=mydefault)
)

客户端调用的SQL表达式¶

这个 Column.default 和 Column.onupdate 也可以传递关键字SQL表达式，在大多数情况下，这些表达式在insert或update语句中以内联方式呈现：

t = Table("mytable", metadata_obj,
    Column('id', Integer, primary_key=True),

    # define 'create_date' to default to now()
    Column('create_date', DateTime, default=func.now()),

    # define 'key' to pull its default from the 'keyvalues' table
    Column('key', String(20), default=select(keyvalues.c.key).where(keyvalues.c.type='type1')),

    # define 'last_modified' to use the current_timestamp SQL function on update
    Column('last_modified', DateTime, onupdate=func.utc_timestamp())
    )

上面， create_date 列将填充 now() SQL函数（取决于后端，它编译为 NOW() 或 CURRENT_TIMESTAMP 在大多数情况下）在insert语句中， key 列中包含从另一个表中选择子查询的结果。这个 last_modified 将用SQL的值填充列 UTC_TIMESTAMP() 当为此表发出update语句时，mysql函数。

默认和更新由指定的SQL表达式 Column.default 和 Column.onupdate 当发生insert或update语句时，由sqlAlchemy显式调用，通常在dml语句内内联呈现，下面列出的某些情况除外。这与“服务器端”默认值不同，后者是表的DDL定义的一部分，例如，作为“create table”语句的一部分，后者可能更常见。有关服务器端默认值，请参阅下一节 服务器调用了DDL显式默认表达式 .

当SQL表达式由 Column.default 与主键列一起使用时，在某些情况下，SQLAlchemy必须“预执行”默认的生成SQL函数，这意味着它在单独的select语句中被调用，并且结果值作为参数传递给insert。这仅适用于请求返回此主键值的insert语句的主键列，其中返回或 cursor.lastrowid 不能使用。安 Insert 用于指定 insert.inline 标志将始终以内联方式呈现默认表达式。

当使用一组参数（即，它不是“ExecuteMany”样式的执行）执行语句时，返回的 CursorResult 将包含可通过访问的集合 CursorResult.postfetch_cols() 其中包含所有 Column 具有内联执行默认值的对象。类似地，绑定到语句的所有参数（包括所有预执行的python和sql表达式）都存在于 CursorResult.last_inserted_params() 或 CursorResult.last_updated_params() 关于收藏 CursorResult . 这个 CursorResult.inserted_primary_key 集合包含所插入行的主键值列表（单列主键和复合列主键以相同格式表示的列表）。

服务器调用了DDL显式默认表达式¶

SQL表达式默认值的变量是 Column.server_default ，在 Table.create() 操作：

t = Table('test', metadata_obj,
    Column('abc', String(20), server_default='abc'),
    Column('created_at', DateTime, server_default=func.sysdate()),
    Column('index_value', Integer, server_default=text("0"))
)

上面表的创建调用将产生：

CREATE TABLE test (
    abc varchar(20) default 'abc',
    created_at datetime default sysdate,
    index_value integer default 0
)

上面的示例说明了 Column.server_default 以及服务器端常量值（上述示例中的整数“0”）。建议使用 text() 为任何文本SQL值构造，而不是传递原始值，因为SQLAlchemy通常不会对这些值执行任何引用或转义。

就像客户端生成的表达式一样， Column.server_default 通常可以容纳SQL表达式，但是可以预期这些表达式通常是简单的函数和表达式，而不是像嵌入的select这样更复杂的情况。

标记隐式生成的值、时间戳和触发的列¶

基于其他服务器端数据库机制（如数据库特定的自动生成行为，如某些平台上的时间戳列）在插入或更新时生成新值的列，以及在插入或更新时调用以生成新值的自定义触发器，可以使用 FetchedValue 作为标记：

from sqlalchemy.schema import FetchedValue

t = Table('test', metadata_obj,
    Column('id', Integer, primary_key=True),
    Column('abc', TIMESTAMP, server_default=FetchedValue()),
    Column('def', String(20), server_onupdate=FetchedValue())
)

这个 FetchedValue 指示器不会影响为创建表呈现的DDL。相反，它将列标记为在执行insert或update语句的过程中由数据库填充新值的列，并且对于支持数据库，可以使用该列指示该列应是该语句的返回或输出子句的一部分。然后，诸如sqlacalchemy orm之类的工具利用这个标记来了解如何在这样的操作之后获取列的值。尤其是， ValuesBase.return_defaults() 方法可以与 Insert 或 Update 构造以指示应返回这些值。

有关使用的详细信息 FetchedValue 使用ORM，请参见 正在获取服务器生成的默认值 .

定义序列¶

SQLAlchemy表示使用 Sequence 对象，它被认为是“列默认值”的特殊情况。它只对那些明确支持序列的数据库有影响，这些数据库目前包括PostgreSQL、Oracle、mariabd10.3或更高版本以及Firebird。这个 Sequence 否则将忽略对象。

这个 Sequence 可以作为插入操作期间要使用的“默认”生成器放在任何列上，也可以配置为在更新操作期间根据需要触发。它通常与单个整数主键列一起使用：

table = Table("cartitems", metadata_obj,
    Column(
        "cart_id",
        Integer,
        Sequence('cart_id_seq', metadata=metadata_obj), primary_key=True),
    Column("description", String(40)),
    Column("createdate", DateTime())
)

在上面，表“cartems”与名为“cart_id_seq”的序列关联。当“cartems”发生insert语句，并且“cart_id”列没有传递值时，“cart_id_seq”序列将用于生成值。通常，sequence函数嵌入在insert语句中，它与返回结合在一起，以便新生成的值可以返回到python代码：

INSERT INTO cartitems (cart_id, description, createdate)
VALUES (next_val(cart_id_seq), 'some description', '2015-10-15 12:00:15')
RETURNING cart_id

当 Sequence 与 Column 作为其 Python-side 默认生成器 Sequence 当为拥有者发出类似的DDL时，也将服从“创建序列”和“删除序列”DDL。 Table . 这是一个有限范围的便利功能，不适合继承 MetaData ，例如默认架构。因此，最好的做法是 Sequence 哪个是本地的 Column / Table ，它与 MetaData 使用 Sequence.metadata 参数。见剖面图 将序列与元数据关联 关于这方面的更多背景。

with my_engine.connect() as conn:
    seq = Sequence('some_sequence')
    nextid = conn.execute(seq)

>>> my_seq = Sequence('some_sequence')
>>> stmt = select(my_seq.next_value())
>>> print(stmt.compile(dialect=postgresql.dialect()))
SELECT nextval('some_sequence') AS next_value_1

table = Table("cartitems", metadata_obj,
    Column("cart_id", Integer, Sequence('cart_id_seq'),
           primary_key=True),
    Column("description", String(40)),
    Column("createdate", DateTime())
)

table = Table("cartitems", metadata_obj,
    Column(
        "cart_id",
        Integer,
        Sequence('cart_id_seq', metadata=metadata_obj), primary_key=True),
    Column("description", String(40)),
    Column("createdate", DateTime())
)

Column(
    "cart_id", Integer, Sequence('cart_id_seq', metadata=metadata_obj),
    primary_key=True)

cart_id_seq = Sequence('cart_id_seq', metadata=metadata_obj)
table = Table("cartitems", metadata_obj,
    Column(
        "cart_id", Integer, cart_id_seq,
        server_default=cart_id_seq.next_value(), primary_key=True),
    Column("description", String(40)),
    Column("createdate", DateTime())
)

class CartItem(Base):
    __tablename__ = 'cartitems'

    cart_id_seq = Sequence('cart_id_seq', metadata=Base.metadata)
    cart_id = Column(
        Integer, cart_id_seq,
        server_default=cart_id_seq.next_value(), primary_key=True)
    description = Column(String(40))
    createdate = Column(DateTime)

CREATE TABLE cartitems (
    cart_id INTEGER DEFAULT nextval('cart_id_seq') NOT NULL,
    description VARCHAR(40),
    createdate TIMESTAMP WITHOUT TIME ZONE,
    PRIMARY KEY (cart_id)
)

计算列（始终生成为）¶

这个 Computed 构造允许 Column 在DDL中声明为“GENERATED ALWAYS as”列，即具有由数据库服务器计算的值的列。构造接受通常使用字符串或 text() 以类似于 CheckConstraint . 然后，数据库服务器解释SQL表达式，以确定行中列的值。

例子：：

from sqlalchemy import Table, Column, MetaData, Integer, Computed

metadata_obj = MetaData()

square = Table(
    "square",
    metadata_obj,
    Column("id", Integer, primary_key=True),
    Column("side", Integer),
    Column("area", Integer, Computed("side * side")),
    Column("perimeter", Integer, Computed("4 * side")),
)

的DDL square 在PostgreSQL 12后端上运行时的表将如下所示：

CREATE TABLE square (
    id SERIAL NOT NULL,
    side INTEGER,
    area INTEGER GENERATED ALWAYS AS (side * side) STORED,
    perimeter INTEGER GENERATED ALWAYS AS (4 * side) STORED,
    PRIMARY KEY (id)
)

该值是在插入和更新时持久化的，还是在获取时计算的，都是数据库的实现细节；前者称为“已存储”，后者称为“虚拟”。有些数据库实现同时支持这两种实现，但有些只支持其中一种。可选的 Computed.persisted 标志可以指定为 True 或 False 指示是否应在DDL中呈现“STORED”或“VIRTUAL”关键字，但是，如果目标后端不支持该关键字，则会引发错误；如果不设置该关键字，则将使用目标后端的工作默认值。

这个 Computed 构造是 FetchedValue 对象，并将自身设置为目标的“服务器默认值”和“服务器onupdate”生成器 Column ，这意味着在生成INSERT和UPDATE语句时，它将被视为默认的生成列，在使用ORM时，它将被作为生成列获取。这包括它将是数据库的RETURNING子句的一部分，用于支持返回的数据库，并且生成的值将被急切地获取。

“GENERATED ALWAYS AS”当前支持：

• MySQL5.7及更高版本

• MariaDB 10.x系列及以后版本

• PostgreSQL自版本12起

• Oracle—附带警告，RETURNING不能与UPDATE一起正常工作（在呈现包含计算列的UPDATE..RETURNING时将发出警告）

• Microsoft SQL服务器

• SQLite从3.31版起

• 火鸟

什么时候？ Computed 与不受支持的后端一起使用，如果目标方言不支持它，则 CompileError 在尝试呈现构造时引发。否则，如果方言支持它，但使用的特定数据库服务器版本不支持，则 DBAPIError ，通常 OperationalError 在向数据库发出DDL时引发。

标识列（默认情况下生成{ALWAYS}作为标识）¶

The Identity construct allows a Column to be declared as an identity column and rendered in DDL as "GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY". An identity column has its value automatically generated by the database server using an incrementing (or decrementing) sequence. The construct shares most of its option to control the database behaviour with Sequence.

例子：：

from sqlalchemy import Table, Column, MetaData, Integer, Computed

metadata_obj = MetaData()

data = Table(
    "data",
    metadata_obj,
    Column('id', Integer, Identity(start=42, cycle=True), primary_key=True),
    Column('data', String)
)

的DDL data 在PostgreSQL 12后端上运行时的表将如下所示：

CREATE TABLE data (
    id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 42 CYCLE) NOT NULL,
    data VARCHAR,
    PRIMARY KEY (id)
)

数据库将为 id 插入时列，从 42 ，如果语句尚未包含 id 列。identity列还可以要求数据库生成列的值，忽略语句传递的值或引发错误，具体取决于后端。要激活此模式，请设置参数 Identity.always 到 True 在 Identity 构造。更新前面的示例以包含此参数将生成以下DDL:：

CREATE TABLE data (
    id INTEGER GENERATED ALWAYS AS IDENTITY (START WITH 42 CYCLE) NOT NULL,
    data VARCHAR,
    PRIMARY KEY (id)
)

这个 Identity 构造是 FetchedValue 对象，并将自身设置为目标的“服务器默认”生成器 Column ，这意味着在生成INSERT语句时，它将被视为默认的生成列，在使用ORM时，它将被作为生成列获取。这包括它将是数据库的RETURNING子句的一部分，用于支持返回的数据库，并且生成的值将被急切地获取。

这个 Identity 目前已知construct受以下支持：

• PostgreSQL从版本10开始。

• 从版本12开始的Oracle。它也支持传球 always=None 启用默认生成模式和参数 on_null=True 将“ON NULL”与“默认”标识列一起指定。

• Microsoft SQL Server。MSSQL使用的自定义语法仅支持 start 和 increment 参数，忽略所有其他参数。

什么时候？ Identity 与不受支持的后端一起使用，则忽略它，并使用用于自动递增列的默认SQLAlchemy逻辑。

当 Column 同时指定 Identity 也设置了 Column.autoincrement 到 False .

默认对象API¶

class sqlalchemy.schema.Computed(sqltext, persisted=None)¶

定义一个生成的列，即“generated ALWAYS AS”语法。

这个 Computed 将参数的内联构造添加到构造的列表中 Column 对象：

from sqlalchemy import Computed

Table('square', meta,
    Column('side', Float, nullable=False),
    Column('area', Float, Computed('side * side'))
)

有关完整的详细信息，请参阅下面的链接文档。

1.3.11 新版功能.

参见

计算列（始终生成为）

类签名

class sqlalchemy.schema.Computed (sqlalchemy.schema.FetchedValue, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.Computed.__init__(sqltext, persisted=None)¶

构造一个生成的ALWAYS AS DDL构造来伴随 Column .

参数

• sqltext¶ -- 包含列生成表达式的字符串（将逐字使用），或SQL表达式构造，例如 text() 对象。如果以字符串形式给定，则对象将转换为 text() 对象。。警告：： Computed.sqltext 参数 Computed 可以作为python字符串参数传递，该参数将被视为 可信SQL文本 并按规定呈现。 不要将不受信任的输入传递给此参数 .

• persisted¶ -- 可选，控制数据库应如何保存此列。可能的值包括： * None, the default, it will use the default persistence defined by the database. * True 将渲染 GENERATED ALWAYS AS ... STORED ，或目标数据库的等效项（如果支持）。* False 将渲染 GENERATED ALWAYS AS ... VIRTUAL ，或目标数据库的等效项（如果支持）。指定 True 或 False 如果目标数据库不支持持久性选项，则在向目标数据库发出DDL时可能会引发错误。保留此参数的默认值 None 对于所有支持 GENERATED ALWAYS AS .

method sqlalchemy.schema.Computed.copy(target_table=None, **kw)¶

1.4 版后已移除: 这个 Computed.copy() 方法已弃用，并将在将来的版本中删除。

class sqlalchemy.schema.ColumnDefault(arg, **kwargs)¶

列上的普通默认值。

这可能对应于常量、可调用函数或SQL子句。

ColumnDefault 每当 default ， onupdate 论点 Column 被使用。一 ColumnDefault 也可以按位置传递。

例如，以下内容：

Column('foo', Integer, default=50)

等于：

Column('foo', Integer, ColumnDefault(50))

类签名

class sqlalchemy.schema.ColumnDefault (sqlalchemy.schema.DefaultGenerator)

class sqlalchemy.schema.DefaultClause(arg, for_update=False, _reflected=False)¶

DDL指定的默认列值。

DefaultClause 是一个 FetchedValue 当发出“create table”时，也会生成一个“default”子句。

DefaultClause 每当 server_default ， server_onupdate 论点 Column 被使用。一 DefaultClause 也可以按位置传递。

例如，以下内容：

Column('foo', Integer, server_default="50")

等于：

Column('foo', Integer, DefaultClause("50"))

类签名

class sqlalchemy.schema.DefaultClause (sqlalchemy.schema.FetchedValue)

class sqlalchemy.schema.DefaultGenerator(for_update=False)¶

列的基类 违约 价值观。

类签名

class sqlalchemy.schema.DefaultGenerator (sqlalchemy.sql.expression.Executable, sqlalchemy.schema.SchemaItem)

class sqlalchemy.schema.FetchedValue(for_update=False)¶

透明数据库端默认值的标记。

使用 FetchedValue 当数据库被配置为为为列提供一些自动默认值时。

例如。：：

Column('foo', Integer, FetchedValue())

将指示某些触发器或默认生成器将为 foo 插入期间的列。

参见

标记隐式生成的值、时间戳和触发的列

类签名

class sqlalchemy.schema.FetchedValue (sqlalchemy.sql.expression.SchemaEventTarget)

class sqlalchemy.schema.Sequence(name, start=None, increment=None, minvalue=None, maxvalue=None, nominvalue=None, nomaxvalue=None, cycle=None, schema=None, cache=None, order=None, data_type=None, optional=False, quote=None, metadata=None, quote_schema=None, for_update=False)¶

表示命名的数据库序列。

这个 Sequence 对象表示数据库序列的名称和配置参数。它还表示一个构造，可以由一个sqlAlchemy“执行” Engine 或 Connection ，为目标数据库呈现相应的“next value”函数并返回结果。

这个 Sequence 通常与主键列关联：：

some_table = Table(
    'some_table', metadata,
    Column('id', Integer, Sequence('some_table_seq'),
    primary_key=True)
)

当为上述发出“创建表”时 Table 如果目标平台支持序列，则也将发出create sequence语句。对于不支持序列的平台， Sequence 忽略构造。

参见

定义序列

CreateSequence

DropSequence

类签名

class sqlalchemy.schema.Sequence (sqlalchemy.schema.IdentityOptions, sqlalchemy.schema.DefaultGenerator)

method sqlalchemy.schema.Sequence.__init__(name, start=None, increment=None, minvalue=None, maxvalue=None, nominvalue=None, nomaxvalue=None, cycle=None, schema=None, cache=None, order=None, data_type=None, optional=False, quote=None, metadata=None, quote_schema=None, for_update=False)¶

构建一个 Sequence 对象。

参数

• name¶ -- 序列的名称。

• start¶ -- 序列的起始索引。当create sequence命令作为“start with”子句的值发送到数据库时，将使用此值。如果 None ，省略了该子句，在大多数平台上，该子句指示的起始值为1。

• increment¶ -- 序列的增量值。当create sequence命令作为“increment by”子句的值发送到数据库时，使用该值。如果 None ，该子句被省略，在大多数平台上，它表示增量为1。

• minvalue¶ -- 序列的最小值。当将create sequence命令作为“minvalue”子句的值发送到数据库时，将使用此值。如果 None ，省略该子句，在大多数平台上，该子句分别表示升序序列和降序序列的最小值1和-2^63-1。…添加的版本：1.0.7

• maxvalue¶ -- 序列的最大值。当将create sequence命令作为“maxvalue”子句的值发送到数据库时，将使用此值。如果 None ，省略该子句，在大多数平台上，它分别表示升序和降序序列的最大值2^63-1和-1。…添加的版本：1.0.7

• nominvalue¶ -- 序列没有最小值。当将create sequence命令作为“no minvalue”子句的值发送到数据库时，将使用此值。如果 None ，省略该子句，在大多数平台上，该子句分别表示升序序列和降序序列的最小值1和-2^63-1。…添加的版本：1.0.7

• nomaxvalue¶ -- 序列没有最大值。当create sequence命令作为“no maxvalue”子句的值发送到数据库时，将使用此值。如果 None ，省略该子句，在大多数平台上，它分别表示升序和降序序列的最大值2^63-1和-1。…添加的版本：1.0.7

• cycle¶ -- 允许序列在分别由升序或降序到达maxvalue或minvalue时换行。当将create sequence命令作为“cycle”子句发送到数据库时，将使用此值。如果达到限制，则生成的下一个数字将分别是minvalue或maxvalue。如果cycle=false（默认值），则在序列达到最大值后对nextval的任何调用都将返回错误。…添加的版本：1.0.7

• schema¶ -- 序列的可选架构名称（如果位于默认架构之外）。当 MetaData 也存在与 Table.schema .

• cache¶ -- 可选整数值；预先计算的序列中未来值的数目。呈现Oracle和PostgreSQL理解的缓存关键字。…添加版本：1.1.12

• order¶ -- 可选布尔值；如果 True ，呈现Oracle可以理解的ORDER关键字，指示序列已明确排序。可能需要使用Oracle RAC提供确定性排序。。版本添加：：1.1.12

• data_type¶ -- 序列返回的类型，对于允许我们在INTEGER、BIGINT等之间进行选择的方言（例如，mssql）。。版本添加：：1.4.0

• optional¶ -- 布尔值，当 True ，表示 Sequence 对象只需要在后端显式生成，而后端不提供生成主键标识符的其他方法。目前，它实质上意味着，“不要在PostgreSQL后端创建这个序列，在那里序列关键字会自动为我们创建一个序列”。

• quote¶ -- 布尔值，当 True 或 False ，显式强制引用 Sequence.name 开还是关。当保留默认值时 None 根据大小写和保留字进行正常报价规则。

• quote_schema¶ -- 设置的报价首选项 schema 姓名。

• metadata¶ -- 可选择的 MetaData 对象 Sequence 将与关联。一 Sequence 与 MetaData 获得以下功能： * The Sequence will inherit the MetaData.schema parameter specified to the target MetaData, which affects the production of CREATE / DROP DDL, if any. * 这个 Sequence.create() 和 Sequence.drop() 方法自动使用绑定到 MetaData 对象（如果有）。＊ MetaData.create_all() 和 MetaData.drop_all() 方法将为此发出create/drop Sequence ，即使 Sequence 不与任何 Table / Column 这是其中的一员 MetaData . 只有当 Sequence 与 MetaData 通过这个参数。…参阅： 将序列与元数据关联 -充分讨论 Sequence.metadata 参数。

• for_update¶ -- 表明这一点 Sequence ，当与 Column 当语句中该列没有其他值时，应为该列的表上的update语句而不是insert语句调用。

attribute sqlalchemy.schema.Sequence.bind¶

method sqlalchemy.schema.Sequence.create(bind=None, checkfirst=True)¶

在数据库中创建此序列。

注解

“bind”参数在SQLAlchemy 2.0中是必需的。

method sqlalchemy.schema.Sequence.drop(bind=None, checkfirst=True)¶

从数据库中删除此序列。

注解

“bind”参数在SQLAlchemy 2.0中是必需的。

method sqlalchemy.schema.Sequence.next_value()¶

返回A next_value 函数元素，它将为此呈现适当的增量函数 Sequence 在任何SQL表达式中。

class sqlalchemy.schema.Identity(always=False, on_null=None, start=None, increment=None, minvalue=None, maxvalue=None, nominvalue=None, nomaxvalue=None, cycle=None, cache=None, order=None)¶

定义一个标识列，即“GENERATED{ALWAYS|DEFAULT}AS identity”语法。

这个 Identity 将参数的内联构造添加到构造的列表中 Column 对象：

from sqlalchemy import Identity

Table('foo', meta,
    Column('id', Integer, Identity())
    Column('description', Text),
)

有关完整的详细信息，请参阅下面的链接文档。

1.4 新版功能.

参见

标识列（默认情况下生成{ALWAYS}作为标识）

类签名

class sqlalchemy.schema.Identity (sqlalchemy.schema.IdentityOptions, sqlalchemy.schema.FetchedValue, sqlalchemy.schema.SchemaItem)

method sqlalchemy.schema.Identity.__init__(always=False, on_null=None, start=None, increment=None, minvalue=None, maxvalue=None, nominvalue=None, nomaxvalue=None, cycle=None, cache=None, order=None)¶

构造一个生成的{ALWAYS|默认情况下是}作为标识DDL构造来伴随 Column .

见 Sequence 大多数参数的完整描述文档。

注解

MSSQL支持将此构造作为在列上生成标识的首选方法，但它使用的非标准语法仅支持 Identity.start 和 Identity.increment . 所有其他参数都将被忽略。

参数

• always¶ -- 布尔值，指示标识列的类型。如果 False 则用户指定的值优先。如果 True 如果指定，则不接受用户指定的值（在某些后端，如PostgreSQL，可以在INSERT中指定重写系统值或类似值来重写序列值）。某些后端也有此参数的默认值， None 可用于省略在DDL中呈现此部分。它将被视为 False 如果后端没有默认值。

• on_null¶ -- 设置为 True 在NULL和 always=False 标识列。此选项仅在某些后端（如Oracle）上受支持。

• start¶ -- 序列的起始索引。

• increment¶ -- 序列的增量值。

• minvalue¶ -- 序列的最小值。

• maxvalue¶ -- 序列的最大值。

• nominvalue¶ -- 没有序列的最小值。

• nomaxvalue¶ -- 序列没有最大值。

• cycle¶ -- 允许序列在达到maxvalue或minvalue时换行。

• cache¶ -- 可选整数值；序列中预先计算的未来值的数目。

• order¶ -- 可选布尔值；如果为true，则呈现ORDER关键字。

method sqlalchemy.schema.Identity.copy(**kw)¶

1.4 版后已移除: 这个 Identity.copy() 方法已弃用，并将在将来的版本中删除。