Table of Contents

• Overview / Installation
  • Overview
  • Tutorials
  • Main Documentation
  • Code Examples
  • API Reference
  • Installing SQLAlchemy
  • Installing a Database API
  • Checking the Installed SQLAlchemy Version
  • 0.5 to 0.6 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
    • Counting
  • Building a Relationship
  • Working with Related Objects
  • Querying with Joins
    • Using join() to Eagerly Load Collections/Attributes
    • Using Aliases
    • Using Subqueries
    • Selecting Entities from Subqueries
    • Using EXISTS
    • Common Relationship Operators
  • Deleting
    • Configuring delete/delete-orphan Cascade
  • Building a Many To Many Relationship
  • 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...
  • Inserts and 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 Relationships with Inheritance
    • Mapping a Class against Multiple Tables
    • Mapping a Class against Arbitrary Selects
    • Multiple Mappers for One Class
    • Multiple “Persistence” Mappers for One Class
    • Constructors and Object Initialization
    • Extending Mapper
  • Relationship 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 relationship()
      • Specifying Foreign Keys
      • Building Query-Enabled Properties
      • Multiple Relationships 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
      • What Kind of Loading to Use ?
      • Routing Explicit Joins/Statements into Eagerly Loaded Collections
    • Working with Large Collections
      • Dynamic Relationship 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
      • Deleting based on Filter Criterion
    • 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
    • Accessing Tables and Columns
    • Creating and Dropping Database Tables
    • Binding MetaData to an Engine or Connection
    • Reflecting Tables
      • Overriding Reflected Columns
      • Reflecting Views
      • Reflecting All Tables at Once
      • Fine Grained Reflection with Inspector
    • Specifying the Schema Name
    • Backend-Specific Options
  • Column Insert/Update Defaults
    • Scalar Defaults
    • Python-Executed Functions
      • Context-Sensitive Default Functions
    • SQL Expressions
    • Server Side Defaults
    • Triggered Columns
    • Defining Sequences
  • Defining Constraints and Indexes
    • Defining Foreign Keys
      • Creating/Dropping Foreign Key Constraints via ALTER
      • ON UPDATE and ON DELETE
    • UNIQUE Constraint
    • CHECK Constraint
    • Indexes
  • Customizing DDL
    • Controlling DDL Sequences
    • Custom DDL
  • Adapting Tables to Alternate Metadata
• Examples
  • Adjacency List
  • Associations
  • Attribute Instrumentation
  • Beaker Caching
  • Derived Attributes
  • Directed Graphs
  • Dynamic Relations as Dictionaries
  • Horizontal Sharding
  • Inheritance Mappings
  • Large Collections
  • Nested Sets
  • Polymorphic Associations
  • PostGIS Integration
  • Versioned Objects
  • Vertical Attribute Mapping
  • XML Persistence
• 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 Generation
      • Internals
    • Schema Introspection
    • Column and Data Types
      • Generic Types
      • SQL Standard Types
      • Vendor-Specific Types
      • Custom Types
    • Interfaces
    • Utilities
  • 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.dialects
    • Supported Databases
      • Firebird
        • Dialects
        • Locking Behavior
        • RETURNING support
        • kinterbasdb
      • Microsoft SQL Server
        • Connecting
        • Auto Increment Behavior
        • Collation Support
        • LIMIT/OFFSET Support
        • Nullability
        • Date / Time Handling
        • Compatibility Levels
        • Known Issues
        • PyODBC
          • Connecting
        • mxODBC
          • Connecting
          • Execution Modes
        • pymssql
          • Connecting
          • Limitations
        • zxjdbc Notes
          • JDBC Driver
          • Connecting
        • AdoDBAPI
      • MySQL
        • Supported Versions and Features
        • Connecting
        • Data Types
        • Connection Timeouts
        • Storage Engines
        • Keys
        • SQL Mode
        • MySQL SQL Extensions
        • Troubleshooting
        • MySQL Column Types
        • MySQL-Python Notes
          • Connecting
          • Character Sets
          • Known Issues
        • OurSQL Notes
          • Connecting
          • Character Sets
        • MySQL-Connector Notes
          • Connecting
        • pyodbc Notes
          • Connecting
          • Limitations
        • zxjdbc Notes
          • JDBC Driver
          • Connecting
          • Character Sets
      • Oracle
        • Connect Arguments
        • Auto Increment Behavior
        • Identifier Casing
        • Unicode
        • LIMIT/OFFSET Support
        • ON UPDATE CASCADE
        • Oracle 8 Compatibility
        • Synonym/DBLINK Reflection
        • Oracle Column Types
        • cx_Oracle Notes
          • Driver
          • Connecting
          • Unicode
          • LOB Objects
          • Two Phase Transaction Support
        • zxjdbc Notes
          • JDBC Driver
      • PostgreSQL
        • Sequences/SERIAL
        • Transaction Isolation Level
        • INSERT/UPDATE...RETURNING
        • Indexes
        • PostgresSQL Column Types
        • psycopg2 Notes
          • Driver
          • Unicode
          • Connecting
          • Transactions
          • NOTICE logging
          • Per-Statement Execution Options
        • py-postgresql Notes
          • Connecting
        • pg8000 Notes
          • Connecting
          • Unicode
          • Interval
        • zxjdbc Notes
          • JDBC Driver
      • SQLite
        • Date and Time Types
        • Auto Incrementing Behavior
        • Transaction Isolation Level
        • Pysqlite
          • Driver
          • Connect Strings
          • Compatibility with sqlite3 “native” date and datetime types
          • Threading Behavior
          • Unicode
      • Sybase
        • python-sybase notes
          • Unicode Support
        • pyodbc notes
          • Unicode Support
        • mxodbc notes
    • Unsupported Databases
      • Microsoft Access
      • Informix
      • MaxDB
        • Overview
        • Connecting
        • Implementation Notes
  • sqlalchemy.ext
    • declarative
      • Synopsis
      • Defining Attributes
      • Association of Metadata and Engine
      • Configuring Relationships
      • Configuring Many-to-Many Relationships
      • Defining Synonyms
      • Table Configuration
      • Mapper Configuration
      • Inheritance Configuration
        • Joined Table Inheritance
        • Single Table Inheritance
        • Concrete Table Inheritance
      • Mixin Classes
        • Mixing in Columns
        • Mixing in Relationships
        • Mixing in deferred(), column_property(), etc.
        • Controlling table inheritance with mixins
        • Combining Table/Mapper Arguments from Multiple Mixins
      • Class Constructor
      • Sessions
      • API Reference
    • associationproxy
      • Simplifying Relationships
      • Simplifying Association Object Relationships
      • Building Complex Views
      • API
    • orderinglist
      • API Reference
    • serializer
    • SqlSoup
      • Introduction
      • Loading objects
        • Full query documentation
      • Modifying objects
      • Joins
      • Relationships
      • Advanced Use
        • Sessions, Transations and Application Integration
        • Mapping arbitrary Selectables
        • Raw SQL
        • Dynamic table names
    • compiler
      • Synopsis
      • Dialect-specific compilation rules
      • Compiling sub-elements of a custom expression construct
        • Cross Compiling between SQL and DDL compilers
      • Changing the default compilation of existing constructs
      • Changing Compilation of Types
      • Subclassing Guidelines
    • Horizontal Shard
      • API Documentation

Indices and tables

• Index
• Search Page