SQLAlchemy Documentation
Version: 0.1.3 Last Updated: 03/01/06 20:54:52
View:
Paged
|
One Page
Table of Contents
(view full table)
Introduction
Connection Pooling
Database Engines
Database Meta Data
Constructing SQL Queries via Python Expressions
Basic Data Mapping
Unit of Work
Advanced Data Mapping
The Types System
Modules and Classes
Table of Contents: Full
(view brief table)
Introduction
Trail Map
Connection Pooling
Establishing a Transparent Connection Pool
Connection Pool Configuration
Database Engines
Establishing a Database Engine
Database Engine Methods
Database Engine Options
Using the Proxy Engine
Using the Global Proxy
Transactions
Database Meta Data
Describing Tables with MetaData
Creating and Dropping Database Tables
Adapting Tables to Alternate Engines
Defining Sequences
Constructing SQL Queries via Python Expressions
Simple Select
Using Column Labels
Table/Column Specification
WHERE Clause
Specifying the Engine
Functions
Literals
Order By
DISTINCT, LIMIT and OFFSET
Inner and Outer Joins
Table Aliases
Subqueries
Correlated Subqueries
EXISTS Clauses
Unions
Custom Bind Parameters
Precompiling a Query
Literal Text Blocks
Using Bind Parameters in Text Blocks
Building Select Objects
Inserts
Updates
Correlated Updates
Deletes
Basic Data Mapping
Synopsis
Attaching Mappers to their Class
Overriding Properties
Selecting from a Mapper
Saving Objects
Defining and Using Relationships
Useful Feature: Private Relations
Useful Feature: Backreferences
Creating Relationships Automatically with cascade_mappers
Selecting from Relationships: Lazy Load
Selecting from Relationships: Eager Load
Switching Lazy/Eager, No Load
One to One/Many to One
Many to Many
Association Object
Unit of Work
Overview
Accessing UnitOfWork Instances
Begin/Commit
Controlling Scope with begin()
Nesting UnitOfWork in a Database Transaction
The Identity Map
Bringing External Instances into the UnitOfWork
Advanced UnitOfWork Management
Per-Object Sessions
Custom Session Objects/Custom Scopes
Analyzing Object Commits
Advanced Data Mapping
More On Relations
Custom Join Conditions
Lazy/Eager Joins Multiple Times to One Table
Relation Options
Controlling Ordering
Limiting Rows
Overriding Column Names
Deferred Column Loading
More on Mapper Options
Mapping a Class with Table Inheritance
Mapping a Class against Multiple Tables
Mapping a Class against Arbitary Selects
Multiple Mappers for One Class
Circular Mapping
Self Referential Mappers
Result-Set Mapping
Extending Mapper
How Mapper Modifies Mapped Classes
The Types System
Built-in Types
Creating your Own Types
Modules and Classes
Module sqlalchemy.schema
Class Column(ColumnClause)
Class ColumnDefault(DefaultGenerator)
Class ForeignKey(SchemaItem)
Class Index(SchemaItem)
Class PassiveDefault(DefaultGenerator)
Class SchemaEngine(object)
Class SchemaItem(object)
Class SchemaVisitor(ClauseVisitor)
Class Sequence(DefaultGenerator)
Class Table(TableClause)
Module sqlalchemy.engine
Module Functions
Class SQLEngine(SchemaEngine)
Class ResultProxy
Class RowProxy
Module sqlalchemy.sql
Module Functions
Class Compiled(ClauseVisitor)
Class ClauseElement(object)
Class TableClause(FromClause)
Class ColumnClause(ColumnElement)
Module sqlalchemy.pool
Module Functions
Class DBProxy(object)
Class Pool(object)
Class QueuePool(Pool)
Class SingletonThreadPool(Pool)
Module sqlalchemy.mapping
Module Functions
Class MapperExtension(object)
Module sqlalchemy.mapping.objectstore
Module Functions
Class Session(object)
Class SessionTrans(object)
Class UnitOfWork(object)
Module sqlalchemy.exceptions
Class ArgumentError
Class AssertionError
Class CommitError
Class DBAPIError
Class InvalidRequestError
Class SQLAlchemyError
Class SQLError
Module sqlalchemy.ext.proxy
Module Functions
Class AutoConnectEngine(BaseProxyEngine)
Class BaseProxyEngine(SchemaEngine)
Class ProxyEngine(BaseProxyEngine)
Class ProxyType(object)
Class ProxyTypeEngine(object)
Class TypeEngine(object)