SQLAlchemy 0.4 Documentation
Multiple Pages
|
One Page
Version: 0.4 Last Updated: 10/17/07 13:56:48
Table of Contents
(view full table)
Overview / Installation
Object Relational Tutorial
SQL Expression Language Tutorial
Mapper Configuration
Using the Session
Database Engines
Database Meta Data
The Types System
Connection Pooling
Plugins
API Documentation
Appendix: Copyright
Table of Contents: Full
(view brief table)
Overview / Installation
Overview
Tutorials
Reference Documentation
Installing SQLAlchemy
Installing a Database API
Checking the Installed SQLAlchemy Version
0.3 to 0.4 Migration
ORM Package is now sqlalchemy.orm
BoundMetaData is now MetaData
Some existing select() methods become generative
collection_class behavior is changed
All "engine", "bind_to", "connectable" Keyword Arguments Changed to "bind"
All "type" Keyword Arguments Changed to "type_"
Object Relational Tutorial
Version Check
Connecting
Define and Create a Table
Define a Python Class to be Mapped
Setting up the Mapping
Creating a Session
Saving Objects
Querying
Building a One-to-Many Relation
Working with Related Objects and Backreferences
Querying with Joins
Relation Operators
Deleting
Building a Many To Many Relation
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
Overriding Attribute Behavior
Composite Column Types
Controlling Ordering
Mapping Class Inheritance Hierarchies
Joined Table Inheritance
Optimizing Joined Table Loads
Single Table Inheritance
Concrete Table Inheritance
Using Relations with Inheritance
Mapping a Class against Multiple Tables
Mapping a Class against Arbitrary Selects
Multiple Mappers for One Class
Extending Mapper
Relation 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 relation()
Multiple Relations against the Same Parent/Child
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
Combining Eager Loads with Statement/Result Set Queries
Working with Large Collections
Dynamic Relation Loaders
Setting Noload
Using Passive Deletes
Using the Session
What does the Session do ?
Getting a Session
Using a sessionmaker() Configuration
Binding Session to an Engine or Connection
Binding Session to a Connection
Using create_session()
Using the Session
Quickie Intro to Object States
Frequently Asked Questions
Session Attributes
Querying
Saving New Instances
Updating/Merging Existing Instances
Deleting
Flushing
Autoflush
Expunge / Clear
Closing
Refreshing / Expiring
Cascades
Managing Transactions
Embedding SQL Insert/Update Expressions into a Flush
Using SQL Expressions with Sessions
Contextual/Thread-local Sessions
Creating a Thread-local Context
Lifespan of a Contextual Session
Associating Classes and Mappers with 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
Binding MetaData to an Engine or Connection
Reflecting Tables
Overriding Reflected Columns
Specifying the Schema Name
ON UPDATE and ON DELETE
Other Options
Creating and Dropping Database Tables
Column Insert/Update Defaults
Pre-Executed Python Functions
Pre-executed and Inline SQL Expressions
DDL-Level Defaults
Defining Sequences
Defining Constraints and Indexes
UNIQUE Constraint
CHECK Constraint
Indexes
Adapting Tables to Alternate Metadata
The Types System
Built-in Types
Dialect Specific Types
Creating your Own Types
Connection Pooling
Establishing a Transparent Connection Pool
Connection Pool Configuration
Custom Pool Construction
Plugins
associationproxy
Simplifying Relations
Simplifying Association Object Relations
Building Complex Views
orderinglist
SqlSoup
Deprecated Extensions
SelectResults
SessionContext
assignmapper
ActiveMapper
API Documentation
module sqlalchemy.engine
Module Functions
create_engine()
engine_descriptors()
engine_from_config()
class BufferedColumnResultProxy(ResultProxy)
class BufferedColumnRow(RowProxy)
class BufferedRowResultProxy(ResultProxy)
class Compiled(object)
class Connectable(object)
class Connection(Connectable)
class DefaultRunner(SchemaVisitor)
class Dialect(object)
class Engine(Connectable)
class ExecutionContext(object)
class NestedTransaction(Transaction)
class ResultProxy(object)
class RootTransaction(Transaction)
class RowProxy(object)
class SchemaIterator(SchemaVisitor)
class Transaction(object)
class TwoPhaseTransaction(Transaction)
module sqlalchemy.engine.default
class DefaultDialect(Dialect)
class DefaultExecutionContext(ExecutionContext)
module sqlalchemy.engine.url
Module Functions
make_url()
class URL(object)
module sqlalchemy.engine.threadlocal
class TLConnection(Connection)
class TLEngine(Engine)
class TLSession(object)
class TLTransaction(Transaction)
module sqlalchemy.exceptions
class ArgumentError()
class AssertionError()
class CircularDependencyError()
class CompileError()
class ConcurrentModificationError()
class DBAPIError()
class DataError()
class DatabaseError()
class DisconnectionError()
class FlushError()
class IntegrityError()
class InterfaceError()
class InvalidRequestError()
class NoSuchColumnError()
class NoSuchTableError()
class NotSupportedError()
class OperationalError()
class ProgrammingError()
class SQLAlchemyError()
class TimeoutError()
module sqlalchemy.schema
class CheckConstraint(Constraint)
class Column(SchemaItem,_ColumnClause)
class ColumnDefault(DefaultGenerator)
class Constraint(SchemaItem)
class DefaultGenerator(SchemaItem)
class ForeignKey(SchemaItem)
class ForeignKeyConstraint(Constraint)
class Index(SchemaItem)
class MetaData(SchemaItem)
class PassiveDefault(DefaultGenerator)
class PrimaryKeyConstraint(Constraint)
class SchemaItem(object)
class SchemaVisitor(ClauseVisitor)
class Sequence(DefaultGenerator)
class Table(SchemaItem,TableClause)
class ThreadLocalMetaData(MetaData)
class UniqueConstraint(Constraint)
module sqlalchemy.sql.compiler
class DDLBase(SchemaIterator)
class DefaultCompiler(Compiled,ClauseVisitor)
class IdentifierPreparer(object)
class SchemaDropper(DDLBase)
class SchemaGenerator(DDLBase)
module sqlalchemy.sql.expression
Module Functions
alias()
and_()
asc()
between()
bindparam()
case()
cast()
column()
delete()
desc()
distinct()
except_()
except_all()
exists()
extract()
insert()
intersect()
intersect_all()
is_column()
join()
label()
literal()
literal_column()
not_()
null()
or_()
outerjoin()
outparam()
select()
subquery()
table()
text()
union()
union_all()
update()
class Alias(FromClause)
class _BinaryExpression(ColumnElement)
class _BindParamClause(ClauseElement,_CompareMixin)
class _CalculatedClause(ColumnElement)
class _Cast(ColumnElement)
class ClauseElement(object)
class ClauseList(ClauseElement)
class _ColumnClause(ColumnElement)
class ColumnCollection(OrderedProperties)
class ColumnElement(ClauseElement,_CompareMixin)
class _ColumnElementAdapter(ColumnElement)
class ColumnOperators(Operators)
class ColumnSet(OrderedSet)
class _CompareMixin(ColumnOperators)
class CompoundSelect(_SelectBaseMixin,FromClause)
class Delete(_UpdateBase)
class _Exists(_UnaryExpression)
class _FigureVisitName(type)
class FromClause(Selectable)
class _FromGrouping(FromClause)
class _Function(_CalculatedClause,FromClause)
class _FunctionGenerator(object)
class _Grouping(_ColumnElementAdapter)
class _IdentifiedClause(ClauseElement)
class Insert(_UpdateBase)
class Join(FromClause)
class _Label(ColumnElement)
class _Null(ColumnElement)
class Operators(object)
class ReleaseSavepointClause(_IdentifiedClause)
class RollbackToSavepointClause(_IdentifiedClause)
class SavepointClause(_IdentifiedClause)
class _ScalarSelect(_Grouping)
class Select(_SelectBaseMixin,FromClause)
class _SelectBaseMixin(object)
class Selectable(ClauseElement)
class TableClause(FromClause)
class _TextClause(ClauseElement)
class _TypeClause(ClauseElement)
class _UnaryExpression(ColumnElement)
class Update(_UpdateBase)
class _UpdateBase(ClauseElement)
module sqlalchemy.interfaces
class PoolListener(object)
module sqlalchemy.pool
Module Functions
clear_managers()
manage()
class AssertionPool(Pool)
class NullPool(Pool)
class Pool(object)
class QueuePool(Pool)
class SingletonThreadPool(Pool)
class StaticPool(Pool)
module sqlalchemy.engine.strategies
class DefaultEngineStrategy(EngineStrategy)
class EngineStrategy(object)
class MockEngineStrategy(EngineStrategy)
class PlainEngineStrategy(DefaultEngineStrategy)
class ThreadLocalEngineStrategy(DefaultEngineStrategy)
module sqlalchemy.types
class BLOB(Binary)
class BOOLEAN(Boolean)
class Binary(TypeEngine)
class Boolean(TypeEngine)
class CHAR(String)
class CLOB(TEXT)
class DATE(Date)
class DATETIME(DateTime)
class DECIMAL(Numeric)
class Date(TypeEngine)
class DateTime(TypeEngine)
class FLOAT(Float)
class Float(Numeric)
class INT(Integer)
class Integer(TypeEngine)
class Interval(TypeDecorator)
class NCHAR(Unicode)
class Numeric(TypeEngine)
class PickleType(MutableType,TypeDecorator)
class SMALLINT(SmallInteger)
class SmallInteger(Integer)
class String(TypeEngine,Concatenable)
class TEXT(String)
class TIME(Time)
class TIMESTAMP(DateTime)
class Time(TypeEngine)
class TypeDecorator(AbstractType)
class TypeEngine(AbstractType)
class Unicode(String)
class VARCHAR(String)
module sqlalchemy.orm
Module Functions
backref()
class_mapper()
clear_mappers()
column_property()
compile_mappers()
composite()
contains_alias()
contains_eager()
create_session()
defer()
deferred()
dynamic_loader()
eagerload()
eagerload_all()
extension()
lazyload()
mapper()
noload()
object_mapper()
object_session()
polymorphic_union()
relation()
scoped_session()
sessionmaker()
synonym()
undefer()
undefer_group()
class MapperExtension(object)
class PropComparator(ColumnOperators)
class Query(object)
module sqlalchemy.orm.collections
Module Functions
attribute_mapped_collection()
collection_adapter()
column_mapped_collection()
mapped_collection()
class collection(object)
class MappedCollection(dict)
class CollectionAdapter(object)
module sqlalchemy.orm.interfaces
class AttributeExtension(object)
class ExtensionOption(MapperOption)
class LoaderStack(object)
class LoaderStrategy(object)
class MapperExtension(object)
class MapperOption(object)
class MapperProperty(object)
class OperationContext(object)
class PropComparator(ColumnOperators)
class PropertyOption(MapperOption)
class StrategizedOption(PropertyOption)
class StrategizedProperty(MapperProperty)
class SynonymProperty(MapperProperty)
module sqlalchemy.orm.mapper
Module Functions
class_mapper()
object_mapper()
class Mapper(object)
module sqlalchemy.orm.properties
class BackRef(object)
class ColumnProperty(StrategizedProperty)
class CompositeProperty(ColumnProperty)
class PropertyLoader(StrategizedProperty)
module sqlalchemy.orm.query
class Query(object)
module sqlalchemy.orm.session
class Session(object)
class SessionExtension(object)
module sqlalchemy.orm.shard
class ShardedQuery(Query)
class ShardedSession(Session)
module sqlalchemy.ext.associationproxy
Module Functions
association_proxy()
class AssociationProxy(object)
module sqlalchemy.ext.orderinglist
Module Functions
ordering_list()
class OrderingList(list)
module sqlalchemy.ext.sqlsoup
class PKNotFoundError()
class SqlSoup()
module sqlalchemy.databases.sqlite
Module Functions
descriptor()
class DateTimeMixin(object)
class PassiveDefault(DefaultGenerator)
class SLBinary(Binary)
class SLBoolean(Boolean)
class SLChar(CHAR)
class SLDate(DateTimeMixin,Date)
class SLDateTime(DateTimeMixin,DateTime)
class SLInteger(Integer)
class SLNumeric(Numeric)
class SLSmallInteger(SmallInteger)
class SLString(String)
class SLText(TEXT)
class SLTime(DateTimeMixin,Time)
class SQLiteCompiler(DefaultCompiler)
class SQLiteDialect(DefaultDialect)
class SQLiteExecutionContext(DefaultExecutionContext)
class SQLiteIdentifierPreparer(IdentifierPreparer)
class SQLiteSchemaDropper(SchemaDropper)
class SQLiteSchemaGenerator(SchemaGenerator)
module sqlalchemy.databases.postgres
Module Functions
descriptor()
class PGArray(TypeEngine,Concatenable)
class PGBigInteger(PGInteger)
class PGBinary(Binary)
class PGBoolean(Boolean)
class PGChar(CHAR)
class PGCompiler(DefaultCompiler)
class PGDate(Date)
class PGDateTime(DateTime)
class PGDefaultRunner(DefaultRunner)
class PGDialect(DefaultDialect)
class PGExecutionContext(DefaultExecutionContext)
class PGFloat(Float)
class PGIdentifierPreparer(IdentifierPreparer)
class PGInet(TypeEngine)
class PGInteger(Integer)
class PGInterval(TypeEngine)
class PGNumeric(Numeric)
class PGSchemaDropper(SchemaDropper)
class PGSchemaGenerator(SchemaGenerator)
class PGSmallInteger(SmallInteger)
class PGString(String)
class PGText(TEXT)
class PGTime(Time)
module sqlalchemy.databases.mysql
class MSBigInteger(MSInteger)
class MSBinary(_BinaryType)
class MSBit(TypeEngine)
class MSBlob(_BinaryType)
class MSBoolean(Boolean)
class MSChar(_StringType,CHAR)
class MSDate(Date)
class MSDateTime(DateTime)
class MSDecimal(MSNumeric)
class MSDouble(MSNumeric)
class MSEnum(MSString)
class MSFloat(Float,_NumericType)
class MSInteger(Integer,_NumericType)
class MSLongBlob(MSBlob)
class MSLongText(MSText)
class MSMediumBlob(MSBlob)
class MSMediumText(MSText)
class MSNChar(_StringType,CHAR)
class MSNVarChar(_StringType,String)
class MSNumeric(Numeric,_NumericType)
class MSSet(MSString)
class MSSmallInteger(SmallInteger,_NumericType)
class MSString(_StringType,String)
class MSText(_StringType,TEXT)
class MSTime(Time)
class MSTimeStamp(TIMESTAMP)
class MSTinyBlob(MSBlob)
class MSTinyInteger(MSInteger)
class MSTinyText(MSText)
class MSVarBinary(_BinaryType)
class MSYear(TypeEngine)
module sqlalchemy.databases.oracle
Module Functions
descriptor()
class OracleBinary(Binary)
class OracleBoolean(Boolean)
class OracleChar(CHAR)
class OracleCompiler(DefaultCompiler)
class OracleDate(Date)
class OracleDateTime(DateTime)
class OracleDefaultRunner(DefaultRunner)
class OracleDialect(DefaultDialect)
class OracleExecutionContext(DefaultExecutionContext)
class OracleIdentifierPreparer(IdentifierPreparer)
class OracleInteger(Integer)
class OracleNumeric(Numeric)
class OracleRaw(Binary)
class OracleSchemaDropper(SchemaDropper)
class OracleSchemaGenerator(SchemaGenerator)
class OracleSmallInteger(SmallInteger)
class OracleString(String)
class OracleText(TEXT)
class OracleTimestamp(TIMESTAMP)
module sqlalchemy.databases.mssql
Module Functions
descriptor()
class AdoMSNVarchar(MSNVarchar)
class MSBigInteger(MSInteger)
class MSBinary(Binary)
class MSBoolean(Boolean)
class MSChar(CHAR)
class MSDate(Date)
class MSDateTime(DateTime)
class MSDateTime_adodbapi(MSDateTime)
class MSDateTime_pyodbc(MSDateTime)
class MSDate_pymssql(MSDate)
class MSDate_pyodbc(MSDate)
class MSFloat(Float)
class MSInteger(Integer)
class MSMoney(TypeEngine)
class MSNChar(NCHAR)
class MSNVarchar(Unicode)
class MSNumeric(Numeric)
class MSSQLCompiler(DefaultCompiler)
class MSSQLDefaultRunner(DefaultRunner)
class MSSQLDialect(DefaultDialect)
class MSSQLDialect_adodbapi(MSSQLDialect)
class MSSQLDialect_pymssql(MSSQLDialect)
class MSSQLDialect_pyodbc(MSSQLDialect)
class MSSQLExecutionContext(DefaultExecutionContext)
class MSSQLExecutionContext_pyodbc(MSSQLExecutionContext)
class MSSQLIdentifierPreparer(IdentifierPreparer)
class MSSQLSchemaDropper(SchemaDropper)
class MSSQLSchemaGenerator(SchemaGenerator)
class MSSmallInteger(MSInteger)
class MSSmallMoney(MSMoney)
class MSString(String)
class MSText(TEXT)
class MSTime(Time)
class MSTimeStamp(TIMESTAMP)
class MSTinyInteger(MSInteger)
class MSUniqueIdentifier(TypeEngine)
class MSVariant(TypeEngine)
module sqlalchemy.databases.firebird
Module Functions
descriptor()
class FBBinary(Binary)
class FBBoolean(Boolean)
class FBChar(CHAR)
class FBCompiler(DefaultCompiler)
class FBDate(DateTime)
class FBDateTime(DateTime)
class FBDefaultRunner(DefaultRunner)
class FBDialect(DefaultDialect)
class FBExecutionContext(DefaultExecutionContext)
class FBFloat(Float)
class FBIdentifierPreparer(IdentifierPreparer)
class FBInteger(Integer)
class FBNumeric(Numeric)
class FBSchemaDropper(SchemaDropper)
class FBSchemaGenerator(SchemaGenerator)
class FBSmallInteger(SmallInteger)
class FBString(String)
class FBText(TEXT)
class FBTime(Time)
module sqlalchemy.databases.sybase
class SybaseBigInteger(SybaseInteger)
class SybaseBinary(Binary)
class SybaseBoolean(Boolean)
class SybaseChar(CHAR)
class SybaseDateTime_mxodbc(DateTime)
class SybaseDateTime_pyodbc(DateTime)
class SybaseDate_mxodbc(Date)
class SybaseDate_pyodbc(Date)
class SybaseFloat(FLOAT,SybaseNumeric)
class SybaseInteger(Integer)
class SybaseMoney(TypeEngine)
class SybaseSmallInteger(SybaseInteger)
class SybaseSmallMoney(SybaseMoney)
class SybaseString(String)
class SybaseText(TEXT)
class SybaseTimeStamp(TIMESTAMP)
class SybaseTime_mxodbc(Time)
class SybaseTime_pyodbc(Time)
class SybaseTinyInteger(SybaseInteger)
class SybaseUniqueIdentifier(TypeEngine)
module sqlalchemy.databases.access
Module Functions
descriptor()
class AcBinary(Binary)
class AcBoolean(Boolean)
class AcChar(CHAR)
class AcDate(Date)
class AcDateTime(DateTime)
class AcFloat(Float)
class AcInteger(Integer)
class AcNumeric(Numeric)
class AcSmallInteger(SmallInteger)
class AcString(String)
class AcText(TEXT)
class AcTimeStamp(TIMESTAMP)
class AcTinyInteger(Integer)
class AcUnicode(Unicode)
class AccessCompiler(DefaultCompiler)
class AccessDefaultRunner(DefaultRunner)
class AccessDialect(DefaultDialect)
class AccessExecutionContext(DefaultExecutionContext)
class AccessIdentifierPreparer(IdentifierPreparer)
class AccessSchemaDropper(SchemaDropper)
class AccessSchemaGenerator(SchemaGenerator)
Appendix: Copyright