SQLAlchemy 0.7 Documentation
Search:
Release:
0.7.3
| Release Date: October 16, 2011
Prev:
Overview
Next:
Object Relational Tutorial
Table of Contents
|
Index
|
view source
SQLAlchemy 0.7 Documentation
» SQLAlchemy ORM
SQLAlchemy ORM
SQLAlchemy ORM
¶
Object Relational Tutorial
Introduction
Version Check
Connecting
Declare a Mapping
Create an Instance of the Mapped Class
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 Aliases
Using Subqueries
Selecting Entities from Subqueries
Using EXISTS
Common Relationship Operators
Eager Loading
Subquery Load
Joined Load
Explicit Join + Eagerload
Deleting
Configuring delete/delete-orphan Cascade
Building a Many To Many Relationship
Further Reference
Mapper Configuration
Classical Mappings
Customizing Column Properties
Naming Columns Distinctly from Attribute Names
Mapping Multiple Columns to a Single Attribute
Using column_property for column level options
Mapping a Subset of Table Columns
Deferred Column Loading
Column Deferral API
SQL Expressions as Mapped Attributes
Alternatives to column_property()
Changing Attribute Behavior
Simple Validators
Using Descriptors
Synonyms
Custom Comparators
Composite Column Types
Tracking In-Place Mutations on Composites
Redefining Comparison Operations for Composites
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
Class Mapping API
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 Self-Referential Eager Loading
Linking Relationships with Backref
Backref Arguments
One Way Backrefs
Specifying Alternate Join Conditions to relationship()
Self-Referential Many-to-Many Relationship
Specifying Foreign Keys
Building Query-Enabled Properties
Multiple Relationships against the Same Parent/Child
Rows that point to themselves / Mutually Dependent Rows
Mutable Primary Keys / Update Cascades
Relationships API
Collection Configuration and Techniques
Working with Large Collections
Dynamic Relationship Loaders
Setting Noload
Using Passive Deletes
Customizing Collection Access
Dictionary Collections
Custom Collection Implementations
Collections API
Mapping Class Inheritance Hierarchies
Joined Table Inheritance
Basic Control of Which Tables are Queried
Advanced Control of Which Tables are Queried
Creating Joins to Specific Subtypes
Single Table Inheritance
Concrete Table Inheritance
Concrete Inheritance with Declarative
Using Relationships with Inheritance
Relationships with Concrete Inheritance
Using Inheritance with Declarative
Using the Session
What does the Session do ?
Getting a Session
Adding Additional Configuration to an Existing sessionmaker()
Creating Ad-Hoc Session Objects with Alternate Arguments
Using the Session
Quickie Intro to Object States
Session 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
Autocommit Mode
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
Contextual Session API
Partitioning Strategies
Vertical Partitioning
Horizontal Partitioning
Sessions API
Session and sessionmaker()
Session Utilites
Attribute and State Management Utilities
Querying
The Query Object
ORM-Specific Query Constructs
Relationship Loading Techniques
Using Loader Strategies: Lazy Loading, Eager Loading
The Zen of Eager Loading
What Kind of Loading to Use ?
Routing Explicit Joins/Statements into Eagerly Loaded Collections
Relation Loader API
ORM Events
Attribute Events
Mapper Events
Instance Events
Session Events
Instrumentation Events
Alternate Class Instrumentation
ORM Extensions
Association Proxy
Simplifying Scalar Collections
Creation of New Values
Simplifying Association Objects
Proxying to Dictionary Based Collections
Composite Association Proxies
Querying with Association Proxies
API Documentation
Declarative
Synopsis
Defining Attributes
Accessing the MetaData
Configuring Relationships
Configuring Many-to-Many Relationships
Defining SQL Expressions
Table Configuration
Using a Hybrid Approach with __table__
Mapper Configuration
Inheritance Configuration
Mixin and Custom Base Classes
Special Directives
Class Constructor
Sessions
API Reference
Mutation Tracking
Establishing Mutability on Scalar Column Values
Establishing Mutability on Composites
API Reference
Ordering List
API Reference
Horizontal Sharding
API Documentation
Hybrid Attributes
Defining Expression Behavior Distinct from Attribute Behavior
Defining Setters
Working with Relationships
Building Custom Comparators
Hybrid Value Objects
API Reference
SqlSoup
Introduction
Loading objects
Modifying objects
Joins
Relationships
Advanced Use
SqlSoup API
Examples
Adjacency List
Associations
Attribute Instrumentation
Beaker Caching
Directed Graphs
Dynamic Relations as Dictionaries
Generic Associations
Horizontal Sharding
Inheritance Mappings
Large Collections
Nested Sets
Polymorphic Associations
PostGIS Integration
Versioned Objects
Vertical Attribute Mapping
XML Persistence
Deprecated ORM Event Interfaces
Mapper Events
Session Events
Attribute Events
ORM Exceptions
ORM Internals
Previous:
Overview
Next:
Object Relational Tutorial
©
Copyright
2007-2011, the SQLAlchemy authors and contributors. Created using
Sphinx
1.0.7.