Index

优质

小牛编辑

133浏览

2023-12-01

符号

**cparams (sqlalchemy.engine.default.DefaultDialect.connect parameter)

(sqlalchemy.engine.Dialect.connect parameter)

**dialect_kw (sqlalchemy.schema.Constraint parameter)

(sqlalchemy.schema.ForeignKey parameter)
(sqlalchemy.schema.ForeignKeyConstraint parameter)

**dialect_kwargs (sqlalchemy.schema.MetaData.reflect parameter)

**kw (sqlalchemy.dialects.mysql.Insert.on_duplicate_key_update parameter)

(sqlalchemy.engine.URL.translate_connect_args parameter)
(sqlalchemy.events.DDLEvents.after_create parameter)

**kwargs (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.operate parameter)

(sqlalchemy.orm.ColumnProperty.Comparator.operate parameter)
(sqlalchemy.orm.PropComparator.any parameter)

**types (sqlalchemy.sql.expression.TextClause.columns parameter)

*addl_attrs (sqlalchemy.orm.defer parameter)

(sqlalchemy.orm.undefer parameter)

*args (sqlalchemy.dialects.mysql.Insert.on_duplicate_key_update parameter)

(sqlalchemy.schema.Column parameter)
(sqlalchemy.schema.Table parameter)

*cargs (sqlalchemy.engine.default.DefaultDialect.connect parameter)

(sqlalchemy.engine.Dialect.connect parameter)

*clauses (sqlalchemy.sql.expression.GenerativeSelect.group_by parameter)

(sqlalchemy.sql.expression.GenerativeSelect.order_by parameter)
(sqlalchemy.sql.expression.Select.group_by parameter)

*col_expressions (sqlalchemy.engine.CursorResult.columns parameter)

(sqlalchemy.engine.Result.columns parameter)

*cols (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)
(sqlalchemy.sql.expression.TextClause.columns parameter)

*columns (sqlalchemy.orm.deferred parameter)

(sqlalchemy.schema.ColumnCollectionConstraint parameter)
(sqlalchemy.schema.UniqueConstraint parameter)

*elements (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

*entities (sqlalchemy.future.select parameter)

(sqlalchemy.orm.Query.from_self parameter)
(sqlalchemy.sql.expression.select parameter)

*enums (sqlalchemy.types.Enum parameter)

*expr (sqlalchemy.orm.Query.distinct parameter)

(sqlalchemy.orm.Query.prefix_with parameter)
(sqlalchemy.orm.Query.suffix_with parameter)

*expressions (sqlalchemy.schema.Index parameter)

*exprs (sqlalchemy.orm.Bundle parameter)

*from_obj (sqlalchemy.orm.Query.select_from parameter)

*fromclauses (sqlalchemy.sql.expression.ScalarSelect.correlate parameter)

(sqlalchemy.sql.expression.ScalarSelect.correlate_except parameter)
(sqlalchemy.sql.expression.Select.correlate parameter)

*multiparams/**params (sqlalchemy.engine.Connection.execute parameter)

*names (sqlalchemy.orm.validates parameter)

*opts (sqlalchemy.orm.Load.options parameter) , [0]

*order_by (sqlalchemy.sql.expression.within_group parameter)

*other (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.operate parameter)

(sqlalchemy.orm.ColumnProperty.Comparator.operate parameter)
(sqlalchemy.orm.PropComparator.operate parameter)

*props (sqlalchemy.orm.Query.join parameter)

*selects (sqlalchemy.sql.expression.except_ parameter)

(sqlalchemy.sql.expression.except_all parameter)
(sqlalchemy.sql.expression.intersect parameter)

*whens (sqlalchemy.sql.expression.case parameter)

1.x风格 , [0]

2.0风格 , [0]

_

__add__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__and__() (sqlalchemy.sql.expression.ColumnOperators 方法)

(sqlalchemy.sql.expression.Operators 方法)

__call__() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.orm.scoping.scoped_session 方法)
(sqlalchemy.orm.sessionmaker 方法)

__delete__() (sqlalchemy.orm.InstrumentedAttribute 方法)

__div__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__eq__() (sqlalchemy.orm.PropComparator 方法)

(sqlalchemy.orm.QueryableAttribute 方法)
(sqlalchemy.orm.RelationshipProperty.Comparator 方法)

__ge__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__get__() (sqlalchemy.orm.InstrumentedAttribute 方法)

__getitem__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__gt__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__hash__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__init__() (sqlalchemy.dialects.mssql.BIT 方法)

(sqlalchemy.dialects.mssql.CHAR 方法)
(sqlalchemy.dialects.mssql.DATETIME2 方法)

__invert__() (sqlalchemy.sql.expression.ColumnOperators 方法)

(sqlalchemy.sql.expression.Operators 方法)

__le__() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

__lshift__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__lt__() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

__mod__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__mul__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__ne__() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)
(sqlalchemy.orm.PropComparator 方法)

__neg__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__or__() (sqlalchemy.sql.expression.ColumnOperators 方法)

(sqlalchemy.sql.expression.Operators 方法)

__radd__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__rdiv__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__rmod__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__rmul__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__rshift__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__rsub__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__rtruediv__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__set__() (sqlalchemy.orm.InstrumentedAttribute 方法)

__sub__() (sqlalchemy.sql.expression.ColumnOperators 方法)

__truediv__() (sqlalchemy.sql.expression.ColumnOperators 方法)

_asdict() (sqlalchemy.engine.Row 方法)

_connection_record (sqlalchemy.pool._ConnectionFairy 属性)

_ConnectionFairy (sqlalchemy.pool 中的类)

_ConnectionRecord (sqlalchemy.pool 中的类)

_create_rule (sqlalchemy.schema.Constraint parameter)

_CreateDropBase (sqlalchemy.schema 中的类)

_fields (sqlalchemy.engine.Row 属性)

_get_listen_keys() (sqlalchemy.ext.mutable.Mutable 类方法)

_listen_on_attribute() (sqlalchemy.ext.mutable.Mutable 类方法)

_mapping (sqlalchemy.engine.Row 属性)

_parents (sqlalchemy.ext.mutable.Mutable 属性)

(sqlalchemy.ext.mutable.MutableBase 属性)

_type_bound (sqlalchemy.schema.Constraint parameter)

A

AbstractConcreteBase (sqlalchemy.ext.declarative 中的类)

ACID

ACID 酸模型

active_history (sqlalchemy.orm.AttributeEvents parameter)

(sqlalchemy.orm.column_property parameter)
(sqlalchemy.orm.composite parameter)

adapt() (sqlalchemy.types.SchemaType 方法)

(sqlalchemy.types.TypeEngine 方法)

adapt_on_names (sqlalchemy.orm.aliased parameter)

adapt_to_emulated() (sqlalchemy.types.Interval 方法)

adapt_to_entity() (sqlalchemy.orm.PropComparator 方法)

(sqlalchemy.orm.QueryableAttribute 方法)
(sqlalchemy.orm.RelationshipProperty.Comparator 方法)

AdaptedConnection (sqlalchemy.engine 中的类)

adapter (sqlalchemy.orm.PropComparator 属性)

(sqlalchemy.orm.QueryableAttribute 属性)
(sqlalchemy.orm.RelationshipProperty.Comparator 属性)

add() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.ext.mutable.MutableSet 方法)

add_all() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

add_column() (sqlalchemy.orm.Query 方法)

add_columns() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)

add_criteria() (sqlalchemy.ext.baked.BakedQuery 方法)

(sqlalchemy.sql.expression.StatementLambdaElement 方法)

add_cte() (sqlalchemy.sql.expression.HasCTE 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.SelectBase 方法)

add_entity() (sqlalchemy.orm.Query 方法)

add_is_dependent_on() (sqlalchemy.schema.Table 方法)

add_properties() (sqlalchemy.orm.Mapper 方法)

add_property() (sqlalchemy.orm.Mapper 方法)

AddConstraint (sqlalchemy.schema 中的类)

adds() (sqlalchemy.orm.collections.collection 静态方法)

adjacent_to() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

after_attach() (sqlalchemy.orm.SessionEvents 方法)

after_begin() (sqlalchemy.orm.SessionEvents 方法)

after_bulk_delete() (sqlalchemy.orm.SessionEvents 方法)

after_bulk_update() (sqlalchemy.orm.SessionEvents 方法)

after_commit() (sqlalchemy.orm.SessionEvents 方法)

after_configured() (sqlalchemy.orm.MapperEvents 方法)

after_create() (sqlalchemy.events.DDLEvents 方法)

after_cursor_execute() (sqlalchemy.events.ConnectionEvents 方法)

after_delete() (sqlalchemy.orm.MapperEvents 方法)

after_drop() (sqlalchemy.events.DDLEvents 方法)

after_execute() (sqlalchemy.events.ConnectionEvents 方法)

after_flush() (sqlalchemy.orm.SessionEvents 方法)

after_flush_postexec() (sqlalchemy.orm.SessionEvents 方法)

after_insert() (sqlalchemy.orm.MapperEvents 方法)

after_parent_attach() (sqlalchemy.events.DDLEvents 方法)

after_rollback() (sqlalchemy.orm.SessionEvents 方法)

after_soft_rollback() (sqlalchemy.orm.SessionEvents 方法)

after_transaction_create() (sqlalchemy.orm.SessionEvents 方法)

after_transaction_end() (sqlalchemy.orm.SessionEvents 方法)

after_update() (sqlalchemy.orm.MapperEvents 方法)

against (sqlalchemy.dialects.mysql.match parameter)

against() (sqlalchemy.schema.DDLElement 方法)

aggregate_order_by (sqlalchemy.dialects.postgresql 中的类)

alias (sqlalchemy.orm.aliased parameter)

Alias (sqlalchemy.sql.expression 中的类)

alias() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.CTE 方法)
(sqlalchemy.sql.expression.FromClause 方法)

aliased (sqlalchemy.orm.Query.join parameter)

(sqlalchemy.orm.with_polymorphic parameter)

aliased() (在 sqlalchemy.orm 模块中)

AliasedClass (sqlalchemy.orm.util 中的类)

AliasedInsp (sqlalchemy.orm.util 中的类)

AliasedReturnsRows (sqlalchemy.sql.expression 中的类)

aliasname (sqlalchemy.orm.polymorphic_union parameter)

all() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

All() (在 sqlalchemy.dialects.postgresql 模块中)

all_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

all_mappers (sqlalchemy.orm.ORMExecuteState 属性)

all_orm_descriptors (sqlalchemy.orm.Mapper 属性)

allow_partial_pks (sqlalchemy.orm.mapper parameter)

allows_lambda (sqlalchemy.sql.expression.ColumnElement 属性)

always (sqlalchemy.schema.Identity parameter)

always_refresh (sqlalchemy.orm.mapper parameter)

AmbiguousForeignKeysError

and_() (sqlalchemy.orm.PropComparator 方法)

(sqlalchemy.orm.QueryableAttribute 方法)
(sqlalchemy.orm.RelationshipProperty.Comparator 方法)

anon_key_label (sqlalchemy.schema.Column 属性)

(sqlalchemy.sql.expression.ColumnElement 属性)

anon_label (sqlalchemy.schema.Column 属性)

(sqlalchemy.sql.expression.ColumnElement 属性)

ansi_bind_rules (sqlalchemy.sql.compiler.SQLCompiler 属性)

AnsiFunction (sqlalchemy.sql.functions 中的类)

any() (sqlalchemy.ext.associationproxy.AssociationProxyInstance 方法)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance 方法)

Any() (在 sqlalchemy.dialects.postgresql 模块中)

any_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

append (sqlalchemy.engine.URL.update_query_dict parameter)

(sqlalchemy.engine.URL.update_query_pairs parameter)
(sqlalchemy.engine.URL.update_query_string parameter)

append() (sqlalchemy.ext.mutable.MutableList 方法)

(sqlalchemy.ext.orderinglist.OrderingList 方法)
(sqlalchemy.orm.AttributeEvents 方法)

append_column() (sqlalchemy.schema.Table 方法)

append_constraint() (sqlalchemy.schema.Table 方法)

append_wo_mutation() (sqlalchemy.orm.AttributeEvents 方法)

appender() (sqlalchemy.orm.collections.collection 静态方法)

AppenderQuery (sqlalchemy.orm 中的类)

apply_labels() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

args (sqlalchemy.orm.InstanceEvents.init parameter)

(sqlalchemy.orm.InstanceEvents.init_failure parameter)

argument (sqlalchemy.orm.relationship parameter)

argument_for() (sqlalchemy.schema.CheckConstraint 类方法)

(sqlalchemy.schema.Column 类方法)
(sqlalchemy.schema.ColumnCollectionConstraint 类方法)

argument_name (sqlalchemy.schema.CheckConstraint.argument_for parameter)

(sqlalchemy.schema.Column.argument_for parameter)
(sqlalchemy.schema.ColumnCollectionConstraint.argument_for parameter)

ArgumentError

ARRAY (sqlalchemy.dialects.postgresql 中的类)

array (sqlalchemy.dialects.postgresql 中的类)

ARRAY (sqlalchemy.types 中的类)

array() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

ARRAY.Comparator (sqlalchemy.dialects.postgresql 中的类)

(sqlalchemy.types 中的类)

array_agg (sqlalchemy.sql.functions 中的类)

array_agg() (在 sqlalchemy.dialects.postgresql 模块中)

as_boolean() (sqlalchemy.types.JSON.Comparator 方法)

as_comparison() (sqlalchemy.sql.functions.FunctionElement 方法)

as_declarative() (在 sqlalchemy.orm 模块中)

as_declarative_base() (sqlalchemy.orm.registry 方法)

as_float() (sqlalchemy.types.JSON.Comparator 方法)

as_generic() (sqlalchemy.types.TypeEngine 方法)

as_immutable() (sqlalchemy.sql.expression.ColumnCollection 方法)

as_integer() (sqlalchemy.types.JSON.Comparator 方法)

as_json() (sqlalchemy.types.JSON.Comparator 方法)

as_mutable() (sqlalchemy.ext.mutable.Mutable 类方法)

as_numeric() (sqlalchemy.types.JSON.Comparator 方法)

as_scalar() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.SelectBase 方法)

as_string() (sqlalchemy.types.JSON.Comparator 方法)

as_tuple (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)

as_uuid (sqlalchemy.dialects.postgresql.UUID parameter)

asc() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

ascii (sqlalchemy.dialects.mysql.ENUM parameter)

(sqlalchemy.dialects.mysql.LONGTEXT parameter)
(sqlalchemy.dialects.mysql.MEDIUMTEXT parameter)

asdecimal (sqlalchemy.dialects.mssql.REAL parameter)

(sqlalchemy.dialects.oracle.DOUBLE_PRECISION parameter)
(sqlalchemy.dialects.oracle.NUMBER parameter)

AssertionPool (sqlalchemy.pool 中的类)

associate_with() (sqlalchemy.ext.mutable.Mutable 类方法)

associate_with_attribute() (sqlalchemy.ext.mutable.Mutable 类方法)

ASSOCIATION_PROXY() (在 sqlalchemy.ext.associationproxy 模块中)

association_proxy() (在 sqlalchemy.ext.associationproxy 模块中)

AssociationProxy (sqlalchemy.ext.associationproxy 中的类)

AssociationProxyInstance (sqlalchemy.ext.associationproxy 中的类)

astext (sqlalchemy.dialects.postgresql.JSON.Comparator 属性)

astext_type (sqlalchemy.dialects.postgresql.JSON parameter)

async_object_session() (在 sqlalchemy.ext.asyncio 模块中)

async_scoped_session (sqlalchemy.ext.asyncio 中的类)

async_session (sqlalchemy.orm.InstanceState 属性)

async_session() (在 sqlalchemy.ext.asyncio 模块中)

AsyncConnection (sqlalchemy.ext.asyncio 中的类)

AsyncEngine (sqlalchemy.ext.asyncio 中的类)

AsyncMappingResult (sqlalchemy.ext.asyncio 中的类)

AsyncResult (sqlalchemy.ext.asyncio 中的类)

AsyncScalarResult (sqlalchemy.ext.asyncio 中的类)

AsyncSession (sqlalchemy.ext.asyncio 中的类)

AsyncSessionTransaction (sqlalchemy.ext.asyncio 中的类)

AsyncTransaction (sqlalchemy.ext.asyncio 中的类)

attr (sqlalchemy.ext.associationproxy.association_proxy parameter)

(sqlalchemy.ext.associationproxy.AssociationProxy parameter)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance 属性)

attr_name (sqlalchemy.ext.indexable.index_property parameter)

attribute_instrument() (sqlalchemy.orm.InstrumentationEvents 方法)

attribute_mapped_collection() (在 sqlalchemy.orm.collections 模块中)

attribute_names (sqlalchemy.ext.asyncio.async_scoped_session.expire parameter)

(sqlalchemy.ext.asyncio.AsyncSession.expire parameter)
(sqlalchemy.orm.scoping.scoped_session.expire parameter)

AttributeEvent (sqlalchemy.orm 中的类)

AttributeEvents (sqlalchemy.orm 中的类)

AttributeState (sqlalchemy.orm 中的类)

attrname (sqlalchemy.ext.automap.generate_relationship parameter)

attrs (sqlalchemy.orm.InstanceEvents.expire parameter)

(sqlalchemy.orm.InstanceEvents.refresh parameter)
(sqlalchemy.orm.InstanceEvents.refresh_flush parameter)

autocommit (sqlalchemy.engine.Connection.execution_options parameter)

(sqlalchemy.orm.Session parameter)
(sqlalchemy.orm.sessionmaker parameter)

autoescape (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.contains parameter)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.endswith parameter)
(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.startswith parameter)

autoflush (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.orm.Session parameter)
(sqlalchemy.orm.sessionmaker parameter)

autoflush() (sqlalchemy.orm.Query 方法)

autoincrement (sqlalchemy.schema.Column parameter)

autoload (sqlalchemy.schema.Table parameter)

autoload_replace (sqlalchemy.schema.MetaData.reflect parameter)

(sqlalchemy.schema.Table parameter)

autoload_with (sqlalchemy.schema.Table parameter)

automap_base() (在 sqlalchemy.ext.automap 模块中)

AutomapBase (sqlalchemy.ext.automap 中的类)

AwaitRequired

B

back_populates (sqlalchemy.orm.relationship parameter)

backref (sqlalchemy.orm.relationship parameter)

backref() (在 sqlalchemy.orm 模块中)

bake_queries (sqlalchemy.orm.relationship parameter)

baked_lazyload() (sqlalchemy.orm.Load 方法) , [3]

BakedQuery (sqlalchemy.ext.baked 中的类)

Bakery (sqlalchemy.ext.baked 中的类)

bakery() (sqlalchemy.ext.baked.BakedQuery 类方法)

(在 sqlalchemy.ext.baked 模块中)

base (sqlalchemy.ext.automap.classname_for_table parameter)

(sqlalchemy.ext.automap.generate_relationship parameter)
(sqlalchemy.ext.automap.name_for_collection_relationship parameter)

base_columns (sqlalchemy.sql.expression.ColumnElement 属性)

base_mapper (sqlalchemy.orm.Mapper 属性)

BaseCursorResult (sqlalchemy.engine 中的类)

batch (sqlalchemy.orm.mapper parameter)

before_attach() (sqlalchemy.orm.SessionEvents 方法)

before_commit() (sqlalchemy.orm.SessionEvents 方法)

before_compile() (sqlalchemy.orm.QueryEvents 方法)

before_compile_delete() (sqlalchemy.orm.QueryEvents 方法)

before_compile_update() (sqlalchemy.orm.QueryEvents 方法)

before_configured() (sqlalchemy.orm.MapperEvents 方法)

before_create() (sqlalchemy.events.DDLEvents 方法)

before_cursor_execute() (sqlalchemy.events.ConnectionEvents 方法)

before_delete() (sqlalchemy.orm.MapperEvents 方法)

before_drop() (sqlalchemy.events.DDLEvents 方法)

before_execute() (sqlalchemy.events.ConnectionEvents 方法)

before_flush() (sqlalchemy.orm.SessionEvents 方法)

before_insert() (sqlalchemy.orm.MapperEvents 方法)

before_mapper_configured() (sqlalchemy.orm.MapperEvents 方法)

before_parent_attach() (sqlalchemy.events.DDLEvents 方法)

before_update() (sqlalchemy.orm.MapperEvents 方法)

begin() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.Engine 方法)
(sqlalchemy.events.ConnectionEvents 方法)

begin_nested() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.ext.asyncio.async_scoped_session 方法)
(sqlalchemy.ext.asyncio.AsyncConnection 方法)

begin_twophase() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.events.ConnectionEvents 方法)

between() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

BFILE (sqlalchemy.dialects.oracle 中的类)

BIGINT (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

BigInteger (sqlalchemy.types 中的类)

BINARY (sqlalchemy.dialects.mysql 中的类)

binary (sqlalchemy.dialects.mysql.CHAR parameter)

(sqlalchemy.dialects.mysql.ENUM parameter)
(sqlalchemy.dialects.mysql.LONGTEXT parameter)

BINARY (sqlalchemy.types 中的类)

BinaryExpression (sqlalchemy.sql.expression 中的类)

bind (sqlalchemy.dialects.postgresql.ENUM.create parameter)

(sqlalchemy.dialects.postgresql.ENUM.drop parameter)
(sqlalchemy.engine.reflection.Inspector parameter)

bind_arguments (sqlalchemy.orm.ORMExecuteState 属性)

(sqlalchemy.orm.ORMExecuteState.invoke_statement parameter)
(sqlalchemy.orm.scoping.scoped_session.connection parameter)

bind_expression() (sqlalchemy.types.TypeDecorator 方法)

(sqlalchemy.types.TypeEngine 方法)

bind_mapper (sqlalchemy.orm.ORMExecuteState 属性)

bind_mapper() (sqlalchemy.orm.Session 方法)

bind_processor() (sqlalchemy.dialects.postgresql.HSTORE 方法)

(sqlalchemy.types.Boolean 方法)
(sqlalchemy.types.Interval 方法)

bind_table() (sqlalchemy.orm.Session 方法)

bindparam() (在 sqlalchemy.sql.expression 模块中)

BindParameter (sqlalchemy.sql.expression 中的类)

bindparams() (sqlalchemy.sql.expression.TextClause 方法)

binds (sqlalchemy.orm.Session parameter)

BIT (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.dialects.postgresql 中的类)

BLANK_SCHEMA (sqlalchemy.schema.sqlalchemy.schema 属性)

BLOB (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

bool_op() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

BOOLEAN (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

Boolean (sqlalchemy.types 中的类)

branch (sqlalchemy.events.ConnectionEvents.engine_connect parameter)

bulk_insert_mappings() (sqlalchemy.orm.scoping.scoped_session 方法)

(sqlalchemy.orm.Session 方法)

bulk_replace() (sqlalchemy.orm.AttributeEvents 方法)

(在 sqlalchemy.orm.collections 模块中)

bulk_save_objects() (sqlalchemy.orm.scoping.scoped_session 方法)

(sqlalchemy.orm.Session 方法)

bulk_update_mappings() (sqlalchemy.orm.scoping.scoped_session 方法)

(sqlalchemy.orm.Session 方法)

Bundle (sqlalchemy.orm 中的类)

BYTEA (sqlalchemy.dialects.postgresql 中的类)

C

c (sqlalchemy.orm.Bundle 属性)

(sqlalchemy.orm.Mapper 属性)
(sqlalchemy.schema.Table 属性)

cache (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

cache_ok (sqlalchemy.types.TypeDecorator 属性)

CacheKey (sqlalchemy.sql.expression 中的类)

callable_ (sqlalchemy.schema.DDLElement 属性)

(sqlalchemy.schema.DDLElement.execute_if parameter)
(sqlalchemy.sql.expression.bindparam parameter)

callables (sqlalchemy.orm.InstanceState 属性)

cascade (sqlalchemy.orm.MapperProperty 属性)

(sqlalchemy.orm.relationship parameter)
(sqlalchemy.orm.RelationshipProperty 属性)

cascade_backrefs (sqlalchemy.orm.relationship parameter)

cascade_iterator() (sqlalchemy.orm.Mapper 方法)

(sqlalchemy.orm.MapperProperty 方法)
(sqlalchemy.orm.RelationshipProperty 方法)

cascade_scalar_deletes (sqlalchemy.ext.associationproxy.AssociationProxy parameter)

CascadeOptions (sqlalchemy.orm 中的类)

Case (sqlalchemy.sql.expression 中的类)

case() (在 sqlalchemy.sql.expression 模块中)

case_sensitive (sqlalchemy.create_engine parameter)

Cast (sqlalchemy.sql.expression 中的类)

cast() (sqlalchemy.schema.Column 方法)

(sqlalchemy.sql.expression.ColumnElement 方法)
(在 sqlalchemy.sql.expression 模块中)

cast_nulls (sqlalchemy.orm.polymorphic_union parameter)

chain() (sqlalchemy.sql.visitors.ExternalTraversal 方法)

chained_exception (sqlalchemy.engine.ExceptionContext 属性)

changed() (sqlalchemy.ext.mutable.Mutable 方法)

(sqlalchemy.ext.mutable.MutableComposite 方法)

CHAR (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.types 中的类)

char_length (sqlalchemy.sql.functions 中的类)

charset (sqlalchemy.dialects.mysql.ENUM parameter)

(sqlalchemy.dialects.mysql.LONGTEXT parameter)
(sqlalchemy.dialects.mysql.MEDIUMTEXT parameter)

check_modified() (sqlalchemy.orm.IdentityMap 方法)

CheckConstraint (sqlalchemy.schema 中的类)

checkfirst (sqlalchemy.dialects.postgresql.ENUM.create parameter)

(sqlalchemy.dialects.postgresql.ENUM.drop parameter)
(sqlalchemy.schema.MetaData.create_all parameter)

checkin() (sqlalchemy.events.PoolEvents 方法)

checkout() (sqlalchemy.events.PoolEvents 方法)

ChunkedIteratorResult (sqlalchemy.engine 中的类)

CIDR (sqlalchemy.dialects.postgresql 中的类)

CircularDependencyError

class_ (sqlalchemy.ext.associationproxy.AssociationProxy.for_class parameter)

(sqlalchemy.orm.composite parameter)
(sqlalchemy.orm.mapper parameter)

class_attribute (sqlalchemy.orm.MapperProperty 属性)

(sqlalchemy.orm.RelationshipProperty 属性)
(sqlalchemy.orm.SynonymProperty 属性)

class_instrument() (sqlalchemy.orm.InstrumentationEvents 方法)

class_manager (sqlalchemy.orm.Mapper 属性)

class_mapper() (在 sqlalchemy.orm 模块中)

class_registry (sqlalchemy.orm.declarative_base parameter)

(sqlalchemy.orm.registry parameter)

class_uninstrument() (sqlalchemy.orm.InstrumentationEvents 方法)

classes (sqlalchemy.ext.automap.AutomapBase 属性)

(sqlalchemy.orm.with_polymorphic parameter)

ClassManager (sqlalchemy.orm 中的类)

ClassManager.memoized_attribute (sqlalchemy.orm 中的类)

classname_for_table (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

classname_for_table() (在 sqlalchemy.ext.automap 模块中)

clause (sqlalchemy.ext.asyncio.async_scoped_session.get_bind parameter)

(sqlalchemy.ext.asyncio.AsyncSession.get_bind parameter)
(sqlalchemy.ext.horizontal_shard.ShardedSession.get_bind parameter)

clauseelement (sqlalchemy.events.ConnectionEvents.after_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_execute parameter)

ClauseElement (sqlalchemy.sql.expression 中的类)

ClauseElement.memoized_attribute (sqlalchemy.sql.expression 中的类)

ClauseList (sqlalchemy.sql.expression 中的类)

clauses (sqlalchemy.sql.functions.FunctionElement 属性)

clear() (sqlalchemy.ext.mutable.MutableDict 方法)

(sqlalchemy.ext.mutable.MutableList 方法)
(sqlalchemy.ext.mutable.MutableSet 方法)

clear_compiled_cache() (sqlalchemy.engine.Engine 方法)

(sqlalchemy.ext.asyncio.AsyncEngine 方法)

clear_mappers() (在 sqlalchemy.orm 模块中)

CLOB (sqlalchemy.types 中的类)

cloned_traverse() (在 sqlalchemy.sql.visitors 模块中)

close() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.CursorResult 方法)
(sqlalchemy.engine.LegacyCursorResult 方法)

close_all() (sqlalchemy.ext.asyncio.async_scoped_session 类方法)

(sqlalchemy.ext.asyncio.AsyncSession 类方法)
(sqlalchemy.orm.scoping.scoped_session 类方法)

close_all_sessions() (在 sqlalchemy.orm 模块中)

close_detached() (sqlalchemy.events.PoolEvents 方法)

close_with_result (sqlalchemy.orm.scoping.scoped_session.connection parameter)

(sqlalchemy.orm.Session.connection parameter)

closed (sqlalchemy.engine.Connection 属性)

cls (sqlalchemy.orm.declarative_base parameter)

(sqlalchemy.orm.registry.generate_base parameter)
(sqlalchemy.orm.registry.map_declaratively parameter)

coalesce (sqlalchemy.sql.functions 中的类)

coerce() (sqlalchemy.ext.mutable.Mutable 类方法)

(sqlalchemy.ext.mutable.MutableBase 类方法)
(sqlalchemy.ext.mutable.MutableDict 类方法)

coerce_compared_value() (sqlalchemy.types.TypeDecorator 方法)

(sqlalchemy.types.TypeEngine 方法)
(sqlalchemy.types.UserDefinedType 方法)

coerce_to_is_types (sqlalchemy.types.TypeDecorator 属性)

collate() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

collation (sqlalchemy.dialects.mssql.CHAR parameter)

(sqlalchemy.dialects.mssql.TEXT parameter)
(sqlalchemy.dialects.mssql.VARCHAR parameter)

collection (sqlalchemy.orm.AttributeEvents.init_collection parameter)

(sqlalchemy.orm.collections 中的类) [0]

collection_adapter (sqlalchemy.orm.AttributeEvents.init_collection parameter)

collection_adapter() (在 sqlalchemy.orm.collections 模块中)

collection_class (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

(sqlalchemy.orm.relationship parameter)

CollectionAdapter (sqlalchemy.orm.collections 中的类)

cols (sqlalchemy.dialects.mysql.match parameter)

(sqlalchemy.sql.expression.ValuesBase.return_defaults parameter)

coltype (sqlalchemy.dialects.postgresql.HSTORE.result_processor parameter)

(sqlalchemy.types.Boolean.result_processor parameter)
(sqlalchemy.types.Float.result_processor parameter)

Column (sqlalchemy.schema 中的类)

column (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKey 属性)
(sqlalchemy.schema.Table.corresponding_column parameter)

column() (sqlalchemy.sql.expression.Select 方法)

(在 sqlalchemy.sql.expression 模块中)

Column.memoized_attribute (sqlalchemy.schema 中的类)

column_attrs (sqlalchemy.orm.Mapper 属性)

column_descriptions (sqlalchemy.orm.Query 属性)

(sqlalchemy.sql.expression.Select 属性)

column_expression() (sqlalchemy.types.TypeDecorator 方法)

(sqlalchemy.types.TypeEngine 方法)

column_keys (sqlalchemy.schema.Column.compile parameter)

(sqlalchemy.schema.ForeignKeyConstraint 属性)
(sqlalchemy.schema.Table.compile parameter)

column_mapped_collection() (在 sqlalchemy.orm.collections 模块中)

column_prefix (sqlalchemy.orm.mapper parameter)

column_property() (在 sqlalchemy.orm 模块中)

column_reflect() (sqlalchemy.events.DDLEvents 方法)

column_valued() (sqlalchemy.sql.functions.FunctionElement 方法)

ColumnAssociationProxyInstance (sqlalchemy.ext.associationproxy 中的类)

ColumnClause (sqlalchemy.sql.expression 中的类)

ColumnCollection (sqlalchemy.sql.expression 中的类)

ColumnCollectionConstraint (sqlalchemy.schema 中的类)

ColumnCollectionMixin (sqlalchemy.schema 中的类)

ColumnDefault (sqlalchemy.schema 中的类)

ColumnElement (sqlalchemy.sql.expression 中的类)

ColumnElement.memoized_attribute (sqlalchemy.sql.expression 中的类)

ColumnOperators (sqlalchemy.sql.expression 中的类)

ColumnProperty (sqlalchemy.orm 中的类)

ColumnProperty.Comparator (sqlalchemy.orm 中的类)

columns (sqlalchemy.orm.Bundle 属性)

(sqlalchemy.orm.Mapper 属性)
(sqlalchemy.schema.ColumnCollectionConstraint 属性)

columns() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

columns_clause_froms (sqlalchemy.sql.expression.Select 属性)

comment (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.Table parameter)

commit() (sqlalchemy.engine.NestedTransaction 方法)

(sqlalchemy.engine.RootTransaction 方法)
(sqlalchemy.engine.Transaction 方法)

commit_twophase() (sqlalchemy.events.ConnectionEvents 方法)

common_parent() (sqlalchemy.orm.Mapper 方法)

Comparator (sqlalchemy.ext.hybrid 中的类)

comparator (sqlalchemy.sql.expression.ColumnElement 属性)

(sqlalchemy.types.PickleType parameter)

comparator() (sqlalchemy.ext.hybrid.hybrid_property 方法)

comparator_factory (sqlalchemy.dialects.postgresql.HSTORE 属性)

(sqlalchemy.dialects.postgresql.JSON 属性)
(sqlalchemy.dialects.postgresql.JSONB 属性)

compare() (sqlalchemy.schema.Column 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.ClauseElement 方法)

compare_against_backend() (sqlalchemy.types.TypeEngine 方法)

compare_values() (sqlalchemy.types.ARRAY 方法)

(sqlalchemy.types.PickleType 方法)
(sqlalchemy.types.TypeDecorator 方法)

compile() (sqlalchemy.schema.Column 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.ClauseElement 方法)

compile_kwargs (sqlalchemy.engine.Compiled parameter)

(sqlalchemy.schema.Column.compile parameter)
(sqlalchemy.schema.Table.compile parameter)

compile_state (sqlalchemy.engine.Compiled 属性)

Compiled (sqlalchemy.engine 中的类)

compiled_cache (sqlalchemy.engine.Connection.execution_options parameter)

CompileError

compiles() (在 sqlalchemy.ext.compiler 模块中)

composite() (在 sqlalchemy.orm 模块中)

CompositeProperty (sqlalchemy.orm 中的类)

CompositeProperty.Comparator (sqlalchemy.orm 中的类)

CompositeProperty.CompositeBundle (sqlalchemy.orm 中的类)

composites (sqlalchemy.orm.Mapper 属性)

CompoundSelect (sqlalchemy.sql.expression 中的类)

Computed (sqlalchemy.schema 中的类)

concat (sqlalchemy.sql.functions 中的类)

concat() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

Concatenable (sqlalchemy.types 中的类)

Concatenable.Comparator (sqlalchemy.types 中的类)

concrete (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)

ConcreteBase (sqlalchemy.ext.declarative 中的类)

ConcurrentModificationError() (在 sqlalchemy.orm.exc 模块中)

configuration (sqlalchemy.engine_from_config parameter)

configure() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.orm.registry 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

configure_mappers() (在 sqlalchemy.orm 模块中)

configured (sqlalchemy.orm.Mapper 属性)

confirm_deleted_rows (sqlalchemy.orm.mapper parameter)

conn (sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

(sqlalchemy.events.ConnectionEvents.after_execute parameter)
(sqlalchemy.events.ConnectionEvents.before_cursor_execute parameter)

conn_type (sqlalchemy.types.TypeEngine.compare_against_backend parameter)

connect() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.default.DefaultDialect 方法)
(sqlalchemy.engine.Dialect 方法)

connect_args (sqlalchemy.create_engine parameter)

Connection (sqlalchemy.engine 中的类)

connection (sqlalchemy.engine.Connection 属性)

(sqlalchemy.engine.default.DefaultDialect.do_begin_twophase parameter)
(sqlalchemy.engine.default.DefaultDialect.do_commit_twophase parameter)

Connection (sqlalchemy.future 中的类)

connection (sqlalchemy.future.Engine.table_names parameter)

(sqlalchemy.orm.MapperEvents.after_delete parameter)
(sqlalchemy.orm.MapperEvents.after_insert parameter)

connection() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

connection_callable() (sqlalchemy.ext.horizontal_shard.ShardedSession 方法)

connection_proxy (sqlalchemy.events.PoolEvents.checkout parameter)

connection_record (sqlalchemy.events.PoolEvents.checkin parameter)

(sqlalchemy.events.PoolEvents.checkout parameter)
(sqlalchemy.events.PoolEvents.close parameter)

ConnectionEvents (sqlalchemy.events 中的类)

constraint (sqlalchemy.dialects.postgresql.Insert.on_conflict_do_nothing parameter)

(sqlalchemy.dialects.postgresql.Insert.on_conflict_do_update parameter)
(sqlalchemy.ext.automap.name_for_collection_relationship parameter)

Constraint (sqlalchemy.schema 中的类)

constraints (sqlalchemy.schema.Table 属性)

construct_arguments (sqlalchemy.engine.default.DefaultDialect 属性)

construct_params() (sqlalchemy.engine.Compiled 方法)

(sqlalchemy.sql.compiler.DDLCompiler 方法)
(sqlalchemy.sql.compiler.SQLCompiler 方法)

constructor (sqlalchemy.orm.declarative_base parameter)

(sqlalchemy.orm.registry parameter)

contained_by() (sqlalchemy.dialects.postgresql.ARRAY.Comparator 方法)

(sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)
(sqlalchemy.dialects.postgresql.JSONB.Comparator 方法)

contains() (sqlalchemy.dialects.postgresql.ARRAY.Comparator 方法)

(sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)
(sqlalchemy.dialects.postgresql.JSONB.Comparator 方法)

contains_column() (sqlalchemy.schema.CheckConstraint 方法)

(sqlalchemy.schema.ColumnCollectionConstraint 方法)
(sqlalchemy.schema.ForeignKeyConstraint 方法)

contains_eager() (sqlalchemy.orm.Load 方法) , [4]

(在 sqlalchemy.orm 模块中)

context (sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_cursor_execute parameter)
(sqlalchemy.events.ConnectionEvents.handle_error parameter)

conv() (在 sqlalchemy.schema 模块中)

convert_int (sqlalchemy.dialects.mssql.ROWVERSION parameter)

(sqlalchemy.dialects.mssql.TIMESTAMP parameter)

convert_unicode (sqlalchemy.create_engine parameter)

(sqlalchemy.dialects.mssql.CHAR parameter)
(sqlalchemy.dialects.mssql.TEXT parameter)

converter() (sqlalchemy.orm.collections.collection 静态方法)

copy() (sqlalchemy.orm.ClassManager 方法)

(sqlalchemy.schema.CheckConstraint 方法)
(sqlalchemy.schema.Column 方法)

correlate (sqlalchemy.sql.expression.Select.create_legacy_select parameter)

correlate() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Exists 方法)
(sqlalchemy.sql.expression.ScalarSelect 方法)

correlate_except() (sqlalchemy.sql.expression.Exists 方法)

(sqlalchemy.sql.expression.ScalarSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

corresponding_column() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.ColumnCollection 方法)
(sqlalchemy.sql.expression.Select 方法)

count (sqlalchemy.engine.Row 属性)

(sqlalchemy.sql.expression.GenerativeSelect.fetch parameter)
(sqlalchemy.sql.expression.Select.fetch parameter)

count() (sqlalchemy.ext.baked.Result 方法)

(sqlalchemy.orm.Query 方法)

count_from (sqlalchemy.ext.orderinglist.ordering_list parameter)

count_from_0() (在 sqlalchemy.ext.orderinglist 模块中)

count_from_1() (在 sqlalchemy.ext.orderinglist 模块中)

count_from_n_factory() (在 sqlalchemy.ext.orderinglist 模块中)

create() (sqlalchemy.dialects.postgresql.ENUM 方法)

(sqlalchemy.engine.URL 类方法)
(sqlalchemy.schema.Index 方法)

create_all() (sqlalchemy.schema.MetaData 方法)

create_async_engine() (在 sqlalchemy.ext.asyncio 模块中)

create_connect_args() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

create_constraint (sqlalchemy.dialects.mssql.BIT parameter)

(sqlalchemy.dialects.mysql.BOOLEAN parameter)
(sqlalchemy.types.Boolean parameter)

create_cursor() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

(sqlalchemy.engine.ExecutionContext 方法)

create_engine() (在 sqlalchemy 模块中)

(在 sqlalchemy.future 模块中)

create_legacy_select() (sqlalchemy.sql.expression.Select 类方法)

create_mock_engine() (在 sqlalchemy 模块中)

create_row_processor() (sqlalchemy.orm.Bundle 方法)

(sqlalchemy.orm.CompositeProperty.CompositeBundle 方法)
(sqlalchemy.orm.MapperProperty 方法)

create_type (sqlalchemy.dialects.postgresql.ENUM parameter)

create_xid() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

CreateColumn (sqlalchemy.schema 中的类)

CreateEnginePlugin (sqlalchemy.engine 中的类)

createfunc (sqlalchemy.util.ScopedRegistry parameter) , [4]

CreateIndex (sqlalchemy.schema 中的类)

CreateSchema (sqlalchemy.schema 中的类)

CreateSequence (sqlalchemy.schema 中的类)

CreateTable (sqlalchemy.schema 中的类)

creator (sqlalchemy.create_engine parameter)

(sqlalchemy.ext.associationproxy.association_proxy parameter)
(sqlalchemy.ext.associationproxy.AssociationProxy parameter)

criterion (sqlalchemy.orm.PropComparator.any parameter)

(sqlalchemy.orm.PropComparator.has parameter)
(sqlalchemy.orm.QueryableAttribute.any parameter)

CRUD

CTE (sqlalchemy.sql.expression 中的类)

cte() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.HasCTE 方法)
(sqlalchemy.sql.expression.Select 方法)

cube (sqlalchemy.sql.functions 中的类)

cume_dist (sqlalchemy.sql.functions 中的类)

current_date (sqlalchemy.sql.functions 中的类)

current_executable (sqlalchemy.sql.compiler.SQLCompiler 属性)

current_parameters (sqlalchemy.engine.default.DefaultExecutionContext 属性)

current_time (sqlalchemy.sql.functions 中的类)

current_timestamp (sqlalchemy.sql.functions 中的类)

current_user (sqlalchemy.sql.functions 中的类)

cursor (sqlalchemy.engine.ExceptionContext 属性)

(sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)
(sqlalchemy.events.ConnectionEvents.before_cursor_execute parameter)

cursor() (sqlalchemy.pool._ConnectionFairy 方法)

CursorResult (sqlalchemy.engine 中的类)

custom_op (sqlalchemy.sql.expression 中的类)

cycle (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

D

data() (sqlalchemy.sql.expression.Values 方法)

data_type (sqlalchemy.schema.Sequence parameter)

database (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)

DatabaseError

DataError

datatype (sqlalchemy.ext.indexable.index_property parameter)

DATE (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.dialects.oracle 中的类)
(sqlalchemy.dialects.sqlite 中的类)

Date (sqlalchemy.types 中的类)

DATERANGE (sqlalchemy.dialects.postgresql 中的类)

DATETIME (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.dialects.sqlite 中的类)
(sqlalchemy.types 中的类)

DateTime (sqlalchemy.types 中的类)

DATETIME2 (sqlalchemy.dialects.mssql 中的类)

DATETIMEOFFSET (sqlalchemy.dialects.mssql 中的类)

day_precision (sqlalchemy.dialects.oracle.INTERVAL parameter)

(sqlalchemy.types.Interval parameter)

DBAPI

dbapi_connection (sqlalchemy.engine.default.DefaultDialect.do_begin parameter)

(sqlalchemy.engine.default.DefaultDialect.do_commit parameter)
(sqlalchemy.engine.default.DefaultDialect.do_rollback parameter)

dbapi_exception_translation_map (sqlalchemy.engine.default.DefaultDialect 属性)

DBAPIError

DDL

(sqlalchemy.schema 中的类)

ddl_compiler (sqlalchemy.engine.default.DefaultDialect 属性)

DDLCompiler (sqlalchemy.sql.compiler 中的类)

DDLElement (sqlalchemy.schema 中的类)

DDLEvents (sqlalchemy.events 中的类)

DECIMAL (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

decimal_return_scale (sqlalchemy.dialects.mssql.REAL parameter)

(sqlalchemy.dialects.oracle.DOUBLE_PRECISION parameter)
(sqlalchemy.dialects.oracle.NUMBER parameter)

declarative_base (sqlalchemy.ext.automap.automap_base parameter)

declarative_base() (在 sqlalchemy.orm 模块中)

declarative_mixin() (在 sqlalchemy.orm 模块中)

declared_attr (sqlalchemy.orm 中的类)

default (sqlalchemy.ext.indexable.index_property parameter)

(sqlalchemy.schema.CheckConstraint.argument_for parameter)
(sqlalchemy.schema.Column parameter)

default_expr (sqlalchemy.orm.query_expression parameter)

default_from() (sqlalchemy.sql.compiler.SQLCompiler 方法)

default_isolation_level (sqlalchemy.engine.Connection 属性)

default_schema_name (sqlalchemy.engine.reflection.Inspector 属性)

DefaultClause (sqlalchemy.schema 中的类)

DefaultDialect (sqlalchemy.engine.default 中的类)

DefaultExecutionContext (sqlalchemy.engine.default 中的类)

DefaultGenerator (sqlalchemy.schema 中的类)

defaultload() (sqlalchemy.orm.Load 方法) , [5]

(在 sqlalchemy.orm 模块中)

defer() (sqlalchemy.orm.Load 方法) , [5]

(在 sqlalchemy.orm 模块中)

deferrable (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

(sqlalchemy.schema.CheckConstraint parameter)
(sqlalchemy.schema.ColumnCollectionConstraint parameter)

deferred (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)

deferred() (在 sqlalchemy.orm 模块中)

deferred_scalar_loader (sqlalchemy.orm.ClassManager 属性)

DeferredReflection (sqlalchemy.ext.declarative 中的类)

define_constraint_remote_table() (sqlalchemy.sql.compiler.DDLCompiler 方法)

defined() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

del_attribute() (在 sqlalchemy.orm.attributes 模块中)

Delete (sqlalchemy.sql.expression 中的类)

delete() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

(sqlalchemy.ext.associationproxy.AssociationProxyInstance 方法)
(sqlalchemy.ext.asyncio.async_scoped_session 方法)

delete_context (sqlalchemy.orm.QueryEvents.before_compile_delete parameter)

(sqlalchemy.orm.SessionEvents.after_bulk_delete parameter)

delete_extra_from_clause() (sqlalchemy.sql.compiler.SQLCompiler 方法)

(sqlalchemy.sql.compiler.StrSQLCompiler 方法)

deleted (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.ext.asyncio.AsyncSession 属性)
(sqlalchemy.orm.InstanceState 属性)

deleted_to_detached() (sqlalchemy.orm.SessionEvents 方法)

deleted_to_persistent() (sqlalchemy.orm.SessionEvents 方法)

deleter() (sqlalchemy.ext.hybrid.hybrid_property 方法)

denormalize_name() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

dense_rank (sqlalchemy.sql.functions 中的类)

deprecated_since (sqlalchemy.exc.RemovedIn20Warning 属性)

(sqlalchemy.exc.SADeprecationWarning 属性)
(sqlalchemy.exc.SAPendingDeprecationWarning 属性)

deregister() (在 sqlalchemy.ext.compiler 模块中)

desc() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

description (sqlalchemy.schema.Table 属性)

(sqlalchemy.sql.expression.AliasedReturnsRows 属性)
(sqlalchemy.sql.expression.ColumnElement 属性)

descriptor (sqlalchemy.orm.synonym parameter)

Deserializer() (在 sqlalchemy.ext.serializer 模块中)

detach() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.events.PoolEvents 方法)
(sqlalchemy.pool._ConnectionFairy 方法)

detached (sqlalchemy.orm.InstanceState 属性)

detached_to_persistent() (sqlalchemy.orm.SessionEvents 方法)

DetachedInstanceError

dialect (sqlalchemy.dialects.postgresql.HSTORE.bind_processor parameter)

(sqlalchemy.dialects.postgresql.HSTORE.result_processor parameter)

Dialect (sqlalchemy.engine 中的类)

dialect (sqlalchemy.engine.Compiled parameter)

(sqlalchemy.pool.Pool parameter)
(sqlalchemy.pool.SingletonThreadPool parameter)

dialect_impl() (sqlalchemy.types.TypeEngine 方法)

dialect_kwargs (sqlalchemy.schema.CheckConstraint 属性)

(sqlalchemy.schema.Column 属性)
(sqlalchemy.schema.ColumnCollectionConstraint 属性)

dialect_name (sqlalchemy.schema.CheckConstraint.argument_for parameter)

(sqlalchemy.schema.Column.argument_for parameter)
(sqlalchemy.schema.ColumnCollectionConstraint.argument_for parameter)

dialect_options (sqlalchemy.schema.CheckConstraint 属性)

(sqlalchemy.schema.Column 属性)
(sqlalchemy.schema.ColumnCollectionConstraint 属性)

DialectEvents (sqlalchemy.events 中的类)

DialectKWArgs (sqlalchemy.sql.base 中的类)

dict (sqlalchemy.orm.InstanceState 属性)

dict_ (sqlalchemy.orm.AttributeEvents.init_scalar parameter)

dict_getter() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

difference_update() (sqlalchemy.ext.mutable.MutableSet 方法)

difference_update_query() (sqlalchemy.engine.URL 方法)

dimensions (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)

direction (sqlalchemy.ext.automap.generate_relationship parameter)

dirty (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.ext.asyncio.AsyncSession 属性)
(sqlalchemy.orm.scoping.scoped_session 属性)

discard() (sqlalchemy.ext.mutable.MutableSet 方法)

DisconnectionError

dispatch() (sqlalchemy.sql.visitors.InternalTraversal 方法)

display_width (sqlalchemy.dialects.mysql.BIGINT parameter)

(sqlalchemy.dialects.mysql.INTEGER parameter)
(sqlalchemy.dialects.mysql.MEDIUMINT parameter)

dispose() (sqlalchemy.engine.Engine 方法)

(sqlalchemy.ext.asyncio.AsyncEngine 方法)
(sqlalchemy.orm.registry 方法)

dispose_collection() (sqlalchemy.orm.AttributeEvents 方法)

distinct (sqlalchemy.sql.expression.Select.create_legacy_select parameter)

distinct() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.Query 方法)

distinct_target_key (sqlalchemy.orm.relationship parameter)

DML

do_begin() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_begin_twophase() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_close() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_commit() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_commit_twophase() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_connect() (sqlalchemy.events.DialectEvents 方法)

do_execute() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.events.DialectEvents 方法)

do_execute_no_params() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.events.DialectEvents 方法)

do_executemany() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.events.DialectEvents 方法)

do_init() (sqlalchemy.orm.ColumnProperty 方法)

(sqlalchemy.orm.CompositeProperty 方法)
(sqlalchemy.orm.MapperProperty 方法)

do_orm_execute() (sqlalchemy.orm.SessionEvents 方法)

do_prepare_twophase() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_recover_twophase() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_release_savepoint() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_rollback() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_rollback_to_savepoint() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_rollback_twophase() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_savepoint() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_set_input_sizes() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

do_setinputsizes() (sqlalchemy.events.DialectEvents 方法)

doc (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)
(sqlalchemy.orm.relationship parameter)

DontWrapMixin (sqlalchemy.exc 中的类)

DOUBLE (sqlalchemy.dialects.mysql 中的类)

DOUBLE_PRECISION (sqlalchemy.dialects.oracle 中的类)

(sqlalchemy.dialects.postgresql 中的类)

dp_annotations_key (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_anon_name (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_boolean (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_clauseelement (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_clauseelement_list (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_clauseelement_tuple (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_clauseelement_tuples (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_dialect_options (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_dml_multi_values (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_dml_ordered_values (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_dml_values (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_fromclause_canonical_column_collection (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_fromclause_ordered_set (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_has_cache_key (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_has_cache_key_list (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_named_ddl_element (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_operator (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_plain_dict (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_plain_obj (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_prefix_sequence (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_propagate_attrs (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_statement_hint_list (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_string (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_string_clauseelement_dict (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_string_list (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_string_multi_dict (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_table_hint_list (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_type (sqlalchemy.sql.visitors.InternalTraversal 属性)

dp_unknown_structure (sqlalchemy.sql.visitors.InternalTraversal 属性)

DQL

driver (sqlalchemy.engine.Engine 属性)

driver_connection (sqlalchemy.engine.AdaptedConnection 属性)

(sqlalchemy.pool._ConnectionFairy 属性)
(sqlalchemy.pool._ConnectionRecord 属性)

drivername (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)
(sqlalchemy.engine.URL.set parameter)

drop() (sqlalchemy.dialects.postgresql.ENUM 方法)

(sqlalchemy.schema.Index 方法)
(sqlalchemy.schema.Sequence 方法)

drop_all() (sqlalchemy.schema.MetaData 方法)

DropConstraint (sqlalchemy.schema 中的类)

DropIndex (sqlalchemy.schema 中的类)

DropSchema (sqlalchemy.schema 中的类)

DropSequence (sqlalchemy.schema 中的类)

DropTable (sqlalchemy.schema 中的类)

dumps() (在 sqlalchemy.ext.serializer 模块中)

dynamic_loader() (在 sqlalchemy.orm 模块中)

E

e (sqlalchemy.pool._ConnectionFairy.invalidate parameter)

(sqlalchemy.pool._ConnectionRecord.invalidate parameter)

eager_defaults (sqlalchemy.orm.mapper parameter)

eagerload() (在 sqlalchemy.orm 模块中)

echo (sqlalchemy.create_engine parameter)

(sqlalchemy.pool.Pool parameter)
(sqlalchemy.pool.SingletonThreadPool parameter)

echo_pool (sqlalchemy.create_engine parameter)

effective_value (sqlalchemy.sql.expression.BindParameter 属性)

element (sqlalchemy.orm.aliased parameter)

(sqlalchemy.schema.CreateIndex parameter)
(sqlalchemy.schema.CreateTable parameter)

elements (sqlalchemy.schema.ForeignKeyConstraint 属性)

else_ (sqlalchemy.sql.expression.case parameter)

empty() (sqlalchemy.orm.attributes.History 方法)

empty_in_strategy (sqlalchemy.create_engine parameter)

enable_assertions() (sqlalchemy.orm.Query 方法)

enable_baked_queries (sqlalchemy.orm.Session parameter)

enable_eagerloads() (sqlalchemy.orm.Query 方法)

enable_from_linting (sqlalchemy.create_engine parameter)

enable_relationship_loading() (sqlalchemy.orm.Session 方法)

enable_tracking (sqlalchemy.sql.expression.lambda_stmt parameter)

encoding (sqlalchemy.create_engine parameter)

endswith() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

Engine (sqlalchemy.engine 中的类)

engine (sqlalchemy.engine.ExceptionContext 属性)

(sqlalchemy.ext.automap.AutomapBase.prepare parameter)

Engine (sqlalchemy.future 中的类)

engine_connect() (sqlalchemy.events.ConnectionEvents 方法)

engine_created() (sqlalchemy.engine.CreateEnginePlugin 方法)

(sqlalchemy.engine.default.DefaultDialect 类方法)
(sqlalchemy.engine.Dialect 类方法)

engine_disposed() (sqlalchemy.events.ConnectionEvents 方法)

engine_from_config() (在 sqlalchemy 模块中)

entities (sqlalchemy.orm.Query parameter)

entity (sqlalchemy.orm.Mapper 属性)

(sqlalchemy.orm.RelationshipProperty 属性)
(sqlalchemy.orm.RelationshipProperty.Comparator 属性)

entity_namespace (sqlalchemy.schema.Table 属性)

(sqlalchemy.sql.expression.ColumnElement 属性)
(sqlalchemy.sql.expression.FromClause 属性)

entity_or_base (sqlalchemy.orm.with_loader_criteria parameter)

ENUM (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.dialects.postgresql 中的类)

Enum (sqlalchemy.types 中的类)

enums (sqlalchemy.dialects.mysql.ENUM parameter)

escape (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.contains parameter)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.endswith parameter)
(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.ilike parameter)

escaped_bind_names (sqlalchemy.sql.compiler.SQLCompiler 属性)

evaluates_none() (sqlalchemy.types.TypeEngine 方法)

Events (sqlalchemy.event.base 中的类)

events (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

examples.adjacency_list

模块

examples.association

模块

examples.asyncio

模块

examples.custom_attributes

模块

examples.dogpile_caching

模块

examples.dynamic_dict

模块

examples.elementtree

模块

examples.extending_query

模块

examples.generic_associations

模块

examples.graphs

模块

examples.inheritance

模块

examples.join_conditions

模块

examples.large_collection

模块

examples.materialized_paths

模块

examples.nested_sets

模块

examples.performance

模块

examples.postgis

模块

examples.sharding

模块

examples.space_invaders

模块

examples.versioned_history

模块

examples.versioned_rows

模块

examples.vertical

模块

except_() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(在 sqlalchemy.sql.expression 模块中)

except_all() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(在 sqlalchemy.sql.expression 模块中)

exception (sqlalchemy.engine.Connection.invalidate parameter)

(sqlalchemy.events.PoolEvents.invalidate parameter)
(sqlalchemy.events.PoolEvents.soft_invalidate parameter)

ExceptionContext (sqlalchemy.engine 中的类)

exclude_properties (sqlalchemy.orm.mapper parameter)

ExcludeConstraint (sqlalchemy.dialects.postgresql 中的类)

excluded (sqlalchemy.dialects.postgresql.Insert 属性)

(sqlalchemy.dialects.sqlite.Insert 属性)

exec_driver_sql() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)

Executable (sqlalchemy.sql.expression 中的类)

execute() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.Engine 方法)
(sqlalchemy.ext.asyncio.async_scoped_session 方法)

execute_chooser (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

execute_if() (sqlalchemy.schema.DDLElement 方法)

execute_sequence_format (sqlalchemy.engine.default.DefaultDialect 属性)

executemany (sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_cursor_execute parameter)

execution_context (sqlalchemy.engine.ExceptionContext 属性)

execution_ctx_cls (sqlalchemy.engine.default.DefaultDialect 属性)

execution_options (sqlalchemy.create_engine parameter)

(sqlalchemy.engine.Compiled 属性)
(sqlalchemy.events.ConnectionEvents.after_execute parameter)

execution_options() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.Engine 方法)
(sqlalchemy.ext.asyncio.AsyncConnection 方法)

ExecutionContext (sqlalchemy.engine 中的类)

executor (sqlalchemy.create_mock_engine parameter)

existing_adapter (sqlalchemy.orm.collections.bulk_replace parameter)

Exists (sqlalchemy.sql.expression 中的类)

exists() (sqlalchemy.orm.Query 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.Select 方法)

expanding (sqlalchemy.sql.expression.bindparam parameter)

expire() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.InstanceEvents 方法)

expire_all() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

expire_on_commit (sqlalchemy.orm.Session parameter)

(sqlalchemy.orm.sessionmaker parameter)

expire_on_flush (sqlalchemy.orm.column_property parameter)

expired_attribute_loader (sqlalchemy.orm.ClassManager 属性)

expired_attributes (sqlalchemy.orm.InstanceState 属性)

exported_columns (sqlalchemy.schema.Table 属性)

(sqlalchemy.sql.expression.FromClause 属性)
(sqlalchemy.sql.expression.ReturnsRows 属性)

expr (sqlalchemy.orm.with_expression parameter)

(sqlalchemy.sql.expression.between parameter)
(sqlalchemy.sql.expression.extract parameter)

expression (sqlalchemy.orm.ColumnProperty 属性)

(sqlalchemy.orm.QueryableAttribute 属性)
(sqlalchemy.schema.Column 属性)

expression() (sqlalchemy.ext.hybrid.hybrid_method 方法)

(sqlalchemy.ext.hybrid.hybrid_property 方法)

expressions (sqlalchemy.orm.ColumnProperty.Comparator 属性)

expunge() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

expunge_all() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

extend() (sqlalchemy.ext.mutable.MutableList 方法)

extend_existing (sqlalchemy.schema.MetaData.reflect parameter)

(sqlalchemy.schema.Table parameter)

ExtendedInstrumentationRegistry (sqlalchemy.ext.instrumentation 中的类)

extension_type (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.ext.hybrid.hybrid_method 属性)
(sqlalchemy.ext.hybrid.hybrid_property 属性)

ExternalTraversal (sqlalchemy.sql.visitors 中的类)

extra_dependencies (sqlalchemy.schema.sort_tables parameter)

(sqlalchemy.schema.sort_tables_and_constraints parameter)

Extract (sqlalchemy.sql.expression 中的类)

extract() (在 sqlalchemy.sql.expression 模块中)

F

false() (在 sqlalchemy.sql.expression 模块中)

False_ (sqlalchemy.sql.expression 中的类)

fetch() (sqlalchemy.sql.expression.GenerativeSelect 方法)

(sqlalchemy.sql.expression.Select 方法)

fetchall() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

FetchedValue (sqlalchemy.schema 中的类)

fetchmany() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

fetchone() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

field (sqlalchemy.sql.expression.extract parameter)

fields (sqlalchemy.dialects.postgresql.INTERVAL parameter)

filter() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.FunctionFilter 方法)
(sqlalchemy.sql.expression.Select 方法)

filter_by() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)

filter_fn (sqlalchemy.schema.sort_tables_and_constraints parameter)

filter_states_for_dep() (sqlalchemy.orm.UOWTransaction 方法)

finalize_flush_changes() (sqlalchemy.orm.UOWTransaction 方法)

first() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

first_connect() (sqlalchemy.events.PoolEvents 方法)

first_init() (sqlalchemy.orm.InstanceEvents 方法)

flag_dirty() (在 sqlalchemy.orm.attributes 模块中)

flag_modified() (在 sqlalchemy.orm.attributes 模块中)

flags (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.regexp_match parameter)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.regexp_replace parameter)
(sqlalchemy.orm.PropComparator.regexp_match parameter)

flat (sqlalchemy.orm.aliased parameter)

(sqlalchemy.orm.with_polymorphic parameter)
(sqlalchemy.sql.expression.alias parameter)

FLOAT (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

Float (sqlalchemy.types 中的类)

flush() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

flush_context (sqlalchemy.orm.InstanceEvents.refresh_flush parameter)

(sqlalchemy.orm.SessionEvents.after_flush parameter)
(sqlalchemy.orm.SessionEvents.after_flush_postexec parameter)

FlushError

for_class() (sqlalchemy.ext.associationproxy.AssociationProxy 方法)

for_executemany (sqlalchemy.sql.compiler.SQLCompiler parameter)

for_proxy() (sqlalchemy.ext.associationproxy.AssociationProxyInstance 类方法)

for_session() (sqlalchemy.ext.baked.BakedQuery 方法)

for_update (sqlalchemy.schema.Sequence parameter)

force (sqlalchemy.sql.compiler.IdentifierPreparer.quote parameter)

(sqlalchemy.sql.compiler.IdentifierPreparer.quote_schema parameter)

foreign() (在 sqlalchemy.orm 模块中)

foreign_key_constraints (sqlalchemy.schema.Table 属性)

foreign_keys (sqlalchemy.orm.relationship parameter)

(sqlalchemy.schema.Column 属性)
(sqlalchemy.schema.Table 属性)

ForeignKey (sqlalchemy.schema 中的类)

ForeignKeyConstraint (sqlalchemy.schema 中的类)

format_column() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

format_label_name() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

format_schema() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

format_table() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

format_table_seq() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

freeze() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.Result 方法)
(sqlalchemy.ext.asyncio.AsyncResult 方法)

from_ (sqlalchemy.sql.expression.Select.join_from parameter)

from_engine() (sqlalchemy.engine.reflection.Inspector 类方法)

from_entity (sqlalchemy.orm.Query.with_parent parameter)

(sqlalchemy.orm.with_parent parameter)

from_joinpoint (sqlalchemy.orm.Query.join parameter)

from_obj (sqlalchemy.orm.Query.select_entity_from parameter)

(sqlalchemy.sql.expression.Select.create_legacy_select parameter)

from_select() (sqlalchemy.sql.expression.Insert 方法)

from_self() (sqlalchemy.orm.Query 方法)

from_statement() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)

FromClause (sqlalchemy.sql.expression 中的类)

fromkeys() (sqlalchemy.orm.ClassManager 方法)

froms (sqlalchemy.sql.expression.Select 属性)

FrozenResult (sqlalchemy.engine 中的类)

fsp (sqlalchemy.dialects.mysql.DATETIME parameter)

(sqlalchemy.dialects.mysql.TIME parameter)
(sqlalchemy.dialects.mysql.TIMESTAMP parameter)

full (sqlalchemy.ext.baked.BakedQuery.spoil parameter)

(sqlalchemy.orm.Query.join parameter)
(sqlalchemy.schema.Table.join parameter)

func() (在 sqlalchemy.sql.expression 模块中)

funcfilter() (在 sqlalchemy.sql.expression 模块中)

Function (sqlalchemy.sql.functions 中的类)

FunctionAsBinary (sqlalchemy.sql.functions 中的类)

FunctionElement (sqlalchemy.sql.functions 中的类)

FunctionFilter (sqlalchemy.sql.expression 中的类)

future (sqlalchemy.create_engine parameter)

(sqlalchemy.orm.Session parameter)

G

generate_base() (sqlalchemy.orm.registry 方法)

generate_relationship (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

generate_relationship() (在 sqlalchemy.ext.automap 模块中)

GenerativeSelect (sqlalchemy.sql.expression 中的类)

GenericFunction (sqlalchemy.sql.functions 中的类)

GenericTypeCompiler (sqlalchemy.sql.compiler 中的类)

get() (sqlalchemy.ext.associationproxy.AssociationProxyInstance 方法)

(sqlalchemy.ext.asyncio.async_scoped_session 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

get_attribute() (在 sqlalchemy.orm.attributes 模块中)

get_attribute_history() (sqlalchemy.orm.UOWTransaction 方法)

get_backend_name() (sqlalchemy.engine.URL 方法)

get_bind() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.ext.horizontal_shard.ShardedSession 方法)

get_check_constraints() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_children() (sqlalchemy.schema.CheckConstraint 方法)

(sqlalchemy.schema.Column 方法)
(sqlalchemy.schema.ColumnCollectionConstraint 方法)

get_columns() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_current_parameters() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

get_dbapi_type() (sqlalchemy.types.Date 方法)

(sqlalchemy.types.DateTime 方法)
(sqlalchemy.types.Integer 方法)

get_default_isolation_level() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

get_dialect() (sqlalchemy.engine.URL 方法)

get_dialect_cls() (sqlalchemy.engine.default.DefaultDialect 类方法)

(sqlalchemy.engine.Dialect 类方法)

get_driver_connection() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

get_driver_name() (sqlalchemy.engine.URL 方法)

get_enums() (sqlalchemy.dialects.postgresql.base.PGInspector 方法)

get_execution_options() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.Engine 方法)
(sqlalchemy.ext.asyncio.AsyncEngine 方法)

get_final_froms() (sqlalchemy.sql.expression.Select 方法)

get_foreign_keys() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_foreign_table_names() (sqlalchemy.dialects.postgresql.base.PGInspector 方法)

get_history() (sqlalchemy.orm.CompositeProperty 方法)

(在 sqlalchemy.orm.attributes 模块中)

get_indexes() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_instance_dict() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

get_isolation_level() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.default.DefaultDialect 方法)
(sqlalchemy.engine.Dialect 方法)

get_label_style (sqlalchemy.orm.Query 属性)

get_label_style() (sqlalchemy.sql.expression.GenerativeSelect 方法)

(sqlalchemy.sql.expression.Select 方法)

get_lastrowid() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

get_nested_transaction() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

get_out_parameter_values() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

(sqlalchemy.engine.ExecutionContext 方法)

get_pk_constraint() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_property() (sqlalchemy.orm.Mapper 方法)

get_property_by_column() (sqlalchemy.orm.Mapper 方法)

get_raw_connection() (sqlalchemy.ext.asyncio.AsyncConnection 方法)

get_referent() (sqlalchemy.schema.ForeignKey 方法)

get_result_cursor_strategy() (sqlalchemy.engine.ExecutionContext 方法)

get_result_processor() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

get_rowcount() (sqlalchemy.engine.ExecutionContext 方法)

get_schema_names() (sqlalchemy.engine.reflection.Inspector 方法)

get_select_precolumns() (sqlalchemy.sql.compiler.SQLCompiler 方法)

get_sequence_names() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_sorted_table_and_fkc_names() (sqlalchemy.engine.reflection.Inspector 方法)

get_table_comment() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_table_names() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_table_oid() (sqlalchemy.dialects.postgresql.base.PGInspector 方法)

get_table_options() (sqlalchemy.engine.reflection.Inspector 方法)

get_temp_table_names() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_temp_view_names() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_transaction() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

get_unique_constraints() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_view_definition() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

get_view_names() (sqlalchemy.dialects.postgresql.base.PGInspector 方法)

(sqlalchemy.engine.default.DefaultDialect 方法)
(sqlalchemy.engine.Dialect 方法)

getset_factory (sqlalchemy.ext.associationproxy.AssociationProxy parameter)

getter() (sqlalchemy.ext.hybrid.hybrid_property 方法)

global_track_bound_values (sqlalchemy.sql.expression.lambda_stmt parameter)

group (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)

group_by (sqlalchemy.sql.expression.Select.create_legacy_select parameter)

group_by() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

group_by_clause() (sqlalchemy.sql.compiler.SQLCompiler 方法)

grouping_sets (sqlalchemy.sql.functions 中的类)

H

handle_dbapi_exception() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

(sqlalchemy.engine.ExecutionContext 方法)

handle_dialect_kwargs() (sqlalchemy.engine.CreateEnginePlugin 方法)

handle_error() (sqlalchemy.events.ConnectionEvents 方法)

handle_pool_kwargs() (sqlalchemy.engine.CreateEnginePlugin 方法)

has() (sqlalchemy.ext.associationproxy.AssociationProxyInstance 方法)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance 方法)

has_all() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

(sqlalchemy.dialects.postgresql.JSONB.Comparator 方法)

has_any() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

(sqlalchemy.dialects.postgresql.JSONB.Comparator 方法)

has_changes() (sqlalchemy.orm.attributes.History 方法)

has_identity (sqlalchemy.orm.InstanceState 属性)

has_index() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

has_inherited_table() (在 sqlalchemy.orm 模块中)

has_key() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

(sqlalchemy.dialects.postgresql.JSONB.Comparator 方法)
(sqlalchemy.engine.LegacyRow 方法)

has_out_parameters (sqlalchemy.sql.compiler.SQLCompiler 属性)

has_parent() (sqlalchemy.orm.ClassManager 方法)

has_sequence() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.reflection.Inspector 方法)

has_table() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)
(sqlalchemy.engine.Engine 方法)

HasCTE (sqlalchemy.sql.expression 中的类)

HasDescriptionCode (sqlalchemy.exc 中的类)

hashable (sqlalchemy.types.ARRAY 属性)

(sqlalchemy.types.TypeEngine 属性)

HasPrefixes (sqlalchemy.sql.expression 中的类)

HasSuffixes (sqlalchemy.sql.expression 中的类)

having (sqlalchemy.sql.expression.Select.create_legacy_select parameter)

having() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)

hide_parameters (sqlalchemy.create_engine parameter)

hide_password (sqlalchemy.engine.URL.render_as_string parameter)

History (sqlalchemy.orm.attributes 中的类)

history (sqlalchemy.orm.AttributeState 属性)

host (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)
(sqlalchemy.engine.URL.set parameter)

HSTORE (sqlalchemy.dialects.postgresql 中的类)

hstore (sqlalchemy.dialects.postgresql 中的类)

HSTORE.Comparator (sqlalchemy.dialects.postgresql 中的类)

hybrid_method (sqlalchemy.ext.hybrid 中的类)

HYBRID_METHOD() (在 sqlalchemy.ext.hybrid 模块中)

hybrid_property (sqlalchemy.ext.hybrid 中的类)

HYBRID_PROPERTY() (在 sqlalchemy.ext.hybrid 模块中)

I

id_chooser (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

ident (sqlalchemy.orm.Query.get parameter)

(sqlalchemy.orm.scoping.scoped_session.get parameter)
(sqlalchemy.orm.Session.get parameter)

Identified (sqlalchemy.log 中的类)

IdentifierError

IdentifierPreparer (sqlalchemy.sql.compiler 中的类)

identity (sqlalchemy.orm.InstanceState 属性)

Identity (sqlalchemy.schema 中的类)

identity_key (sqlalchemy.orm.InstanceState 属性)

identity_key() (sqlalchemy.ext.asyncio.async_scoped_session 类方法)

(sqlalchemy.ext.asyncio.AsyncSession 类方法)
(sqlalchemy.orm.scoping.scoped_session 类方法)

identity_key_from_instance() (sqlalchemy.orm.Mapper 方法)

identity_key_from_primary_key() (sqlalchemy.orm.Mapper 方法)

identity_key_from_row() (sqlalchemy.orm.Mapper 方法)

identity_map (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.orm.Session 属性)

IdentityMap (sqlalchemy.orm 中的类)

if_exists (sqlalchemy.schema.DropIndex parameter)

(sqlalchemy.schema.DropTable parameter)

if_not_exists (sqlalchemy.schema.CreateIndex parameter)

(sqlalchemy.schema.CreateTable parameter)

ilike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

IMAGE (sqlalchemy.dialects.mssql 中的类)

immediateload() (sqlalchemy.orm.Load 方法) , [10]

(在 sqlalchemy.orm 模块中)

impl (sqlalchemy.types.Interval 属性)

(sqlalchemy.types.PickleType parameter)
(sqlalchemy.types.PickleType 属性)

implicit_returning (sqlalchemy.create_engine parameter)

(sqlalchemy.schema.Table parameter)
(sqlalchemy.sql.expression.TableClause 属性)

in_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

in_boolean_mode (sqlalchemy.dialects.mysql.match parameter)

in_boolean_mode() (sqlalchemy.dialects.mysql.match 方法)

in_natural_language_mode (sqlalchemy.dialects.mysql.match parameter)

in_natural_language_mode() (sqlalchemy.dialects.mysql.match 方法)

in_nested_transaction() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

in_transaction() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

include (sqlalchemy.dialects.postgresql.base.PGInspector.get_view_names parameter)

include_aliases (sqlalchemy.orm.with_loader_criteria parameter)

include_backrefs (sqlalchemy.orm.validates parameter)

include_collections (sqlalchemy.ext.asyncio.async_scoped_session.is_modified parameter)

(sqlalchemy.ext.asyncio.AsyncSession.is_modified parameter)
(sqlalchemy.orm.scoping.scoped_session.is_modified parameter)

include_columns (sqlalchemy.engine.reflection.Inspector.reflect_table parameter)

(sqlalchemy.schema.Table parameter)

include_defaults (sqlalchemy.sql.expression.Insert.from_select parameter)

include_foreign_key_constraints (sqlalchemy.schema.CreateTable parameter)

include_properties (sqlalchemy.orm.mapper parameter)

include_removes (sqlalchemy.orm.validates parameter)

increment (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

index (sqlalchemy.engine.CursorResult.scalars parameter)

(sqlalchemy.engine.Result.scalars parameter)
(sqlalchemy.engine.Row 属性)

Index (sqlalchemy.schema 中的类)

index (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.Column 属性)

index_elements (sqlalchemy.dialects.postgresql.Insert.on_conflict_do_nothing parameter)

(sqlalchemy.dialects.postgresql.Insert.on_conflict_do_update parameter)
(sqlalchemy.dialects.sqlite.Insert.on_conflict_do_nothing parameter)

index_property (sqlalchemy.ext.indexable 中的类)

index_where (sqlalchemy.dialects.postgresql.Insert.on_conflict_do_nothing parameter)

(sqlalchemy.dialects.postgresql.Insert.on_conflict_do_update parameter)
(sqlalchemy.dialects.sqlite.Insert.on_conflict_do_nothing parameter)

Indexable (sqlalchemy.types 中的类)

Indexable.Comparator (sqlalchemy.types 中的类)

indexes (sqlalchemy.schema.Table 属性)

INET (sqlalchemy.dialects.postgresql 中的类)

info (sqlalchemy.engine.Connection 属性)

(sqlalchemy.ext.associationproxy.AssociationProxy parameter)
(sqlalchemy.ext.associationproxy.AssociationProxy 属性)

inherit_condition (sqlalchemy.orm.mapper parameter)

inherit_foreign_keys (sqlalchemy.orm.mapper parameter)

inherit_schema (sqlalchemy.types.Enum parameter)

inherits (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)

init() (sqlalchemy.orm.InstanceEvents 方法)

(sqlalchemy.orm.MapperProperty 方法)
(sqlalchemy.orm.RelationshipProperty 方法)

init_collection() (sqlalchemy.orm.AttributeEvents 方法)

(在 sqlalchemy.orm.attributes 模块中)

init_failure() (sqlalchemy.orm.InstanceEvents 方法)

init_scalar() (sqlalchemy.orm.AttributeEvents 方法)

initialize() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

initialize_instance_dict() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

initially (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

(sqlalchemy.schema.CheckConstraint parameter)
(sqlalchemy.schema.ColumnCollectionConstraint parameter)

initiator (sqlalchemy.orm.AttributeEvents.append parameter)

(sqlalchemy.orm.AttributeEvents.append_wo_mutation parameter)
(sqlalchemy.orm.AttributeEvents.bulk_replace parameter)

inline (sqlalchemy.dialects.mysql.insert parameter)

(sqlalchemy.dialects.postgresql.insert parameter)
(sqlalchemy.dialects.sqlite.insert parameter)

inline() (sqlalchemy.sql.expression.Insert 方法)

(sqlalchemy.sql.expression.Update 方法)

inner_columns (sqlalchemy.sql.expression.Select 属性)

innerjoin (sqlalchemy.orm.joinedload parameter)

(sqlalchemy.orm.relationship parameter)
(sqlalchemy.orm.with_polymorphic parameter)

Insert (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.dialects.postgresql 中的类)
(sqlalchemy.dialects.sqlite 中的类)

insert (sqlalchemy.event.listen parameter)

Insert (sqlalchemy.sql.expression 中的类)

insert() (sqlalchemy.ext.mutable.MutableList 方法)

(sqlalchemy.ext.orderinglist.OrderingList 方法)
(sqlalchemy.schema.Table 方法)

insert_single_values_expr (sqlalchemy.sql.compiler.SQLCompiler 属性)

inserted (sqlalchemy.dialects.mysql.Insert 属性)

inserted_primary_key (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

inserted_primary_key_rows (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

inspect() (在 sqlalchemy 模块中)

InspectionAttr (sqlalchemy.orm 中的类)

InspectionAttrInfo (sqlalchemy.orm 中的类)

Inspector (sqlalchemy.engine.reflection 中的类)

install_descriptor() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

install_member() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

install_state() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

instance (sqlalchemy.ext.asyncio.async_object_session parameter)

(sqlalchemy.ext.asyncio.async_scoped_session.expire parameter)
(sqlalchemy.ext.asyncio.async_scoped_session.is_modified parameter)

instance_state() (在 sqlalchemy.orm.attributes 模块中)

InstanceEvents (sqlalchemy.orm 中的类)

instances (sqlalchemy.orm.SessionEvents.before_flush parameter)

instances() (sqlalchemy.orm.Query 方法)

InstanceState (sqlalchemy.orm 中的类)

instrument_attribute() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

instrument_class() (sqlalchemy.orm.ColumnProperty 方法)

(sqlalchemy.orm.CompositeProperty 方法)
(sqlalchemy.orm.MapperEvents 方法)

instrument_collection_class() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

instrumentation_finders() (在 sqlalchemy.ext.instrumentation 模块中)

INSTRUMENTATION_MANAGER() (在 sqlalchemy.ext.instrumentation 模块中)

InstrumentationEvents (sqlalchemy.orm 中的类)

InstrumentationFactory (sqlalchemy.orm.instrumentation 中的类)

InstrumentationManager (sqlalchemy.ext.instrumentation 中的类)

InstrumentedAttribute (sqlalchemy.orm 中的类)

InstrumentedDict (sqlalchemy.orm.collections 中的类)

InstrumentedList (sqlalchemy.orm.collections 中的类)

InstrumentedSet (sqlalchemy.orm.collections 中的类)

INT() (在 sqlalchemy.types 模块中)

INT4RANGE (sqlalchemy.dialects.postgresql 中的类)

INT8RANGE (sqlalchemy.dialects.postgresql 中的类)

INTEGER (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

Integer (sqlalchemy.types 中的类)

IntegrityError

InterfaceError

InternalError

internally_instrumented() (sqlalchemy.orm.collections.collection 静态方法)

InternalTraversal (sqlalchemy.sql.visitors 中的类)

intersect() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(在 sqlalchemy.sql.expression 模块中)

intersect_all() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(在 sqlalchemy.sql.expression 模块中)

intersection_update() (sqlalchemy.ext.mutable.MutableSet 方法)

INTERVAL (sqlalchemy.dialects.oracle 中的类)

(sqlalchemy.dialects.postgresql 中的类)

Interval (sqlalchemy.types 中的类)

invalidate() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.events.PoolEvents 方法)
(sqlalchemy.ext.asyncio.AsyncConnection 方法)

invalidate_pool_on_disconnect (sqlalchemy.engine.ExceptionContext 属性)

invalidated (sqlalchemy.engine.Connection 属性)

InvalidatePoolError

InvalidRequestError

invoke_statement() (sqlalchemy.orm.ORMExecuteState 方法)

is_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

is_active (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.ext.asyncio.AsyncSession 属性)
(sqlalchemy.orm.scoping.scoped_session 属性)

is_aliased_class (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)

is_attribute (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)

is_bound() (sqlalchemy.schema.MetaData 方法)

(sqlalchemy.schema.ThreadLocalMetaData 方法)

is_bundle (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)

is_clause_element (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)
(sqlalchemy.sql.expression.ColumnElement 属性)

is_column_load (sqlalchemy.orm.ORMExecuteState 属性)

is_comparison (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.op parameter)

(sqlalchemy.orm.PropComparator.op parameter)
(sqlalchemy.orm.QueryableAttribute.op parameter)

is_delete (sqlalchemy.orm.ORMExecuteState 属性)

is_deleted() (sqlalchemy.orm.UOWTransaction 方法)

is_derived_from() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.AliasedReturnsRows 方法)
(sqlalchemy.sql.expression.FromClause 方法)

is_disconnect (sqlalchemy.engine.ExceptionContext 属性)

is_disconnect() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

is_distinct_from() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

is_insert (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)
(sqlalchemy.orm.ORMExecuteState 属性)

is_instance (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)

is_instrumented() (在 sqlalchemy.orm.instrumentation 模块中)

is_literal (sqlalchemy.sql.expression.column parameter)

is_mapper (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)
(sqlalchemy.orm.Mapper 属性)

is_modified() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.scoping.scoped_session 方法)

is_not() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

is_not_distinct_from() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

is_orm_statement (sqlalchemy.orm.ORMExecuteState 属性)

is_prepared (sqlalchemy.engine.default.DefaultDialect.do_commit_twophase parameter)

(sqlalchemy.engine.default.DefaultDialect.do_rollback_twophase parameter)
(sqlalchemy.engine.Dialect.do_commit_twophase parameter)

is_property (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)
(sqlalchemy.orm.MapperProperty 属性)

is_relationship_load (sqlalchemy.orm.ORMExecuteState 属性)

is_select (sqlalchemy.orm.ORMExecuteState 属性)

is_selectable (sqlalchemy.ext.associationproxy.AssociationProxy 属性)

(sqlalchemy.orm.InspectionAttr 属性)
(sqlalchemy.sql.expression.ColumnElement 属性)

is_sibling() (sqlalchemy.orm.Mapper 方法)

is_single_entity (sqlalchemy.orm.Query 属性)

is_update (sqlalchemy.orm.ORMExecuteState 属性)

is_valid (sqlalchemy.pool._ConnectionFairy 属性)

isa() (sqlalchemy.orm.Mapper 方法)

isdelete (sqlalchemy.sql.compiler.SQLCompiler 属性)

isnot() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

isnot_distinct_from() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

isolate_multiinsert_groups (sqlalchemy.engine.default.DefaultExecutionContext.get_current_parameters parameter)

isolation_level (sqlalchemy.create_engine parameter)

(sqlalchemy.engine.Connection.execution_options parameter)

isouter (sqlalchemy.orm.Query.join parameter)

(sqlalchemy.schema.Table.join parameter)
(sqlalchemy.sql.expression.FromClause.join parameter)

isoutparam (sqlalchemy.sql.expression.bindparam parameter)

item_type (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)

items() (sqlalchemy.engine.LegacyRow 方法)

(sqlalchemy.engine.RowMapping 方法)
(sqlalchemy.orm.ClassManager 方法)

iterate() (sqlalchemy.sql.visitors.ExternalTraversal 方法)

(在 sqlalchemy.sql.visitors 模块中)

iterate_properties (sqlalchemy.orm.Mapper 属性)

iterator (sqlalchemy.sql.visitors.traverse_using parameter)

iterator() (sqlalchemy.orm.collections.collection 静态方法)

IteratorResult (sqlalchemy.engine 中的类)

iterkeys() (sqlalchemy.engine.LegacyRow 方法)

itervalues() (sqlalchemy.engine.LegacyRow 方法)

J

Join (sqlalchemy.sql.expression 中的类)

join() (sqlalchemy.orm.Query 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.FromClause 方法)

join_depth (sqlalchemy.orm.relationship parameter)

join_from() (sqlalchemy.sql.expression.Select 方法)

joinedload() (sqlalchemy.orm.Load 方法) , [11]

(在 sqlalchemy.orm 模块中)

JSON (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.dialects.postgresql 中的类)

JSON.Comparator (sqlalchemy.dialects.postgresql 中的类)

(sqlalchemy.types 中的类)

JSON.JSONElementType (sqlalchemy.types 中的类)

JSON.JSONIndexType (sqlalchemy.types 中的类)

JSON.JSONIntIndexType (sqlalchemy.types 中的类)

JSON.JSONPathType (sqlalchemy.types 中的类)

JSON.JSONStrIndexType (sqlalchemy.types 中的类)

json_deserializer (sqlalchemy.create_engine parameter)

json_serializer (sqlalchemy.create_engine parameter)

JSONB (sqlalchemy.dialects.postgresql 中的类)

JSONB.Comparator (sqlalchemy.dialects.postgresql 中的类)

K

keep_existing (sqlalchemy.schema.Table parameter)

key (sqlalchemy.ext.mutable.Mutable.coerce parameter)

(sqlalchemy.ext.mutable.MutableBase.coerce parameter)
(sqlalchemy.orm.attributes.get_history parameter)

key_share (sqlalchemy.sql.expression.GenerativeSelect.with_for_update parameter)

(sqlalchemy.sql.expression.Select.with_for_update parameter)

key_value_pairs (sqlalchemy.engine.URL.update_query_pairs parameter)

keys() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

(sqlalchemy.engine.CursorResult 方法)
(sqlalchemy.engine.MappingResult 方法)

kwargs (sqlalchemy.engine.CreateEnginePlugin parameter)

(sqlalchemy.engine_from_config parameter)
(sqlalchemy.orm.InstanceEvents.init parameter)

L

Label (sqlalchemy.sql.expression 中的类)

label() (sqlalchemy.orm.Bundle 方法)

(sqlalchemy.orm.Query 方法)
(sqlalchemy.schema.Column 方法)

label_length (sqlalchemy.create_engine parameter)

LABEL_STYLE_DEFAULT() (在 sqlalchemy.sql.expression 模块中)

LABEL_STYLE_DISAMBIGUATE_ONLY() (在 sqlalchemy.sql.expression 模块中)

LABEL_STYLE_NONE() (在 sqlalchemy.sql.expression 模块中)

LABEL_STYLE_TABLENAME_PLUS_COL() (在 sqlalchemy.sql.expression 模块中)

lambda_cache (sqlalchemy.sql.expression.lambda_stmt parameter)

lambda_stmt() (在 sqlalchemy.sql.expression 模块中)

LambdaElement (sqlalchemy.sql.expression 中的类)

LargeBinary (sqlalchemy.types 中的类)

last_inserted_params() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)

last_updated_params() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)

lastrow_has_defaults() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)
(sqlalchemy.engine.default.DefaultExecutionContext 方法)

lastrowid (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

Lateral (sqlalchemy.sql.expression 中的类)

lateral() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.Selectable 方法)

lazy (sqlalchemy.orm.relationship parameter)

lazy_loaded_from (sqlalchemy.orm.ORMExecuteState 属性)

(sqlalchemy.orm.Query 属性)

lazyload() (sqlalchemy.orm.Load 方法) , [13]

(在 sqlalchemy.orm 模块中)

left (sqlalchemy.sql.expression.join parameter)

(sqlalchemy.sql.expression.outerjoin parameter)

left_index (sqlalchemy.sql.functions.FunctionElement.as_comparison parameter)

legacy_is_orphan (sqlalchemy.orm.mapper parameter)

LegacyCursorResult (sqlalchemy.engine 中的类)

LegacyRow (sqlalchemy.engine 中的类)

length (sqlalchemy.dialects.mssql.CHAR parameter)

(sqlalchemy.dialects.mssql.IMAGE parameter)
(sqlalchemy.dialects.mssql.TEXT parameter)

like() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

limit (sqlalchemy.sql.expression.GenerativeSelect.limit parameter)

(sqlalchemy.sql.expression.Select.create_legacy_select parameter)
(sqlalchemy.sql.expression.Select.limit parameter)

limit() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

link_to_name (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

listen() (在 sqlalchemy.event 模块中)

listeners (sqlalchemy.create_engine parameter)

(sqlalchemy.schema.Table parameter)

listens_for() (在 sqlalchemy.event 模块中)

literal() (在 sqlalchemy.sql.expression 模块中)

literal_binds (sqlalchemy.sql.expression.values parameter)

literal_column() (在 sqlalchemy.sql.expression 模块中)

literal_execute (sqlalchemy.sql.expression.bindparam parameter)

literal_execute_params (sqlalchemy.sql.compiler.SQLCompiler 属性)

literal_processor() (sqlalchemy.types.Boolean 方法)

(sqlalchemy.types.Integer 方法)
(sqlalchemy.types.JSON.JSONElementType 方法)

lmb (sqlalchemy.sql.expression.lambda_stmt parameter)

Load (sqlalchemy.orm 中的类) , [13]

load (sqlalchemy.orm.scoping.scoped_session.merge parameter)

(sqlalchemy.orm.Session.merge parameter)

load() (sqlalchemy.orm.InstanceEvents 方法)

load_dialect_impl() (sqlalchemy.types.TypeDecorator 方法)

load_history() (sqlalchemy.orm.AttributeState 方法)

load_on_pending (sqlalchemy.orm.relationship parameter)

load_only() (sqlalchemy.orm.Load 方法) , [13]

(在 sqlalchemy.orm 模块中)

load_options (sqlalchemy.orm.ORMExecuteState 属性)

load_provisioning() (sqlalchemy.engine.Dialect 类方法)

loaded_as_persistent() (sqlalchemy.orm.SessionEvents 方法)

loaded_value (sqlalchemy.orm.AttributeState 属性)

loader_strategy_path (sqlalchemy.orm.ORMExecuteState 属性)

LoaderStrategyException

loads() (在 sqlalchemy.ext.serializer 模块中)

local_attr (sqlalchemy.ext.associationproxy.AssociationProxyInstance 属性)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 属性)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance 属性)

local_cls (sqlalchemy.ext.automap.generate_relationship parameter)

(sqlalchemy.ext.automap.name_for_collection_relationship parameter)
(sqlalchemy.ext.automap.name_for_scalar_relationship parameter)

local_execution_options (sqlalchemy.orm.ORMExecuteState 属性)

local_table (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)
(sqlalchemy.orm.registry.map_imperatively parameter)

localtime (sqlalchemy.sql.functions 中的类)

localtimestamp (sqlalchemy.sql.functions 中的类)

logging_name (sqlalchemy.create_engine parameter)

(sqlalchemy.pool.Pool parameter)
(sqlalchemy.pool.SingletonThreadPool parameter)

logging_token (sqlalchemy.engine.Connection.execution_options parameter)

LONG (sqlalchemy.dialects.oracle 中的类)

LONGBLOB (sqlalchemy.dialects.mysql 中的类)

LONGTEXT (sqlalchemy.dialects.mysql 中的类)

lower_bound (sqlalchemy.sql.expression.between parameter)

M

MACADDR (sqlalchemy.dialects.postgresql 中的类)

maintain_column_froms (sqlalchemy.sql.expression.Select.with_only_columns parameter)

make_transient() (在 sqlalchemy.orm 模块中)

make_transient_to_detached() (在 sqlalchemy.orm 模块中)

make_url() (在 sqlalchemy.engine 模块中)

manage() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

(sqlalchemy.orm.ClassManager 方法)

manager_getter() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

MANYTOMANY() (在 sqlalchemy.orm 模块中)

MANYTOONE() (在 sqlalchemy.orm 模块中)

map_column (sqlalchemy.orm.synonym parameter)

map_declaratively() (sqlalchemy.orm.registry 方法)

map_imperatively() (sqlalchemy.orm.registry 方法)

Mapped (sqlalchemy.orm 中的类)

mapped() (sqlalchemy.orm.registry 方法)

mapped_collection() (在 sqlalchemy.orm.collections 模块中)

mapped_table (sqlalchemy.orm.Mapper 属性)

MappedCollection (sqlalchemy.orm.collections 中的类)

mapper (sqlalchemy.ext.asyncio.async_scoped_session.get_bind parameter)

(sqlalchemy.ext.asyncio.AsyncSession.get_bind parameter)
(sqlalchemy.ext.horizontal_shard.ShardedSession.get_bind parameter)

Mapper (sqlalchemy.orm 中的类)

mapper (sqlalchemy.orm.declarative_base parameter)

(sqlalchemy.orm.InstanceState 属性)
(sqlalchemy.orm.Mapper 属性)

mapper() (在 sqlalchemy.orm 模块中)

mapper_configured() (sqlalchemy.orm.MapperEvents 方法)

MapperEvents (sqlalchemy.orm 中的类)

MapperProperty (sqlalchemy.orm 中的类)

mappers (sqlalchemy.orm.registry 属性)

mapping (sqlalchemy.types.Variant parameter)

MappingResult (sqlalchemy.engine 中的类)

mappings (sqlalchemy.orm.scoping.scoped_session.bulk_insert_mappings parameter)

(sqlalchemy.orm.scoping.scoped_session.bulk_update_mappings parameter)
(sqlalchemy.orm.Session.bulk_insert_mappings parameter)

mappings() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.Result 方法)
(sqlalchemy.ext.asyncio.AsyncResult 方法)

match (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.schema.ForeignKey parameter)
(sqlalchemy.schema.ForeignKeyConstraint parameter)

match() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

MatchType (sqlalchemy.types 中的类)

matrix() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

max (sqlalchemy.sql.functions 中的类)

max_identifier_length (sqlalchemy.create_engine parameter)

max_overflow (sqlalchemy.create_engine parameter)

(sqlalchemy.pool.QueuePool parameter)

maxvalue (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

MEDIUMBLOB (sqlalchemy.dialects.mysql 中的类)

MEDIUMINT (sqlalchemy.dialects.mysql 中的类)

MEDIUMTEXT (sqlalchemy.dialects.mysql 中的类)

memoized_instancemethod() (sqlalchemy.orm.ClassManager 类方法)

(sqlalchemy.orm.QueryableAttribute 类方法)
(sqlalchemy.schema.Column 类方法)

merge() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.Result 方法)
(sqlalchemy.ext.asyncio.async_scoped_session 方法)

merge_frozen_result() (在 sqlalchemy.orm 模块中)

merge_result() (sqlalchemy.orm.Query 方法)

(在 sqlalchemy.orm 模块中)

MergedResult (sqlalchemy.engine 中的类)

metaclass (sqlalchemy.orm.declarative_base parameter)

(sqlalchemy.orm.registry.generate_base parameter)

metadata (sqlalchemy.orm.declarative_base parameter)

(sqlalchemy.orm.registry parameter)

MetaData (sqlalchemy.schema 中的类)

metadata (sqlalchemy.schema.Sequence parameter)

(sqlalchemy.schema.Table parameter)
(sqlalchemy.schema.Table.to_metadata parameter)

min (sqlalchemy.sql.functions 中的类)

minvalue (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

MissingGreenlet

mode (sqlalchemy.sql.functions 中的类)

modified() (sqlalchemy.orm.AttributeEvents 方法)

module (sqlalchemy.create_engine parameter)

MONEY (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.postgresql 中的类)

MovedIn20Warning

multiparams (sqlalchemy.events.ConnectionEvents.after_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_execute parameter)

MultipleResultsFound

must_exist (sqlalchemy.schema.Table parameter)

mutable (sqlalchemy.ext.indexable.index_property parameter)

Mutable (sqlalchemy.ext.mutable 中的类)

MutableBase (sqlalchemy.ext.mutable 中的类)

MutableComposite (sqlalchemy.ext.mutable 中的类)

MutableDict (sqlalchemy.ext.mutable 中的类)

MutableList (sqlalchemy.ext.mutable 中的类)

MutableSet (sqlalchemy.ext.mutable 中的类)

N

name (sqlalchemy.dialects.mssql.BIT parameter)

(sqlalchemy.dialects.mysql.BOOLEAN parameter)
(sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

name_for_collection_relationship (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

name_for_collection_relationship() (在 sqlalchemy.ext.automap 模块中)

name_for_scalar_relationship (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

name_for_scalar_relationship() (在 sqlalchemy.ext.automap 模块中)

named (sqlalchemy.event.listen parameter)

names (sqlalchemy.engine.URL.translate_connect_args parameter)

(sqlalchemy.sql.expression.Insert.from_select parameter)

naming_convention (sqlalchemy.schema.MetaData parameter)

national (sqlalchemy.dialects.mysql.LONGTEXT parameter)

(sqlalchemy.dialects.mysql.MEDIUMTEXT parameter)
(sqlalchemy.dialects.mysql.TEXT parameter)

native (sqlalchemy.types.Interval parameter)

native_enum (sqlalchemy.types.Enum parameter)

NCHAR (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.types 中的类)

NCLOB (sqlalchemy.dialects.oracle 中的类)

nested (sqlalchemy.orm.scoping.scoped_session.begin parameter)

(sqlalchemy.orm.Session.begin parameter)
(sqlalchemy.orm.SessionTransaction 属性)

NestedTransaction (sqlalchemy.engine 中的类)

nesting (sqlalchemy.sql.expression.HasCTE.cte parameter)

(sqlalchemy.sql.expression.Select.cte parameter)
(sqlalchemy.sql.expression.SelectBase.cte parameter)

new (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.ext.asyncio.AsyncSession 属性)
(sqlalchemy.orm.scoping.scoped_session 属性)

new_adapter (sqlalchemy.orm.collections.bulk_replace parameter)

next_value (sqlalchemy.sql.functions 中的类)

next_value() (sqlalchemy.schema.Sequence 方法)

no_autoflush (sqlalchemy.ext.asyncio.async_scoped_session 属性)

(sqlalchemy.ext.asyncio.AsyncSession 属性)
(sqlalchemy.orm.scoping.scoped_session 属性)

no_parameters (sqlalchemy.engine.Connection.execution_options parameter)

NO_STATE() (在 sqlalchemy.orm.exc 模块中)

NoForeignKeysError

NoInspectionAvailable

noload() (sqlalchemy.orm.Load 方法) , [15]

(在 sqlalchemy.orm 模块中)

nomaxvalue (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

nominvalue (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

non_added() (sqlalchemy.orm.attributes.History 方法)

non_deleted() (sqlalchemy.orm.attributes.History 方法)

non_primary (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)

none_as_null (sqlalchemy.dialects.mssql.JSON parameter)

(sqlalchemy.dialects.postgresql.JSON parameter)
(sqlalchemy.types.JSON parameter)

NoReferencedColumnError

NoReferencedTableError

NoReferenceError

NoResultFound

normalize_name() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

normalized_query (sqlalchemy.engine.URL 属性)

NoSuchColumnError

NoSuchModuleError

NoSuchTableError

not_() (在 sqlalchemy.sql.expression 模块中)

not_extend_left_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

not_extend_right_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

NOT_EXTENSION() (在 sqlalchemy.orm 模块中)

not_ilike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

not_in() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

not_like() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

notilike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

notin_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

notlike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

NotSupportedError

now (sqlalchemy.sql.functions 中的类)

nowait (sqlalchemy.sql.expression.GenerativeSelect.with_for_update parameter)

(sqlalchemy.sql.expression.Select.with_for_update parameter)

NTEXT (sqlalchemy.dialects.mssql 中的类)

Null (sqlalchemy.sql.expression 中的类)

NULL (sqlalchemy.types.JSON 属性)

null() (在 sqlalchemy.sql.expression 模块中)

nullable (sqlalchemy.schema.Column parameter)

NullPool (sqlalchemy.pool 中的类)

nulls_first() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

nulls_last() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

nullsfirst() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

nullslast() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

NullType (sqlalchemy.types 中的类)

num (sqlalchemy.engine.ChunkedIteratorResult.yield_per parameter)

(sqlalchemy.engine.CursorResult.yield_per parameter)
(sqlalchemy.engine.Result.yield_per parameter)

NUMBER (sqlalchemy.dialects.oracle 中的类)

NUMERIC (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

Numeric (sqlalchemy.types 中的类)

NUMRANGE (sqlalchemy.dialects.postgresql 中的类)

NVARCHAR (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.types 中的类)

N加1

n加上一个问题

O

obj (sqlalchemy.ext.associationproxy.AssociationProxy.for_class parameter)

(sqlalchemy.orm.attributes.get_history parameter)
(sqlalchemy.orm.attributes.init_collection parameter)

object (sqlalchemy.ext.asyncio.AsyncConnection.execute parameter)

(sqlalchemy.orm.InstanceState 属性)

object_mapper() (在 sqlalchemy.orm 模块中)

object_session() (sqlalchemy.ext.asyncio.async_scoped_session 类方法)

(sqlalchemy.ext.asyncio.AsyncSession 类方法)
(sqlalchemy.orm.scoping.scoped_session 类方法)

object_state() (在 sqlalchemy.orm.util 模块中)

ObjectAssociationProxyInstance (sqlalchemy.ext.associationproxy 中的类)

ObjectDeletedError

ObjectDereferencedError

ObjectNotExecutableError

objects (sqlalchemy.orm.scoping.scoped_session.bulk_save_objects parameter)

(sqlalchemy.orm.scoping.scoped_session.flush parameter)
(sqlalchemy.orm.Session.bulk_save_objects parameter)

of (sqlalchemy.sql.expression.GenerativeSelect.with_for_update parameter)

(sqlalchemy.sql.expression.Select.with_for_update parameter)

of_type() (sqlalchemy.orm.PropComparator 方法)

(sqlalchemy.orm.QueryableAttribute 方法)
(sqlalchemy.orm.RelationshipProperty.Comparator 方法)

offset (sqlalchemy.sql.expression.GenerativeSelect.offset parameter)

(sqlalchemy.sql.expression.Select.create_legacy_select parameter)
(sqlalchemy.sql.expression.Select.offset parameter)

offset() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

OID (sqlalchemy.dialects.postgresql 中的类)

oldvalue (sqlalchemy.orm.AttributeEvents.set parameter)

omit_aliases (sqlalchemy.types.Enum parameter)

omit_join (sqlalchemy.orm.relationship parameter)

on (sqlalchemy.schema.CreateIndex parameter)

(sqlalchemy.schema.CreateTable parameter)
(sqlalchemy.schema.DDLElement 属性)

on_conflict_do_nothing() (sqlalchemy.dialects.postgresql.Insert 方法)

(sqlalchemy.dialects.sqlite.Insert 方法)

on_conflict_do_update() (sqlalchemy.dialects.postgresql.Insert 方法)

(sqlalchemy.dialects.sqlite.Insert 方法)

on_connect() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

on_connect_url() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

on_duplicate_key_update() (sqlalchemy.dialects.mysql.Insert 方法)

on_null (sqlalchemy.schema.Identity parameter)

once (sqlalchemy.event.listen parameter)

onclause (sqlalchemy.schema.Table.join parameter)

(sqlalchemy.schema.Table.outerjoin parameter)
(sqlalchemy.sql.expression.FromClause.join parameter)

ondelete (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

one() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

one_or_none() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

onebased (sqlalchemy.ext.indexable.index_property parameter)

ONETOMANY() (在 sqlalchemy.orm 模块中)

only (sqlalchemy.schema.MetaData.reflect parameter)

only_return_tuples() (sqlalchemy.orm.Query 方法)

only_synonyms (sqlalchemy.sql.expression.Select.reduce_columns parameter)

onupdate (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.ForeignKey parameter)
(sqlalchemy.schema.ForeignKeyConstraint parameter)

op (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.operate parameter)

(sqlalchemy.orm.ColumnProperty.Comparator.operate parameter)
(sqlalchemy.orm.PropComparator.operate parameter)

op() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

operate() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.ColumnProperty.Comparator 方法)
(sqlalchemy.orm.PropComparator 方法)

OperationalError

operator (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.op parameter)

(sqlalchemy.orm.PropComparator.op parameter)
(sqlalchemy.orm.QueryableAttribute.op parameter)

Operators (sqlalchemy.sql.expression 中的类)

ops (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

optional (sqlalchemy.schema.Sequence parameter)

options (sqlalchemy.orm.scoping.scoped_session.get parameter)

(sqlalchemy.orm.scoping.scoped_session.merge parameter)
(sqlalchemy.orm.Session.get parameter)

options() (sqlalchemy.orm.Load 方法) , [16]

(sqlalchemy.orm.Query 方法)
(sqlalchemy.sql.expression.Executable 方法)

opts (sqlalchemy.events.ConnectionEvents.set_connection_execution_options parameter)

(sqlalchemy.events.ConnectionEvents.set_engine_execution_options parameter)
(sqlalchemy.sql.visitors.iterate parameter)

or_() (在 sqlalchemy.sql.expression 模块中)

order (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

order_by (sqlalchemy.orm.relationship parameter)

(sqlalchemy.sql.expression.over parameter)
(sqlalchemy.sql.expression.Select.create_legacy_select parameter)

order_by() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

order_by_clause() (sqlalchemy.sql.compiler.SQLCompiler 方法)

ordered_values() (sqlalchemy.sql.expression.Update 方法)

OrderedSetAgg (sqlalchemy.sql.functions 中的类)

ordering_attr (sqlalchemy.ext.orderinglist.OrderingList parameter)

ordering_func (sqlalchemy.ext.orderinglist.OrderingList parameter)

ordering_list() (在 sqlalchemy.ext.orderinglist 模块中)

OrderingList (sqlalchemy.ext.orderinglist 中的类)

orig (sqlalchemy.exc.StatementError 属性)

original (sqlalchemy.sql.expression.AliasedReturnsRows 属性)

original_exception (sqlalchemy.engine.ExceptionContext 属性)

orm_execute_state (sqlalchemy.orm.SessionEvents.do_orm_execute parameter)

ORMExecuteState (sqlalchemy.orm 中的类)

other (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.contains parameter)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.endswith parameter)
(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.ilike parameter)

outerjoin() (sqlalchemy.orm.Query 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.FromClause 方法)

outerjoin_from() (sqlalchemy.sql.expression.Select 方法)

outparam() (在 sqlalchemy.sql.expression 模块中)

Over (sqlalchemy.sql.expression 中的类)

over() (sqlalchemy.sql.expression.FunctionFilter 方法)

(sqlalchemy.sql.expression.WithinGroup 方法)
(sqlalchemy.sql.functions.FunctionElement 方法)

overlap() (sqlalchemy.dialects.postgresql.ARRAY.Comparator 方法)

overlaps (sqlalchemy.orm.relationship parameter)

overlaps() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

overrides (sqlalchemy.ext.hybrid.hybrid_property 属性)

P

packagenames (sqlalchemy.sql.functions.Function parameter)

parameters (sqlalchemy.engine.Connection.exec_driver_sql parameter)

(sqlalchemy.engine.ExceptionContext 属性)
(sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

params (sqlalchemy.engine.Compiled 属性)

(sqlalchemy.engine.Compiled.construct_params parameter)
(sqlalchemy.events.ConnectionEvents.after_execute parameter)

params() (sqlalchemy.ext.baked.Result 方法)

(sqlalchemy.orm.Query 方法)
(sqlalchemy.schema.Column 方法)

paramstyle (sqlalchemy.create_engine parameter)

parent (sqlalchemy.events.DDLEvents.after_parent_attach parameter)

(sqlalchemy.events.DDLEvents.before_parent_attach parameter)
(sqlalchemy.orm.QueryableAttribute 属性)

partition_by (sqlalchemy.sql.expression.over parameter)

partitions() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

passive (sqlalchemy.orm.attributes.get_history parameter)

passive_deletes (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.relationship parameter)

passive_updates (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.relationship parameter)

password (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)
(sqlalchemy.engine.URL.set parameter)

pattern (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.regexp_match parameter)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.regexp_replace parameter) [0]
(sqlalchemy.orm.PropComparator.regexp_match parameter)

pending (sqlalchemy.orm.InstanceState 属性)

pending_to_persistent() (sqlalchemy.orm.SessionEvents 方法)

pending_to_transient() (sqlalchemy.orm.SessionEvents 方法)

PendingRollbackError

PEP-249

percent (sqlalchemy.sql.expression.GenerativeSelect.fetch parameter)

(sqlalchemy.sql.expression.Select.fetch parameter)

percent_rank (sqlalchemy.sql.functions 中的类)

percentile_cont (sqlalchemy.sql.functions 中的类)

percentile_disc (sqlalchemy.sql.functions 中的类)

persist_selectable (sqlalchemy.orm.Mapper 属性)

persisted (sqlalchemy.schema.Computed parameter)

persistent (sqlalchemy.orm.InstanceState 属性)

persistent_to_deleted() (sqlalchemy.orm.SessionEvents 方法)

persistent_to_detached() (sqlalchemy.orm.SessionEvents 方法)

persistent_to_transient() (sqlalchemy.orm.SessionEvents 方法)

PGInspector (sqlalchemy.dialects.postgresql.base 中的类)

pickle() (sqlalchemy.orm.InstanceEvents 方法)

pickler (sqlalchemy.types.PickleType parameter)

PickleType (sqlalchemy.types 中的类)

plugins (sqlalchemy.create_engine parameter)

polymorphic_identity (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)

polymorphic_iterator() (sqlalchemy.orm.Mapper 方法)

polymorphic_load (sqlalchemy.orm.mapper parameter)

polymorphic_map (sqlalchemy.orm.Mapper 属性)

polymorphic_on (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)
(sqlalchemy.orm.with_polymorphic parameter)

polymorphic_union() (在 sqlalchemy.orm 模块中)

pool (sqlalchemy.create_engine parameter)

Pool (sqlalchemy.pool 中的类)

pool_logging_name (sqlalchemy.create_engine parameter)

pool_pre_ping (sqlalchemy.create_engine parameter)

pool_recycle (sqlalchemy.create_engine parameter)

pool_reset_on_return (sqlalchemy.create_engine parameter)

pool_size (sqlalchemy.create_engine parameter)

(sqlalchemy.pool.QueuePool parameter)
(sqlalchemy.pool.SingletonThreadPool parameter)

pool_timeout (sqlalchemy.create_engine parameter)

pool_use_lifo (sqlalchemy.create_engine parameter)

poolclass (sqlalchemy.create_engine parameter)

PoolEvents (sqlalchemy.events 中的类)

pop() (sqlalchemy.ext.mutable.MutableDict 方法)

(sqlalchemy.ext.mutable.MutableList 方法)
(sqlalchemy.ext.mutable.MutableSet 方法)

popitem() (sqlalchemy.ext.mutable.MutableDict 方法)

(sqlalchemy.orm.ClassManager 方法)
(sqlalchemy.orm.collections.MappedCollection 方法)

populate_existing (sqlalchemy.orm.scoping.scoped_session.get parameter)

(sqlalchemy.orm.Session.get parameter)

populate_existing() (sqlalchemy.orm.Query 方法)

port (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)
(sqlalchemy.engine.URL.set parameter)

post_compile_params (sqlalchemy.sql.compiler.SQLCompiler 属性)

post_configure_attribute() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

post_exec() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

(sqlalchemy.engine.ExecutionContext 方法)

post_instrument_class() (sqlalchemy.orm.MapperProperty 方法)

(sqlalchemy.orm.RelationshipProperty 方法)
(sqlalchemy.orm.SynonymProperty 方法)

post_update (sqlalchemy.orm.relationship parameter)

postfetch_cols() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)

postfetch_lastrowid (sqlalchemy.sql.compiler.SQLCompiler 属性)

pre_exec() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

(sqlalchemy.engine.ExecutionContext 方法)

pre_ping (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

precedence (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.op parameter)

(sqlalchemy.orm.PropComparator.op parameter)
(sqlalchemy.orm.QueryableAttribute.op parameter)

precision (sqlalchemy.dialects.mssql.REAL parameter)

(sqlalchemy.dialects.mysql.DECIMAL parameter)
(sqlalchemy.dialects.mysql.DOUBLE parameter)

prefetch_cols() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)

prefix (sqlalchemy.engine_from_config parameter)

prefix_with() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.HasPrefixes 方法)
(sqlalchemy.sql.expression.Select 方法)

prefixes (sqlalchemy.schema.Table parameter)

prepare() (sqlalchemy.engine.TwoPhaseTransaction 方法)

(sqlalchemy.ext.automap.AutomapBase 类方法)
(sqlalchemy.ext.declarative.DeferredReflection 类方法)

prepare_instrumentation() (在 sqlalchemy.orm.collections 模块中)

prepare_twophase() (sqlalchemy.events.ConnectionEvents 方法)

preparer (sqlalchemy.engine.default.DefaultDialect 属性)

preserve_order (sqlalchemy.orm.scoping.scoped_session.bulk_save_objects parameter)

(sqlalchemy.orm.Session.bulk_save_objects parameter)

preserve_parameter_order (sqlalchemy.sql.expression.update parameter)

previous_transaction (sqlalchemy.orm.SessionEvents.after_soft_rollback parameter)

primary_key (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.Mapper 属性)
(sqlalchemy.orm.Mapper.identity_key_from_primary_key parameter)

primary_key_from_instance() (sqlalchemy.orm.Mapper 方法)

primary_mapper() (sqlalchemy.orm.Mapper 方法)

primaryjoin (sqlalchemy.orm.relationship parameter)

PrimaryKeyConstraint (sqlalchemy.schema 中的类)

process_bind_param() (sqlalchemy.types.TypeDecorator 方法)

process_compile_state() (sqlalchemy.orm.Load 方法) , [17]

process_compile_state_replaced_entities() (sqlalchemy.orm.Load 方法) , [17]

process_literal_param() (sqlalchemy.types.TypeDecorator 方法)

process_result_value() (sqlalchemy.types.TypeDecorator 方法)

ProgrammingError

propagate (sqlalchemy.event.listen parameter)

(sqlalchemy.orm.AttributeEvents parameter)
(sqlalchemy.orm.InstanceEvents parameter)

propagate_to_loaders (sqlalchemy.orm.with_loader_criteria parameter)

PropComparator (sqlalchemy.orm 中的类)

properties (sqlalchemy.orm.mapper parameter)

property (sqlalchemy.orm.Query.with_parent parameter)

(sqlalchemy.orm.QueryableAttribute 属性)
(sqlalchemy.orm.with_parent parameter)

protocol (sqlalchemy.types.PickleType parameter)

proxy_bulk_set (sqlalchemy.ext.associationproxy.AssociationProxy parameter)

proxy_factory (sqlalchemy.ext.associationproxy.AssociationProxy parameter)

proxy_set (sqlalchemy.sql.expression.ColumnElement 属性)

Python 提高建议

PEP 249 [0] [1] [2] [3]
PEP 484 [0] [1] [2] [3]

python_type (sqlalchemy.types.ARRAY 属性)

(sqlalchemy.types.Boolean 属性)
(sqlalchemy.types.Date 属性)

Q

query (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)
(sqlalchemy.engine.URL.set parameter)

Query (sqlalchemy.orm 中的类)

query (sqlalchemy.orm.QueryEvents.before_compile_delete parameter)

(sqlalchemy.orm.QueryEvents.before_compile_update parameter)

query() (sqlalchemy.orm.scoping.scoped_session 方法)

(sqlalchemy.orm.Session 方法)

query_cache_size (sqlalchemy.create_engine parameter)

query_class (sqlalchemy.orm.relationship parameter)

query_cls (sqlalchemy.orm.Session parameter)

query_expression() (在 sqlalchemy.orm 模块中)

query_or_session (sqlalchemy.ext.baked.BakedQuery.to_query parameter)

query_parameters (sqlalchemy.engine.URL.update_query_dict parameter)

query_property() (sqlalchemy.orm.scoping.scoped_session 方法)

query_string (sqlalchemy.engine.URL.update_query_string parameter)

QueryableAttribute (sqlalchemy.orm 中的类)

QueryableAttribute.memoized_attribute (sqlalchemy.orm 中的类)

QueryContext (sqlalchemy.orm 中的类)

QueryContext.default_load_options (sqlalchemy.orm 中的类)

QueryEvents (sqlalchemy.orm 中的类)

QueuePool (sqlalchemy.pool 中的类)

quote (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.Index parameter)
(sqlalchemy.schema.Sequence parameter)

quote() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

quote_identifier() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

quote_schema (sqlalchemy.schema.MetaData parameter)

(sqlalchemy.schema.Sequence parameter)
(sqlalchemy.schema.Table parameter)

quote_schema() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

quoted_name (sqlalchemy.sql.expression 中的类)

quoting (sqlalchemy.dialects.mysql.ENUM parameter)

(sqlalchemy.dialects.mysql.SET parameter)

R

raiseerr (sqlalchemy.inspect parameter)

raiseload (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.defer parameter)
(sqlalchemy.orm.deferred parameter)

raiseload() (sqlalchemy.orm.Load 方法) , [19]

(在 sqlalchemy.orm 模块中)

random (sqlalchemy.sql.functions 中的类)

range_ (sqlalchemy.sql.expression.over parameter)

RangeOperators (sqlalchemy.dialects.postgresql.ranges 中的类)

RangeOperators.comparator_factory (sqlalchemy.dialects.postgresql.ranges 中的类)

rank (sqlalchemy.sql.functions 中的类)

RAW (sqlalchemy.dialects.oracle 中的类)

raw (sqlalchemy.orm.AttributeEvents parameter)

(sqlalchemy.orm.InstanceEvents parameter)
(sqlalchemy.orm.MapperEvents parameter)

raw_connection() (sqlalchemy.engine.Engine 方法)

(sqlalchemy.ext.asyncio.AsyncEngine 方法)

read (sqlalchemy.sql.expression.GenerativeSelect.with_for_update parameter)

(sqlalchemy.sql.expression.Select.with_for_update parameter)

REAL (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.dialects.postgresql 中的类)

reconstructor() (在 sqlalchemy.orm 模块中)

record_info (sqlalchemy.pool._ConnectionFairy 属性)

(sqlalchemy.pool._ConnectionRecord 属性)

recover (sqlalchemy.engine.default.DefaultDialect.do_commit_twophase parameter)

(sqlalchemy.engine.default.DefaultDialect.do_rollback_twophase parameter)
(sqlalchemy.engine.Dialect.do_commit_twophase parameter)

recreate() (sqlalchemy.pool.Pool 方法)

recursive (sqlalchemy.sql.expression.HasCTE.cte parameter)

(sqlalchemy.sql.expression.Select.cte parameter)
(sqlalchemy.sql.expression.SelectBase.cte parameter)

recycle (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

reduce_columns (sqlalchemy.orm.Query.subquery parameter)

reduce_columns() (sqlalchemy.sql.expression.Select 方法)

refcolumns (sqlalchemy.schema.ForeignKeyConstraint parameter)

references() (sqlalchemy.schema.Column 方法)

(sqlalchemy.schema.ForeignKey 方法)

referred_cls (sqlalchemy.ext.automap.generate_relationship parameter)

(sqlalchemy.ext.automap.name_for_collection_relationship parameter)
(sqlalchemy.ext.automap.name_for_scalar_relationship parameter)

referred_schema_fn (sqlalchemy.schema.Table.to_metadata parameter)

referred_table (sqlalchemy.schema.ForeignKeyConstraint 属性)

reflect (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

reflect() (sqlalchemy.schema.MetaData 方法)

reflect_table() (sqlalchemy.engine.reflection.Inspector 方法)

reflection_options (sqlalchemy.ext.automap.AutomapBase.prepare parameter)

reflecttable() (sqlalchemy.engine.reflection.Inspector 方法)

refresh() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)
(sqlalchemy.orm.InstanceEvents 方法)

refresh_flush() (sqlalchemy.orm.InstanceEvents 方法)

REGCLASS (sqlalchemy.dialects.postgresql 中的类)

regexp (sqlalchemy.dialects.sqlite.DATE parameter)

(sqlalchemy.dialects.sqlite.DATETIME parameter)
(sqlalchemy.dialects.sqlite.TIME parameter)

regexp_match() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

regexp_replace() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

register_function() (在 sqlalchemy.sql.functions 模块中)

registry (sqlalchemy.orm 中的类)

relation() (在 sqlalchemy.orm 模块中)

relationship() (在 sqlalchemy.orm 模块中)

RelationshipProperty (sqlalchemy.orm 中的类)

RelationshipProperty.Comparator (sqlalchemy.orm 中的类)

relationships (sqlalchemy.orm.Mapper 属性)

release_savepoint() (sqlalchemy.events.ConnectionEvents 方法)

remote() (在 sqlalchemy.orm 模块中)

remote_attr (sqlalchemy.ext.associationproxy.AssociationProxyInstance 属性)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 属性)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance 属性)

remote_side (sqlalchemy.orm.relationship parameter)

remove() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.mutable.MutableList 方法)
(sqlalchemy.ext.mutable.MutableSet 方法)

remove_state() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

remove_state_actions() (sqlalchemy.orm.UOWTransaction 方法)

RemovedIn20Warning

remover() (sqlalchemy.orm.collections.collection 静态方法)

removes() (sqlalchemy.orm.collections.collection 静态方法)

removes_return() (sqlalchemy.orm.collections.collection 静态方法)

render_as_string() (sqlalchemy.engine.URL 方法)

render_derived() (sqlalchemy.sql.expression.TableValuedAlias 方法)

render_literal_execute() (sqlalchemy.sql.expression.BindParameter 方法)

render_literal_value() (sqlalchemy.sql.compiler.SQLCompiler 方法)

render_nulls (sqlalchemy.orm.scoping.scoped_session.bulk_insert_mappings parameter)

(sqlalchemy.orm.Session.bulk_insert_mappings parameter)

render_table_with_column_in_update_from (sqlalchemy.sql.compiler.SQLCompiler 属性)

reorder() (sqlalchemy.ext.orderinglist.OrderingList 方法)

reorder_on_append (sqlalchemy.ext.orderinglist.OrderingList parameter)

replace_existing (sqlalchemy.schema.Table.append_column parameter)

replace_selectable() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.Selectable 方法)

replacement_traverse() (在 sqlalchemy.sql.visitors 模块中)

replaces() (sqlalchemy.orm.collections.collection 静态方法)

require_embedded (sqlalchemy.schema.Table.corresponding_column parameter)

(sqlalchemy.sql.expression.ColumnCollection.corresponding_column parameter)
(sqlalchemy.sql.expression.Select.corresponding_column parameter)

required (sqlalchemy.sql.expression.bindparam parameter)

reset() (sqlalchemy.events.PoolEvents 方法)

reset_isolation_level() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

reset_joinpoint() (sqlalchemy.orm.Query 方法)

reset_on_return (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

resolve_fks (sqlalchemy.schema.MetaData.reflect parameter)

(sqlalchemy.schema.Table parameter)

ResourceClosedError

restore_load_context (sqlalchemy.orm.InstanceEvents parameter)

(sqlalchemy.orm.SessionEvents parameter)

Result (sqlalchemy.engine 中的类)

result (sqlalchemy.events.ConnectionEvents.after_execute parameter)

Result (sqlalchemy.ext.baked 中的类)

result_processor() (sqlalchemy.dialects.postgresql.HSTORE 方法)

(sqlalchemy.types.Boolean 方法)
(sqlalchemy.types.Float 方法)

retrieve_as_bitwise (sqlalchemy.dialects.mysql.SET parameter)

return_defaults (sqlalchemy.orm.scoping.scoped_session.bulk_insert_mappings parameter)

(sqlalchemy.orm.scoping.scoped_session.bulk_save_objects parameter)
(sqlalchemy.orm.Session.bulk_insert_mappings parameter)

return_defaults() (sqlalchemy.sql.expression.ValuesBase 方法)

return_fn (sqlalchemy.ext.automap.generate_relationship parameter)

return_type (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance.op parameter)

(sqlalchemy.orm.PropComparator.op parameter)
(sqlalchemy.orm.QueryableAttribute.op parameter)

returned_defaults (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

returned_defaults_rows (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

RETURNING

returning (sqlalchemy.sql.compiler.SQLCompiler 属性)

returning() (sqlalchemy.sql.expression.Delete 方法)

(sqlalchemy.sql.expression.Insert 方法)
(sqlalchemy.sql.expression.Update 方法)

returning_precedes_values (sqlalchemy.sql.compiler.SQLCompiler 属性)

RETURNS_BYTES (sqlalchemy.types.String 属性)

RETURNS_CONDITIONAL (sqlalchemy.types.String 属性)

returns_rows (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

RETURNS_UNICODE (sqlalchemy.types.String 属性)

returns_unicode_strings (sqlalchemy.engine.default.DefaultDialect 属性)

RETURNS_UNKNOWN (sqlalchemy.types.String 属性)

ReturnsRows (sqlalchemy.sql.expression 中的类)

ReturnTypeFromArgs (sqlalchemy.sql.functions 中的类)

retval (sqlalchemy.event.listen parameter)

(sqlalchemy.events.ConnectionEvents parameter)
(sqlalchemy.orm.AttributeEvents parameter)

reverse() (sqlalchemy.ext.mutable.MutableList 方法)

reverse_operate() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.ColumnProperty.Comparator 方法)
(sqlalchemy.orm.PropComparator 方法)

right (sqlalchemy.schema.Table.join parameter)

(sqlalchemy.schema.Table.outerjoin parameter)
(sqlalchemy.sql.expression.FromClause.join parameter)

right_index (sqlalchemy.sql.functions.FunctionElement.as_comparison parameter)

rollback() (sqlalchemy.engine.NestedTransaction 方法)

(sqlalchemy.engine.RootTransaction 方法)
(sqlalchemy.engine.Transaction 方法)

rollback_savepoint() (sqlalchemy.events.ConnectionEvents 方法)

rollback_twophase() (sqlalchemy.events.ConnectionEvents 方法)

rollup (sqlalchemy.sql.functions 中的类)

RootTransaction (sqlalchemy.engine 中的类)

Row (sqlalchemy.engine 中的类)

row (sqlalchemy.orm.Mapper.identity_key_from_row parameter)

rowcount (sqlalchemy.engine.BaseCursorResult 属性)

(sqlalchemy.engine.CursorResult 属性)

RowMapping (sqlalchemy.engine 中的类)

rows (sqlalchemy.sql.expression.over parameter)

ROWVERSION (sqlalchemy.dialects.mssql 中的类)

run_callable() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.Engine 方法)
(sqlalchemy.future.Engine 方法)

run_sync() (sqlalchemy.ext.asyncio.AsyncConnection 方法)

(sqlalchemy.ext.asyncio.AsyncSession 方法)

S

SADeprecationWarning

sampling (sqlalchemy.sql.expression.tablesample parameter)

SAPendingDeprecationWarning

savepoint() (sqlalchemy.events.ConnectionEvents 方法)

SAWarning

scalar (sqlalchemy.ext.associationproxy.AssociationProxyInstance 属性)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 属性)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance 属性)

scalar() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.CursorResult 方法)
(sqlalchemy.engine.Engine 方法)

scalar_one() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.Result 方法)
(sqlalchemy.ext.asyncio.AsyncResult 方法)

scalar_one_or_none() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.Result 方法)
(sqlalchemy.ext.asyncio.AsyncResult 方法)

scalar_subquery() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.SelectBase 方法)

scalar_table_valued() (sqlalchemy.sql.functions.FunctionElement 方法)

ScalarFunctionColumn (sqlalchemy.sql.functions 中的类)

ScalarResult (sqlalchemy.engine 中的类)

scalars() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.CursorResult 方法)
(sqlalchemy.engine.Result 方法)

ScalarSelect (sqlalchemy.sql.expression 中的类)

scale (sqlalchemy.dialects.mysql.DECIMAL parameter)

(sqlalchemy.dialects.mysql.DOUBLE parameter)
(sqlalchemy.dialects.mysql.FLOAT parameter)

schema (sqlalchemy.dialects.postgresql.base.PGInspector.get_enums parameter)

(sqlalchemy.dialects.postgresql.base.PGInspector.get_view_names parameter)
(sqlalchemy.engine.default.DefaultDialect.get_sequence_names parameter)

schema_for_object (sqlalchemy.sql.compiler.IdentifierPreparer 属性)

schema_for_object() (sqlalchemy.engine.Connection 方法)

schema_translate_map (sqlalchemy.engine.Compiled parameter)

(sqlalchemy.engine.Connection.execution_options parameter)
(sqlalchemy.sql.compiler.DDLCompiler parameter)

SchemaEventTarget (sqlalchemy.events 中的类)

SchemaItem (sqlalchemy.schema 中的类)

SchemaType (sqlalchemy.types 中的类)

scoped_session (sqlalchemy.orm.scoping 中的类)

ScopedRegistry (sqlalchemy.util 中的类)

scopefunc (sqlalchemy.ext.asyncio.async_scoped_session parameter)

(sqlalchemy.orm.scoping.scoped_session parameter)
(sqlalchemy.util.ScopedRegistry parameter) [0]

second_precision (sqlalchemy.dialects.oracle.INTERVAL parameter)

(sqlalchemy.types.Interval parameter)

secondary (sqlalchemy.orm.relationship parameter)

secondaryjoin (sqlalchemy.orm.relationship parameter)

seed (sqlalchemy.sql.expression.tablesample parameter)

Select (sqlalchemy.sql.expression 中的类)

select (sqlalchemy.sql.expression.Insert.from_select parameter)

select() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.Exists 方法)
(sqlalchemy.sql.expression.FromClause 方法)

select_entity_from() (sqlalchemy.orm.Query 方法)

select_from() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Exists 方法)
(sqlalchemy.sql.expression.Select 方法)

selectable (sqlalchemy.orm.Mapper 属性)

(sqlalchemy.orm.Query 属性)
(sqlalchemy.orm.with_polymorphic parameter)

Selectable (sqlalchemy.sql.expression 中的类)

selectable (sqlalchemy.sql.expression.alias parameter)

(sqlalchemy.sql.expression.UpdateBase.with_hint parameter)

SelectBase (sqlalchemy.sql.expression 中的类)

selected_columns (sqlalchemy.sql.expression.CompoundSelect 属性)

(sqlalchemy.sql.expression.Select 属性)
(sqlalchemy.sql.expression.SelectBase 属性)

selectin_polymorphic() (sqlalchemy.orm.Load 方法) , [20]

(在 sqlalchemy.orm 模块中)

selectinload() (sqlalchemy.orm.Load 方法) , [20]

(在 sqlalchemy.orm 模块中)

self_and_descendants (sqlalchemy.orm.Mapper 属性)

self_group() (sqlalchemy.schema.Column 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.BinaryExpression 方法)

Sequence (sqlalchemy.schema 中的类)

sequence_name (sqlalchemy.engine.reflection.Inspector.has_sequence parameter)

Serializer() (在 sqlalchemy.ext.serializer 模块中)

server_default (sqlalchemy.schema.Column parameter)

server_onupdate (sqlalchemy.schema.Column parameter)

session (sqlalchemy.ext.asyncio.async_session parameter)

Session (sqlalchemy.orm 中的类)

session (sqlalchemy.orm.InstanceState 属性)

(sqlalchemy.orm.ORMExecuteState 属性)
(sqlalchemy.orm.Query parameter)

session_factory (sqlalchemy.ext.asyncio.async_scoped_session parameter)

(sqlalchemy.orm.scoping.scoped_session parameter)
(sqlalchemy.orm.scoping.scoped_session 属性)

session_user (sqlalchemy.sql.functions 中的类)

SessionEvents (sqlalchemy.orm 中的类)

sessionmaker (sqlalchemy.orm 中的类)

SessionTransaction (sqlalchemy.orm 中的类)

SET (sqlalchemy.dialects.mysql 中的类)

set() (sqlalchemy.engine.URL 方法)

(sqlalchemy.ext.associationproxy.AssociationProxyInstance 方法)
(sqlalchemy.orm.AttributeEvents 方法)

set_ (sqlalchemy.dialects.postgresql.Insert.on_conflict_do_update parameter)

(sqlalchemy.dialects.sqlite.Insert.on_conflict_do_update parameter)

set_attribute() (在 sqlalchemy.orm.attributes 模块中)

set_committed_value() (在 sqlalchemy.orm.attributes 模块中)

set_connection_execution_options() (sqlalchemy.events.ConnectionEvents 方法)

set_engine_execution_options() (sqlalchemy.events.ConnectionEvents 方法)

set_isolation_level() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 方法)

set_label_style() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

set_parent() (sqlalchemy.orm.MapperProperty 方法)

(sqlalchemy.orm.RelationshipProperty 方法)
(sqlalchemy.orm.SynonymProperty 方法)

set_shard() (sqlalchemy.ext.horizontal_shard.ShardedQuery 方法)

setdefault() (sqlalchemy.ext.mutable.MutableDict 方法)

(sqlalchemy.orm.ClassManager 方法)
(sqlalchemy.orm.collections.MappedCollection 方法)

setter() (sqlalchemy.ext.hybrid.hybrid_property 方法)

setup() (sqlalchemy.orm.MapperProperty 方法)

(sqlalchemy.orm.RelationshipProperty 方法)
(sqlalchemy.orm.SynonymProperty 方法)

shard_chooser (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

ShardedQuery (sqlalchemy.ext.horizontal_shard 中的类)

ShardedSession (sqlalchemy.ext.horizontal_shard 中的类)

shards (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

shares_lineage() (sqlalchemy.schema.Column 方法)

(sqlalchemy.sql.expression.ColumnElement 方法)

should_autocommit_text() (sqlalchemy.engine.default.DefaultExecutionContext 方法)

(sqlalchemy.engine.ExecutionContext 方法)

should_evaluate_none (sqlalchemy.types.JSON 属性)

(sqlalchemy.types.TypeEngine 属性)

single (sqlalchemy.orm.Mapper 属性)

single_entity (sqlalchemy.orm.Bundle parameter)

(sqlalchemy.orm.Bundle 属性)

single_parent (sqlalchemy.orm.relationship parameter)

SingletonThreadPool (sqlalchemy.pool 中的类)

size (sqlalchemy.engine.CursorResult.partitions parameter)

(sqlalchemy.engine.Result.partitions parameter)

skip_fn (sqlalchemy.schema.sort_tables parameter)

skip_locked (sqlalchemy.sql.expression.GenerativeSelect.with_for_update parameter)

(sqlalchemy.sql.expression.Select.with_for_update parameter)

slice() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

(sqlalchemy.orm.Query 方法)
(sqlalchemy.sql.expression.GenerativeSelect 方法)

SMALLDATETIME (sqlalchemy.dialects.mssql 中的类)

SMALLINT (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

SmallInteger (sqlalchemy.types 中的类)

SMALLMONEY (sqlalchemy.dialects.mssql 中的类)

soft (sqlalchemy.pool._ConnectionFairy.invalidate parameter)

(sqlalchemy.pool._ConnectionRecord.invalidate parameter)

soft_invalidate() (sqlalchemy.events.PoolEvents 方法)

sort() (sqlalchemy.ext.mutable.MutableList 方法)

sort_key_function (sqlalchemy.types.Enum parameter)

(sqlalchemy.types.TypeEngine 属性)

sort_tables() (在 sqlalchemy.schema 模块中)

sort_tables_and_constraints() (在 sqlalchemy.schema 模块中)

sorted_tables (sqlalchemy.schema.MetaData 属性)

spoil() (sqlalchemy.ext.baked.BakedQuery 方法)

(sqlalchemy.sql.expression.StatementLambdaElement 方法)

sql_compiler (sqlalchemy.engine.Compiled 属性)

(sqlalchemy.sql.compiler.DDLCompiler 属性)
(sqlalchemy.sql.compiler.SQLCompiler 属性)

sql_only (sqlalchemy.orm.raiseload parameter)

SQL_VARIANT (sqlalchemy.dialects.mssql 中的类)

sqlalchemy.dialects.firebird.base

模块

sqlalchemy.dialects.firebird.fdb

模块

sqlalchemy.dialects.firebird.kinterbasdb

模块

sqlalchemy.dialects.mssql.base

模块

sqlalchemy.dialects.mssql.mxodbc

模块

sqlalchemy.dialects.mssql.pymssql

模块

sqlalchemy.dialects.mssql.pyodbc

模块

sqlalchemy.dialects.mysql.aiomysql

模块

sqlalchemy.dialects.mysql.asyncmy

模块

sqlalchemy.dialects.mysql.base

模块

sqlalchemy.dialects.mysql.cymysql

模块

sqlalchemy.dialects.mysql.mysqlconnector

模块

sqlalchemy.dialects.mysql.mysqldb

模块

sqlalchemy.dialects.mysql.oursql

模块

sqlalchemy.dialects.mysql.pymysql

模块

sqlalchemy.dialects.mysql.pyodbc

模块

sqlalchemy.dialects.oracle.base

模块

sqlalchemy.dialects.oracle.cx_oracle

模块

sqlalchemy.dialects.postgresql.asyncpg

模块

sqlalchemy.dialects.postgresql.base

模块

sqlalchemy.dialects.postgresql.pg8000

模块

sqlalchemy.dialects.postgresql.psycopg2

模块

sqlalchemy.dialects.postgresql.psycopg2cffi

模块

sqlalchemy.dialects.postgresql.pygresql

模块

sqlalchemy.dialects.postgresql.pypostgresql

模块

sqlalchemy.dialects.sqlite

模块

sqlalchemy.dialects.sqlite.aiosqlite

模块

sqlalchemy.dialects.sqlite.base

模块

sqlalchemy.dialects.sqlite.pysqlcipher

模块

sqlalchemy.dialects.sqlite.pysqlite

模块

sqlalchemy.dialects.sybase.base

模块

sqlalchemy.dialects.sybase.mxodbc

模块

sqlalchemy.dialects.sybase.pyodbc

模块

sqlalchemy.dialects.sybase.pysybase

模块

sqlalchemy.engine

模块

sqlalchemy.exc

模块

sqlalchemy.ext.associationproxy

模块

sqlalchemy.ext.automap

模块

sqlalchemy.ext.baked

模块

sqlalchemy.ext.compiler

模块

sqlalchemy.ext.declarative

模块

sqlalchemy.ext.horizontal_shard

模块

sqlalchemy.ext.hybrid

模块

sqlalchemy.ext.indexable

模块

sqlalchemy.ext.instrumentation

模块

sqlalchemy.ext.mutable

模块

sqlalchemy.ext.orderinglist

模块

sqlalchemy.ext.serializer

模块

sqlalchemy.future

模块

sqlalchemy.inspection

模块

sqlalchemy.orm.exc

模块

sqlalchemy.orm.instrumentation

模块

sqlalchemy.orm.session

模块

sqlalchemy.pool

模块

sqlalchemy.schema

模块

sqlalchemy.sql.expression

模块

sqlalchemy.sql.functions

模块

sqlalchemy.sql.visitors

模块

sqlalchemy.types

模块

sqlalchemy_exception (sqlalchemy.engine.ExceptionContext 属性)

SQLAlchemyError

SQLCompiler (sqlalchemy.sql.compiler 中的类)

sqltext (sqlalchemy.schema.CheckConstraint parameter)

(sqlalchemy.schema.Computed parameter)

StaleDataError

start (sqlalchemy.schema.Identity parameter)

(sqlalchemy.schema.Sequence parameter)

start() (sqlalchemy.ext.asyncio.AsyncConnection 方法)

(sqlalchemy.ext.asyncio.AsyncTransaction 方法)

startswith() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance 方法)

(sqlalchemy.orm.PropComparator 方法)
(sqlalchemy.orm.QueryableAttribute 方法)

state (sqlalchemy.orm.Mapper.cascade_iterator parameter)

(sqlalchemy.schema.DDLElement.execute_if parameter)

state_dict (sqlalchemy.orm.InstanceEvents.pickle parameter)

(sqlalchemy.orm.InstanceEvents.unpickle parameter)

state_getter() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

(sqlalchemy.orm.ClassManager 方法)

statement (sqlalchemy.engine.Compiled parameter)

(sqlalchemy.engine.Connection.exec_driver_sql parameter)
(sqlalchemy.engine.Connection.execute parameter)

statement_compiler (sqlalchemy.engine.default.DefaultDialect 属性)

StatementError

StatementLambdaElement (sqlalchemy.sql.expression 中的类)

StaticPool (sqlalchemy.pool 中的类)

storage_format (sqlalchemy.dialects.sqlite.DATE parameter)

(sqlalchemy.dialects.sqlite.DATETIME parameter)
(sqlalchemy.dialects.sqlite.TIME parameter)

strategy (sqlalchemy.engine.CursorResult.unique parameter)

(sqlalchemy.engine.Result.unique parameter)

stream() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

stream_results (sqlalchemy.engine.Connection.execution_options parameter)

stream_scalars() (sqlalchemy.ext.asyncio.async_scoped_session 方法)

(sqlalchemy.ext.asyncio.AsyncConnection 方法)
(sqlalchemy.ext.asyncio.AsyncSession 方法)

strict (sqlalchemy.dialects.mysql.ENUM parameter)

strictly_left_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

strictly_right_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory 方法)

String (sqlalchemy.types 中的类)

stringify_dialect (sqlalchemy.sql.expression.ColumnElement 属性)

StrSQLCompiler (sqlalchemy.sql.compiler 中的类)

subject (sqlalchemy.inspect parameter)

Subquery (sqlalchemy.sql.expression 中的类)

subquery() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.SelectBase 方法)

subqueryload() (sqlalchemy.orm.Load 方法) , [20]

(在 sqlalchemy.orm 模块中)

subtransactions (sqlalchemy.orm.scoping.scoped_session.begin parameter)

(sqlalchemy.orm.Session.begin parameter)

suffix_with() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.HasSuffixes 方法)
(sqlalchemy.sql.expression.Select 方法)

sum (sqlalchemy.sql.functions 中的类)

sum() (sqlalchemy.orm.attributes.History 方法)

supports_default_metavalue (sqlalchemy.engine.default.DefaultDialect 属性)

supports_default_values (sqlalchemy.engine.default.DefaultDialect 属性)

supports_empty_insert (sqlalchemy.engine.default.DefaultDialect 属性)

supports_execution (sqlalchemy.sql.expression.ColumnElement 属性)

supports_sane_multi_rowcount() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)

supports_sane_rowcount() (sqlalchemy.engine.BaseCursorResult 方法)

(sqlalchemy.engine.CursorResult 方法)

supports_sane_rowcount_returning (sqlalchemy.engine.default.DefaultDialect 属性)

supports_statement_cache (sqlalchemy.engine.Dialect 属性)

symmetric (sqlalchemy.sql.expression.between parameter)

symmetric_difference_update() (sqlalchemy.ext.mutable.MutableSet 方法)

sync_backref (sqlalchemy.orm.relationship parameter)

sync_connection (sqlalchemy.ext.asyncio.AsyncConnection 属性)

sync_engine (sqlalchemy.ext.asyncio.AsyncConnection 属性)

(sqlalchemy.ext.asyncio.AsyncEngine 属性)

sync_session (sqlalchemy.ext.asyncio.AsyncSession 属性)

sync_session_class (sqlalchemy.ext.asyncio.AsyncSession parameter)

(sqlalchemy.ext.asyncio.AsyncSession 属性)

synchronize_session (sqlalchemy.orm.Query.delete parameter)

(sqlalchemy.orm.Query.update parameter)

synonym() (在 sqlalchemy.orm 模块中)

synonym_for() (在 sqlalchemy.orm 模块中)

SynonymProperty (sqlalchemy.orm 中的类)

synonyms (sqlalchemy.orm.Mapper 属性)

sysdate (sqlalchemy.sql.functions 中的类)

system (sqlalchemy.schema.Column parameter)

T

table (sqlalchemy.dialects.mysql.insert parameter)

(sqlalchemy.dialects.postgresql.insert parameter)
(sqlalchemy.dialects.sqlite.insert parameter)

Table (sqlalchemy.schema 中的类)

table (sqlalchemy.sql.expression.delete parameter)

(sqlalchemy.sql.expression.insert parameter)
(sqlalchemy.sql.expression.update parameter)

table() (在 sqlalchemy.sql.expression 模块中)

Table.memoized_attribute (sqlalchemy.schema 中的类)

table_map (sqlalchemy.orm.polymorphic_union parameter)

table_name (sqlalchemy.engine.reflection.Inspector.get_check_constraints parameter)

(sqlalchemy.engine.reflection.Inspector.get_columns parameter)
(sqlalchemy.engine.reflection.Inspector.get_foreign_keys parameter)

table_names() (sqlalchemy.engine.Engine 方法)

(sqlalchemy.future.Engine 方法)

table_valued() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.FromClause 方法)
(sqlalchemy.sql.expression.TableClause 方法)

TableClause (sqlalchemy.sql.expression 中的类)

TableClause.memoized_attribute (sqlalchemy.sql.expression 中的类)

tablename (sqlalchemy.ext.automap.classname_for_table parameter)

tables (sqlalchemy.orm.Mapper 属性)

(sqlalchemy.schema.MetaData 属性)
(sqlalchemy.schema.MetaData.create_all parameter)

TableSample (sqlalchemy.sql.expression 中的类)

tablesample() (sqlalchemy.schema.Table 方法)

(sqlalchemy.sql.expression.FromClause 方法)
(sqlalchemy.sql.expression.TableClause 方法)

TableValuedAlias (sqlalchemy.sql.expression 中的类)

target (sqlalchemy.events.DDLEvents.after_create parameter)

(sqlalchemy.events.DDLEvents.after_drop parameter)
(sqlalchemy.events.DDLEvents.after_parent_attach parameter)

target_class (sqlalchemy.ext.associationproxy.AssociationProxyInstance 属性)

target_collection (sqlalchemy.ext.associationproxy.association_proxy parameter)

(sqlalchemy.ext.associationproxy.AssociationProxy parameter)

target_fullname (sqlalchemy.schema.ForeignKey 属性)

TEXT (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)

text (sqlalchemy.sql.expression.column parameter)

(sqlalchemy.sql.expression.literal_column parameter)
(sqlalchemy.sql.expression.text parameter)

TEXT (sqlalchemy.types 中的类)

Text (sqlalchemy.types 中的类)

text() (在 sqlalchemy.sql.expression 模块中)

text_type (sqlalchemy.dialects.postgresql.HSTORE parameter)

TextClause (sqlalchemy.sql.expression 中的类)

TextualSelect (sqlalchemy.sql.expression 中的类)

TextualSelect.memoized_attribute (sqlalchemy.sql.expression 中的类)

thread safety

Connection
Transaction

ThreadLocalMetaData (sqlalchemy.schema 中的类)

ThreadLocalRegistry (sqlalchemy.util 中的类)

TIME (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.dialects.sqlite 中的类)

Time (sqlalchemy.types 中的类)

timeout (sqlalchemy.pool.QueuePool parameter)

TimeoutError

TIMESTAMP (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.types 中的类)

timetuple (sqlalchemy.sql.expression.ColumnElement 属性)

(sqlalchemy.sql.expression.ColumnOperators 属性)

timezone (sqlalchemy.dialects.mssql.SMALLDATETIME parameter)

(sqlalchemy.dialects.mysql.DATETIME parameter)
(sqlalchemy.dialects.mysql.TIME parameter)

TINYBLOB (sqlalchemy.dialects.mysql 中的类)

TINYINT (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)

TINYTEXT (sqlalchemy.dialects.mysql 中的类)

to_metadata() (sqlalchemy.schema.Table 方法)

to_offline_string() (sqlalchemy.sql.expression.CacheKey 方法)

to_query() (sqlalchemy.ext.baked.BakedQuery 方法)

tometadata() (sqlalchemy.schema.Table 方法)

track_bound_values (sqlalchemy.sql.expression.lambda_stmt parameter)

track_closure_variables (sqlalchemy.orm.with_loader_criteria parameter)

(sqlalchemy.sql.expression.lambda_stmt parameter)

Transaction (sqlalchemy.engine 中的类)

transaction (sqlalchemy.orm.Session 属性)

(sqlalchemy.orm.SessionEvents.after_begin parameter)
(sqlalchemy.orm.SessionEvents.after_transaction_create parameter)

transaction() (sqlalchemy.engine.Connection 方法)

(sqlalchemy.engine.Engine 方法)
(sqlalchemy.future.Engine 方法)

transient (sqlalchemy.orm.InstanceState 属性)

transient_to_pending() (sqlalchemy.orm.SessionEvents 方法)

translate_connect_args() (sqlalchemy.engine.URL 方法)

translate_select_structure (sqlalchemy.sql.compiler.SQLCompiler 属性)

traverse() (sqlalchemy.sql.visitors.ExternalTraversal 方法)

(在 sqlalchemy.sql.visitors 模块中)

traverse_using() (在 sqlalchemy.sql.visitors 模块中)

Traversible (sqlalchemy.sql.visitors 中的类)

TraversibleType (sqlalchemy.sql.visitors 中的类)

true() (在 sqlalchemy.sql.expression 模块中)

True_ (sqlalchemy.sql.expression 中的类)

try_cast() (在 sqlalchemy.dialects.mssql 模块中)

TSRANGE (sqlalchemy.dialects.postgresql 中的类)

TSTZRANGE (sqlalchemy.dialects.postgresql 中的类)

TSVECTOR (sqlalchemy.dialects.postgresql 中的类)

Tuple (sqlalchemy.sql.expression 中的类)

tuple_() (在 sqlalchemy.sql.expression 模块中)

twophase (sqlalchemy.orm.Session parameter)

TwoPhaseTransaction (sqlalchemy.engine 中的类)

type (sqlalchemy.dialects.postgresql.hstore 属性)

(sqlalchemy.sql.expression.column parameter)
(sqlalchemy.sql.expression.ColumnElement 属性)

type_ (sqlalchemy.orm.Mapper.cascade_iterator parameter)

(sqlalchemy.schema.Column parameter)
(sqlalchemy.sql.expression.bindparam parameter)

type_coerce() (在 sqlalchemy.sql.expression 模块中)

type_compiler (sqlalchemy.engine.default.DefaultDialect 属性)

type_descriptor() (sqlalchemy.engine.default.DefaultDialect 方法)

(sqlalchemy.engine.Dialect 类方法)

type_engine() (sqlalchemy.types.TypeDecorator 方法)

TypeCoerce (sqlalchemy.sql.expression 中的类)

typecolname (sqlalchemy.orm.polymorphic_union parameter)

TypeDecorator (sqlalchemy.types 中的类)

TypeDecorator.Comparator (sqlalchemy.types 中的类)

TypeEngine (sqlalchemy.types 中的类)

TypeEngine.Comparator (sqlalchemy.types 中的类)

U

UnaryExpression (sqlalchemy.sql.expression 中的类)

UnboundExecutionError

undefer() (sqlalchemy.orm.Load 方法) , [22]

(在 sqlalchemy.orm 模块中)

undefer_group() (sqlalchemy.orm.Load 方法) , [22]

(在 sqlalchemy.orm 模块中)

unformat_identifiers() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

unicode (sqlalchemy.dialects.mysql.ENUM parameter)

(sqlalchemy.dialects.mysql.LONGTEXT parameter)
(sqlalchemy.dialects.mysql.MEDIUMTEXT parameter)

Unicode (sqlalchemy.types 中的类)

unicode_error (sqlalchemy.dialects.mssql.CHAR parameter)

(sqlalchemy.dialects.mssql.TEXT parameter)
(sqlalchemy.dialects.mssql.VARCHAR parameter)

UnicodeText (sqlalchemy.types 中的类)

uninstall_descriptor() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

uninstall_member() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

union() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(在 sqlalchemy.sql.expression 模块中)

union_all() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(在 sqlalchemy.sql.expression 模块中)

unique (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.Column 属性)
(sqlalchemy.schema.Index parameter)

unique() (sqlalchemy.engine.CursorResult 方法)

(sqlalchemy.engine.MappingResult 方法)
(sqlalchemy.engine.Result 方法)

unique_params() (sqlalchemy.schema.Column 方法)

(sqlalchemy.schema.Table 方法)
(sqlalchemy.sql.expression.ClauseElement 方法)

UniqueConstraint (sqlalchemy.schema 中的类)

UNIQUEIDENTIFIER (sqlalchemy.dialects.mssql 中的类)

unloaded (sqlalchemy.orm.InstanceState 属性)

unloaded_expirable (sqlalchemy.orm.InstanceState 属性)

UnmappedClassError

UnmappedColumnError

UnmappedError

UnmappedInstanceError

unmodified (sqlalchemy.orm.InstanceState 属性)

unmodified_intersection() (sqlalchemy.orm.InstanceState 方法)

unpickle() (sqlalchemy.orm.InstanceEvents 方法)

UnreflectableTableError

unregister() (sqlalchemy.ext.instrumentation.InstrumentationManager 方法)

(sqlalchemy.orm.ClassManager 方法)

unsigned (sqlalchemy.dialects.mysql.BIGINT parameter)

(sqlalchemy.dialects.mysql.DECIMAL parameter)
(sqlalchemy.dialects.mysql.DOUBLE parameter)

UnsupportedCompilationError

UOWTransaction (sqlalchemy.orm 中的类)

Update (sqlalchemy.sql.expression 中的类)

update() (sqlalchemy.ext.mutable.MutableDict 方法)

(sqlalchemy.ext.mutable.MutableSet 方法)
(sqlalchemy.orm.ClassManager 方法)

update_args (sqlalchemy.orm.Query.update parameter)

update_changed_only (sqlalchemy.orm.scoping.scoped_session.bulk_save_objects parameter)

(sqlalchemy.orm.Session.bulk_save_objects parameter)

update_context (sqlalchemy.orm.QueryEvents.before_compile_update parameter)

(sqlalchemy.orm.SessionEvents.after_bulk_update parameter)

update_delete_options (sqlalchemy.orm.ORMExecuteState 属性)

update_execution_options() (sqlalchemy.engine.Engine 方法)

(sqlalchemy.ext.asyncio.AsyncEngine 方法)

update_expression() (sqlalchemy.ext.hybrid.hybrid_property 方法)

update_from_clause() (sqlalchemy.sql.compiler.SQLCompiler 方法)

(sqlalchemy.sql.compiler.StrSQLCompiler 方法)

update_limit_clause() (sqlalchemy.sql.compiler.SQLCompiler 方法)

update_query_dict() (sqlalchemy.engine.URL 方法)

update_query_pairs() (sqlalchemy.engine.URL 方法)

update_query_string() (sqlalchemy.engine.URL 方法)

update_tables_clause() (sqlalchemy.sql.compiler.SQLCompiler 方法)

update_url() (sqlalchemy.engine.CreateEnginePlugin 方法)

UpdateBase (sqlalchemy.sql.expression 中的类)

upper_bound (sqlalchemy.sql.expression.between parameter)

url (sqlalchemy.create_mock_engine parameter)

URL (sqlalchemy.engine 中的类)

url (sqlalchemy.engine.CreateEnginePlugin parameter)

(sqlalchemy.engine.default.DefaultDialect.create_connect_args parameter)
(sqlalchemy.engine.default.DefaultDialect.on_connect_url parameter)

use_alter (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

use_labels (sqlalchemy.sql.expression.Select.create_legacy_select parameter)

use_lifo (sqlalchemy.pool.QueuePool parameter)

uselist (sqlalchemy.orm.relationship parameter)

user (sqlalchemy.sql.functions 中的类)

user_defined_options (sqlalchemy.orm.ORMExecuteState 属性)

UserDefinedType (sqlalchemy.types 中的类)

username (sqlalchemy.engine.URL 属性)

(sqlalchemy.engine.URL.create parameter)
(sqlalchemy.engine.URL.set parameter)

uses_inspection (sqlalchemy.sql.expression.ColumnElement 属性)

uses_objects (sqlalchemy.orm.SynonymProperty 属性)

using (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

UUID (sqlalchemy.dialects.postgresql 中的类)

V

validate_sql_phrase() (sqlalchemy.sql.compiler.IdentifierPreparer 方法)

validate_strings (sqlalchemy.types.Enum parameter)

validates() (在 sqlalchemy.orm 模块中)

validators (sqlalchemy.orm.Mapper 属性)

vals() (sqlalchemy.dialects.postgresql.HSTORE.Comparator 方法)

value (sqlalchemy.ext.mutable.Mutable.coerce parameter)

(sqlalchemy.ext.mutable.MutableBase.coerce parameter)
(sqlalchemy.orm.AttributeEvents.append parameter)

value() (sqlalchemy.orm.Query 方法)

values (sqlalchemy.dialects.mysql.insert parameter)

(sqlalchemy.dialects.mysql.SET parameter)
(sqlalchemy.dialects.postgresql.insert parameter)

Values (sqlalchemy.sql.expression 中的类)

values (sqlalchemy.sql.expression.insert parameter)

(sqlalchemy.sql.expression.update parameter)
(sqlalchemy.sql.expression.Values.data parameter)

values() (sqlalchemy.engine.LegacyRow 方法)

(sqlalchemy.engine.RowMapping 方法)
(sqlalchemy.orm.ClassManager 方法)

values_callable (sqlalchemy.types.Enum parameter)

ValuesBase (sqlalchemy.sql.expression 中的类)

VARBINARY (sqlalchemy.dialects.mysql 中的类)

(sqlalchemy.types 中的类)

VARCHAR (sqlalchemy.dialects.mssql 中的类)

(sqlalchemy.dialects.mysql 中的类)
(sqlalchemy.types 中的类)

Variant (sqlalchemy.types 中的类)

version_id_col (sqlalchemy.orm.mapper parameter)

version_id_generator (sqlalchemy.orm.mapper parameter)

viewonly (sqlalchemy.orm.relationship parameter)

views (sqlalchemy.schema.MetaData.reflect parameter)

visitor_iterator (sqlalchemy.sql.visitors.ExternalTraversal 属性)

visitors (sqlalchemy.sql.visitors.traverse parameter)

(sqlalchemy.sql.visitors.traverse_using parameter)

W

was_already_deleted() (sqlalchemy.orm.UOWTransaction 方法)

was_deleted (sqlalchemy.orm.InstanceState 属性)

was_deleted() (在 sqlalchemy.orm.util 模块中)

where (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

(sqlalchemy.dialects.postgresql.Insert.on_conflict_do_update parameter)
(sqlalchemy.dialects.sqlite.Insert.on_conflict_do_update parameter)

where() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Delete 方法)
(sqlalchemy.sql.expression.Exists 方法)

where_criteria (sqlalchemy.orm.with_loader_criteria parameter)

whereclause (sqlalchemy.orm.Query 属性)

(sqlalchemy.schema.Table.select parameter)
(sqlalchemy.sql.expression.delete parameter)

with_criteria() (sqlalchemy.ext.baked.BakedQuery 方法)

with_dialect_options() (sqlalchemy.sql.expression.UpdateBase 方法)

with_entities() (sqlalchemy.orm.Query 方法)

with_expression() (sqlalchemy.orm.Load 方法) , [24]

(在 sqlalchemy.orm 模块中)

with_for_update (sqlalchemy.orm.scoping.scoped_session.get parameter)

(sqlalchemy.orm.scoping.scoped_session.refresh parameter)
(sqlalchemy.orm.Session.get parameter)

with_for_update() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.GenerativeSelect 方法)
(sqlalchemy.sql.expression.Select 方法)

with_hint() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)
(sqlalchemy.sql.expression.UpdateBase 方法)

with_labels (sqlalchemy.orm.Query.subquery parameter)

with_labels() (sqlalchemy.orm.Query 方法)

with_loader_criteria() (在 sqlalchemy.orm 模块中)

with_only_columns() (sqlalchemy.sql.expression.Select 方法)

with_ordinality (sqlalchemy.sql.functions.FunctionElement.table_valued parameter)

with_parent() (sqlalchemy.orm.Query 方法)

(在 sqlalchemy.orm 模块中)

with_polymorphic (sqlalchemy.orm.mapper parameter)

with_polymorphic() (sqlalchemy.orm.Query 方法)

(在 sqlalchemy.orm 模块中)

with_polymorphic_mappers (sqlalchemy.orm.Mapper 属性)

with_post_criteria() (sqlalchemy.ext.baked.Result 方法)

with_query_expansion (sqlalchemy.dialects.mysql.match parameter)

with_query_expansion() (sqlalchemy.dialects.mysql.match 方法)

with_session() (sqlalchemy.orm.Query 方法)

with_statement_hint() (sqlalchemy.orm.Query 方法)

(sqlalchemy.sql.expression.Select 方法)

with_ties (sqlalchemy.sql.expression.GenerativeSelect.fetch parameter)

(sqlalchemy.sql.expression.Select.fetch parameter)

with_transformation() (sqlalchemy.orm.Query 方法)

with_types (sqlalchemy.sql.expression.TableValuedAlias.render_derived parameter)

with_variant() (sqlalchemy.types.TypeEngine 方法)

(sqlalchemy.types.Variant 方法)

within_group() (sqlalchemy.sql.functions.FunctionElement 方法)

(在 sqlalchemy.sql.expression 模块中)

within_group_type() (sqlalchemy.sql.functions.FunctionElement 方法)

(sqlalchemy.sql.functions.OrderedSetAgg 方法)

WithinGroup (sqlalchemy.sql.expression 中的类)

WrapsColumnExpression (sqlalchemy.sql.elements 中的类)

X

xid (sqlalchemy.engine.Connection.begin_twophase parameter)

(sqlalchemy.engine.default.DefaultDialect.do_begin_twophase parameter)
(sqlalchemy.engine.default.DefaultDialect.do_commit_twophase parameter)

XML (sqlalchemy.dialects.mssql 中的类)

Y

YEAR (sqlalchemy.dialects.mysql 中的类)

yield_per() (sqlalchemy.engine.ChunkedIteratorResult 方法)

(sqlalchemy.engine.CursorResult 方法)
(sqlalchemy.engine.Result 方法)

Z

zero_indexes (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)
(sqlalchemy.types.ARRAY 属性)

zerofill (sqlalchemy.dialects.mysql.BIGINT parameter)

(sqlalchemy.dialects.mysql.DECIMAL parameter)
(sqlalchemy.dialects.mysql.DOUBLE parameter)

一

一对多
一致性

主

主键
主键约束

从

从句

仪

仪器仪表
仪器化的

仪表化

会

会话

何

何处条款

候

候选关键字

元

元数据

光

光标

克

克鲁德

关

关系 , [38]
关系代数
关系型

关联关系

列

列条款

删

删除

到

到期 , [41]

原

原子性

双

双向关系

发

发行版

可

可串行化的
可选择的

可重复读

叶

叶栅

同

同一映射

唯

唯一约束
唯一键索引

圈

圈复杂度

在

在CI中经过全面测试

复

复合主键

外

外观
外键约束

多

多对一
多对多
多态

多态的

子

子查询

孤

孤立的

尽

尽最大努力

工

工作单位

已

已提交读取

延

延迟初始化
延迟加载

怠

怠速载荷

急

急装
急载 , [61]

悬

悬而未决的

惰

惰性负载

懒

懒散加载

持

持久的

描

描述符 , [66]

插

插件

数

数据库元数据
数据编组

方

方法链
方言

映

映射 , [70]
映射类

期

期满 , [71]

标

标量子查询

检

检查约束

模

模块

examples.adjacency_list
examples.association

正

正常支撑

注

注解

版

版本id列

特

特定于插件

独

独立的

生

生成的

登

登记处

相

相关
相关子查询 , [82]

瞬

瞬态

笛

笛卡尔积

约

约束
约束条件

约束的

绑

绑定参数 , [86] , [86] , [86]

编

编组

耐

耐久性

背

背衬

表

表元数据

读

读取未提交

过

过期

迫

迫不及待地

释

释放 , [94]

鉴

鉴别器

隔

隔离 , [96]
隔离级别

领

领域模型