SQLAlchemy 0.6beta2 Documentation
Search:
Version:
0.6beta2
Last Updated: 03/20/2010 14:44:55
API Reference
|
Index
(
view source)
Table of Contents
Next:
Overview / Installation
Table of Contents
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...
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
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
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
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.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
pymssql
zxjdbc Notes
JDBC Driver
Connecting
AdoDBAPI
MySQL
Overview
Supported Versions and Features
Storage Engines
Keys
SQL Mode
MySQL SQL Extensions
Boolean Types
Troubleshooting
MySQL Column Types
MySQL-Python Notes
Character Sets
OurSQL Notes
Character Sets
MySQL-Connector Notes
pyodbc Notes
zxjdbc Notes
JDBC Driver
Character Sets
Oracle
Connect Arguments
Auto Increment Behavior
Identifier Casing
Unicode
LIMIT/OFFSET Support
ON UPDATE CASCADE
Oracle 8 Compatibility
Synonym/DBLINK Reflection
cx_Oracle Notes
Driver
Connecting
Unicode
LOB Objects
Two Phase Transaction Support
zxjdbc Notes
JDBC Driver
PostgreSQL
Sequences/SERIAL
INSERT/UPDATE...RETURNING
Indexes
PostgresSQL Column Types
psycopg2 Notes
Driver
Connecting
Transactions
Per-Statement Execution Options
pg8000 Notes
Connecting
Unicode
Interval
zxjdbc Notes
JDBC Driver
SQLite
Date and Time Types
Auto Incrementing Behavior
Pysqlite
Driver
Connect Strings
Compatibility with sqlite3 “native” date and datetime types
Threading Behavior
Unicode
Unsupported Databases
Microsoft Access
Informix
MaxDB
Overview
Connecting
Implementation Notes
Sybase
python-sybase notes
Unicode Support
pyodbc notes
Unicode Support
mxodbc 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
Mix-in Classes
Class Constructor
Sessions
API Reference
associationproxy
Simplifying Relationships
Simplifying Association Object Relationships
Building Complex Views
API
orderinglist
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
Subclassing Guidelines
Indices and tables
¶
Index
Search Page
Next:
Overview / Installation
©
Copyright
2007, 2008, 2009, 2010, the SQLAlchemy authors and contributors. Created using
Sphinx
0.6.5.