SQLAlchemy 0.7.1 Documentation
Search:
Version:
0.7.1
Last Updated: 06/05/2011 13:13:59
Prev:
Overview
Next:
Object Relational Tutorial
Table of Contents
|
Index
|
view source
SQLAlchemy 0.7.1 Documentation
» SQLAlchemy ORM
SQLAlchemy ORM
SQLAlchemy ORM
¶
Object Relational Tutorial
Introduction
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
Mapper Configuration
Customizing Column Properties
Mapping a Subset of Table Columns
Attribute Names for Mapped Columns
Mapping Multiple Columns to a Single Attribute
Using column_property for column level options
Deferred Column Loading
Column Deferral API
SQL Expressions as Mapped Attributes
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 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
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
Custom Collection Implementations
Annotating Custom Collections via Decorators
Dictionary-Based Collections
Instrumentation and Custom Types
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
Using Relationships with Inheritance
Relationships with Concrete Inheritance
Using Inheritance with Declarative
Using the Session
What does the Session do ?
Getting a Session
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
Using Subtransactions
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 Relationships
Simplifying Association Object Relationships
Building Complex Views
API
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 Classes
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.