SQLAlchemy Documentation
Attributes
Classs
Exceptions
Functions
Guides
Methods
Modules
Parameters
Sections
- 1.x to 2.0 Migration
- A bind was located via legacy bound metadata, but since future=True is set on this Session, this bind is ignored.
- A value is required for bind parameter <x> (in parameter group <y>)
- API Documentation - Available Pool Implementations
- Abstract Concrete Classes
- Accessing Table and Metadata
- Accessing Tables and Columns
- Adding Criteria to loader options
- Adding New or Existing Items
- Adding Relationships to Mapped Classes After Declaration
- Adding global WHERE / ON criteria
- Additional ORM API Constructs
- Adjacency List
- Aggregate functions with GROUP BY / HAVING
- Aiosqlite
- Allowing Bulk ORM Update
- Altering Database Objects through Migrations
- Alternate Attribute Names for Mapping Table Columns
- Alternate Class Instrumentation
- An alias is being generated automatically due to overlapping tables
- An alias is being generated automatically for raw clauseelement
- Appending additional columns to an existing Declarative mapped class
- Applying Dynamic Schema Naming Conventions
- Applying Load, Persistence and Mapping Options for Imperative Table Columns
- Applying ORM Mappings to an existing dataclass (legacy dataclass use)
- Applying ORM mappings to an existing attrs class
- Applying SQL-level Bind/Result Processing
- Applying loader options to the subclasses loaded by selectin_polymorphic
- Applying loader options when selectin_polymorphic is itself a sub-option
- Applying selectin_polymorphic() to an existing eager load
- Associating a Sequence with the MetaData
- Association Object
- Association Proxy
- Associations
- Asyncio Integration
- Asyncio Platform Installation Notes (Including Apple M1)
- Attribute Events
- Attribute Instrumentation
- Augmenting Existing Types
- Auto Begin
- Auto Increment Behavior / IDENTITY Columns
- Autoflush
- Automap
- Automating Column Naming Schemes from Reflected Tables
- Avoiding transaction-related exceptions on Azure Synapse Analytics
- AwaitRequired
- Backend-agnostic GUID Type
- Backend-specific “UPPERCASE” datatypes
- Baked Queries
- Basic Use
- Basics of Statement Execution
- Basics of Using a Session
- Behavior of save-update cascade with bi-directional relationships
- Bitwise Operators
- Building Custom Comparators
- Building Deeper Hierarchies with polymorphic_abstract
- Building Query-Enabled Properties
- Building the Cython Extensions
- Bulk / Multi Row INSERT, upsert, UPDATE and DELETE
- Bulk INSERT for Joined Table Inheritance
- Bulk Operations
- Bulk UPDATE by Primary Key for Joined Table Inheritance
- CREATE TABLE arguments including Storage Engines
- Caching for Third Party Dialects
- Calling Stored Procedures and User Defined Functions
- Can’t reconnect until invalid transaction is rolled back. Please rollback() fully before proceeding
- Cascading Objects into the Session
- Cascading Scalar Deletes
- Changing Compilation of Types
- Changing the sql_mode
- Client-Invoked SQL Expressions
- Closing
- Closing a Session
- Clustered Index Support
- Code Profiling
- Coercing Encoded Strings to Unicode
- Column Element Foundational Constructors
- Column Element Modifier Constructors
- Column Valued Functions
- Column Valued Functions - Table Valued Function as a Scalar Column
- Combining Association Object with Many-to-Many Access Patterns
- Combining Relationship with Custom ON Criteria
- Committing
- Committing Changes
- Compiler StrSQLCompiler can’t render element of type <element type>
- Compiling sub-elements of a custom expression construct
- Composing from Column Properties at Mapping Time
- Composite Association Proxies
- Composite “Secondary” Joins
- Computed Columns (GENERATED ALWAYS AS)
- Concrete Polymorphic Loading Configuration
- Concrete Table Inheritance
- Configuring Column Deferral on Mappings
- Configuring Constraint Naming Conventions
- Configuring Loader Strategies at Mapping Time
- Configuring Logging
- Configuring Many-to-Many Relationships
- Configuring Naming for Boolean, Enum, and other schema types
- Configuring Self-Referential Eager Loading
- Configuring Sentinel Columns
- Configuring mapper-level “raiseload” behavior
- Configuring with_polymorphic() on mappers
- Connecting to databases with access tokens
- Connection Pooling
- Connection Timeouts and Disconnects
- Constraint Reflection
- Context-Sensitive Default Functions
- Controlling DDL Generation of Constraints and Indexes
- Controlling DDL Sequences
- Controlling the Batch Size
- Core Exceptions
- Correlated Updates
- Correlating RETURNING records with input data order
- Correlating RETURNING rows to parameter sets
- Covering Indexes
- Creating Custom Foreign Conditions
- Creating Indexes and Constraints with Naming Conventions on Mixins
- Creating/Dropping Foreign Key Constraints via ALTER
- Creation of New Values
- Custom / Legacy Pessimistic Ping
- Custom Collection Implementations
- Custom DBAPI connect() arguments / on-connect routines
- Custom Dictionary-Based Collections
- Custom SQL Constructs and Compilation Extension
- Custom Version Counters / Types
- Custom Vertical Partitioning
- Custom operators based on SQL functions
- Customizing Collection Access
- Customizing the Type Map
- DBAPI Errors
- DDL Comment Support
- DDL Expression Constructs API
- DML Foundational Constructors
- Data Casts and Type Coercion
- DataError
- Database Locking Behavior / Concurrency
- Database URLs
- DatabaseError
- Date and Time Types
- Dealing with Binary Data Warnings and Unicode
- Dealing with Disconnects
- Dealing with Key Mutations and back-populating for Dictionary collections
- Declarative Dataclass Mapping
- Declarative Mapping
- Declarative Mapping using a Decorator (no declarative base)
- Declarative Table Configuration
- Declarative Table with mapped_column()
- Declarative with Imperative Table (a.k.a. Hybrid Declarative)
- Declaring Mapped Classes
- Default Constructor
- Defining Expression Behavior Distinct from Attribute Behavior
- Defining Foreign Keys
- Defining Mapped Properties with Declarative
- Defining Sequences
- Deleting
- Deleting ORM Objects using the Unit of Work pattern
- Deleting Rows from the Many to Many Table
- Describing Databases with MetaData
- Dictionary Collections
- Disabling Autobegin to Prevent Implicit Transactions
- Disabling Bulk ORM Update by Primary Key for an UPDATE statement with multiple parameter sets
- Disabling or using an alternate dictionary to cache some (or all) statements
- Disconnect Handling - Pessimistic
- Documentation Overview
- Dogpile Caching
- Dotted Column Names
- Dynamic Relationship Loaders
- EXISTS forms: has() / any()
- EXISTS subqueries
- Eager Loading of Polymorphic Subtypes
- Embedding SQL Insert/Update Expressions into a Flush
- Emitting DDL to the Database
- Enabling Caching Support for Custom Constructs
- Enabling Two-Phase Commit
- Encoding Errors
- Engine Creation API
- Engine Disposal
- Establishing Mutability on Composites
- Establishing Mutability on Scalar Column Values
- Establishing a Declarative Base
- Estimating Cache Performance Using Logging
- Evaluation of relationship arguments
- Execute Events
- Executing with an ORM Session
- Expected FROM clause, got Select. To create a FROM clause, use the .subquery() method
- Expiring / Refreshing
- Explicit Begin
- Explicit FROM clauses and JOINs
- Explicit Join + Eager load
- Explicit Schema Name with Declarative Table
- External Dialects
- External Dialects
- FLOAT / DOUBLE Support and Behaviors
- Fast Executemany Mode
- Fetching Large Result Sets with Yield Per
- Fetching Rows
- Fetching Server-Generated Defaults
- Filtered Indexes
- Filtering Subclass Attributes with with_polymorphic()
- Fine Grained Reflection with Inspector
- Fine grained control over cx_Oracle data binding performance with setinputsizes
- Fine grained control over python-oracledb data binding with setinputsizes
- Flushing
- For relationship <relationship>, delete-orphan cascade is normally configured only on the “one” side of a one-to-many relationship, and not on the “many” side of a many-to-one or many-to-many relation
- Forcing NULL on a column with a default
- Foreign Key Support
- Framing out a begin / commit / rollback block
- Full Text Search
- Functional Indexes
- Generating Mappings from Multiple Schemas
- Generating dynamic authentication tokens
- Generic Associations
- Generic “CamelCase” Types
- Get by Primary Key
- Getting Affected Row Count from UPDATE, DELETE
- Getting ORM Results from Textual Statements
- Getting a Connection
- Getting new objects with RETURNING
- Grouping Selected Attributes with Bundles
- HSTORE type
- Handling Multiple Join Paths
- Horizontal Sharding
- Horizontal Sharding
- How Do I “Retry” a Statement Execution Automatically?
- How can I get the CREATE TABLE/ DROP TABLE output as a string?
- How can I profile a SQLAlchemy powered application?
- How do I get at the raw DBAPI connection when using an Engine?
- How do I map a table that has no primary key?
- How do I render SQL expressions as strings, possibly with bound parameters inlined?
- How do I walk all objects that are related to a given object?
- Hybrid Attributes
- INSERT behavior
- INSERT usually generates the “values” clause automatically
- INSERT…FROM SELECT
- INSERT…ON CONFLICT (Upsert)
- INSERT…ON CONFLICT (Upsert)
- INSERT…ON DUPLICATE KEY UPDATE (Upsert)
- INSERT…RETURNING
- Identity Columns (GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY)
- Identity Token
- IllegalStateChangeError and concurrency exceptions
- Imperative Mapping
- Important Notes and Caveats for ORM-Enabled Update and Delete
- Included Dialects
- Index
- Index Storage Parameters
- Indexable
- Indexes
- Indexes with CONCURRENTLY
- Inheritance Mapping Recipes
- Inserting Rows using the ORM Unit of Work pattern
- Inspecting entities and columns from ORM-enabled SELECT and DML statements
- Inspection of Mapped Instances
- Inspection of Mapper objects
- Installation Guide
- Instance <instance> is already associated with an instance of <instance> via its <attribute> attribute, and is only allowed a single parent.
- Integrating with Alternate Dataclass Providers such as Pydantic
- IntegrityError
- Interaction of Schema-qualified Reflection with the Default Schema
- Intercepting Column Definitions
- InterfaceError
- InternalError
- Is the Session thread-safe? Is AsyncSession safe to share in concurrent tasks?
- I’m getting a warning or error about “Implicitly combining column X under attribute Y”
- I’m getting an error about greenlet not being installed when I try to use asyncio
- I’m getting errors related to “numpy.int64”, “numpy.bool_”, etc.
- I’m re-loading data with my Session but it isn’t seeing changes that I committed elsewhere
- I’m using op() to generate a custom operator and my parenthesis are not coming out correctly
- JSON Types
- Joined Eager Loading
- Joined Table Inheritance
- Joining a Session into an External Transaction (such as for test suites)
- Joining to Subqueries
- Joining to specific sub-types or with_polymorphic() entities
- Joins
- Joins to a Target with an ON Clause
- LATERAL correlation
- LOB Datatypes
- Large Text/Binary Type Deprecation
- Late-Evaluation of Relationship Arguments
- Lazy Loading
- Legacy Schema Mode
- Legacy Session Bulk INSERT Methods
- Legacy Session Bulk UPDATE Methods
- Limiting which Columns Load with Column Deferral
- Loader Strategies
- Loading Arbitrary SQL Expressions onto Objects
- Loading Relationships
- Loading deferred columns in groups
- Logging and Events
- Maintaining Multiple Isolation Levels for a Single Engine
- Maintaining Non-Mapped State Across Loads
- Managing Transactions
- Many To Many
- Many To One
- Map columns directly, pass attribute names to composite
- Mapped Class Behavior
- Mapped Class Essential Components
- Mapper Configuration Options with Declarative
- Mapper-level Flush Events
- Mapping Declaratively with Reflected Tables
- Mapping Multiple Type Configurations to Python Types
- Mapping Whole Column Declarations to Python Types
- Mapping a Class against Arbitrary Subqueries
- Mapping a Class against Multiple Tables
- Mapping a Subset of Table Columns
- Mapping pre-existing dataclasses using Declarative With Imperative Table
- Mapping pre-existing dataclasses using Declarative-style fields
- Mapping pre-existing dataclasses using Imperative Mapping
- Mapping to an Explicit Set of Primary Key Columns
- MariaDB-Only Mode
- Marking Implicitly Generated Values, timestamps, and Triggered Columns
- Maximum Identifier Lengths
- Merging
- Microsoft SQL Server
- MissingGreenlet
- Mixing in Relationships
- Mixing in _orm.column_property() and other _orm.MapperProperty classes
- Modifiers
- More on Invalidation
- Multihost Connections
- Multipart Schema Names
- Multiple Table Deletes
- Mutable Primary Keys / Update Cascades
- Mutation Tracking
- My Query does not return the same number of objects as query.count() tells me - why?
- MySQL / MariaDB Foreign Keys
- MySQL / MariaDB Unique Constraints and Reflection
- MySQL / MariaDB- Specific Index Options
- MySQL and MariaDB
- Named Argument Styles
- Naming CHECK Constraints
- Naming Declarative Mapped Columns Explicitly
- Network Data Types
- No Inspection Available
- Non-Batched Mode Operation
- NotSupportedError
- Notes on Delete - Deleting Objects Referenced from Collections and Scalar Relationships
- Notes on using the viewonly relationship parameter
- Nullable Many-to-One
- ON CONFLICT support for constraints
- ON UPDATE and ON DELETE
- ORDER BY
- ORDER BY, GROUP BY, HAVING
- ORM Bulk INSERT Statements
- ORM Bulk Insert with Per Row SQL Expressions
- ORM Bulk Insert with SQL Expressions
- ORM Bulk UPDATE by Primary Key
- ORM Entity Aliases
- ORM Entity Subqueries/CTEs
- ORM Events
- ORM Examples
- ORM Exceptions
- ORM Execution Options
- ORM Mapping Styles
- ORM Query Events
- ORM UPDATE and DELETE with Custom WHERE Criteria
- ORM “upsert” Statements
- Object Lifecycle Events
- Object cannot be converted to ‘persistent’ state, as this identity map is no longer valid.
- Object is being merged into a Session along the backref cascade
- Object will not produce a cache key, Performance Implications
- One To Many
- One To One
- Opening and Closing a Session
- OperationalError
- Operator Classes
- Operator Customization
- Oracle
- Oracle Database Specific Index Options
- Oracle Database Table Options
- Ordering or Grouping by a Label
- Other mapping forms for composites
- Overlapping Foreign Keys
- Overriding Reflected Columns
- Parameter Ordered Updates
- Parent instance <x> is not bound to a Session; (lazy load/deferred load/refresh/etc.) operation cannot proceed
- Partial Indexes
- Partial Indexes
- Partitioning Strategies (e.g. multiple database backends per Session)
- Per-Entity Wildcard Loading Strategies
- Per-Statement/Connection Execution Options
- Performance
- Persistence Events
- Pool class cannot be used with asyncio engine (or vice versa)
- Pooling Behavior
- Populate Existing
- PostgreSQL
- PostgreSQL Constraint Options
- PostgreSQL Index Reflection
- PostgreSQL Table Options
- PostgreSQL-Specific Index Options
- Precision Numerics
- Prepared Statement Cache
- Prepared Statement Name with PGBouncer
- Preventing Implicit IO when Using AsyncSession
- Preventing unwanted lazy loads using raiseload
- ProgrammingError
- Proxying to Dictionary Based Collections
- Psycopg2 Fast Execution Helpers
- Psycopg2 Transaction Isolation Level
- PyODBC
- Pysqlcipher
- Pysqlite
- Python dataclasses error encountered when creating dataclass for <classname>
- Query-time SQL expressions as mapped attributes
- Querying
- QueuePool limit of size <x> overflow <y> reached, connection timed out, timeout <z>
- Quickie Intro to Object States
- RETURNING Support
- Range and Multirange Types
- Re-Executing Statements
- Redefining Comparison Operations for Composites
- Redefining and Creating New Operators
- Reflecting Tables from Other Schemas
- Reflecting internal schema tables
- Reflecting with Database-Agnostic Types
- Refreshing / Expiring
- Regular Expression Support
- Relationship Instance Comparison Operators
- Relationship Loading with Loader Options
- Relationship WHERE Operators
- Relationship WHERE Operators
- Relationship to Aliased Class
- Remote-Schema Table Introspection and PostgreSQL search_path
- Rendering ON UPDATE CURRENT TIMESTAMP for MySQL / MariaDB’s explicit_defaults_for_timestamp
- Reset On Return
- Resolving Column Conflicts with use_existing_column
- Reusing Hybrid Properties across Subclasses
- Rolling Back
- Routing Explicit Joins/Statements into Eagerly Loaded Collections
- Row-Limited Relationships with Window Functions
- Rowcount Support / ORM Versioning
- Rows that point to themselves / Mutually Dependent Rows
- Running Synchronous Methods and Functions under asyncio
- Runtime Inspection API
- Runtime Introspection of Mapped classes, Instances and Mappers
- SELECT Statements for Single Inheritance Mappings
- SQL Compilation Caching
- SQL Execution and Connection Events
- SQL Standard and Multiple Vendor “UPPERCASE” Types
- SQL Statements and Expressions API
- SQLite
- SQLite Auto Incrementing Behavior
- SSL Connections
- SSL Connections
- Scalar and Correlated Subqueries
- Search Page
- Select IN loading
- Selectable Foundational Constructors
- Selectable Modifier Constructors
- Selecting Entities from Subqueries
- Selecting Entities from UNIONs and other set operations
- Selecting Multiple ORM Entities Simultaneously
- Selecting ORM Aliases
- Selecting ORM Entities
- Selecting ORM Entities and Attributes
- Selecting ORM Entities and Columns
- Selecting ORM Entities from Unions
- Selecting a Synchronization Strategy
- Selecting with Textual Column Expressions
- Self-Referential Many-to-Many Relationship
- Self-Referential Query Strategies
- Sending Multiple Parameters
- Sending NULL values in ORM bulk INSERT statements
- Sending Parameters
- Sequences/SERIAL/IDENTITY
- Serializable isolation / Savepoints / Transactional DDL
- Serializable isolation / Savepoints / Transactional DDL (asyncio version)
- Server Side Cursors
- Server Side Cursors
- Server Side Version Counters
- Server-invoked DDL-Explicit Default Expressions
- Session Attributes
- Session Frequently Asked Questions
- Session Referencing Behavior
- Session-level vs. Engine level transaction control
- Setinputsizes Support
- Setting Alternate Search Paths on Connect
- Setting Isolation For A Sessionmaker / Engine Wide
- Setting Load and Persistence Options for Declarative Mapped Columns
- Setting Per-Connection / Sub-Engine Tokens
- Setting Pool Recycle
- Setting READ ONLY / DEFERRABLE
- Setting RaiseLoad
- Setting Transaction Isolation Levels / DBAPI AUTOCOMMIT
- Setting Transaction Isolation Levels including DBAPI Autocommit
- Setting a Default Schema for New Connections
- Setting the COLUMNS and FROM clause
- Setting the ON Clause
- Setting the leftmost FROM clause in a join
- Setting up MetaData with Table objects
- Simple Relationship Joins
- Simple Validators
- Simple plain text matching with match()
- Simplifying Scalar Collections
- Single Table Inheritance
- Space Invaders
- Special Modifiers WITHIN GROUP, FILTER
- Specifying Alternate Join Conditions
- Specifying Sub-Options with Load.options()
- Specifying a Default Schema Name with MetaData
- Specifying multiple fallback hosts
- Specifying the Schema Name
- Streaming with a dynamically growing buffer using stream_results
- String Alteration
- Subqueries and CTEs
- Subquery Eager Loading
- Support for Type Alias Types (defined by PEP 695) and NewType
- Supported Databases
- Supporting new database error codes for disconnect scenarios
- Switching Pool Implementations
- Synonyms
- Synopsis - ORM
- TIMESTAMP Columns and NULL
- Table Reflection
- Table values, Table and Column valued functions, Row and Tuple objects
- Table-Valued Functions
- Table-Valued Functions
- Temporary Table / Resource Reset for Connection Pooling
- Temporary Table / Resource Reset for Connection Pooling
- The <some function> in SQLAlchemy 2.0 will no longer <something>
- The Default Naming Convention
- The WHERE clause
- The Zen of Joined Eager Loading
- The delete() SQL Expression Construct
- The properties dictionary
- The update() SQL Expression Construct
- This Compiled object is not bound to any Engine or Connection
- This Session’s transaction has been rolled back due to a previous exception during flush
- This connection is on an inactive transaction. Please rollback() fully before proceeding
- Thread-Local Scope
- Threading/Pooling Behavior
- Transaction Events
- Transaction Isolation Level
- Transaction Isolation Level
- Transaction Isolation Level
- Transaction Isolation Level / Autocommit
- Transaction Isolation Level / Autocommit
- Translation of Schema Names
- Triggers
- Type Reflection
- Type annotation can’t be interpreted for Annotated Declarative Table form
- UNION, UNION ALL and other set operations
- UNIQUE Constraint
- UPDATE..FROM
- UPDATE/DELETE with Custom WHERE Criteria for Joined Table Inheritance
- URI Connections
- Understanding the DBAPI-Level Autocommit Isolation Level
- Unicode
- Unicode
- Unicode
- Unicode with Psycopg2
- Union types inside the Type Map
- Updating ORM Objects using the Unit of Work pattern
- Use of a MultiRange sequence to infer the multirange type
- User-Defined Functions
- Using @declared_attr and Declarative Mixins
- Using Aliases
- Using Annotated Declarative Table (Type Annotated Forms for mapped_column())
- Using AsyncSession with Concurrent Tasks
- Using Connection Pools with Multiprocessing or os.fork()
- Using DBAPI Autocommit Allows for a Readonly Version of Transparent Reconnect
- Using Declarative Mixins with pre-existing dataclasses
- Using DeferredReflection
- Using Descriptors and Hybrids
- Using ENUM with ARRAY
- Using FIFO vs. LIFO
- Using Heterogeneous Parameter Dictionaries
- Using IN expressions
- Using INSERT, UPDATE and ON CONFLICT (i.e. upsert) to return ORM Objects
- Using JSON/JSONB with ARRAY
- Using Lambdas to add significant speed gains to statement production
- Using Legacy Non-Dataclasses
- Using Mixins and Base Classes with Mapped Inheritance Patterns
- Using Non-Mapped Dataclass Fields
- Using ORM Declarative Forms to Define Table Metadata
- Using Oracle Database Resident Connection Pooling (DRCP)
- Using Python Enum or pep-586 Literal types in the type map
- Using RETURNING with UPDATE/DELETE and Custom WHERE Criteria
- Using RETURNING with upsert statements
- Using Relationship to join between aliased targets
- Using Relationships in Queries
- Using Relationships to Join
- Using SAVEPOINT
- Using SQL Expressions with Sessions
- Using Server Side Cursors (a.k.a. stream results)
- Using Sets, Lists, or other Collection Types for One To Many
- Using Thread-Local Scope with Web Applications
- Using Window Functions
- Using _orm.declared_attr() to generate table-specific inheriting columns
- Using a Declarative Base Class
- Using a Hybrid Approach with __table__
- Using a late-evaluated form for the “secondary” argument of many-to-many
- Using aliasing with with_polymorphic
- Using asyncio scoped session
- Using awaitable-only driver methods in connection pool and other events
- Using column_property
- Using custom operators in join conditions
- Using cx_Oracle SessionPool
- Using defer() to omit specific columns
- Using deferred() for imperative mappers, mapped SQL expressions
- Using delete cascade with many-to-many relationships
- Using events with the asyncio extension
- Using foreign key ON DELETE cascade with ORM relationships
- Using foreign key ON DELETE with many-to-many relationships
- Using inplace to create pep-484 compliant hybrid properties
- Using load_only() on related objects and collections
- Using load_only() to reduce loaded columns
- Using mixins and abstract superclasses
- Using raiseload to prevent deferred column loads
- Using selectin_polymorphic()
- Using the Inspector to inspect schema objects
- Using the Session
- Using the before_compile event
- Using with_expression() with UNIONs, other subqueries
- Using with_polymorphic()
- Using “UPPERCASE” and Backend-specific types for multiple backends
- Versioning Objects
- Versioning using Temporal Rows
- Versioning with a History Table
- Vertical Attribute Mapping
- What Kind of Loading to Use ?
- What are default, default_factory and insert_default and what should I use?
- When do I construct a Session, when do I commit it, and when do I close it?
- When transforming <cls> to a dataclass, attribute(s) originate from superclass <cls> which is not a dataclass.
- Why are percent signs being doubled up when stringifying SQL statements?
- Why does post_update emit UPDATE in addition to the first UPDATE?
- Why is ORDER BY recommended with LIMIT (especially with subqueryload())?
- Why is my application slow after upgrading to 1.4 and/or 2.x?
- Wildcard Loading Strategies
- Working with Custom Types and Reflection
- Working with Driver SQL and Raw DBAPI Connections
- Working with Engines and Connections
- Working with SQL Functions
- Working with the DBAPI cursor directly
- Write Only Relationships
- Writing your Own Suites
- __abstract__
- __table_cls__
- aioodbc
- asyncpg
- cx_Oracle
- delete
- delete-orphan
- expunge
- mapped_column() derives the datatype and nullability from the Mapped annotation
- merge
- metadata
- per-row ORM Bulk Update by Primary Key requires that records contain primary key values
- pg8000
- pg8000 Transaction Isolation Level
- psycopg
- psycopg2
- psycopg2 Connect Arguments
- python-oracledb
- refresh-expire
- relationship X will copy column Q to column P, which conflicts with relationship(s): ‘Y’
- save-update
- select() construct created in “legacy” mode; keyword arguments, etc.
- “Commands out of sync; you can’t run this command now” / “This result object does not return rows. It has been closed automatically”
- “Insert Many Values” Behavior for INSERT statements
- “This Session’s transaction has been rolled back due to a previous exception during flush.” (or similar)