Index

Symbols | _ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

Symbols

**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.dml.Insert.on_duplicate_key_update parameter)

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

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

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

*addl_attrs (sqlalchemy.orm.defer parameter)

(sqlalchemy.orm.undefer parameter)

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

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

*cols (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)

*columns (sqlalchemy.orm.deferred parameter)

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

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

*entities (sqlalchemy.orm.query.Query.from_self parameter)

*enums (sqlalchemy.types.Enum parameter)

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

(sqlalchemy.sql.expression.CTE.suffix_with parameter)
(sqlalchemy.sql.expression.Delete.prefix_with parameter)

*expressions (sqlalchemy.schema.Index parameter)

*exprs (sqlalchemy.orm.query.Bundle parameter)

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

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

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

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

*names (sqlalchemy.orm.validates parameter)

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

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

(sqlalchemy.orm.attributes.QueryableAttribute.operate parameter)
(sqlalchemy.orm.interfaces.PropComparator.operate parameter)

*prefixes (sqlalchemy.orm.query.Query.prefix_with parameter)

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

*suffixes (sqlalchemy.orm.query.Query.suffix_with parameter)

_

__add__() (sqlalchemy.sql.operators.ColumnOperators method)

__and__() (sqlalchemy.sql.operators.ColumnOperators method)

(sqlalchemy.sql.operators.Operators method)

__call__() (sqlalchemy.orm.scoping.scoped_session method)

(sqlalchemy.orm.session.sessionmaker method)
(sqlalchemy.schema.DDLElement method)

__delattr__ (sqlalchemy.sql.operators.ColumnOperators attribute)

__delete__() (sqlalchemy.orm.attributes.InstrumentedAttribute method)

__dir__() (sqlalchemy.sql.operators.ColumnOperators method)

__div__() (sqlalchemy.sql.operators.ColumnOperators method)

__eq__ (sqlalchemy.engine.default.DefaultDialect attribute)

(sqlalchemy.ext.associationproxy.AssociationProxy attribute)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

__eq__() (sqlalchemy.orm.attributes.QueryableAttribute method)

(sqlalchemy.orm.interfaces.PropComparator method)
(sqlalchemy.orm.properties.ColumnProperty.Comparator method)

__format__() (sqlalchemy.sql.operators.ColumnOperators method)

__ge__() (sqlalchemy.sql.operators.ColumnOperators method)

__get__() (sqlalchemy.orm.attributes.InstrumentedAttribute method)

__getattribute__ (sqlalchemy.sql.operators.ColumnOperators attribute)

__getitem__() (sqlalchemy.sql.operators.ColumnOperators method)

__gt__() (sqlalchemy.sql.operators.ColumnOperators method)

__hash__ (sqlalchemy.sql.operators.ColumnOperators attribute)

__init__ (sqlalchemy.dialects.mssql.BIT attribute)

(sqlalchemy.dialects.mssql.MONEY attribute)
(sqlalchemy.dialects.mssql.SMALLMONEY attribute)

__init__() (sqlalchemy.dialects.mssql.CHAR method)

(sqlalchemy.dialects.mssql.DATETIME2 method)
(sqlalchemy.dialects.mssql.DATETIMEOFFSET method)

__init_subclass__() (sqlalchemy.sql.operators.ColumnOperators method)

__invert__() (sqlalchemy.sql.operators.ColumnOperators method)

(sqlalchemy.sql.operators.Operators method)

__le__ (sqlalchemy.engine.default.DefaultDialect attribute)

(sqlalchemy.ext.associationproxy.AssociationProxy attribute)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

__le__() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

__lshift__() (sqlalchemy.sql.operators.ColumnOperators method)

__lt__ (sqlalchemy.engine.default.DefaultDialect attribute)

(sqlalchemy.ext.associationproxy.AssociationProxy attribute)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

__lt__() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

__mod__() (sqlalchemy.sql.operators.ColumnOperators method)

__mul__() (sqlalchemy.sql.operators.ColumnOperators method)

__ne__ (sqlalchemy.engine.default.DefaultDialect attribute)

(sqlalchemy.ext.associationproxy.AssociationProxy attribute)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

__ne__() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

__neg__() (sqlalchemy.sql.operators.ColumnOperators method)

__new__() (sqlalchemy.sql.operators.ColumnOperators method)

__or__() (sqlalchemy.sql.operators.ColumnOperators method)

(sqlalchemy.sql.operators.Operators method)

__radd__() (sqlalchemy.sql.operators.ColumnOperators method)

__rdiv__() (sqlalchemy.sql.operators.ColumnOperators method)

__reduce__() (sqlalchemy.sql.operators.ColumnOperators method)

__reduce_ex__() (sqlalchemy.sql.operators.ColumnOperators method)

__repr__ (sqlalchemy.sql.operators.ColumnOperators attribute)

__rmod__() (sqlalchemy.sql.operators.ColumnOperators method)

__rmul__() (sqlalchemy.sql.operators.ColumnOperators method)

__rshift__() (sqlalchemy.sql.operators.ColumnOperators method)

__rsub__() (sqlalchemy.sql.operators.ColumnOperators method)

__rtruediv__() (sqlalchemy.sql.operators.ColumnOperators method)

__set__() (sqlalchemy.orm.attributes.InstrumentedAttribute method)

__setattr__ (sqlalchemy.sql.operators.ColumnOperators attribute)

__sizeof__() (sqlalchemy.sql.operators.ColumnOperators method)

__str__ (sqlalchemy.sql.operators.ColumnOperators attribute)

__sub__() (sqlalchemy.sql.operators.ColumnOperators method)

__subclasshook__() (sqlalchemy.sql.operators.ColumnOperators method)

__truediv__() (sqlalchemy.sql.operators.ColumnOperators method)

_asdict() (sqlalchemy.util.KeyedTuple method)

_connection_record (sqlalchemy.pool._ConnectionFairy attribute)

_ConnectionFairy (class in sqlalchemy.pool)

_ConnectionRecord (class in sqlalchemy.pool)

_create_rule (sqlalchemy.schema.Constraint parameter)

_CreateDropBase (class in sqlalchemy.schema)

_cursor_description() (sqlalchemy.engine.ResultProxy method)

_declarative_constructor() (in module sqlalchemy.ext.declarative.api)

_enable_transaction_accounting (sqlalchemy.orm.session.Session parameter)

_fields (sqlalchemy.util.KeyedTuple attribute)

_get_listen_keys() (sqlalchemy.ext.mutable.Mutable class method)

_listen_on_attribute() (sqlalchemy.ext.mutable.Mutable class method)

_parents (sqlalchemy.ext.mutable.Mutable attribute)

(sqlalchemy.ext.mutable.MutableBase attribute)

_process_row (sqlalchemy.engine.ResultProxy attribute)

_soft_close() (sqlalchemy.engine.ResultProxy method)

A

AbstractConcreteBase (class in sqlalchemy.ext.declarative)

ACID

ACID model

active_history (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)
(sqlalchemy.orm.events.AttributeEvents parameter)

adapt() (sqlalchemy.types.SchemaType method)

(sqlalchemy.types.TypeDecorator method)
(sqlalchemy.types.TypeEngine method)

adapt_on_names (sqlalchemy.orm.aliased parameter)

adapt_to_emulated() (sqlalchemy.types.Interval method)

adapt_to_entity() (sqlalchemy.orm.attributes.QueryableAttribute method)

(sqlalchemy.orm.interfaces.PropComparator method)
(sqlalchemy.orm.properties.ColumnProperty.Comparator method)

adapter (sqlalchemy.orm.attributes.QueryableAttribute attribute)

(sqlalchemy.orm.interfaces.PropComparator attribute)
(sqlalchemy.orm.properties.ColumnProperty.Comparator attribute)

add() (sqlalchemy.ext.mutable.MutableSet method)

(sqlalchemy.orm.session.Session method)
(sqlalchemy.sql.expression.ColumnCollection method)

add_all() (sqlalchemy.orm.session.Session method)

add_column() (sqlalchemy.orm.query.Query method)

add_columns() (sqlalchemy.orm.query.Query method)

add_criteria() (sqlalchemy.ext.baked.BakedQuery method)

add_entity() (sqlalchemy.orm.query.Query method)

add_is_dependent_on() (sqlalchemy.schema.Table method)

add_properties() (sqlalchemy.orm.mapper.Mapper method)

add_property() (sqlalchemy.orm.mapper.Mapper method)

AddConstraint (class in sqlalchemy.schema)

adds() (sqlalchemy.orm.collections.collection static method)

adjacent_to() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

after_attach() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_begin() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_bulk_delete() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_bulk_update() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_commit() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_configured() (sqlalchemy.orm.events.MapperEvents method)

after_create() (sqlalchemy.events.DDLEvents method)

after_cursor_execute() (sqlalchemy.events.ConnectionEvents method)

after_delete() (sqlalchemy.orm.events.MapperEvents method)

(sqlalchemy.orm.interfaces.MapperExtension method)

after_drop() (sqlalchemy.events.DDLEvents method)

after_execute() (sqlalchemy.events.ConnectionEvents method)

after_flush() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_flush_postexec() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_insert() (sqlalchemy.orm.events.MapperEvents method)

(sqlalchemy.orm.interfaces.MapperExtension method)

after_parent_attach() (sqlalchemy.events.DDLEvents method)

after_rollback() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

after_soft_rollback() (sqlalchemy.orm.events.SessionEvents method)

after_transaction_create() (sqlalchemy.orm.events.SessionEvents method)

after_transaction_end() (sqlalchemy.orm.events.SessionEvents method)

after_update() (sqlalchemy.orm.events.MapperEvents method)

(sqlalchemy.orm.interfaces.MapperExtension method)

against() (sqlalchemy.schema.DDLElement method)

aggregate_order_by (class in sqlalchemy.dialects.postgresql)

Alias (class in sqlalchemy.sql.expression)

alias (sqlalchemy.orm.aliased parameter)

(sqlalchemy.orm.contains_alias parameter)

alias() (in module sqlalchemy.sql.expression)

(sqlalchemy.schema.Table method)
(sqlalchemy.sql.expression.Alias method)

aliased (sqlalchemy.orm.query.Query.join parameter)

(sqlalchemy.orm.with_polymorphic parameter)

aliased() (in module sqlalchemy.orm)

AliasedClass (class in sqlalchemy.orm.util)

AliasedInsp (class in sqlalchemy.orm.util)

aliasname (sqlalchemy.orm.util.polymorphic_union parameter)

All() (in module sqlalchemy.dialects.postgresql)

all() (sqlalchemy.ext.baked.Result method)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.types.ARRAY.Comparator method)

all_() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

all_orm_descriptors (sqlalchemy.orm.mapper.Mapper attribute)

allow_partial_pks (sqlalchemy.orm.mapper parameter)

always_refresh (sqlalchemy.orm.mapper parameter)

AmbiguousForeignKeysError

and_() (in module sqlalchemy.sql.expression)

annotations

anon_label (sqlalchemy.schema.Column attribute)

(sqlalchemy.sql.expression.ColumnElement attribute)

ansi_bind_rules (sqlalchemy.sql.compiler.SQLCompiler attribute)

AnsiFunction (class in sqlalchemy.sql.functions)

Any() (in module sqlalchemy.dialects.postgresql)

any() (sqlalchemy.ext.associationproxy.AssociationProxyInstance method)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance method)

any_() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

append() (sqlalchemy.ext.mutable.MutableList method)

(sqlalchemy.ext.orderinglist.OrderingList method)
(sqlalchemy.orm.events.AttributeEvents method)

append_column() (sqlalchemy.schema.Table method)

(sqlalchemy.sql.expression.Select method)

append_constraint() (sqlalchemy.schema.Table method)

append_correlation() (sqlalchemy.sql.expression.Select method)

append_ddl_listener() (sqlalchemy.schema.MetaData method)

(sqlalchemy.schema.Table method)

append_from() (sqlalchemy.sql.expression.Select method)

append_group_by() (sqlalchemy.sql.expression.CompoundSelect method)

(sqlalchemy.sql.expression.GenerativeSelect method)
(sqlalchemy.sql.expression.Select method)

append_having() (sqlalchemy.sql.expression.Select method)

append_order_by() (sqlalchemy.sql.expression.CompoundSelect method)

(sqlalchemy.sql.expression.GenerativeSelect method)
(sqlalchemy.sql.expression.Select method)

append_prefix() (sqlalchemy.sql.expression.Select method)

append_whereclause() (sqlalchemy.sql.expression.Select method)

appender() (sqlalchemy.orm.collections.collection static method)

apply_labels() (sqlalchemy.sql.expression.CompoundSelect method)

(sqlalchemy.sql.expression.GenerativeSelect method)
(sqlalchemy.sql.expression.Select method)

args (sqlalchemy.orm.events.InstanceEvents.init parameter)

(sqlalchemy.orm.events.InstanceEvents.init_failure parameter)

argument (sqlalchemy.orm.relationship parameter)

argument_for() (sqlalchemy.schema.CheckConstraint class method)

(sqlalchemy.schema.Column class method)
(sqlalchemy.schema.ColumnCollectionConstraint class method)

argument_name (sqlalchemy.schema.CheckConstraint.argument_for parameter)

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

ArgumentError

ARRAY (class in sqlalchemy.dialects.postgresql)

array (class in sqlalchemy.dialects.postgresql)

ARRAY (class in sqlalchemy.types)

array() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

ARRAY.Comparator (class in sqlalchemy.dialects.postgresql)

(class in sqlalchemy.types)

array_agg (class in sqlalchemy.sql.functions)

array_agg() (in module sqlalchemy.dialects.postgresql)

array_for_multi_clause (sqlalchemy.sql.functions.OrderedSetAgg attribute)

(sqlalchemy.sql.functions.percentile_cont attribute)
(sqlalchemy.sql.functions.percentile_disc attribute)

as_comparison() (sqlalchemy.sql.functions.FunctionElement method)

as_declarative() (in module sqlalchemy.ext.declarative)

as_immutable() (sqlalchemy.sql.expression.ColumnCollection method)

as_mutable() (sqlalchemy.ext.mutable.Mutable class method)

as_scalar() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.GenerativeSelect method)

as_tuple (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)

as_uuid (sqlalchemy.dialects.postgresql.UUID parameter)

asc() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

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 (class in sqlalchemy.pool)

associate_with() (sqlalchemy.ext.mutable.Mutable class method)

associate_with_attribute() (sqlalchemy.ext.mutable.Mutable class method)

association relationship

ASSOCIATION_PROXY (in module sqlalchemy.ext.associationproxy)

association_proxy() (in module sqlalchemy.ext.associationproxy)

AssociationProxy (class in sqlalchemy.ext.associationproxy)

AssociationProxyInstance (class in sqlalchemy.ext.associationproxy)

astext (sqlalchemy.dialects.postgresql.JSON.Comparator attribute)

astext_type (sqlalchemy.dialects.postgresql.JSON parameter)

atomicity

attr (sqlalchemy.ext.associationproxy.association_proxy parameter)

(sqlalchemy.ext.associationproxy.AssociationProxy parameter)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

attr_name (sqlalchemy.ext.indexable.index_property parameter)

attribute_instrument() (sqlalchemy.orm.events.InstrumentationEvents method)

attribute_mapped_collection() (in module sqlalchemy.orm.collections)

attribute_names (sqlalchemy.orm.session.Session.expire parameter)

(sqlalchemy.orm.session.Session.refresh parameter)

AttributeEvents (class in sqlalchemy.orm.events)

AttributeExtension (class in sqlalchemy.orm.interfaces)

AttributeState (class in sqlalchemy.orm.state)

attrname (sqlalchemy.ext.automap.generate_relationship parameter)

attrs (sqlalchemy.orm.events.InstanceEvents.expire parameter)

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

autocommit (sqlalchemy.engine.Connection.execution_options parameter)

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

autocommit() (sqlalchemy.sql.expression.CompoundSelect method)

(sqlalchemy.sql.expression.GenerativeSelect method)
(sqlalchemy.sql.expression.Select method)

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

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

autoflush (sqlalchemy.orm.session.Session parameter)

(sqlalchemy.orm.session.sessionmaker parameter)

autoflush() (sqlalchemy.orm.query.Query method)

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() (in module sqlalchemy.ext.automap)

AutomapBase (class in sqlalchemy.ext.automap)

B

back_populates (sqlalchemy.orm.relationship parameter)

backref

(sqlalchemy.orm.relationship parameter)

backref() (in module sqlalchemy.orm)

bake_queries (sqlalchemy.orm.relationship parameter)

baked_lazyload() (sqlalchemy.orm.strategy_options.Load method)

BakedQuery (class in sqlalchemy.ext.baked)

Bakery (class in sqlalchemy.ext.baked)

bakery() (in module sqlalchemy.ext.baked)

(sqlalchemy.ext.baked.BakedQuery class method)

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 attribute)

base_mapper (sqlalchemy.orm.mapper.Mapper attribute)

batch (sqlalchemy.orm.mapper parameter)

before_attach() (sqlalchemy.orm.events.SessionEvents method)

before_commit() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

before_compile() (sqlalchemy.orm.events.QueryEvents method)

before_compile_delete() (sqlalchemy.orm.events.QueryEvents method)

before_compile_update() (sqlalchemy.orm.events.QueryEvents method)

before_configured() (sqlalchemy.orm.events.MapperEvents method)

before_create() (sqlalchemy.events.DDLEvents method)

before_cursor_execute() (sqlalchemy.events.ConnectionEvents method)

before_delete() (sqlalchemy.orm.events.MapperEvents method)

(sqlalchemy.orm.interfaces.MapperExtension method)

before_drop() (sqlalchemy.events.DDLEvents method)

before_execute() (sqlalchemy.events.ConnectionEvents method)

before_flush() (sqlalchemy.orm.events.SessionEvents method)

(sqlalchemy.orm.interfaces.SessionExtension method)

before_insert() (sqlalchemy.orm.events.MapperEvents method)

(sqlalchemy.orm.interfaces.MapperExtension method)

before_mapper_configured() (sqlalchemy.orm.events.MapperEvents method)

before_parent_attach() (sqlalchemy.events.DDLEvents method)

before_update() (sqlalchemy.orm.events.MapperEvents method)

(sqlalchemy.orm.interfaces.MapperExtension method)

begin() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.Engine method)
(sqlalchemy.events.ConnectionEvents method)

begin_nested() (sqlalchemy.engine.Connection method)

(sqlalchemy.orm.session.Session method)

begin_twophase() (sqlalchemy.engine.Connection method)

(sqlalchemy.events.ConnectionEvents method)
(sqlalchemy.interfaces.ConnectionProxy method)

between() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

BFILE (class in sqlalchemy.dialects.oracle)

bidirectional relationship

BIGINT (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

BigInteger (class in sqlalchemy.types)

BINARY (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

binary (sqlalchemy.dialects.mysql.CHAR parameter)

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

BinaryExpression (class in sqlalchemy.sql.expression)

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

(sqlalchemy.dialects.postgresql.ENUM.drop parameter)
(sqlalchemy.engine.interfaces.Compiled parameter)

bind_expression() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)

bind_mapper() (sqlalchemy.orm.session.Session method)

bind_processor() (sqlalchemy.dialects.postgresql.HSTORE method)

(sqlalchemy.types.Boolean method)
(sqlalchemy.types.Interval method)

bind_table() (sqlalchemy.orm.session.Session method)

bindparam() (in module sqlalchemy.sql.expression)

BindParameter (class in sqlalchemy.sql.expression)

bindparams (sqlalchemy.sql.expression.text parameter)

bindparams() (sqlalchemy.sql.expression.TextClause method)

binds (sqlalchemy.orm.session.Session parameter)

BIT (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.dialects.postgresql)

BLANK_SCHEMA (sqlalchemy.schema.sqlalchemy.schema attribute)

BLOB (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

bool_op() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

BOOLEAN (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

Boolean (class in sqlalchemy.types)

branch (sqlalchemy.events.ConnectionEvents.engine_connect parameter)

bulk_insert_mappings() (sqlalchemy.orm.session.Session method)

bulk_replace() (in module sqlalchemy.orm.collections)

(sqlalchemy.orm.events.AttributeEvents method)

bulk_save_objects() (sqlalchemy.orm.session.Session method)

bulk_update_mappings() (sqlalchemy.orm.session.Session method)

Bundle (class in sqlalchemy.orm.query)

BYTEA (class in sqlalchemy.dialects.postgresql)

C

c (sqlalchemy.orm.mapper.Mapper attribute)

(sqlalchemy.orm.query.Bundle attribute)
(sqlalchemy.schema.Table attribute)

cache (sqlalchemy.schema.Sequence parameter)

callable_ (sqlalchemy.schema.DDLElement attribute)

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

callables (sqlalchemy.orm.state.InstanceState attribute)

candidate key

cascade (sqlalchemy.orm.interfaces.MapperProperty attribute)

(sqlalchemy.orm.properties.RelationshipProperty attribute)
(sqlalchemy.orm.relationship parameter)

cascade_backrefs (sqlalchemy.orm.relationship parameter)

cascade_iterator() (sqlalchemy.orm.descriptor_props.SynonymProperty method)

(sqlalchemy.orm.interfaces.MapperProperty method)
(sqlalchemy.orm.mapper.Mapper method)

cascade_scalar_deletes (sqlalchemy.ext.associationproxy.AssociationProxy parameter)

CascadeOptions (class in sqlalchemy.orm.util)

cascading (sqlalchemy.ext.declarative.declared_attr attribute)

Case (class in sqlalchemy.sql.expression)

case() (in module sqlalchemy.sql.expression)

case_sensitive (sqlalchemy.create_engine parameter)

Cast (class in sqlalchemy.sql.expression)

cast() (in module sqlalchemy.sql.expression)

(sqlalchemy.schema.Column method)
(sqlalchemy.sql.expression.ColumnElement method)

cast_nulls (sqlalchemy.orm.util.polymorphic_union parameter)

chained_exception (sqlalchemy.engine.ExceptionContext attribute)

changed() (sqlalchemy.ext.mutable.Mutable method)

(sqlalchemy.ext.mutable.MutableComposite method)

CHAR (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.types)

char_length (class in sqlalchemy.sql.functions)

charset (sqlalchemy.dialects.mysql.ENUM parameter)

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

check constraint

check_modified() (sqlalchemy.orm.identity.IdentityMap method)

CheckConstraint (class in 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 method)

(sqlalchemy.interfaces.PoolListener method)

checkout() (sqlalchemy.events.PoolEvents method)

(sqlalchemy.interfaces.PoolListener method)

CIDR (class in sqlalchemy.dialects.postgresql)

CircularDependencyError

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

(sqlalchemy.orm.attributes.QueryableAttribute.of_type parameter)
(sqlalchemy.orm.composite parameter)

class_attribute (sqlalchemy.orm.descriptor_props.SynonymProperty attribute)

(sqlalchemy.orm.interfaces.MapperProperty attribute)
(sqlalchemy.orm.properties.ColumnProperty attribute)

class_instrument() (sqlalchemy.orm.events.InstrumentationEvents method)

class_manager (sqlalchemy.orm.mapper.Mapper attribute)

class_mapper() (in module sqlalchemy.orm)

class_registry (sqlalchemy.ext.declarative.declarative_base parameter)

class_uninstrument() (sqlalchemy.orm.events.InstrumentationEvents method)

classes (sqlalchemy.ext.automap.AutomapBase attribute)

(sqlalchemy.orm.with_polymorphic parameter)

ClassManager (class in sqlalchemy.orm.instrumentation)

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

classname_for_table() (in module sqlalchemy.ext.automap)

clause (sqlalchemy.ext.horizontal_shard.ShardedSession.connection parameter)

(sqlalchemy.ext.horizontal_shard.ShardedSession.get_bind parameter)
(sqlalchemy.orm.session.Session.connection parameter)

ClauseElement (class in sqlalchemy.sql.expression)

clauseelement (sqlalchemy.events.ConnectionEvents.after_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_execute parameter)

ClauseList (class in sqlalchemy.sql.expression)

clauses (sqlalchemy.sql.functions.FunctionElement attribute)

clear() (sqlalchemy.ext.mutable.MutableDict method)

(sqlalchemy.ext.mutable.MutableList method)
(sqlalchemy.ext.mutable.MutableSet method)

clear_mappers() (in module sqlalchemy.orm)

CLOB (class in sqlalchemy.types)

close() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.ResultProxy method)
(sqlalchemy.engine.Transaction method)

close_all() (sqlalchemy.orm.session.Session class method)

(sqlalchemy.orm.session.sessionmaker class method)

close_all_sessions() (in module sqlalchemy.orm.session)

close_detached() (sqlalchemy.events.PoolEvents method)

close_with_result (sqlalchemy.engine.Engine.contextual_connect parameter)

(sqlalchemy.ext.horizontal_shard.ShardedSession.connection parameter)
(sqlalchemy.orm.session.Session.connection parameter)

closed (sqlalchemy.engine.Connection attribute)

cls (sqlalchemy.ext.declarative.declarative_base parameter)

coalesce (class in sqlalchemy.sql.functions)

coerce() (sqlalchemy.ext.mutable.Mutable class method)

(sqlalchemy.ext.mutable.MutableBase class method)
(sqlalchemy.ext.mutable.MutableDict class method)

coerce_arguments (sqlalchemy.sql.functions.GenericFunction attribute)

coerce_compared_value() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)
(sqlalchemy.types.UserDefinedType method)

coerce_to_is_types (sqlalchemy.types.TypeDecorator attribute)

collate() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

collation (sqlalchemy.dialects.mssql.CHAR parameter)

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

collection (class in sqlalchemy.orm.collections) , [4]

(sqlalchemy.orm.events.AttributeEvents.init_collection parameter)

collection_adapter (in module sqlalchemy.orm.collections)

(sqlalchemy.orm.events.AttributeEvents.init_collection parameter)

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

(sqlalchemy.orm.relationship parameter)

CollectionAdapter (class in sqlalchemy.orm.collections)

cols (sqlalchemy.sql.expression.Insert.return_defaults parameter)

(sqlalchemy.sql.expression.Update.return_defaults 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 (class in sqlalchemy.schema)

column (sqlalchemy.schema.ForeignKey attribute)

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

column() (in module sqlalchemy.sql.expression)

(sqlalchemy.sql.expression.Select method)

column_attrs (sqlalchemy.orm.mapper.Mapper attribute)

column_descriptions (sqlalchemy.orm.query.Query attribute)

column_expression() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)

column_keys (sqlalchemy.schema.Column.compile parameter)

(sqlalchemy.schema.ForeignKeyConstraint attribute)
(sqlalchemy.schema.Table.compile parameter)

column_mapped_collection() (in module sqlalchemy.orm.collections)

column_prefix (sqlalchemy.orm.mapper parameter)

column_property() (in module sqlalchemy.orm)

column_reflect() (sqlalchemy.events.DDLEvents method)

ColumnAssociationProxyInstance (class in sqlalchemy.ext.associationproxy)

ColumnClause (class in sqlalchemy.sql.expression)

ColumnCollection (class in sqlalchemy.sql.expression)

ColumnCollectionConstraint (class in sqlalchemy.schema)

ColumnCollectionMixin (class in sqlalchemy.schema)

ColumnDefault (class in sqlalchemy.schema)

ColumnElement (class in sqlalchemy.sql.expression)

ColumnOperators (class in sqlalchemy.sql.operators)

ColumnProperty (class in sqlalchemy.orm.properties)

ColumnProperty.Comparator (class in sqlalchemy.orm.properties)

columns (sqlalchemy.orm.mapper.Mapper attribute)

(sqlalchemy.orm.query.Bundle attribute)
(sqlalchemy.schema.ColumnCollectionConstraint attribute)

columns clause

columns() (sqlalchemy.sql.expression.TextClause method)

comment (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.Table parameter)

commit() (sqlalchemy.engine.Transaction method)

(sqlalchemy.events.ConnectionEvents method)
(sqlalchemy.interfaces.ConnectionProxy method)

commit_twophase() (sqlalchemy.events.ConnectionEvents method)

(sqlalchemy.interfaces.ConnectionProxy method)

common_parent() (sqlalchemy.orm.mapper.Mapper method)

comparable_using() (in module sqlalchemy.ext.declarative)

ComparableProperty (class in sqlalchemy.orm.properties)

Comparator (class in sqlalchemy.ext.hybrid)

comparator (sqlalchemy.sql.expression.ColumnElement attribute)

(sqlalchemy.types.PickleType parameter)

comparator() (sqlalchemy.ext.hybrid.hybrid_property method)

comparator_factory (sqlalchemy.dialects.postgresql.HSTORE attribute)

(sqlalchemy.dialects.postgresql.JSON attribute)
(sqlalchemy.dialects.postgresql.JSONB attribute)

compare() (sqlalchemy.schema.Column method)

(sqlalchemy.schema.Table method)
(sqlalchemy.sql.elements.False_ method)

compare_against_backend() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)

compare_values() (sqlalchemy.types.ARRAY method)

(sqlalchemy.types.PickleType method)
(sqlalchemy.types.TypeDecorator method)

compile() (sqlalchemy.engine.interfaces.Compiled method)

(sqlalchemy.schema.Column method)
(sqlalchemy.schema.Table method)

compile_kwargs (sqlalchemy.engine.interfaces.Compiled parameter)

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

Compiled (class in sqlalchemy.engine.interfaces)

compiled_cache (sqlalchemy.engine.Connection.execution_options parameter)

CompileError

compiles() (in module sqlalchemy.ext.compiler)

composite() (in module sqlalchemy.orm)

CompositeProperty (class in sqlalchemy.orm.descriptor_props)

CompositeProperty.Comparator (class in sqlalchemy.orm.descriptor_props)

CompositeProperty.CompositeBundle (class in sqlalchemy.orm.descriptor_props)

composites (sqlalchemy.orm.mapper.Mapper attribute)

CompoundSelect (class in sqlalchemy.sql.expression)

concat (class in sqlalchemy.sql.functions)

concat() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

Concatenable (class in sqlalchemy.types)

Concatenable.Comparator (class in sqlalchemy.types)

concrete (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.mapper.Mapper attribute)

ConcreteBase (class in sqlalchemy.ext.declarative)

ConcurrentModificationError (in module sqlalchemy.orm.exc)

configuration (sqlalchemy.engine_from_config parameter)

configure() (sqlalchemy.orm.scoping.scoped_session method)

(sqlalchemy.orm.session.sessionmaker method)

configure_mappers() (in module sqlalchemy.orm)

configured (sqlalchemy.orm.mapper.Mapper attribute)

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.TypeDecorator.compare_against_backend parameter)

(sqlalchemy.types.TypeEngine.compare_against_backend parameter)

connect() (sqlalchemy.engine.Connectable method)

(sqlalchemy.engine.Connection method)
(sqlalchemy.engine.Engine method)

connect_args (sqlalchemy.create_engine parameter)

Connectable (class in sqlalchemy.engine)

Connection (class in sqlalchemy.engine)

connection (sqlalchemy.engine.Connection attribute)

(sqlalchemy.engine.Engine.table_names parameter)
(sqlalchemy.engine.ExceptionContext attribute)

connection() (sqlalchemy.ext.horizontal_shard.ShardedSession method)

(sqlalchemy.orm.session.Session method)

connection_proxy (sqlalchemy.events.PoolEvents.checkout parameter)

connection_record (sqlalchemy.events.PoolEvents.checkin parameter)

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

ConnectionEvents (class in sqlalchemy.events)

ConnectionProxy (class in sqlalchemy.interfaces)

consistency

constrained

constraint

Constraint (class in sqlalchemy.schema)

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

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

constraints

construct_arguments (sqlalchemy.engine.default.DefaultDialect attribute)

construct_params() (sqlalchemy.engine.interfaces.Compiled method)

(sqlalchemy.sql.compiler.DDLCompiler method)
(sqlalchemy.sql.compiler.SQLCompiler method)

constructor (sqlalchemy.ext.declarative.declarative_base parameter)

contained_by() (sqlalchemy.dialects.postgresql.ARRAY.Comparator method)

(sqlalchemy.dialects.postgresql.HSTORE.Comparator method)
(sqlalchemy.dialects.postgresql.JSONB.Comparator method)

contains() (in module sqlalchemy.event)

(sqlalchemy.dialects.postgresql.ARRAY.Comparator method)
(sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

contains_alias() (in module sqlalchemy.orm)

contains_column() (sqlalchemy.schema.CheckConstraint method)

(sqlalchemy.schema.ColumnCollectionConstraint method)
(sqlalchemy.schema.ForeignKeyConstraint method)

contains_eager() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

contains_expanding_parameters (sqlalchemy.sql.compiler.SQLCompiler attribute)

context (sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

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

contextual_connect() (sqlalchemy.engine.Connectable method)

(sqlalchemy.engine.Engine method)

conv() (in module 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 static method)

copy() (sqlalchemy.orm.instrumentation.ClassManager method)

(sqlalchemy.schema.Column method)
(sqlalchemy.schema.ForeignKey method)

correlate (sqlalchemy.sql.expression.select parameter)

correlate() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.Select method)

correlate_except() (sqlalchemy.sql.expression.Select method)

correlated subqueries

correlated subquery

correlates

correspond_on_equivalents() (sqlalchemy.schema.Table method)

(sqlalchemy.sql.expression.Alias method)
(sqlalchemy.sql.expression.CTE method)

corresponding_column() (sqlalchemy.schema.Table method)

(sqlalchemy.sql.expression.Alias method)
(sqlalchemy.sql.expression.CTE method)

count (class in sqlalchemy.sql.functions)

count() (sqlalchemy.ext.baked.Result method)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.schema.Table method)

count_from (sqlalchemy.ext.orderinglist.ordering_list parameter)

count_from_0() (in module sqlalchemy.ext.orderinglist)

count_from_1() (in module sqlalchemy.ext.orderinglist)

count_from_n_factory() (in module sqlalchemy.ext.orderinglist)

create() (sqlalchemy.dialects.postgresql.ENUM method)

(sqlalchemy.engine.Connectable method)
(sqlalchemy.schema.Index method)

create_all() (sqlalchemy.schema.MetaData method)

create_connect_args() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

create_constraint (sqlalchemy.dialects.mysql.BOOLEAN parameter)

(sqlalchemy.types.Boolean parameter)
(sqlalchemy.types.Enum parameter)

create_cursor() (sqlalchemy.engine.default.DefaultExecutionContext method)

(sqlalchemy.engine.interfaces.ExecutionContext method)

create_engine() (in module sqlalchemy)

create_row_processor() (sqlalchemy.orm.descriptor_props.CompositeProperty.CompositeBundle method)

(sqlalchemy.orm.descriptor_props.SynonymProperty method)
(sqlalchemy.orm.interfaces.MapperProperty method)

create_type (sqlalchemy.dialects.postgresql.ENUM parameter)

create_xid() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

CreateColumn (class in sqlalchemy.schema)

CreateEnginePlugin (class in sqlalchemy.engine)

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

CreateIndex (class in sqlalchemy.schema)

CreateSchema (class in sqlalchemy.schema)

CreateSequence (class in sqlalchemy.schema)

CreateTable (class in sqlalchemy.schema)

creator (sqlalchemy.create_engine parameter)

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

criterion (sqlalchemy.orm.attributes.QueryableAttribute.any parameter)

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

crud

CTE (class in sqlalchemy.sql.expression)

cte() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.Delete method)

cube (class in sqlalchemy.sql.functions)

cume_dist (class in sqlalchemy.sql.functions)

current_date (class in sqlalchemy.sql.functions)

current_parameters (sqlalchemy.engine.default.DefaultExecutionContext attribute)

current_time (class in sqlalchemy.sql.functions)

current_timestamp (class in sqlalchemy.sql.functions)

current_user (class in sqlalchemy.sql.functions)

cursor (sqlalchemy.engine.ExceptionContext attribute)

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

cursor() (sqlalchemy.pool._ConnectionFairy method)

cursor_execute() (sqlalchemy.interfaces.ConnectionProxy method)

custom_op (class in sqlalchemy.sql.operators)

cycle (sqlalchemy.schema.Sequence parameter)

D

database (sqlalchemy.engine.url.URL parameter)

DatabaseError

DataError

datatype (sqlalchemy.ext.indexable.index_property parameter)

DATE (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.dialects.oracle)
(class in sqlalchemy.dialects.sqlite)

Date (class in sqlalchemy.types)

DATERANGE (class in sqlalchemy.dialects.postgresql)

DATETIME (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.dialects.sqlite)
(class in sqlalchemy.types)

DateTime (class in sqlalchemy.types)

DATETIME2 (class in sqlalchemy.dialects.mssql)

DATETIMEOFFSET (class in 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_error() (sqlalchemy.events.ConnectionEvents method)

dbapi_exception_translation_map (sqlalchemy.engine.default.DefaultDialect attribute)

DBAPIError

DDL

(class in sqlalchemy.schema)

ddl_compiler (sqlalchemy.engine.default.DefaultDialect attribute)

DDLCompiler (class in sqlalchemy.sql.compiler)

DDLElement (class in sqlalchemy.schema)

DDLEvents (class in sqlalchemy.events)

DECIMAL (class in sqlalchemy.dialects.mysql)

(class in 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() (in module sqlalchemy.ext.declarative)

declared_attr (class in sqlalchemy.ext.declarative)

default (sqlalchemy.ext.indexable.index_property parameter)

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

default_from() (sqlalchemy.sql.compiler.SQLCompiler method)

default_isolation_level (sqlalchemy.engine.Connection attribute)

default_schema_name (sqlalchemy.engine.reflection.Inspector attribute)

DefaultClause (class in sqlalchemy.schema)

DefaultDialect (class in sqlalchemy.engine.default)

DefaultExecutionContext (class in sqlalchemy.engine.default)

DefaultGenerator (class in sqlalchemy.schema)

defaultload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

defer() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

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() (in module sqlalchemy.orm)

DeferredReflection (class in sqlalchemy.ext.declarative)

define_constraint_remote_table() (sqlalchemy.sql.compiler.DDLCompiler method)

defined() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

del_attribute() (in module sqlalchemy.orm.attributes)

Delete (class in sqlalchemy.sql.expression)

delete() (in module sqlalchemy.sql.expression)

(sqlalchemy.dialects.postgresql.HSTORE.Comparator method)
(sqlalchemy.ext.associationproxy.AssociationProxyInstance method)

delete_context (sqlalchemy.orm.events.QueryEvents.before_compile_delete parameter)

(sqlalchemy.orm.events.SessionEvents.after_bulk_delete parameter)

delete_extra_from_clause() (sqlalchemy.sql.compiler.SQLCompiler method)

(sqlalchemy.sql.compiler.StrSQLCompiler method)

deleted

(sqlalchemy.orm.events.SessionEvents.persistent_to_detached parameter)
(sqlalchemy.orm.session.Session attribute)

deleted_to_detached() (sqlalchemy.orm.events.SessionEvents method)

deleted_to_persistent() (sqlalchemy.orm.events.SessionEvents method)

deleter() (sqlalchemy.ext.hybrid.hybrid_property method)

denormalize_name() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

dense_rank (class in sqlalchemy.sql.functions)

deregister() (in module sqlalchemy.ext.compiler)

desc() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

description (sqlalchemy.sql.expression.Alias attribute)

(sqlalchemy.sql.expression.CTE attribute)
(sqlalchemy.sql.expression.ColumnElement attribute)

descriptor

(sqlalchemy.orm.synonym parameter)

descriptors

Deserializer() (in module sqlalchemy.ext.serializer)

detach() (sqlalchemy.engine.Connection method)

(sqlalchemy.events.PoolEvents method)
(sqlalchemy.pool._ConnectionFairy method)

detached

(sqlalchemy.orm.state.InstanceState attribute)

detached_to_persistent() (sqlalchemy.orm.events.SessionEvents method)

DetachedInstanceError

Dialect (class in sqlalchemy.engine.interfaces)

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

(sqlalchemy.dialects.postgresql.HSTORE.result_processor parameter)
(sqlalchemy.engine.interfaces.Compiled parameter)

dialect_impl() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)

dialect_kwargs (sqlalchemy.schema.CheckConstraint attribute)

(sqlalchemy.schema.Column attribute)
(sqlalchemy.schema.ColumnCollectionConstraint attribute)

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 attribute)

(sqlalchemy.schema.Column attribute)
(sqlalchemy.schema.ColumnCollectionConstraint attribute)

DialectEvents (class in sqlalchemy.events)

DialectKWArgs (class in sqlalchemy.sql.base)

dict (sqlalchemy.orm.state.InstanceState attribute)

dict_ (sqlalchemy.orm.events.AttributeEvents.init_scalar parameter)

dict_getter() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

difference_update() (sqlalchemy.ext.mutable.MutableSet method)

dimensions (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)

direction (sqlalchemy.ext.automap.generate_relationship parameter)

dirty (sqlalchemy.orm.session.Session attribute)

discard() (sqlalchemy.ext.mutable.MutableSet method)

DisconnectionError

discriminator

display_width (sqlalchemy.dialects.mysql.BIGINT parameter)

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

dispose() (sqlalchemy.engine.Engine method)

(sqlalchemy.ext.instrumentation.InstrumentationManager method)
(sqlalchemy.orm.instrumentation.ClassManager method)

dispose_collection() (sqlalchemy.orm.events.AttributeEvents method)

distinct (sqlalchemy.sql.expression.select parameter)

distinct() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

distinct_target_key (sqlalchemy.orm.relationship parameter)

do_begin() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_begin_twophase() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_close() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_commit() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_commit_twophase() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_connect() (sqlalchemy.events.DialectEvents method)

do_execute() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.events.DialectEvents method)

do_execute_no_params() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.events.DialectEvents method)

do_executemany() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.events.DialectEvents method)

do_init() (sqlalchemy.orm.descriptor_props.CompositeProperty method)

(sqlalchemy.orm.descriptor_props.SynonymProperty method)
(sqlalchemy.orm.interfaces.MapperProperty method)

do_prepare_twophase() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_recover_twophase() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_release_savepoint() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_rollback() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_rollback_to_savepoint() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_rollback_twophase() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_savepoint() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

do_setinputsizes() (sqlalchemy.events.DialectEvents method)

doc (sqlalchemy.orm.column_property parameter)

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

domain model

DontWrapMixin (class in sqlalchemy.exc)

DOUBLE (class in sqlalchemy.dialects.mysql)

DOUBLE_PRECISION (class in sqlalchemy.dialects.oracle)

(class in sqlalchemy.dialects.postgresql)

driver (sqlalchemy.engine.Engine attribute)

drivername (sqlalchemy.engine.url.URL parameter)

drop() (sqlalchemy.dialects.postgresql.ENUM method)

(sqlalchemy.engine.Connectable method)
(sqlalchemy.schema.Index method)

drop_all() (sqlalchemy.schema.MetaData method)

DropConstraint (class in sqlalchemy.schema)

DropIndex (class in sqlalchemy.schema)

DropSchema (class in sqlalchemy.schema)

DropSequence (class in sqlalchemy.schema)

DropTable (class in sqlalchemy.schema)

dumps() (in module sqlalchemy.ext.serializer)

durability

dynamic_loader() (in module sqlalchemy.orm)

E

e (sqlalchemy.pool._ConnectionFairy.invalidate parameter)

(sqlalchemy.pool._ConnectionRecord.invalidate parameter)

eager_defaults (sqlalchemy.orm.mapper parameter)

eagerload() (in module sqlalchemy.orm)

eagerload_all() (in module 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 attribute)

element (sqlalchemy.orm.aliased parameter)

(sqlalchemy.schema.CreateTable parameter)
(sqlalchemy.sql.expression.Over attribute)

elements (sqlalchemy.schema.ForeignKeyConstraint attribute)

else_ (sqlalchemy.sql.expression.case parameter)

empty() (sqlalchemy.orm.attributes.History method)

empty_in_strategy (sqlalchemy.create_engine parameter)

enable_assertions() (sqlalchemy.orm.query.Query method)

enable_baked_queries (sqlalchemy.orm.session.Session parameter)

enable_eagerloads() (sqlalchemy.orm.query.Query method)

enable_relationship_loading() (sqlalchemy.orm.session.Session method)

encoding (sqlalchemy.create_engine parameter)

endswith() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

Engine (class in sqlalchemy.engine)

engine (sqlalchemy.engine.ExceptionContext attribute)

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

engine_connect() (sqlalchemy.events.ConnectionEvents method)

engine_created() (sqlalchemy.engine.CreateEnginePlugin method)

(sqlalchemy.engine.default.DefaultDialect class method)
(sqlalchemy.engine.interfaces.Dialect class method)

engine_disposed() (sqlalchemy.events.ConnectionEvents method)

engine_from_config() (in module sqlalchemy)

entities (sqlalchemy.orm.query.Query parameter)

entity (sqlalchemy.orm.mapper.Mapper attribute)

(sqlalchemy.orm.properties.RelationshipProperty attribute)
(sqlalchemy.orm.properties.RelationshipProperty.Comparator attribute)

ENUM (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.dialects.postgresql)

Enum (class in sqlalchemy.types)

enums (sqlalchemy.dialects.mysql.ENUM parameter)

equivalents (sqlalchemy.schema.Column.compare parameter)

(sqlalchemy.sql.elements.False_.compare parameter)
(sqlalchemy.sql.elements.Null.compare parameter)

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

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

evaluates_none() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)

Event (class in sqlalchemy.orm.attributes)

event (sqlalchemy.schema.DDLElement.execute_at parameter)

Events (class in sqlalchemy.event.base)

events (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

examples.adjacency_list (module)

examples.association (module)

examples.custom_attributes (module)

examples.dogpile_caching (module)

examples.dynamic_dict (module)

examples.elementtree (module)

examples.generic_associations (module)

examples.graphs (module)

examples.inheritance (module)

examples.join_conditions (module)

examples.large_collection (module)

examples.materialized_paths (module)

examples.nested_sets (module)

examples.performance (module)

examples.postgis (module)

examples.sharding (module)

examples.space_invaders (module)

examples.versioned_history (module)

examples.versioned_rows (module)

examples.vertical (module)

except_() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Select method)

except_all() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Select method)

exception (sqlalchemy.engine.interfaces.ExecutionContext attribute)

(sqlalchemy.events.ConnectionEvents.dbapi_error parameter)
(sqlalchemy.events.PoolEvents.invalidate parameter)

ExceptionContext (class in sqlalchemy.engine)

exclude_properties (sqlalchemy.orm.mapper parameter)

ExcludeConstraint (class in sqlalchemy.dialects.postgresql)

excluded (sqlalchemy.dialects.postgresql.dml.Insert attribute)

Executable (class in sqlalchemy.sql.expression)

execute() (sqlalchemy.engine.Connectable method)

(sqlalchemy.engine.Connection method)
(sqlalchemy.engine.Engine method)

execute_at() (sqlalchemy.schema.DDLElement method)

execute_if() (sqlalchemy.schema.DDLElement method)

execute_sequence_format (sqlalchemy.engine.default.DefaultDialect attribute)

executemany (sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_cursor_execute parameter)

execution_context (sqlalchemy.engine.ExceptionContext attribute)

execution_ctx_cls (sqlalchemy.engine.default.DefaultDialect attribute)

execution_options (sqlalchemy.create_engine parameter)

(sqlalchemy.engine.interfaces.Compiled attribute)
(sqlalchemy.ext.horizontal_shard.ShardedSession.connection parameter)

execution_options() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.Engine method)
(sqlalchemy.orm.query.Query method)

ExecutionContext (class in sqlalchemy.engine.interfaces)

executor (sqlalchemy.create_engine parameter)

existing_adapter (sqlalchemy.orm.collections.bulk_replace parameter)

exists() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.schema.Table method)

expanding (sqlalchemy.sql.expression.bindparam parameter)

expire

expire() (sqlalchemy.orm.events.InstanceEvents method)

(sqlalchemy.orm.session.Session method)

expire_all() (sqlalchemy.orm.session.Session method)

expire_on_commit (sqlalchemy.orm.session.Session parameter)

(sqlalchemy.orm.session.sessionmaker parameter)

expire_on_flush (sqlalchemy.orm.column_property parameter)

expired_attributes (sqlalchemy.orm.state.InstanceState attribute)

expires

expiring

expr (sqlalchemy.orm.with_expression parameter)

(sqlalchemy.sql.expression.between parameter)

expression (sqlalchemy.orm.properties.ColumnProperty attribute)

(sqlalchemy.schema.Column attribute)
(sqlalchemy.sql.expression.ColumnElement attribute)

expression() (sqlalchemy.ext.hybrid.hybrid_method method)

(sqlalchemy.ext.hybrid.hybrid_property method)

expunge() (sqlalchemy.orm.session.Session method)

expunge_all() (sqlalchemy.orm.session.Session method)

extend() (sqlalchemy.ext.mutable.MutableList method)

extend_existing (sqlalchemy.schema.MetaData.reflect parameter)

(sqlalchemy.schema.Table parameter)

ExtendedInstrumentationRegistry (class in sqlalchemy.ext.instrumentation)

extension (sqlalchemy.orm.column_property parameter)

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

extension_type (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.attributes.QueryableAttribute attribute)
(sqlalchemy.orm.base.InspectionAttr attribute)

extra_dependencies (sqlalchemy.schema.sort_tables parameter)

(sqlalchemy.schema.sort_tables_and_constraints parameter)

Extract (class in sqlalchemy.sql.expression)

extract() (in module sqlalchemy.sql.expression)

F

false() (in module sqlalchemy.sql.expression)

False_ (class in sqlalchemy.sql.elements)

fetchall() (sqlalchemy.engine.ResultProxy method)

FetchedValue (class in sqlalchemy.schema)

fetchmany() (sqlalchemy.engine.ResultProxy method)

fetchone() (sqlalchemy.engine.ResultProxy method)

fields (sqlalchemy.dialects.postgresql.INTERVAL parameter)

filter() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.FunctionFilter method)
(sqlalchemy.sql.functions.FunctionElement method)

filter_by() (sqlalchemy.orm.query.Query method)

filter_fn (sqlalchemy.schema.sort_tables_and_constraints parameter)

filter_states_for_dep() (sqlalchemy.orm.session.UOWTransaction method)

finalize_flush_changes() (sqlalchemy.orm.session.UOWTransaction method)

first() (sqlalchemy.engine.ResultProxy method)

(sqlalchemy.ext.baked.Result method)
(sqlalchemy.orm.query.Query method)

first_connect() (sqlalchemy.events.PoolEvents method)

(sqlalchemy.interfaces.PoolListener method)

first_init() (sqlalchemy.orm.events.InstanceEvents method)

flag_dirty() (in module sqlalchemy.orm.attributes)

flag_modified() (in module sqlalchemy.orm.attributes)

flat (sqlalchemy.orm.aliased parameter)

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

FLOAT (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

Float (class in sqlalchemy.types)

flush() (sqlalchemy.orm.session.Session method)

flush_context (sqlalchemy.orm.events.InstanceEvents.refresh_flush parameter)

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

FlushError

for_class() (sqlalchemy.ext.associationproxy.AssociationProxy method)

for_proxy() (sqlalchemy.ext.associationproxy.AssociationProxyInstance class method)

for_session() (sqlalchemy.ext.baked.BakedQuery method)

for_update (sqlalchemy.schema.Sequence parameter)

(sqlalchemy.sql.expression.CompoundSelect attribute)
(sqlalchemy.sql.expression.GenerativeSelect attribute)

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

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

foreign key constraint

foreign() (in module sqlalchemy.orm)

foreign_key_constraints (sqlalchemy.schema.Table attribute)

foreign_keys (sqlalchemy.orm.relationship parameter)

(sqlalchemy.schema.Table attribute)
(sqlalchemy.sql.expression.Alias attribute)

ForeignKey (class in sqlalchemy.schema)

ForeignKeyConstraint (class in sqlalchemy.schema)

format_column() (sqlalchemy.sql.compiler.IdentifierPreparer method)

format_schema() (sqlalchemy.sql.compiler.IdentifierPreparer method)

format_table() (sqlalchemy.sql.compiler.IdentifierPreparer method)

format_table_seq() (sqlalchemy.sql.compiler.IdentifierPreparer method)

FROM clause

from_engine() (sqlalchemy.engine.reflection.Inspector class method)

from_entity (sqlalchemy.orm.query.Query.with_parent parameter)

(sqlalchemy.orm.with_parent parameter)

from_joinpoint (sqlalchemy.orm.query.Query.join parameter)

from_obj (sqlalchemy.orm.query.Query.select_entity_from parameter)

(sqlalchemy.sql.expression.select parameter)

from_select() (sqlalchemy.sql.expression.Insert method)

from_self() (sqlalchemy.orm.query.Query method)

from_statement() (sqlalchemy.orm.query.Query method)

FromClause (class in sqlalchemy.sql.expression)

fromkeys() (sqlalchemy.orm.instrumentation.ClassManager method)

froms (sqlalchemy.sql.expression.Select attribute)

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.Query.join parameter)
(sqlalchemy.schema.Table.join parameter)

func (in module sqlalchemy.sql.expression)

(sqlalchemy.sql.expression.Over attribute)

funcfilter() (in module sqlalchemy.sql.expression)

Function (class in sqlalchemy.sql.functions)

FunctionAsBinary (class in sqlalchemy.sql.functions)

FunctionElement (class in sqlalchemy.sql.functions)

FunctionFilter (class in sqlalchemy.sql.expression)

G

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

generate_relationship() (in module sqlalchemy.ext.automap)

generative

GenerativeSelect (class in sqlalchemy.sql.expression)

GenericFunction (class in sqlalchemy.sql.functions)

GenericTypeCompiler (class in sqlalchemy.sql.compiler)

get() (sqlalchemy.ext.associationproxy.AssociationProxyInstance method)

(sqlalchemy.ext.baked.Result method)
(sqlalchemy.orm.instrumentation.ClassManager method)

get_attribute() (in module sqlalchemy.orm.attributes)

get_attribute_history() (sqlalchemy.orm.session.UOWTransaction method)

get_bind() (sqlalchemy.ext.horizontal_shard.ShardedSession method)

(sqlalchemy.orm.session.Session method)

get_check_constraints() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_children() (sqlalchemy.schema.CheckConstraint method)

(sqlalchemy.schema.Column method)
(sqlalchemy.schema.ColumnCollectionConstraint method)

get_columns() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_current_parameters() (sqlalchemy.engine.default.DefaultExecutionContext method)

get_dbapi_type() (sqlalchemy.types.Date method)

(sqlalchemy.types.DateTime method)
(sqlalchemy.types.Integer method)

get_dialect() (sqlalchemy.engine.url.URL method)

get_dialect_cls() (sqlalchemy.engine.default.DefaultDialect class method)

(sqlalchemy.engine.interfaces.Dialect class method)

get_enums() (sqlalchemy.dialects.postgresql.base.PGInspector method)

get_execution_options() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.Engine method)
(sqlalchemy.orm.query.Query method)

get_foreign_keys() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_foreign_table_names() (sqlalchemy.dialects.postgresql.base.PGInspector method)

get_history() (in module sqlalchemy.orm.attributes)

(sqlalchemy.orm.descriptor_props.CompositeProperty method)

get_indexes() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_instance_dict() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

get_isolation_level() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.default.DefaultDialect method)
(sqlalchemy.engine.interfaces.Dialect method)

get_lastrowid() (sqlalchemy.engine.default.DefaultExecutionContext method)

get_pk_constraint() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_primary_keys() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_property() (sqlalchemy.orm.mapper.Mapper method)

get_property_by_column() (sqlalchemy.orm.mapper.Mapper method)

get_referent() (sqlalchemy.schema.ForeignKey method)

get_result_processor() (sqlalchemy.engine.default.DefaultExecutionContext method)

get_rowcount() (sqlalchemy.engine.interfaces.ExecutionContext method)

get_schema_names() (sqlalchemy.engine.reflection.Inspector method)

get_select_precolumns() (sqlalchemy.sql.compiler.SQLCompiler method)

get_sorted_table_and_fkc_names() (sqlalchemy.engine.reflection.Inspector method)

get_table_comment() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_table_names() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_table_oid() (sqlalchemy.dialects.postgresql.base.PGInspector method)

get_table_options() (sqlalchemy.engine.reflection.Inspector method)

get_temp_table_names() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_temp_view_names() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_unique_constraints() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_view_definition() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

get_view_names() (sqlalchemy.dialects.postgresql.base.PGInspector method)

(sqlalchemy.engine.default.DefaultDialect method)
(sqlalchemy.engine.interfaces.Dialect method)

getset_factory (sqlalchemy.ext.associationproxy.AssociationProxy parameter)

getter() (sqlalchemy.ext.hybrid.hybrid_property method)

group (sqlalchemy.orm.column_property parameter)

(sqlalchemy.orm.composite parameter)

group_by (sqlalchemy.sql.expression.select parameter)

group_by() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.GenerativeSelect method)

group_by_clause() (sqlalchemy.sql.compiler.SQLCompiler method)

grouping_sets (class in sqlalchemy.sql.functions)

H

handle_dbapi_exception() (sqlalchemy.engine.default.DefaultExecutionContext method)

(sqlalchemy.engine.interfaces.ExecutionContext method)

handle_dialect_kwargs() (sqlalchemy.engine.CreateEnginePlugin method)

handle_error() (sqlalchemy.events.ConnectionEvents method)

handle_pool_kwargs() (sqlalchemy.engine.CreateEnginePlugin method)

has() (sqlalchemy.ext.associationproxy.AssociationProxyInstance method)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance method)

has_all() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

(sqlalchemy.dialects.postgresql.JSONB.Comparator method)

has_any() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

(sqlalchemy.dialects.postgresql.JSONB.Comparator method)

has_changes() (sqlalchemy.orm.attributes.History method)

has_identity (sqlalchemy.orm.state.InstanceState attribute)

has_inherited_table() (in module sqlalchemy.ext.declarative)

has_key() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

(sqlalchemy.dialects.postgresql.JSONB.Comparator method)
(sqlalchemy.engine.RowProxy method)

has_parent() (sqlalchemy.orm.instrumentation.ClassManager method)

has_sequence() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

has_table() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.Engine method)
(sqlalchemy.engine.interfaces.Dialect method)

HasCTE (class in sqlalchemy.sql.expression)

hashable (sqlalchemy.types.ARRAY attribute)

(sqlalchemy.types.TypeEngine attribute)

HasPrefixes (class in sqlalchemy.sql.expression)

HasSuffixes (class in sqlalchemy.sql.expression)

having (sqlalchemy.sql.expression.select parameter)

having() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.Select method)

History (class in sqlalchemy.orm.attributes)

history (sqlalchemy.orm.state.AttributeState attribute)

host (sqlalchemy.engine.url.URL parameter)

HSTORE (class in sqlalchemy.dialects.postgresql)

hstore (class in sqlalchemy.dialects.postgresql)

HSTORE.Comparator (class in sqlalchemy.dialects.postgresql)

hybrid_method (class in sqlalchemy.ext.hybrid)

HYBRID_METHOD (in module sqlalchemy.ext.hybrid)

hybrid_property (class in sqlalchemy.ext.hybrid)

HYBRID_PROPERTY (in module sqlalchemy.ext.hybrid)

I

id_chooser (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

ident (sqlalchemy.orm.query.Query.get parameter)

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

Identified (class in sqlalchemy.log)

identifier (sqlalchemy.sql.functions.AnsiFunction attribute)

(sqlalchemy.sql.functions.GenericFunction attribute)
(sqlalchemy.sql.functions.OrderedSetAgg attribute)

IdentifierError

IdentifierPreparer (class in sqlalchemy.sql.compiler)

identity (sqlalchemy.orm.state.InstanceState attribute)

identity map

identity_key (sqlalchemy.orm.state.InstanceState attribute)

identity_key() (in module sqlalchemy.orm.util)

(sqlalchemy.orm.session.Session class method)
(sqlalchemy.orm.session.sessionmaker class method)

identity_key_from_instance() (sqlalchemy.orm.mapper.Mapper method)

identity_key_from_primary_key() (sqlalchemy.orm.mapper.Mapper method)

identity_key_from_row() (sqlalchemy.orm.mapper.Mapper method)

identity_map (sqlalchemy.orm.session.Session attribute)

IdentityMap (class in sqlalchemy.orm.identity)

ilike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

IMAGE (class in sqlalchemy.dialects.mssql)

immediateload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

impl (sqlalchemy.types.Interval attribute)

(sqlalchemy.types.PickleType attribute)

implicit_returning (sqlalchemy.create_engine parameter)

(sqlalchemy.schema.Table parameter)
(sqlalchemy.sql.expression.TableClause attribute)

in_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

in_transaction() (sqlalchemy.engine.Connection method)

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

include_backrefs (sqlalchemy.orm.validates parameter)

include_collections (sqlalchemy.orm.session.Session.is_modified parameter)

include_columns (sqlalchemy.engine.reflection.Inspector.reflecttable 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.Sequence parameter)

Index (class in sqlalchemy.schema)

index (sqlalchemy.ext.indexable.index_property parameter)

(sqlalchemy.schema.Column parameter)

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

(sqlalchemy.dialects.postgresql.dml.Insert.on_conflict_do_update parameter)

index_property (class in sqlalchemy.ext.indexable)

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

(sqlalchemy.dialects.postgresql.dml.Insert.on_conflict_do_update parameter)

Indexable (class in sqlalchemy.types)

Indexable.Comparator (class in sqlalchemy.types)

INET (class in sqlalchemy.dialects.postgresql)

info (sqlalchemy.engine.Connection attribute)

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

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.Mapper attribute)

init() (sqlalchemy.orm.descriptor_props.SynonymProperty method)

(sqlalchemy.orm.events.InstanceEvents method)
(sqlalchemy.orm.interfaces.MapperProperty method)

init_collection() (in module sqlalchemy.orm.attributes)

(sqlalchemy.orm.events.AttributeEvents method)

init_failed() (sqlalchemy.orm.interfaces.MapperExtension method)

init_failure() (sqlalchemy.orm.events.InstanceEvents method)

init_instance() (sqlalchemy.orm.interfaces.MapperExtension method)

init_scalar() (sqlalchemy.orm.events.AttributeEvents method)

initialize() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

initialize_instance_dict() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

initially (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

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

initiator (sqlalchemy.orm.attributes.set_attribute parameter)

(sqlalchemy.orm.events.AttributeEvents.append parameter)
(sqlalchemy.orm.events.AttributeEvents.bulk_replace parameter)

inline (sqlalchemy.schema.Column.compile parameter)

(sqlalchemy.schema.Table.compile parameter)
(sqlalchemy.sql.compiler.SQLCompiler parameter)

inner_columns (sqlalchemy.sql.expression.Select attribute)

innerjoin (sqlalchemy.orm.joinedload parameter)

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

Insert (class in sqlalchemy.dialects.mysql.dml)

(class in sqlalchemy.dialects.postgresql.dml)
(class in sqlalchemy.sql.expression)

insert() (in module sqlalchemy.dialects.mysql.dml)

(in module sqlalchemy.dialects.postgresql.dml)
(in module sqlalchemy.sql.expression)

inserted (sqlalchemy.dialects.mysql.dml.Insert attribute)

inserted_primary_key (sqlalchemy.engine.ResultProxy attribute)

inspect() (in module sqlalchemy.inspection)

InspectionAttr (class in sqlalchemy.orm.base)

InspectionAttrInfo (class in sqlalchemy.orm.base)

Inspector (class in sqlalchemy.engine.reflection)

install_descriptor() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

install_member() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

install_state() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

instance (sqlalchemy.orm.attributes.set_attribute parameter)

(sqlalchemy.orm.events.SessionEvents.detached_to_persistent parameter)
(sqlalchemy.orm.events.SessionEvents.loaded_as_persistent parameter)

instance_state() (in module sqlalchemy.orm.attributes)

InstanceEvents (class in sqlalchemy.orm.events)

instances (sqlalchemy.orm.events.SessionEvents.before_flush parameter)

instances() (sqlalchemy.orm.query.Query method)

InstanceState (class in sqlalchemy.orm.state)

instrument_attribute() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

instrument_class() (sqlalchemy.orm.descriptor_props.CompositeProperty method)

(sqlalchemy.orm.descriptor_props.SynonymProperty method)
(sqlalchemy.orm.events.MapperEvents method)

instrument_collection_class() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

instrument_declarative() (in module sqlalchemy.ext.declarative)

instrumentation

instrumentation_finders (in module sqlalchemy.ext.instrumentation)

INSTRUMENTATION_MANAGER (in module sqlalchemy.ext.instrumentation)

InstrumentationEvents (class in sqlalchemy.orm.events)

InstrumentationFactory (class in sqlalchemy.orm.instrumentation)

InstrumentationManager (class in sqlalchemy.ext.instrumentation)

instrumented

InstrumentedAttribute (class in sqlalchemy.orm.attributes)

InstrumentedDict (class in sqlalchemy.orm.collections)

InstrumentedList (class in sqlalchemy.orm.collections)

InstrumentedSet (class in sqlalchemy.orm.collections)

instrumenting

INT (in module sqlalchemy.types)

INT4RANGE (class in sqlalchemy.dialects.postgresql)

INT8RANGE (class in sqlalchemy.dialects.postgresql)

INTEGER (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

Integer (class in sqlalchemy.types)

IntegrityError

InterfaceError

InternalError

internally_instrumented() (sqlalchemy.orm.collections.collection static method)

intersect() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Select method)

intersect_all() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Select method)

intersection_update() (sqlalchemy.ext.mutable.MutableSet method)

INTERVAL (class in sqlalchemy.dialects.oracle)

(class in sqlalchemy.dialects.postgresql)

Interval (class in sqlalchemy.types)

invalidate() (sqlalchemy.engine.Connection method)

(sqlalchemy.events.PoolEvents method)
(sqlalchemy.orm.session.Session method)

invalidate_pool_on_disconnect (sqlalchemy.engine.ExceptionContext attribute)

invalidated (sqlalchemy.engine.Connection attribute)

InvalidatePoolError

InvalidRequestError

is_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

is_active (sqlalchemy.orm.session.Session attribute)

is_aliased_class (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)

is_attribute (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)

is_bound() (sqlalchemy.schema.MetaData method)

(sqlalchemy.schema.ThreadLocalMetaData method)

is_clause_element (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)
(sqlalchemy.sql.expression.ColumnElement attribute)

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

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

is_deleted() (sqlalchemy.orm.session.UOWTransaction method)

is_derived_from() (sqlalchemy.schema.Table method)

(sqlalchemy.sql.expression.Alias method)
(sqlalchemy.sql.expression.CTE method)

is_disconnect (sqlalchemy.engine.ExceptionContext attribute)

(sqlalchemy.engine.interfaces.ExecutionContext attribute)

is_disconnect() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

is_distinct_from() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

is_insert (sqlalchemy.engine.ResultProxy attribute)

is_instance (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)

is_instrumented() (in module sqlalchemy.orm.instrumentation)

is_literal (sqlalchemy.sql.expression.column parameter)

is_mapper (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)
(sqlalchemy.orm.mapper.Mapper attribute)

is_modified() (sqlalchemy.orm.session.Session method)

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

(sqlalchemy.engine.default.DefaultDialect.do_rollback_twophase parameter)
(sqlalchemy.engine.interfaces.Dialect.do_commit_twophase parameter)

is_property (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)
(sqlalchemy.orm.interfaces.MapperProperty attribute)

is_selectable (sqlalchemy.ext.associationproxy.AssociationProxy attribute)

(sqlalchemy.orm.base.InspectionAttr attribute)
(sqlalchemy.sql.expression.ColumnElement attribute)

is_valid (sqlalchemy.pool._ConnectionFairy attribute)

isa() (sqlalchemy.orm.mapper.Mapper method)

isdelete (sqlalchemy.sql.compiler.SQLCompiler attribute)

isnot() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

isnot_distinct_from() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

isolate_multiinsert_groups (sqlalchemy.engine.default.DefaultExecutionContext.get_current_parameters parameter)

isolated

isolation

isolation_level (sqlalchemy.create_engine parameter)

(sqlalchemy.engine.Connection.execution_options parameter)

isouter (sqlalchemy.orm.query.Query.join parameter)

(sqlalchemy.schema.Table.join parameter)
(sqlalchemy.sql.expression.Alias.join parameter)

isoutparam (sqlalchemy.sql.expression.bindparam parameter)

item_type (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY parameter)

items() (sqlalchemy.engine.RowProxy method)

(sqlalchemy.orm.instrumentation.ClassManager method)

iterate_properties (sqlalchemy.orm.mapper.Mapper attribute)

iterator() (sqlalchemy.orm.collections.collection static method)

J

Join (class in sqlalchemy.sql.expression)

join() (in module sqlalchemy.orm)

(in module sqlalchemy.sql.expression)
(sqlalchemy.orm.query.Query method)

join_depth (sqlalchemy.orm.relationship parameter)

joinedload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

joinedload_all() (in module sqlalchemy.orm)

JSON (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.dialects.postgresql)
(class in sqlalchemy.dialects.sqlite)

JSON.Comparator (class in sqlalchemy.dialects.postgresql)

(class in sqlalchemy.types)

JSON.JSONElementType (class in sqlalchemy.types)

JSON.JSONIndexType (class in sqlalchemy.types)

JSON.JSONPathType (class in sqlalchemy.types)

JSONB (class in sqlalchemy.dialects.postgresql)

JSONB.Comparator (class in 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.CompoundSelect.with_for_update parameter)

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

KeyedTuple (class in sqlalchemy.util)

keys() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

(sqlalchemy.engine.ResultProxy method)
(sqlalchemy.engine.RowProxy method)

kwargs (sqlalchemy.engine.CreateEnginePlugin parameter)

(sqlalchemy.engine_from_config parameter)
(sqlalchemy.orm.events.InstanceEvents.init parameter)

L

Label (class in sqlalchemy.sql.expression)

label() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Bundle method)
(sqlalchemy.orm.query.Query method)

label_length (sqlalchemy.create_engine parameter)

LargeBinary (class in sqlalchemy.types)

last_inserted_params() (sqlalchemy.engine.ResultProxy method)

last_updated_params() (sqlalchemy.engine.ResultProxy method)

lastrow_has_defaults() (sqlalchemy.engine.default.DefaultExecutionContext method)

(sqlalchemy.engine.ResultProxy method)
(sqlalchemy.engine.interfaces.ExecutionContext method)

lastrowid (sqlalchemy.engine.ResultProxy attribute)

Lateral (class in sqlalchemy.sql.expression)

lateral() (in module sqlalchemy.sql.expression)

(sqlalchemy.schema.Table method)
(sqlalchemy.sql.expression.Alias method)

lazy (sqlalchemy.orm.relationship parameter)

lazy_loaded_from (sqlalchemy.orm.query.Query attribute)

lazyload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

left (sqlalchemy.sql.expression.join parameter)

(sqlalchemy.sql.expression.outerjoin parameter)
(sqlalchemy.sql.functions.FunctionAsBinary attribute)

left_index (sqlalchemy.sql.functions.FunctionElement.as_comparison parameter)

legacy_is_orphan (sqlalchemy.orm.mapper parameter)

length (sqlalchemy.dialects.mssql.CHAR parameter)

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

like() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

limit (sqlalchemy.sql.expression.CompoundSelect.limit parameter)

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

limit() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.GenerativeSelect method)

link() (sqlalchemy.orm.collections.collection static method)

link_to_name (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

linker() (sqlalchemy.orm.collections.collection static method)

listen() (in module sqlalchemy.event)

listeners (sqlalchemy.create_engine parameter)

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

listens_for() (in module sqlalchemy.event)

literal() (in module sqlalchemy.sql.expression)

literal_column() (in module sqlalchemy.sql.expression)

literal_processor() (sqlalchemy.types.Boolean method)

(sqlalchemy.types.Integer method)
(sqlalchemy.types.JSON.JSONElementType method)

Load (class in sqlalchemy.orm)

(class in sqlalchemy.orm.strategy_options)

load (sqlalchemy.orm.session.Session.merge parameter)

load() (sqlalchemy.orm.events.InstanceEvents method)

load_dialect_impl() (sqlalchemy.types.TypeDecorator method)

load_history() (sqlalchemy.orm.state.AttributeState method)

load_on_pending (sqlalchemy.orm.relationship parameter)

load_only() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

loaded_as_persistent() (sqlalchemy.orm.events.SessionEvents method)

loaded_value (sqlalchemy.orm.state.AttributeState attribute)

LoaderStrategyException

loads() (in module sqlalchemy.ext.serializer)

local_attr (sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance attribute)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance attribute)

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_table (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.mapper.Mapper attribute)

localtime (class in sqlalchemy.sql.functions)

localtimestamp (class in sqlalchemy.sql.functions)

locate_all_froms() (sqlalchemy.sql.expression.Select method)

lockmode (sqlalchemy.orm.session.Session.refresh parameter)

logging_name (sqlalchemy.create_engine parameter)

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

LONG (class in sqlalchemy.dialects.oracle)

LONGBLOB (class in sqlalchemy.dialects.mysql)

LONGTEXT (class in sqlalchemy.dialects.mysql)

lower_bound (sqlalchemy.sql.expression.between parameter)

M

MACADDR (class in sqlalchemy.dialects.postgresql)

make_transient() (in module sqlalchemy.orm.session)

make_transient_to_detached() (in module sqlalchemy.orm.session)

make_url() (in module sqlalchemy.engine.url)

manage() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

(sqlalchemy.orm.instrumentation.ClassManager method)

manager_getter() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

many to many

many to one

MANYTOMANY (in module sqlalchemy.orm.interfaces)

MANYTOONE (in module sqlalchemy.orm.interfaces)

map_column (sqlalchemy.orm.synonym parameter)

mapped

mapped_collection() (in module sqlalchemy.orm.collections)

mapped_table (sqlalchemy.orm.mapper.Mapper attribute)

MappedCollection (class in sqlalchemy.orm.collections)

Mapper (class in sqlalchemy.orm.mapper)

mapper (sqlalchemy.ext.declarative.declarative_base parameter)

(sqlalchemy.ext.horizontal_shard.ShardedSession.connection parameter)
(sqlalchemy.ext.horizontal_shard.ShardedSession.get_bind parameter)

mapper() (in module sqlalchemy.orm)

mapper_configured() (sqlalchemy.orm.events.MapperEvents method)

MapperEvents (class in sqlalchemy.orm.events)

MapperExtension (class in sqlalchemy.orm.interfaces)

MapperProperty (class in sqlalchemy.orm.interfaces)

mapping

mappings (sqlalchemy.orm.session.Session.bulk_insert_mappings parameter)

(sqlalchemy.orm.session.Session.bulk_update_mappings parameter)

match (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

match() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

MatchType (class in sqlalchemy.types)

matrix() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

max (class in sqlalchemy.sql.functions)

max_overflow (sqlalchemy.create_engine parameter)

(sqlalchemy.pool.QueuePool parameter)

maxvalue (sqlalchemy.schema.Sequence parameter)

MEDIUMBLOB (class in sqlalchemy.dialects.mysql)

MEDIUMINT (class in sqlalchemy.dialects.mysql)

MEDIUMTEXT (class in sqlalchemy.dialects.mysql)

merge() (sqlalchemy.orm.descriptor_props.SynonymProperty method)

(sqlalchemy.orm.interfaces.MapperProperty method)
(sqlalchemy.orm.properties.ColumnProperty method)

merge_result() (sqlalchemy.orm.query.Query method)

metaclass (sqlalchemy.ext.declarative.declarative_base parameter)

MetaData (class in sqlalchemy.schema)

metadata (sqlalchemy.ext.declarative.declarative_base parameter)

(sqlalchemy.schema.Sequence parameter)
(sqlalchemy.schema.Table parameter)

method chaining

min (class in sqlalchemy.sql.functions)

minvalue (sqlalchemy.schema.Sequence parameter)

mode (class in sqlalchemy.sql.functions)

(sqlalchemy.orm.query.Query.with_lockmode parameter)

modified() (sqlalchemy.orm.events.AttributeEvents method)

module (sqlalchemy.create_engine parameter)

MONEY (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.postgresql)

multiparams (sqlalchemy.events.ConnectionEvents.after_execute parameter)

(sqlalchemy.events.ConnectionEvents.before_execute parameter)

MultipleResultsFound

mustexist (sqlalchemy.schema.Table parameter)

Mutable (class in sqlalchemy.ext.mutable)

mutable (sqlalchemy.ext.indexable.index_property parameter)

MutableBase (class in sqlalchemy.ext.mutable)

MutableComposite (class in sqlalchemy.ext.mutable)

MutableDict (class in sqlalchemy.ext.mutable)

MutableList (class in sqlalchemy.ext.mutable)

MutableSet (class in sqlalchemy.ext.mutable)

N

N plus one problem

name (sqlalchemy.dialects.mysql.BOOLEAN parameter)

(sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)
(sqlalchemy.engine.Engine attribute)

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

name_for_collection_relationship() (in module sqlalchemy.ext.automap)

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

name_for_scalar_relationship() (in module sqlalchemy.ext.automap)

names (sqlalchemy.engine.url.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 (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.types)

NCLOB (class in sqlalchemy.dialects.oracle)

nested (sqlalchemy.orm.session.Session.begin parameter)

(sqlalchemy.orm.session.SessionTransaction attribute)

NestedTransaction (class in sqlalchemy.engine)

new (sqlalchemy.orm.session.Session attribute)

new_adapter (sqlalchemy.orm.collections.bulk_replace parameter)

next() (sqlalchemy.engine.ResultProxy method)

next_value (class in sqlalchemy.sql.functions)

next_value() (sqlalchemy.schema.Sequence method)

no_autoflush (sqlalchemy.orm.session.Session attribute)

no_parameters (sqlalchemy.engine.Connection.execution_options parameter)

NO_STATE (in module sqlalchemy.orm.exc)

NoForeignKeysError

NoInspectionAvailable

noload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

nomaxvalue (sqlalchemy.schema.Sequence parameter)

nominvalue (sqlalchemy.schema.Sequence parameter)

non_added() (sqlalchemy.orm.attributes.History method)

non_deleted() (sqlalchemy.orm.attributes.History method)

non_primary (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.mapper.Mapper attribute)

none_as_null (sqlalchemy.dialects.postgresql.JSON parameter)

(sqlalchemy.types.JSON parameter)

NoReferencedColumnError

NoReferencedTableError

NoReferenceError

NoResultFound

normalize_name() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

NoSuchColumnError

NoSuchModuleError

NoSuchTableError

not_() (in module sqlalchemy.sql.expression)

not_extend_left_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

not_extend_right_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

NOT_EXTENSION (in module sqlalchemy.orm.interfaces)

notilike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

notin_() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

notlike() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

NotSupportedError

now (class in sqlalchemy.sql.functions)

nowait (sqlalchemy.sql.expression.CompoundSelect.with_for_update parameter)

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

NTEXT (class in sqlalchemy.dialects.mssql)

Null (class in sqlalchemy.sql.elements)

NULL (sqlalchemy.types.JSON attribute)

null() (in module sqlalchemy.sql.expression)

nullable (sqlalchemy.schema.Column parameter)

NullPool (class in sqlalchemy.pool)

nullsfirst() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

nullslast() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)
(sqlalchemy.orm.attributes.QueryableAttribute method)

NullType (class in sqlalchemy.types)

NUMBER (class in sqlalchemy.dialects.oracle)

NUMERIC (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

Numeric (class in sqlalchemy.types)

NUMRANGE (class in sqlalchemy.dialects.postgresql)

NVARCHAR (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.types)

O

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

(sqlalchemy.orm.attributes.get_history parameter)
(sqlalchemy.orm.attributes.init_collection parameter)

object (sqlalchemy.engine.Connection.execute parameter)

(sqlalchemy.orm.state.InstanceState attribute)

object_mapper() (in module sqlalchemy.orm)

object_session() (in module sqlalchemy.orm.session)

(sqlalchemy.orm.session.Session class method)
(sqlalchemy.orm.session.sessionmaker class method)

object_state() (in module sqlalchemy.orm.util)

ObjectAssociationProxyInstance (class in sqlalchemy.ext.associationproxy)

ObjectDeletedError

ObjectDereferencedError

ObjectNotExecutableError

objects (sqlalchemy.orm.session.Session.bulk_save_objects parameter)

(sqlalchemy.orm.session.Session.flush parameter)

of (sqlalchemy.sql.expression.CompoundSelect.with_for_update parameter)

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

of_type() (sqlalchemy.orm.attributes.QueryableAttribute method)

(sqlalchemy.orm.interfaces.PropComparator method)
(sqlalchemy.orm.properties.ColumnProperty.Comparator method)

offset (sqlalchemy.sql.expression.CompoundSelect.offset parameter)

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

offset() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.GenerativeSelect method)

OID (class in sqlalchemy.dialects.postgresql)

oldvalue (sqlalchemy.orm.events.AttributeEvents.set parameter)

omit_join (sqlalchemy.orm.relationship parameter)

on (sqlalchemy.schema.CreateTable parameter)

(sqlalchemy.schema.DDL parameter)
(sqlalchemy.schema.DDLElement attribute)

on_conflict_do_nothing() (sqlalchemy.dialects.postgresql.dml.Insert method)

on_conflict_do_update() (sqlalchemy.dialects.postgresql.dml.Insert method)

on_connect() (sqlalchemy.engine.default.DefaultDialect method)

on_duplicate_key_update() (sqlalchemy.dialects.mysql.dml.Insert method)

onclause (sqlalchemy.schema.Table.join parameter)

(sqlalchemy.schema.Table.outerjoin parameter)
(sqlalchemy.sql.expression.Alias.join parameter)

ondelete (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

one to many

one() (sqlalchemy.ext.baked.Result method)

(sqlalchemy.orm.query.Query method)

one_or_none() (sqlalchemy.ext.baked.Result method)

(sqlalchemy.orm.query.Query method)

onebased (sqlalchemy.ext.indexable.index_property parameter)

ONETOMANY (in module sqlalchemy.orm.interfaces)

only (sqlalchemy.schema.MetaData.reflect parameter)

only_return_tuples() (sqlalchemy.orm.query.Query method)

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.attributes.QueryableAttribute.operate parameter)
(sqlalchemy.orm.interfaces.PropComparator.operate parameter)

op() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

operate() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

OperationalError

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

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

Operators (class in sqlalchemy.sql.operators)

optional (sqlalchemy.schema.Sequence parameter)

options() (sqlalchemy.orm.query.Query method)

opts (sqlalchemy.events.ConnectionEvents.set_connection_execution_options parameter)

(sqlalchemy.events.ConnectionEvents.set_engine_execution_options parameter)

or_() (in module sqlalchemy.sql.expression)

order (sqlalchemy.schema.Sequence parameter)

order_by (sqlalchemy.engine.reflection.Inspector.get_table_names parameter)

(sqlalchemy.orm.mapper parameter)
(sqlalchemy.orm.relationship parameter)

order_by() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.GenerativeSelect method)

order_by_clause() (sqlalchemy.sql.compiler.SQLCompiler method)

OrderedSetAgg (class in sqlalchemy.sql.functions)

ordering_attr (sqlalchemy.ext.orderinglist.OrderingList parameter)

ordering_func (sqlalchemy.ext.orderinglist.OrderingList parameter)

ordering_list() (in module sqlalchemy.ext.orderinglist)

OrderingList (class in sqlalchemy.ext.orderinglist)

orig (sqlalchemy.exc.StatementError attribute)

original_exception (sqlalchemy.engine.ExceptionContext attribute)

original_init (sqlalchemy.orm.instrumentation.ClassManager attribute)

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

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

outerjoin() (in module sqlalchemy.orm)

(in module sqlalchemy.sql.expression)
(sqlalchemy.orm.query.Query method)

outparam() (in module sqlalchemy.sql.expression)

Over (class in sqlalchemy.sql.expression)

over() (in module sqlalchemy.sql.expression)

(sqlalchemy.sql.expression.FunctionFilter method)
(sqlalchemy.sql.expression.WithinGroup method)

overlap() (sqlalchemy.dialects.postgresql.ARRAY.Comparator method)

overlaps() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

overrides (sqlalchemy.ext.hybrid.hybrid_property attribute)

P

packagenames (sqlalchemy.sql.functions.FunctionElement attribute)

parameters (sqlalchemy.engine.ExceptionContext attribute)

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

params (sqlalchemy.engine.interfaces.Compiled attribute)

(sqlalchemy.engine.interfaces.Compiled.construct_params parameter)
(sqlalchemy.events.ConnectionEvents.after_execute parameter)

params() (sqlalchemy.ext.baked.Result method)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Alias method)

paramstyle (sqlalchemy.create_engine parameter)

parent (sqlalchemy.events.DDLEvents.after_parent_attach parameter)

(sqlalchemy.events.DDLEvents.before_parent_attach parameter)
(sqlalchemy.orm.attributes.QueryableAttribute attribute)

partition_by (sqlalchemy.sql.expression.over parameter)

passive (sqlalchemy.orm.attributes.get_history parameter)

(sqlalchemy.orm.session.Session.is_modified parameter)

passive_deletes (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.relationship parameter)

passive_updates (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.relationship parameter)

PassiveDefault (class in sqlalchemy.schema)

password (sqlalchemy.engine.url.URL parameter)

pending

(sqlalchemy.orm.state.InstanceState attribute)

pending_to_persistent() (sqlalchemy.orm.events.SessionEvents method)

pending_to_transient() (sqlalchemy.orm.events.SessionEvents method)

percent_rank (class in sqlalchemy.sql.functions)

percentile_cont (class in sqlalchemy.sql.functions)

percentile_disc (class in sqlalchemy.sql.functions)

persist_selectable (sqlalchemy.orm.mapper.Mapper attribute)

persistent

(sqlalchemy.orm.state.InstanceState attribute)

persistent_to_deleted() (sqlalchemy.orm.events.SessionEvents method)

persistent_to_detached() (sqlalchemy.orm.events.SessionEvents method)

persistent_to_transient() (sqlalchemy.orm.events.SessionEvents method)

PGInspector (class in sqlalchemy.dialects.postgresql.base)

pickle() (sqlalchemy.orm.events.InstanceEvents method)

pickler (sqlalchemy.types.PickleType parameter)

PickleType (class in sqlalchemy.types)

plugins (sqlalchemy.create_engine parameter)

polymorphic

polymorphic_identity (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.mapper.Mapper attribute)

polymorphic_iterator() (sqlalchemy.orm.mapper.Mapper method)

polymorphic_load (sqlalchemy.orm.mapper parameter)

polymorphic_map (sqlalchemy.orm.mapper.Mapper attribute)

polymorphic_on (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.mapper.Mapper attribute)
(sqlalchemy.orm.with_polymorphic parameter)

polymorphic_union() (in module sqlalchemy.orm.util)

polymorphically

Pool (class in sqlalchemy.pool)

pool (sqlalchemy.create_engine parameter)

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 (class in sqlalchemy.events)

PoolListener (class in sqlalchemy.interfaces)

pop() (sqlalchemy.ext.mutable.MutableDict method)

(sqlalchemy.ext.mutable.MutableList method)
(sqlalchemy.ext.mutable.MutableSet method)

popitem() (sqlalchemy.ext.mutable.MutableDict method)

(sqlalchemy.orm.collections.MappedCollection method)
(sqlalchemy.orm.instrumentation.ClassManager method)

populate_existing() (sqlalchemy.orm.query.Query method)

port (sqlalchemy.engine.url.URL parameter)

post_configure_attribute() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

post_exec() (sqlalchemy.engine.default.DefaultExecutionContext method)

(sqlalchemy.engine.interfaces.ExecutionContext method)

post_instrument_class() (sqlalchemy.orm.descriptor_props.SynonymProperty method)

(sqlalchemy.orm.interfaces.MapperProperty method)
(sqlalchemy.orm.properties.ColumnProperty method)

post_update (sqlalchemy.orm.relationship parameter)

postfetch_cols() (sqlalchemy.engine.ResultProxy method)

pre_exec() (sqlalchemy.engine.default.DefaultExecutionContext method)

(sqlalchemy.engine.interfaces.ExecutionContext method)

pre_ping (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

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

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

precision (sqlalchemy.dialects.mssql.REAL parameter)

(sqlalchemy.dialects.mysql.DECIMAL parameter)
(sqlalchemy.dialects.mysql.DOUBLE parameter)

prefetch_cols() (sqlalchemy.engine.ResultProxy method)

prefix (sqlalchemy.engine_from_config parameter)

prefix_with() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.Delete method)
(sqlalchemy.sql.expression.HasPrefixes method)

prefixes (sqlalchemy.schema.Table parameter)

prepare() (sqlalchemy.engine.TwoPhaseTransaction method)

(sqlalchemy.ext.automap.AutomapBase class method)
(sqlalchemy.ext.declarative.DeferredReflection class method)

prepare_instrumentation() (in module sqlalchemy.orm.collections)

prepare_twophase() (sqlalchemy.events.ConnectionEvents method)

(sqlalchemy.interfaces.ConnectionProxy method)

preparer (sqlalchemy.engine.default.DefaultDialect attribute)

preserve_order (sqlalchemy.orm.session.Session.bulk_save_objects parameter)

preserve_parameter_order (sqlalchemy.sql.expression.update parameter)

previous_transaction (sqlalchemy.orm.events.SessionEvents.after_soft_rollback parameter)

primary key

primary key constraint

primary_key (sqlalchemy.orm.mapper parameter)

(sqlalchemy.orm.mapper.Mapper attribute)
(sqlalchemy.orm.mapper.Mapper.identity_key_from_primary_key parameter)

primary_key_from_instance() (sqlalchemy.orm.mapper.Mapper method)

primary_mapper() (sqlalchemy.orm.mapper.Mapper method)

primaryjoin (sqlalchemy.orm.relationship parameter)

PrimaryKeyConstraint (class in sqlalchemy.schema)

process_bind_param() (sqlalchemy.types.TypeDecorator method)

process_literal_param() (sqlalchemy.types.TypeDecorator method)

process_query() (sqlalchemy.orm.strategy_options.Load method)

process_query_conditionally() (sqlalchemy.orm.strategy_options.Load method)

process_result_value() (sqlalchemy.types.TypeDecorator method)

ProgrammingError

propagate (sqlalchemy.orm.events.AttributeEvents parameter)

(sqlalchemy.orm.events.InstanceEvents parameter)
(sqlalchemy.orm.events.MapperEvents parameter)

PropComparator (class in sqlalchemy.orm.interfaces)

properties (sqlalchemy.orm.mapper parameter)

property (sqlalchemy.orm.attributes.QueryableAttribute attribute)

(sqlalchemy.orm.query.Query.with_parent parameter)
(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 attribute)

prune() (sqlalchemy.orm.session.Session method)

python_type (sqlalchemy.types.ARRAY attribute)

(sqlalchemy.types.Boolean attribute)
(sqlalchemy.types.Date attribute)

Q

Query (class in sqlalchemy.orm.query)

query (sqlalchemy.engine.url.URL parameter)

(sqlalchemy.orm.events.QueryEvents.before_compile_delete parameter)
(sqlalchemy.orm.events.QueryEvents.before_compile_update parameter)

query() (sqlalchemy.orm.session.Session method)

query_chooser (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

query_class (sqlalchemy.orm.relationship parameter)

query_cls (sqlalchemy.orm.session.Session parameter)

query_expression() (in module sqlalchemy.orm)

query_or_session (sqlalchemy.ext.baked.BakedQuery.to_query parameter)

query_property() (sqlalchemy.orm.scoping.scoped_session method)

QueryableAttribute (class in sqlalchemy.orm.attributes)

QueryContext (class in sqlalchemy.orm.query)

QueryEvents (class in sqlalchemy.orm.events)

QueuePool (class in sqlalchemy.pool)

quote (sqlalchemy.schema.CheckConstraint attribute)

(sqlalchemy.schema.Column attribute)
(sqlalchemy.schema.Column parameter)

quote() (sqlalchemy.sql.compiler.IdentifierPreparer method)

quote_identifier() (sqlalchemy.sql.compiler.IdentifierPreparer method)

quote_schema (sqlalchemy.schema.MetaData parameter)

(sqlalchemy.schema.Sequence parameter)
(sqlalchemy.schema.Table attribute)

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

quoted_name (class in sqlalchemy.sql.elements)

quoting (sqlalchemy.dialects.mysql.ENUM parameter)

(sqlalchemy.dialects.mysql.SET parameter)

R

raiseerr (sqlalchemy.inspection.inspect parameter)

raiseload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

random (class in sqlalchemy.sql.functions)

range_ (sqlalchemy.sql.expression.over parameter)

RangeOperators (class in sqlalchemy.dialects.postgresql.ranges)

RangeOperators.comparator_factory (class in sqlalchemy.dialects.postgresql.ranges)

rank (class in sqlalchemy.sql.functions)

RAW (class in sqlalchemy.dialects.oracle)

raw (sqlalchemy.orm.events.AttributeEvents parameter)

(sqlalchemy.orm.events.InstanceEvents parameter)
(sqlalchemy.orm.events.MapperEvents parameter)

raw_connection() (sqlalchemy.engine.Engine method)

read (sqlalchemy.sql.expression.CompoundSelect.with_for_update parameter)

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

REAL (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.dialects.postgresql)

reconstruct_instance() (sqlalchemy.orm.interfaces.MapperExtension method)

reconstructor() (in module sqlalchemy.orm)

record_info (sqlalchemy.pool._ConnectionFairy attribute)

(sqlalchemy.pool._ConnectionRecord attribute)

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

(sqlalchemy.engine.default.DefaultDialect.do_rollback_twophase parameter)
(sqlalchemy.engine.interfaces.Dialect.do_commit_twophase parameter)

recreate() (sqlalchemy.pool.Pool method)

recursive (sqlalchemy.sql.expression.CompoundSelect.cte parameter)

(sqlalchemy.sql.expression.Delete.cte parameter)
(sqlalchemy.sql.expression.GenerativeSelect.cte parameter)

recycle (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

reduce_columns (sqlalchemy.orm.query.Query.subquery parameter)

reduce_columns() (sqlalchemy.sql.expression.Select method)

refcolumns (sqlalchemy.schema.ForeignKeyConstraint parameter)

references() (sqlalchemy.schema.Column method)

(sqlalchemy.schema.ForeignKey method)

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.tometadata parameter)

referred_table (sqlalchemy.schema.ForeignKeyConstraint attribute)

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

(sqlalchemy.schema.MetaData parameter)

reflect() (sqlalchemy.schema.MetaData method)

reflecttable() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)
(sqlalchemy.engine.reflection.Inspector method)

refresh() (sqlalchemy.orm.events.InstanceEvents method)

(sqlalchemy.orm.session.Session method)

refresh_flush() (sqlalchemy.orm.events.InstanceEvents method)

REGCLASS (class in sqlalchemy.dialects.postgresql)

regexp (sqlalchemy.dialects.sqlite.DATE parameter)

(sqlalchemy.dialects.sqlite.DATETIME parameter)
(sqlalchemy.dialects.sqlite.TIME parameter)

register_function() (in module sqlalchemy.sql.functions)

relation() (in module sqlalchemy.orm)

relationship

relationship() (in module sqlalchemy.orm)

RelationshipProperty (class in sqlalchemy.orm.properties)

RelationshipProperty.Comparator (class in sqlalchemy.orm.properties)

relationships

(sqlalchemy.orm.mapper.Mapper attribute)

release

release_savepoint() (sqlalchemy.events.ConnectionEvents method)

(sqlalchemy.interfaces.ConnectionProxy method)

released

releases

remote() (in module sqlalchemy.orm)

remote_attr (sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance attribute)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance attribute)

remote_side (sqlalchemy.orm.relationship parameter)

remove() (in module sqlalchemy.event)

(sqlalchemy.ext.mutable.MutableList method)
(sqlalchemy.ext.mutable.MutableSet method)

remove_state() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

remove_state_actions() (sqlalchemy.orm.session.UOWTransaction method)

remover() (sqlalchemy.orm.collections.collection static method)

removes() (sqlalchemy.orm.collections.collection static method)

removes_return() (sqlalchemy.orm.collections.collection static method)

render_literal_value() (sqlalchemy.sql.compiler.SQLCompiler method)

render_nulls (sqlalchemy.orm.session.Session.bulk_insert_mappings parameter)

render_table_with_column_in_update_from (sqlalchemy.sql.compiler.SQLCompiler attribute)

reorder() (sqlalchemy.ext.orderinglist.OrderingList method)

reorder_on_append (sqlalchemy.ext.orderinglist.OrderingList parameter)

replace() (sqlalchemy.sql.expression.ColumnCollection method)

replace_selectable() (sqlalchemy.schema.Table method)

(sqlalchemy.sql.expression.Alias method)
(sqlalchemy.sql.expression.CTE method)

replaces() (sqlalchemy.orm.collections.collection static method)

require_embedded (sqlalchemy.schema.Table.corresponding_column parameter)

(sqlalchemy.sql.expression.Alias.corresponding_column parameter)
(sqlalchemy.sql.expression.CTE.corresponding_column parameter)

required (sqlalchemy.sql.expression.bindparam parameter)

reset() (sqlalchemy.events.PoolEvents method)

reset_isolation_level() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

reset_joinpoint() (sqlalchemy.orm.query.Query method)

reset_on_return (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

resolve_fks (sqlalchemy.schema.MetaData.reflect parameter)

(sqlalchemy.schema.Table parameter)

ResourceClosedError

Result (class in sqlalchemy.ext.baked)

result (sqlalchemy.events.ConnectionEvents.after_execute parameter)

result() (sqlalchemy.engine.interfaces.ExecutionContext method)

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

(sqlalchemy.types.Boolean method)
(sqlalchemy.types.Float method)

ResultProxy (class in sqlalchemy.engine)

retrieve_as_bitwise (sqlalchemy.dialects.mysql.SET parameter)

return_defaults (sqlalchemy.orm.session.Session.bulk_insert_mappings parameter)

(sqlalchemy.orm.session.Session.bulk_save_objects parameter)

return_defaults() (sqlalchemy.sql.expression.Insert method)

(sqlalchemy.sql.expression.Update method)
(sqlalchemy.sql.expression.ValuesBase method)

return_fn (sqlalchemy.ext.automap.generate_relationship parameter)

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

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

returned_defaults (sqlalchemy.engine.ResultProxy attribute)

RETURNING

returning (sqlalchemy.sql.compiler.SQLCompiler attribute)

returning() (sqlalchemy.sql.expression.Delete method)

(sqlalchemy.sql.expression.Insert method)
(sqlalchemy.sql.expression.Update method)

returning_precedes_values (sqlalchemy.sql.compiler.SQLCompiler attribute)

returns_rows (sqlalchemy.engine.ResultProxy attribute)

ReturnTypeFromArgs (class in sqlalchemy.sql.functions)

retval (sqlalchemy.events.ConnectionEvents parameter)

(sqlalchemy.orm.events.AttributeEvents parameter)
(sqlalchemy.orm.events.MapperEvents parameter)

reverse() (sqlalchemy.ext.mutable.MutableList method)

reverse_operate() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

right (sqlalchemy.schema.Table.join parameter)

(sqlalchemy.schema.Table.outerjoin parameter)
(sqlalchemy.sql.expression.Alias.join parameter)

right_index (sqlalchemy.sql.functions.FunctionElement.as_comparison parameter)

rollback() (sqlalchemy.engine.Transaction method)

(sqlalchemy.events.ConnectionEvents method)
(sqlalchemy.interfaces.ConnectionProxy method)

rollback_savepoint() (sqlalchemy.events.ConnectionEvents method)

(sqlalchemy.interfaces.ConnectionProxy method)

rollback_twophase() (sqlalchemy.events.ConnectionEvents method)

(sqlalchemy.interfaces.ConnectionProxy method)

rollup (class in sqlalchemy.sql.functions)

row (sqlalchemy.orm.mapper.Mapper.identity_key_from_row parameter)

rowcount (sqlalchemy.engine.ResultProxy attribute)

RowProxy (class in sqlalchemy.engine)

rows (sqlalchemy.sql.expression.over parameter)

ROWVERSION (class in sqlalchemy.dialects.mssql)

run_callable() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.Engine method)

S

SADeprecationWarning

sampling (sqlalchemy.sql.expression.tablesample parameter)

SAPendingDeprecationWarning

savepoint() (sqlalchemy.events.ConnectionEvents method)

(sqlalchemy.interfaces.ConnectionProxy method)

SAWarning

scalar (sqlalchemy.ext.associationproxy.AssociationProxyInstance attribute)

(sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance attribute)
(sqlalchemy.ext.associationproxy.ObjectAssociationProxyInstance attribute)

scalar() (sqlalchemy.engine.Connectable method)

(sqlalchemy.engine.Connection method)
(sqlalchemy.engine.Engine method)

ScalarSelect (class in 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.Engine.table_names parameter)

schema_for_object (sqlalchemy.engine.Connection attribute)

(sqlalchemy.engine.Engine attribute)

schema_translate_map (sqlalchemy.engine.Connection.execution_options parameter)

(sqlalchemy.engine.interfaces.Compiled parameter)
(sqlalchemy.sql.compiler.DDLCompiler parameter)

SchemaEventTarget (class in sqlalchemy.events)

SchemaItem (class in sqlalchemy.schema)

SchemaType (class in sqlalchemy.types)

scoped_session (class in sqlalchemy.orm.scoping)

ScopedRegistry (class in sqlalchemy.util)

scopefunc (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 (class in sqlalchemy.sql.expression)

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

select() (in module sqlalchemy.sql.expression)

(sqlalchemy.schema.Table method)
(sqlalchemy.sql.expression.Alias method)

select_entity_from() (sqlalchemy.orm.query.Query method)

select_from() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.Select method)

Selectable (class in sqlalchemy.sql.expression)

selectable (sqlalchemy.orm.mapper.Mapper attribute)

(sqlalchemy.orm.query.Query attribute)
(sqlalchemy.orm.with_polymorphic parameter)

SelectBase (class in sqlalchemy.sql.expression)

selectin_polymorphic() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

selectinload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

selectinload_all() (in module sqlalchemy.orm)

self_and_descendants (sqlalchemy.orm.mapper.Mapper attribute)

self_group() (sqlalchemy.schema.Column method)

(sqlalchemy.schema.Table method)
(sqlalchemy.sql.expression.Alias method)

Sequence (class in sqlalchemy.schema)

Serializer() (in module sqlalchemy.ext.serializer)

server_default (sqlalchemy.schema.Column parameter)

server_onupdate (sqlalchemy.schema.Column parameter)

Session

(class in sqlalchemy.orm.session)

session (sqlalchemy.orm.events.SessionEvents.after_begin parameter)

(sqlalchemy.orm.events.SessionEvents.after_commit parameter)
(sqlalchemy.orm.events.SessionEvents.after_flush parameter)

session_factory (sqlalchemy.orm.scoping.scoped_session attribute)

(sqlalchemy.orm.scoping.scoped_session parameter)

session_user (class in sqlalchemy.sql.functions)

SessionEvents (class in sqlalchemy.orm.events)

SessionExtension (class in sqlalchemy.orm.interfaces)

sessionmaker (class in sqlalchemy.orm.session)

SessionTransaction (class in sqlalchemy.orm.session)

SET (class in sqlalchemy.dialects.mysql)

set() (sqlalchemy.ext.associationproxy.AssociationProxyInstance method)

(sqlalchemy.orm.collections.MappedCollection method)
(sqlalchemy.orm.events.AttributeEvents method)

set_ (sqlalchemy.dialects.postgresql.dml.Insert.on_conflict_do_update parameter)

set_attribute() (in module sqlalchemy.orm.attributes)

set_committed_value() (in module sqlalchemy.orm.attributes)

set_connection_execution_options() (sqlalchemy.events.ConnectionEvents method)

set_engine_execution_options() (sqlalchemy.events.ConnectionEvents method)

set_input_sizes() (sqlalchemy.engine.default.DefaultExecutionContext method)

set_isolation_level() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect method)

set_parent() (sqlalchemy.orm.descriptor_props.SynonymProperty method)

(sqlalchemy.orm.interfaces.MapperProperty method)
(sqlalchemy.orm.properties.ColumnProperty method)

set_shard() (sqlalchemy.ext.horizontal_shard.ShardedQuery method)

setdefault() (sqlalchemy.ext.mutable.MutableDict method)

(sqlalchemy.orm.collections.MappedCollection method)
(sqlalchemy.orm.instrumentation.ClassManager method)

setter() (sqlalchemy.ext.hybrid.hybrid_property method)

setup() (sqlalchemy.orm.descriptor_props.SynonymProperty method)

(sqlalchemy.orm.interfaces.MapperProperty method)
(sqlalchemy.orm.properties.ColumnProperty method)

shard_chooser (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

ShardedQuery (class in sqlalchemy.ext.horizontal_shard)

ShardedSession (class in sqlalchemy.ext.horizontal_shard)

shards (sqlalchemy.ext.horizontal_shard.ShardedSession parameter)

shares_lineage() (sqlalchemy.schema.Column method)

(sqlalchemy.sql.expression.ColumnElement method)

should_autocommit_text() (sqlalchemy.engine.default.DefaultExecutionContext method)

(sqlalchemy.engine.interfaces.ExecutionContext method)

should_evaluate_none (sqlalchemy.types.JSON attribute)

(sqlalchemy.types.TypeEngine attribute)

single (sqlalchemy.orm.mapper.Mapper attribute)

single_entity (sqlalchemy.orm.query.Bundle attribute)

(sqlalchemy.orm.query.Bundle parameter)

single_parent (sqlalchemy.orm.relationship parameter)

SingletonThreadPool (class in sqlalchemy.pool)

skip_fn (sqlalchemy.schema.sort_tables parameter)

skip_locked (sqlalchemy.sql.expression.CompoundSelect.with_for_update parameter)

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

slice() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

(sqlalchemy.orm.query.Query method)

SMALLDATETIME (class in sqlalchemy.dialects.mssql)

SMALLINT (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

SmallInteger (class in sqlalchemy.types)

SMALLMONEY (class in sqlalchemy.dialects.mssql)

soft (sqlalchemy.pool._ConnectionFairy.invalidate parameter)

(sqlalchemy.pool._ConnectionRecord.invalidate parameter)

soft_invalidate() (sqlalchemy.events.PoolEvents method)

sort() (sqlalchemy.ext.mutable.MutableList method)

sort_tables() (in module sqlalchemy.schema)

sort_tables_and_constraints() (in module sqlalchemy.schema)

sorted_tables (sqlalchemy.schema.MetaData attribute)

spoil() (sqlalchemy.ext.baked.BakedQuery method)

sql_compiler (sqlalchemy.engine.interfaces.Compiled attribute)

(sqlalchemy.sql.compiler.SQLCompiler attribute)

sql_only (sqlalchemy.orm.raiseload parameter)

SQL_VARIANT (class in sqlalchemy.dialects.mssql)

sqlalchemy.dialects.firebird.base (module)

sqlalchemy.dialects.firebird.fdb (module)

sqlalchemy.dialects.firebird.kinterbasdb (module)

sqlalchemy.dialects.mssql.adodbapi (module)

sqlalchemy.dialects.mssql.base (module)

sqlalchemy.dialects.mssql.mxodbc (module)

sqlalchemy.dialects.mssql.pymssql (module)

sqlalchemy.dialects.mssql.pyodbc (module)

sqlalchemy.dialects.mssql.zxjdbc (module)

sqlalchemy.dialects.mysql.base (module)

sqlalchemy.dialects.mysql.cymysql (module)

sqlalchemy.dialects.mysql.gaerdbms (module)

sqlalchemy.dialects.mysql.mysqlconnector (module)

sqlalchemy.dialects.mysql.mysqldb (module)

sqlalchemy.dialects.mysql.oursql (module)

sqlalchemy.dialects.mysql.pymysql (module)

sqlalchemy.dialects.mysql.pyodbc (module)

sqlalchemy.dialects.mysql.zxjdbc (module)

sqlalchemy.dialects.oracle.base (module)

sqlalchemy.dialects.oracle.cx_oracle (module)

sqlalchemy.dialects.oracle.zxjdbc (module)

sqlalchemy.dialects.postgresql.base (module)

sqlalchemy.dialects.postgresql.pg8000 (module)

sqlalchemy.dialects.postgresql.psycopg2 (module)

sqlalchemy.dialects.postgresql.psycopg2cffi (module)

sqlalchemy.dialects.postgresql.pygresql (module)

sqlalchemy.dialects.postgresql.pypostgresql (module)

sqlalchemy.dialects.postgresql.zxjdbc (module)

sqlalchemy.dialects.sqlite (module)

sqlalchemy.dialects.sqlite.base (module)

sqlalchemy.dialects.sqlite.pysqlcipher (module)

sqlalchemy.dialects.sqlite.pysqlite (module)

sqlalchemy.dialects.sybase.base (module)

sqlalchemy.dialects.sybase.mxodbc (module)

sqlalchemy.dialects.sybase.pyodbc (module)

sqlalchemy.dialects.sybase.pysybase (module)

sqlalchemy.engine (module)

sqlalchemy.exc (module)

sqlalchemy.ext.associationproxy (module)

sqlalchemy.ext.automap (module)

sqlalchemy.ext.baked (module)

sqlalchemy.ext.compiler (module)

sqlalchemy.ext.declarative (module)

sqlalchemy.ext.horizontal_shard (module)

sqlalchemy.ext.hybrid (module)

sqlalchemy.ext.indexable (module)

sqlalchemy.ext.instrumentation (module)

sqlalchemy.ext.mutable (module)

sqlalchemy.ext.orderinglist (module)

sqlalchemy.ext.serializer (module)

sqlalchemy.inspection (module)

sqlalchemy.interfaces (module)

sqlalchemy.orm (module) , [20] , [20] , [20] , [20] , [20] , [20] , [20] , [20] , [20] , [20]

sqlalchemy.orm.exc (module)

sqlalchemy.orm.instrumentation (module)

sqlalchemy.orm.interfaces (module)

sqlalchemy.orm.session (module) , [20]

sqlalchemy.pool (module)

sqlalchemy.schema (module) , [20] , [20] , [20] , [20] , [20]

sqlalchemy.sql.expression (module) , [20] , [20] , [20] , [20]

sqlalchemy.sql.functions (module)

sqlalchemy.types (module) , [20] , [20]

sqlalchemy_exception (sqlalchemy.engine.ExceptionContext attribute)

SQLAlchemyError

SQLCompiler (class in sqlalchemy.sql.compiler)

sqltext (sqlalchemy.schema.CheckConstraint parameter)

StaleDataError

start (sqlalchemy.schema.Sequence parameter)

startswith() (sqlalchemy.ext.associationproxy.ColumnAssociationProxyInstance method)

(sqlalchemy.orm.attributes.QueryableAttribute method)
(sqlalchemy.orm.interfaces.PropComparator method)

state (sqlalchemy.orm.mapper.Mapper.cascade_iterator parameter)

(sqlalchemy.schema.DDLElement.execute_if parameter)

state_dict (sqlalchemy.orm.events.InstanceEvents.pickle parameter)

(sqlalchemy.orm.events.InstanceEvents.unpickle parameter)

state_getter() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

(sqlalchemy.orm.instrumentation.ClassManager method)

statement (sqlalchemy.engine.ExceptionContext attribute)

(sqlalchemy.engine.interfaces.Compiled parameter)
(sqlalchemy.events.ConnectionEvents.after_cursor_execute parameter)

statement_compiler (sqlalchemy.engine.default.DefaultDialect attribute)

StatementError

StaticPool (class in sqlalchemy.pool)

storage_format (sqlalchemy.dialects.sqlite.DATE parameter)

(sqlalchemy.dialects.sqlite.DATETIME parameter)
(sqlalchemy.dialects.sqlite.TIME parameter)

strategy (sqlalchemy.create_engine parameter)

stream_results (sqlalchemy.engine.Connection.execution_options parameter)

strict (sqlalchemy.dialects.mysql.ENUM parameter)

strictly_left_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

strictly_right_of() (sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory method)

String (class in sqlalchemy.types)

StrSQLCompiler (class in sqlalchemy.sql.compiler)

subject (sqlalchemy.inspection.inspect parameter)

subquery

subquery() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)

subqueryload() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

subqueryload_all() (in module sqlalchemy.orm)

subtransactions (sqlalchemy.orm.session.Session.begin parameter)

suffix_with() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CTE method)
(sqlalchemy.sql.expression.HasSuffixes method)

sum (class in sqlalchemy.sql.functions)

sum() (sqlalchemy.orm.attributes.History method)

supports_execution (sqlalchemy.sql.expression.ColumnElement attribute)

supports_sane_multi_rowcount() (sqlalchemy.engine.ResultProxy method)

supports_sane_rowcount() (sqlalchemy.engine.ResultProxy method)

symmetric (sqlalchemy.sql.expression.between parameter)

symmetric_difference_update() (sqlalchemy.ext.mutable.MutableSet method)

synchronize_session (sqlalchemy.orm.query.Query.delete parameter)

(sqlalchemy.orm.query.Query.update parameter)

synonym() (in module sqlalchemy.orm)

synonym_for() (in module sqlalchemy.ext.declarative)

SynonymProperty (class in sqlalchemy.orm.descriptor_props)

synonyms (sqlalchemy.orm.mapper.Mapper attribute)

sysdate (class in sqlalchemy.sql.functions)

system (sqlalchemy.schema.Column parameter)

T

Table (class in sqlalchemy.schema)

table (sqlalchemy.engine.reflection.Inspector.reflecttable parameter)

(sqlalchemy.ext.automap.classname_for_table parameter)
(sqlalchemy.orm.session.Session.bind_table parameter)

table() (in module sqlalchemy.sql.expression)

table_map (sqlalchemy.orm.util.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 method)

TableClause (class in sqlalchemy.sql.expression)

tablename (sqlalchemy.ext.automap.classname_for_table parameter)

tables (sqlalchemy.orm.mapper.Mapper attribute)

(sqlalchemy.schema.MetaData attribute)
(sqlalchemy.schema.MetaData.create_all parameter)

TableSample (class in sqlalchemy.sql.expression)

tablesample() (in module sqlalchemy.sql.expression)

(sqlalchemy.schema.Table method)
(sqlalchemy.sql.expression.Alias method)

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 attribute)

target_collection (sqlalchemy.ext.associationproxy.association_proxy parameter)

(sqlalchemy.ext.associationproxy.AssociationProxy parameter)

target_fullname (sqlalchemy.schema.ForeignKey attribute)

TEXT (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.types)

Text (class in sqlalchemy.types)

text (sqlalchemy.sql.expression.column parameter)

(sqlalchemy.sql.expression.Delete.with_hint parameter)
(sqlalchemy.sql.expression.Insert.with_hint parameter)

text() (in module sqlalchemy.sql.expression)

text_type (sqlalchemy.dialects.postgresql.HSTORE parameter)

TextAsFrom (class in sqlalchemy.sql.expression)

TextClause (class in sqlalchemy.sql.expression)

thread safety

Connection
Transaction

ThreadLocalMetaData (class in sqlalchemy.schema)

ThreadLocalRegistry (class in sqlalchemy.util)

TIME (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.dialects.sqlite)

Time (class in sqlalchemy.types)

timeout (sqlalchemy.pool.QueuePool parameter)

TimeoutError

TIMESTAMP (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.types)

timetuple (sqlalchemy.sql.expression.ColumnElement attribute)

(sqlalchemy.sql.operators.ColumnOperators attribute)

timezone (sqlalchemy.dialects.mssql.SMALLDATETIME parameter)

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

TINYBLOB (class in sqlalchemy.dialects.mysql)

TINYINT (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)

TINYTEXT (class in sqlalchemy.dialects.mysql)

to_query() (sqlalchemy.ext.baked.BakedQuery method)

tometadata() (sqlalchemy.schema.Table method)

Transaction (class in sqlalchemy.engine)

transaction (sqlalchemy.orm.events.SessionEvents.after_begin parameter)

(sqlalchemy.orm.events.SessionEvents.after_transaction_create parameter)
(sqlalchemy.orm.events.SessionEvents.after_transaction_end parameter)

transaction() (sqlalchemy.engine.Connection method)

(sqlalchemy.engine.Engine method)

transient

(sqlalchemy.orm.state.InstanceState attribute)

transient_to_pending() (sqlalchemy.orm.events.SessionEvents method)

translate_connect_args() (sqlalchemy.engine.url.URL method)

true() (in module sqlalchemy.sql.expression)

True_ (class in sqlalchemy.sql.elements)

TSRANGE (class in sqlalchemy.dialects.postgresql)

TSTZRANGE (class in sqlalchemy.dialects.postgresql)

TSVECTOR (class in sqlalchemy.dialects.postgresql)

Tuple (class in sqlalchemy.sql.expression)

tuple_() (in module sqlalchemy.sql.expression)

twophase (sqlalchemy.orm.session.Session parameter)

TwoPhaseTransaction (class in sqlalchemy.engine)

type (sqlalchemy.dialects.postgresql.hstore attribute)

(sqlalchemy.sql.expression.ColumnElement attribute)
(sqlalchemy.sql.expression.column parameter)

type_ (sqlalchemy.orm.mapper.Mapper.cascade_iterator parameter)

(sqlalchemy.schema.Column parameter)
(sqlalchemy.sql.expression.bindparam parameter)

type_coerce() (in module sqlalchemy.sql.expression)

type_compiler (sqlalchemy.engine.default.DefaultDialect attribute)

type_descriptor() (sqlalchemy.engine.default.DefaultDialect method)

(sqlalchemy.engine.interfaces.Dialect class method)

type_engine() (sqlalchemy.types.TypeDecorator method)

TypeCoerce (class in sqlalchemy.sql.expression)

typecolname (sqlalchemy.orm.util.polymorphic_union parameter)

TypeDecorator (class in sqlalchemy.types)

TypeDecorator.Comparator (class in sqlalchemy.types)

TypeEngine (class in sqlalchemy.types)

TypeEngine.Comparator (class in sqlalchemy.types)

typemap (sqlalchemy.sql.expression.text parameter)

U

UnaryExpression (class in sqlalchemy.sql.expression)

UnboundExecutionError

undefer() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

undefer_group() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

unformat_identifiers() (sqlalchemy.sql.compiler.IdentifierPreparer method)

Unicode (class in sqlalchemy.types)

unicode (sqlalchemy.dialects.mysql.ENUM parameter)

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

unicode_error (sqlalchemy.dialects.mssql.CHAR parameter)

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

UnicodeText (class in sqlalchemy.types)

uninstall_descriptor() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

uninstall_member() (sqlalchemy.ext.instrumentation.InstrumentationManager method)

union() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Select method)

union_all() (in module sqlalchemy.sql.expression)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Select method)

unique (sqlalchemy.schema.Column parameter)

(sqlalchemy.schema.Index parameter)
(sqlalchemy.sql.expression.bindparam parameter)

unique constraint

unique key index

unique_connection() (sqlalchemy.pool.Pool method)

(sqlalchemy.pool.QueuePool method)

unique_params() (sqlalchemy.sql.expression.Alias method)

(sqlalchemy.sql.expression.CTE method)
(sqlalchemy.sql.expression.ClauseElement method)

UniqueConstraint (class in sqlalchemy.schema)

UNIQUEIDENTIFIER (class in sqlalchemy.dialects.mssql)

unit of work

unloaded (sqlalchemy.orm.state.InstanceState attribute)

unloaded_expirable (sqlalchemy.orm.state.InstanceState attribute)

UnmappedClassError

UnmappedColumnError

UnmappedError

UnmappedInstanceError

unmodified (sqlalchemy.orm.state.InstanceState attribute)

unmodified_intersection() (sqlalchemy.orm.state.InstanceState method)

unpickle() (sqlalchemy.orm.events.InstanceEvents method)

UnreflectableTableError

unregister() (sqlalchemy.orm.instrumentation.ClassManager method)

unsigned (sqlalchemy.dialects.mysql.BIGINT parameter)

(sqlalchemy.dialects.mysql.DECIMAL parameter)
(sqlalchemy.dialects.mysql.DOUBLE parameter)

UnsupportedCompilationError

UOWTransaction (class in sqlalchemy.orm.session)

Update (class in sqlalchemy.sql.expression)

update() (in module sqlalchemy.sql.expression)

(sqlalchemy.ext.mutable.MutableDict method)
(sqlalchemy.ext.mutable.MutableSet method)

update_args (sqlalchemy.orm.query.Query.update parameter)

update_changed_only (sqlalchemy.orm.session.Session.bulk_save_objects parameter)

update_context (sqlalchemy.orm.events.QueryEvents.before_compile_update parameter)

(sqlalchemy.orm.events.SessionEvents.after_bulk_update parameter)

update_execution_options() (sqlalchemy.engine.Engine method)

update_expression() (sqlalchemy.ext.hybrid.hybrid_property method)

update_from_clause() (sqlalchemy.sql.compiler.SQLCompiler method)

(sqlalchemy.sql.compiler.StrSQLCompiler method)

update_limit_clause() (sqlalchemy.sql.compiler.SQLCompiler method)

update_tables_clause() (sqlalchemy.sql.compiler.SQLCompiler method)

UpdateBase (class in sqlalchemy.sql.expression)

upper_bound (sqlalchemy.sql.expression.between parameter)

URL (class in sqlalchemy.engine.url)

url (sqlalchemy.engine.CreateEnginePlugin parameter)

use_alter (sqlalchemy.schema.ForeignKey parameter)

(sqlalchemy.schema.ForeignKeyConstraint parameter)

use_labels (sqlalchemy.sql.expression.select parameter)

use_lifo (sqlalchemy.pool.QueuePool parameter)

use_proxies (sqlalchemy.schema.Column.compare parameter)

(sqlalchemy.sql.elements.False_.compare parameter)
(sqlalchemy.sql.elements.Null.compare parameter)

use_threadlocal (sqlalchemy.pool.Pool parameter)

(sqlalchemy.pool.SingletonThreadPool parameter)

useexisting (sqlalchemy.schema.Table parameter)

uselist (sqlalchemy.orm.relationship parameter)

user (class in sqlalchemy.sql.functions)

UserDefinedType (class in sqlalchemy.types)

UserDefinedType.Comparator (class in sqlalchemy.types)

username (sqlalchemy.engine.url.URL parameter)

using (sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

UUID (class in sqlalchemy.dialects.postgresql)

V

validate_sql_phrase() (sqlalchemy.sql.compiler.IdentifierPreparer method)

validate_strings (sqlalchemy.types.Enum parameter)

validates() (in module sqlalchemy.orm)

validators (sqlalchemy.orm.mapper.Mapper attribute)

vals() (sqlalchemy.dialects.postgresql.HSTORE.Comparator method)

value (sqlalchemy.ext.mutable.Mutable.coerce parameter)

(sqlalchemy.ext.mutable.MutableBase.coerce parameter)
(sqlalchemy.orm.attributes.set_attribute parameter)

value() (sqlalchemy.orm.query.Query method)

values (sqlalchemy.dialects.mysql.SET parameter)

(sqlalchemy.orm.collections.bulk_replace parameter)
(sqlalchemy.orm.query.Query.update parameter)

values() (sqlalchemy.orm.instrumentation.ClassManager method)

(sqlalchemy.orm.query.Query method)
(sqlalchemy.sql.expression.Insert method)

values_callable (sqlalchemy.types.Enum parameter)

ValuesBase (class in sqlalchemy.sql.expression)

VARBINARY (class in sqlalchemy.dialects.mysql)

(class in sqlalchemy.types)

VARCHAR (class in sqlalchemy.dialects.mssql)

(class in sqlalchemy.dialects.mysql)
(class in sqlalchemy.types)

Variant (class in 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)

W

was_already_deleted() (sqlalchemy.orm.session.UOWTransaction method)

was_deleted (sqlalchemy.orm.state.InstanceState attribute)

was_deleted() (in module sqlalchemy.orm.util)

weak_identity_map (sqlalchemy.orm.session.Session parameter)

whens (sqlalchemy.sql.expression.case parameter)

where (sqlalchemy.dialects.postgresql.dml.Insert.on_conflict_do_update parameter)

(sqlalchemy.dialects.postgresql.ExcludeConstraint parameter)

WHERE clause

where() (sqlalchemy.sql.expression.Delete method)

(sqlalchemy.sql.expression.ScalarSelect method)
(sqlalchemy.sql.expression.Select method)

whereclause (sqlalchemy.orm.query.Query attribute)

(sqlalchemy.sql.expression.Join.select parameter)
(sqlalchemy.sql.expression.delete parameter)

with_criteria() (sqlalchemy.ext.baked.BakedQuery method)

with_entities() (sqlalchemy.orm.query.Query method)

with_expression() (in module sqlalchemy.orm)

(sqlalchemy.orm.strategy_options.Load method)

with_for_update (sqlalchemy.orm.session.Session.refresh parameter)

with_for_update() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.CompoundSelect method)
(sqlalchemy.sql.expression.GenerativeSelect method)

with_hint() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.Delete method)
(sqlalchemy.sql.expression.Insert method)

with_labels (sqlalchemy.orm.query.Query.subquery parameter)

with_labels() (sqlalchemy.orm.query.Query method)

with_lockmode() (sqlalchemy.orm.query.Query method)

with_only_columns() (sqlalchemy.sql.expression.Select method)

with_parent() (in module sqlalchemy.orm)

(sqlalchemy.orm.query.Query method)

with_polymorphic (sqlalchemy.orm.mapper parameter)

with_polymorphic() (in module sqlalchemy.orm)

(sqlalchemy.orm.query.Query method)

with_polymorphic_mappers (sqlalchemy.orm.mapper.Mapper attribute)

with_post_criteria() (sqlalchemy.ext.baked.Result method)

with_session() (sqlalchemy.orm.query.Query method)

with_statement_hint() (sqlalchemy.orm.query.Query method)

(sqlalchemy.sql.expression.Select method)

with_transformation() (sqlalchemy.orm.query.Query method)

with_variant() (sqlalchemy.types.TypeDecorator method)

(sqlalchemy.types.TypeEngine method)

within_group() (in module sqlalchemy.sql.expression)

(sqlalchemy.sql.functions.FunctionElement method)

within_group_type() (sqlalchemy.sql.functions.FunctionElement method)

(sqlalchemy.sql.functions.OrderedSetAgg method)

WithinGroup (class in sqlalchemy.sql.expression)

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 (class in sqlalchemy.dialects.mssql)

Y

YEAR (class in sqlalchemy.dialects.mysql)
yield_per() (sqlalchemy.orm.query.Query method)

Z

zero_indexes (sqlalchemy.dialects.postgresql.ARRAY parameter)

(sqlalchemy.types.ARRAY attribute)
(sqlalchemy.types.ARRAY parameter)

zerofill (sqlalchemy.dialects.mysql.BIGINT parameter)

(sqlalchemy.dialects.mysql.DECIMAL parameter)
(sqlalchemy.dialects.mysql.DOUBLE parameter)

Website generation by zeekofile, with huge thanks to the Blogofile project.

SQLAlchemy 1.3 Documentation

Index

Symbols

_

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z