SQLAlchemy 0.5 Documentation

Table of Contents

• 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

• Overview / Installation
• • Overview
  • Tutorials
  • Reference Documentation
  • Installing SQLAlchemy
  • • Installing a Database API
    • Checking the Installed SQLAlchemy Version
  • 0.4 to 0.5 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
  • Building a Relation
  • Working with Related Objects
  • Querying with Joins
  • • Using Aliases
    • Using Subqueries
    • Using EXISTS
    • Common Relation Operators
  • Deleting
  • • Configuring delete/delete-orphan Cascade
  • 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
    • Changing Attribute Behavior
    • • Simple Validators
      • Using Descriptors
    • Composite Column Types
    • Controlling Ordering
    • Mapping Class Inheritance Hierarchies
    • • Joined Table Inheritance
      • • Polymorphic Querying Strategies
        • 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
    • Constructors and Object Initialization
    • 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()
    • • Specifying Foreign Keys
      • Building Query-Enabled Properties
      • 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
    • • Routing Explicit Joins/Statements into Eagerly Loaded Collections
    • Working with Large Collections
    • • Dynamic Relation 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
    • 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
  • • 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
    • Triggered Columns
    • Defining Sequences
  • Defining Constraints and Indexes
  • • UNIQUE Constraint
    • CHECK Constraint
    • Indexes
  • Adapting Tables to Alternate Metadata
• The Types System
• • Built-in Types
  • • String
    • Unicode
    • Text / UnicodeText
    • Numeric
    • Float
    • DateTime/Date/Time
    • Interval
    • Binary
    • Boolean
    • PickleType
    • SQL-Specific Types
  • Dialect Specific Types
  • Creating your Own Types
• Connection Pooling
• • Establishing a Transparent Connection Pool
  • Connection Pool Configuration
  • Custom Pool Construction
• Plugins
• • declarative
  • associationproxy
  • • Simplifying Relations
    • Simplifying Association Object Relations
    • Building Complex Views
  • orderinglist
  • serializer
  • SqlSoup
• API Documentation
• • module sqlalchemy.engine
  • • Module Functions
    • • create_engine()
      • 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.strategies
  • • class DefaultEngineStrategy(EngineStrategy)
    • class EngineStrategy(object)
    • class MockEngineStrategy(EngineStrategy)
    • class PlainEngineStrategy(DefaultEngineStrategy)
    • class ThreadLocalEngineStrategy(DefaultEngineStrategy)
    • class attrgetter(object)
  • module sqlalchemy.engine.threadlocal
  • • class TLConnection(Connection)
    • class TLEngine(Engine)
    • class TLSession(object)
    • class TLTransaction(Transaction)
  • module sqlalchemy.engine.url
  • • Module Functions
    • • make_url()
    • class URL(object)
  • module sqlalchemy.exc
  • • class ArgumentError()
    • class CircularDependencyError()
    • class CompileError()
    • class ConcurrentModificationError()
    • class DBAPIError()
    • class DataError()
    • class DatabaseError()
    • class DisconnectionError()
    • class FlushError()
    • class IdentifierError()
    • class IntegrityError()
    • class InterfaceError()
    • class InternalError()
    • class InvalidRequestError()
    • class NoReferenceError()
    • class NoReferencedColumnError()
    • class NoReferencedTableError()
    • class NoSuchColumnError()
    • class NoSuchTableError()
    • class NotSupportedError()
    • class OperationalError()
    • class ProgrammingError()
    • class SADeprecationWarning()
    • class SAPendingDeprecationWarning()
    • class SAWarning()
    • class SQLAlchemyError()
    • class TimeoutError()
    • class UnboundExecutionError()
  • module sqlalchemy.interfaces
  • • class ConnectionProxy(object)
    • class PoolListener(object)
  • module sqlalchemy.pool
  • • Module Functions
    • • as_interface()
      • clear_managers()
      • manage()
    • class AssertionPool(Pool)
    • class NullPool(Pool)
    • class Pool(object)
    • class QueuePool(Pool)
    • class SingletonThreadPool(Pool)
    • class StaticPool(Pool)
  • module sqlalchemy.schema
  • • class CheckConstraint(Constraint)
    • class Column(SchemaItem,_ColumnClause)
    • class ColumnDefault(DefaultGenerator)
    • class Constraint(SchemaItem)
    • class DDL(object)
    • class DefaultClause(FetchedValue)
    • class DefaultGenerator(SchemaItem)
    • class FetchedValue(object)
    • class ForeignKey(SchemaItem)
    • class ForeignKeyConstraint(Constraint)
    • class Index(SchemaItem)
    • class MetaData(SchemaItem)
    • class PrimaryKeyConstraint(Constraint)
    • class SchemaItem(Visitable)
    • 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)
    • class IdentifierPreparer(object)
    • class SchemaDropper(DDLBase)
    • class SchemaGenerator(DDLBase)
  • module sqlalchemy.sql.expression
  • • Module Functions
    • • alias()
      • and_()
      • asc()
      • between()
      • bindparam()
      • case()
      • cast()
      • cloned_traverse()
      • collate()
      • 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(ColumnElement)
    • class BooleanClauseList(ClauseList,ColumnElement)
    • class _CalculatedClause(ColumnElement)
    • class _Cast(ColumnElement)
    • class ClauseElement(Visitable)
    • class ClauseList(ClauseElement)
    • class _ColumnClause(_Immutable,ColumnElement)
    • class ColumnCollection(OrderedProperties)
    • class ColumnElement(ClauseElement,_CompareMixin)
    • class ColumnOperators(Operators)
    • class ColumnSet(OrderedSet)
    • class _CompareMixin(ColumnOperators)
    • class CompoundSelect(_SelectBaseMixin,FromClause)
    • class Delete(_UpdateBase)
    • class _Exists(_UnaryExpression)
    • class FromClause(Selectable)
    • class _FromGrouping(FromClause)
    • class _Function(_CalculatedClause,FromClause)
    • class _FunctionGenerator(object)
    • class _Grouping(ColumnElement)
    • class _IdentifiedClause(ClauseElement)
    • class _Immutable(object)
    • class Insert(_ValuesBase)
    • 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(_Immutable,FromClause)
    • class _TextClause(ClauseElement)
    • class _TypeClause(ClauseElement)
    • class _UnaryExpression(ColumnElement)
    • class Update(_ValuesBase)
    • class _UpdateBase(ClauseElement)
    • class _ValuesBase(_UpdateBase)
    • class Visitable(object)
    • class attrgetter(object)
    • class _generated_label(unicode)
  • module sqlalchemy.types
  • • class AbstractType(object)
    • class BLOB(Binary)
    • class BOOLEAN(Boolean)
    • class Binary(TypeEngine)
    • class Boolean(TypeEngine)
    • class CHAR(String)
    • class CLOB(Text)
    • class Concatenable(object)
    • 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 MutableType(object)
    • class NCHAR(Unicode)
    • class NUMERIC(Numeric)
    • class Numeric(TypeEngine)
    • class PickleType(MutableType,TypeDecorator)
    • class SMALLINT(SmallInteger)
    • class SmallInteger(Integer)
    • class String(Concatenable,TypeEngine)
    • class TIME(Time)
    • class TIMESTAMP(DateTime)
    • class Text(String)
    • class Time(TypeEngine)
    • class TypeDecorator(AbstractType)
    • class TypeEngine(AbstractType)
    • class Unicode(String)
    • class UnicodeText(Text)
    • class VARCHAR(String)
  • module sqlalchemy.orm
  • • Module Functions
    • • backref()
      • class_mapper()
      • clear_mappers()
      • column_property()
      • comparable_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()
      • reconstructor()
      • relation()
      • scoped_session()
      • sessionmaker()
      • synonym()
      • undefer()
      • undefer_group()
      • validates()
    • class AliasedClass(object)
    • class InstrumentationManager(object)
    • class MapperExtension(object)
    • class PropComparator(ColumnOperators)
    • class Query(object)
    • class Validator(AttributeExtension)
  • module sqlalchemy.orm.attributes
  • • Module Functions
    • • collect_management_factories_for()
      • del_attribute()
      • find_native_user_instrumentation_hook()
      • get_attribute()
      • get_history()
      • has_parent()
      • identity_equal()
      • init_collection()
      • is_instrumented()
      • proxied_attribute_factory()
      • register_attribute()
      • register_class()
      • set_attribute()
      • unregister_attribute()
      • unregister_class()
    • class AttributeImpl(object)
    • class ClassManager(dict)
    • class CollectionAttributeImpl(AttributeImpl)
    • class Events(object)
    • class GenericBackrefExtension(AttributeExtension)
    • class History(tuple)
    • class InstanceState(object)
    • class InstrumentationRegistry(object)
    • class InstrumentedAttribute(QueryableAttribute)
    • class MutableScalarAttributeImpl(ScalarAttributeImpl)
    • class PendingCollection(object)
    • class QueryableAttribute(PropComparator)
    • class ScalarAttributeImpl(AttributeImpl)
    • class ScalarObjectAttributeImpl(ScalarAttributeImpl)
    • class attrgetter(object)
    • class itemgetter(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
  • • Module Functions
    • • build_path()
    • class AttributeExtension(object)
    • class ExtensionOption(MapperOption)
    • class InstrumentationManager(object)
    • class LoaderStrategy(object)
    • class MapperExtension(object)
    • class MapperOption(object)
    • class MapperProperty(object)
    • class PropComparator(ColumnOperators)
    • class PropertyOption(MapperOption)
    • class SessionExtension(object)
    • class StrategizedOption(PropertyOption)
    • class StrategizedProperty(MapperProperty)
  • module sqlalchemy.orm.mapper
  • • Module Functions
    • • class_mapper()
    • class Mapper(object)
  • module sqlalchemy.orm.properties
  • • class BackRef(object)
    • class ColumnProperty(StrategizedProperty)
    • class ComparableProperty(MapperProperty)
    • class CompositeProperty(ColumnProperty)
    • class PropertyLoader(StrategizedProperty)
    • class SynonymProperty(MapperProperty)
  • 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.declarative
  • • Module Functions
    • • comparable_using()
      • declarative_base()
      • instrument_declarative()
      • synonym_for()
  • 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.serializer
  • • Module Functions
    • • Deserializer()
      • Serializer()
      • dumps()
      • loads()
  • module sqlalchemy.ext.sqlsoup
  • • class PKNotFoundError()
    • class SqlSoup()
  • module sqlalchemy.databases.access
  • • 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)
  • module sqlalchemy.databases.firebird
  • • 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.informix
  • • class InfoBinary(Binary)
    • class InfoBoolean(Boolean)
    • class InfoChar(CHAR)
    • class InfoCompiler(DefaultCompiler)
    • class InfoDate(Date)
    • class InfoDateTime(DateTime)
    • class InfoDialect(DefaultDialect)
    • class InfoExecutionContext(DefaultExecutionContext)
    • class InfoIdentifierPreparer(IdentifierPreparer)
    • class InfoInteger(Integer)
    • class InfoNumeric(Numeric)
    • class InfoSchemaDropper(SchemaDropper)
    • class InfoSchemaGenerator(SchemaGenerator)
    • class InfoSmallInteger(SmallInteger)
    • class InfoString(String)
    • class InfoText(String)
    • class InfoTime(Time)
    • class SingletonThreadPool(Pool)
    • class informix_cursor(object)
  • module sqlalchemy.databases.maxdb
  • • class MaxBlob(Binary)
    • class MaxBoolean(Boolean)
    • class MaxChar(_StringType)
    • class MaxDate(Date)
    • class MaxFloat(Float)
    • class MaxInteger(Integer)
    • class MaxNumeric(Numeric)
    • class MaxSmallInteger(MaxInteger)
    • class MaxString(_StringType)
    • class MaxText(_StringType)
    • class MaxTime(Time)
    • class MaxTimestamp(DateTime)
    • class MaxUnicode(_StringType)
  • module sqlalchemy.databases.mssql
  • • class AdoMSNVarchar(MSNVarchar)
    • class Decimal(object)
    • 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_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 MSSmallDate(Date)
    • 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.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(Float,_NumericType)
    • class MSEnum(MSString)
    • class MSFloat(Float,_NumericType)
    • class MSInteger(Integer,_NumericType)
    • class MSLongBlob(MSBlob)
    • class MSLongText(MSText)
    • class MSMediumBlob(MSBlob)
    • class MSMediumInteger(MSInteger)
    • class MSMediumText(MSText)
    • class MSNChar(_StringType,CHAR)
    • class MSNVarChar(_StringType,String)
    • class MSNumeric(Numeric,_NumericType)
    • class MSSet(MSString)
    • class MSSmallInteger(SmallInteger,MSInteger)
    • 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
  • • 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(OracleBinary)
    • class OracleSchemaDropper(SchemaDropper)
    • class OracleSchemaGenerator(SchemaGenerator)
    • class OracleSmallInteger(SmallInteger)
    • class OracleString(String)
    • class OracleText(Text)
    • class OracleTimestamp(TIMESTAMP)
  • module sqlalchemy.databases.postgres
  • • class PGArray(MutableType,Concatenable,TypeEngine)
    • class PGBigInteger(PGInteger)
    • class PGBinary(Binary)
    • class PGBoolean(Boolean)
    • class PGChar(CHAR)
    • class PGCidr(TypeEngine)
    • 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 PGMacAddr(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.sqlite
  • • class DateTimeMixin(object)
    • class DefaultClause(FetchedValue)
    • class NoneType(object)
    • class SLBinary(Binary)
    • class SLBoolean(Boolean)
    • class SLChar(SLUnicodeMixin,CHAR)
    • class SLDate(DateTimeMixin,Date)
    • class SLDateTime(DateTimeMixin,DateTime)
    • class SLFloat(Float)
    • class SLInteger(Integer)
    • class SLNumeric(Numeric)
    • class SLSmallInteger(SmallInteger)
    • class SLString(SLUnicodeMixin,String)
    • class SLText(SLUnicodeMixin,Text)
    • class SLTime(DateTimeMixin,Time)
    • class SLUnicodeMixin(object)
    • class SQLiteCompiler(DefaultCompiler)
    • class SQLiteDialect(DefaultDialect)
    • class SQLiteExecutionContext(DefaultExecutionContext)
    • class SQLiteIdentifierPreparer(IdentifierPreparer)
    • class SQLiteSchemaDropper(SchemaDropper)
    • class SQLiteSchemaGenerator(SchemaGenerator)
  • 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)
• Appendix: Copyright