Table of Contents

• Overview / Installation
  • Overview
  • Tutorials
  • Main Documentation
  • API Reference
  • Installing SQLAlchemy
  • Installing a Database API
  • Checking the Installed SQLAlchemy Version
  • 0.4 to 0.5 Migration
• Object Relational Tutorial
  • Version Check
  • Connecting
  • Define and Create a Table
  • Define a Python Class to be Mapped
  • Setting up the Mapping
  • Creating Table, Class and Mapper All at Once Declaratively
  • Creating a Session
  • Adding new Objects
  • Rolling Back
  • Querying
    • Common Filter Operators
    • Returning Lists and Scalars
    • Using Literal SQL
  • Building a Relation
  • Working with Related Objects
  • Querying with Joins
    • Using Aliases
    • Using Subqueries
    • Selecting Entities from Subqueries
    • Using EXISTS
    • Common Relation Operators
  • Deleting
    • Configuring delete/delete-orphan Cascade
  • Building a Many To Many Relation
  • Further Reference
• SQL Expression Language Tutorial
  • Version Check
  • Connecting
  • Define and Create Tables
  • Insert Expressions
  • Executing
  • Executing Multiple Statements
  • Connectionless / Implicit Execution
  • Selecting
  • Operators
  • Conjunctions
  • Using Text
  • Using Aliases
  • Using Joins
  • Intro to Generative Selects and Transformations
  • Everything Else
    • Bind Parameter Objects
    • Functions
    • Unions and Other Set Operations
    • Scalar Selects
    • Correlated Subqueries
    • Ordering, Grouping, Limiting, Offset...ing...
  • Updates
    • Correlated Updates
  • Deletes
  • Further Reference
• Mapper Configuration
  • Mapper Configuration
    • Customizing Column Properties
    • Deferred Column Loading
    • SQL Expressions as Mapped Attributes
    • Changing Attribute Behavior
      • Simple Validators
      • Using Descriptors
      • Custom Comparators
    • Composite Column Types
    • Controlling Ordering
    • Mapping Class Inheritance Hierarchies
      • Joined Table Inheritance
        • Controlling Which Tables are Queried
        • Creating Joins to Specific Subtypes
      • Single Table Inheritance
      • Concrete Table Inheritance
      • Using Relations with Inheritance
    • Mapping a Class against Multiple Tables
    • Mapping a Class against Arbitrary Selects
    • Multiple Mappers for One Class
    • Constructors and Object Initialization
    • Extending Mapper
  • Relation Configuration
    • Basic Relational Patterns
      • One To Many
      • Many To One
      • One To One
      • Many To Many
      • Association Object
    • Adjacency List Relationships
      • Self-Referential Query Strategies
      • Configuring Eager Loading
    • Specifying Alternate Join Conditions to relation()
      • Specifying Foreign Keys
      • Building Query-Enabled Properties
      • Multiple Relations against the Same Parent/Child
    • Rows that point to themselves / Mutually Dependent Rows
    • Alternate Collection Implementations
      • Custom Collection Implementations
      • Annotating Custom Collections via Decorators
      • Dictionary-Based Collections
      • Instrumentation and Custom Types
    • Configuring Loader Strategies: Lazy Loading, Eager Loading
      • Routing Explicit Joins/Statements into Eagerly Loaded Collections
    • Working with Large Collections
      • Dynamic Relation Loaders
      • Setting Noload
      • Using Passive Deletes
    • Mutable Primary Keys / Update Cascades
• Using the Session
  • What does the Session do ?
  • Getting a Session
    • Using a sessionmaker() Configuration
    • Binding Session to an Engine
    • Binding Session to a Connection
    • Using create_session()
    • Configurational Arguments
  • Using the Session
    • Quickie Intro to Object States
    • Frequently Asked Questions
    • Querying
    • Adding New or Existing Items
    • Merging
    • Deleting
    • Flushing
    • Committing
    • Rolling Back
    • Expunging
    • Closing
    • Refreshing / Expiring
    • Session Attributes
  • Cascades
  • Managing Transactions
    • Using SAVEPOINT
    • Enabling Two-Phase Commit
  • Embedding SQL Insert/Update Expressions into a Flush
  • Using SQL Expressions with Sessions
  • Joining a Session into an External Transaction
  • Contextual/Thread-local Sessions
    • Creating a Thread-local Context
    • Lifespan of a Contextual Session
  • Partitioning Strategies
    • Vertical Partitioning
    • Horizontal Partitioning
  • Extending Session
• Database Engines
  • Supported Databases
  • create_engine() URL Arguments
    • Custom DBAPI connect() arguments
  • Database Engine Options
  • More On Connections
  • Using Transactions with Connection
    • Understanding Autocommit
  • Connectionless Execution, Implicit Execution
    • Using the Threadlocal Execution Strategy
  • Configuring Logging
• Database Meta Data
  • Describing Databases with MetaData
    • Defining Foreign Keys
    • Accessing Tables and Columns
    • Binding MetaData to an Engine or Connection
    • Reflecting Tables
      • Overriding Reflected Columns
      • Reflecting All Tables at Once
    • Specifying the Schema Name
    • ON UPDATE and ON DELETE
    • Other Options
  • Creating and Dropping Database Tables
  • Column Insert/Update Defaults
    • Pre-Executed Python Functions
    • Pre-executed and Inline SQL Expressions
    • DDL-Level Defaults
    • Triggered Columns
    • Defining Sequences
  • Defining Constraints and Indexes
    • UNIQUE Constraint
    • CHECK Constraint
    • Indexes
  • Adapting Tables to Alternate Metadata
• API Reference
  • sqlalchemy
    • Connections
      • Creating Engines
      • Connectables
      • Result Objects
      • Transactions
      • Internals
    • Connection Pooling
      • Connection Pool Configuration
      • Custom Pool Construction
      • Builtin Pool Implementations
      • Pooling Plain DB-API Connections
    • SQL Statements and Expressions
      • Functions
      • Classes
      • Generic Functions
    • Database Schema
      • Tables and Columns
      • Constraints
      • Default Generators and Markers
      • DDL
      • Internals
    • Column and Data Types
      • Generic Types
      • SQL Standard Types
      • Vendor-Specific Types
      • Custom Types
    • Interfaces
  • sqlalchemy.orm
    • Class Mapping
      • Defining Mappings
      • Mapper Properties
      • Decorators
      • Utilities
      • Attribute Utilities
      • Internals
    • Collection Mapping
    • Querying
      • The Query Object
      • ORM-Specific Query Constructs
      • Query Options
    • Sessions
    • Interfaces
    • Utilities
  • sqlalchemy.databases
    • Access
    • Firebird
      • Firebird backend
        • Firebird dialects
        • Pooling connections
        • RETURNING support
    • Informix
    • MaxDB
      • Overview
      • Connecting
      • Implementation Notes
    • SQL Server
      • Driver
      • Connecting
      • Auto Increment Behavior
      • Collation Support
      • LIMIT/OFFSET Support
      • Nullability
      • Date / Time Handling
      • Compatibility Levels
      • Known Issues
    • MySQL
      • Overview
      • Supported Versions and Features
      • Character Sets
      • Storage Engines
      • Keys
      • SQL Mode
      • MySQL SQL Extensions
      • Troubleshooting
      • MySQL Column Types
    • Oracle
      • Driver
      • Connecting
      • Auto Increment Behavior
      • LOB Objects
      • LIMIT/OFFSET Support
      • Two Phase Transaction Support
      • Oracle 8 Compatibility
      • Synonym/DBLINK Reflection
    • PostgreSQL
      • Driver
      • Connecting
      • Sequences/SERIAL
      • INSERT/UPDATE...RETURNING
      • Indexes
      • Transactions
    • SQLite
      • Driver
      • Connect Strings
      • Threading Behavior
      • Date and Time Types
      • Unicode
    • Sybase
  • sqlalchemy.ext
    • declarative
      • Synopsis
      • Defining Attributes
      • Association of Metadata and Engine
      • Configuring Relations
      • Configuring Many-to-Many Relations
      • Defining Synonyms
      • Table Configuration
      • Mapper Configuration
      • Inheritance Configuration
        • Joined Table Inheritance
        • Single Table Inheritance
        • Concrete Table Inheritance
      • Class Usage
    • associationproxy
      • Simplifying Relations
      • Simplifying Association Object Relations
      • Building Complex Views
      • API
    • orderinglist
    • serializer
    • SqlSoup
      • Introduction
      • Loading objects
        • Full query documentation
      • Modifying objects
      • Joins
      • Relations
      • Advanced Use
        • Accessing the Session
        • Mapping arbitrary Selectables
        • Raw SQL
        • Dynamic table names
      • Extra tests
    • compiler
      • Synopsis

Indices and tables

• Index
• Search Page