Declarative Extensions

Changed in version 1.4: The vast majority of the Declarative extension is now integrated into the SQLAlchemy ORM and is importable from the namespace. See the documentation at Declarative Mapping for new documentation. For an overview of the change, see .

class sqlalchemy.ext.declarative.AbstractConcreteBase

A helper class for ‘concrete’ declarative mappings.

AbstractConcreteBase will use the function automatically, against all tables mapped as a subclass to this class. The function is called via the __declare_first__() function, which is essentially a hook for the before_configured() event.

applies Mapper for its immediately inheriting class, as would occur for any other declarative mapped class. However, the is not mapped to any particular Table object. Instead, it’s mapped directly to the “polymorphic” selectable produced by , and performs no persistence operations on its own. Compare to ConcreteBase, which maps its immediately inheriting class to an actual that stores rows directly.

Note

The AbstractConcreteBase delays the mapper creation of the base class until all the subclasses have been defined, as it needs to create a mapping against a selectable that will include all subclass tables. In order to achieve this, it waits for the mapper configuration event to occur, at which point it scans through all the configured subclasses and sets up a mapping that will query against all subclasses at once.

While this event is normally invoked automatically, in the case of , it may be necessary to invoke it explicitly after all subclass mappings are defined, if the first operation is to be a query against this base class. To do so, once all the desired classes have been configured, the registry.configure() method on the in use can be invoked, which is available in relation to a particular declarative base class:

Example:

from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.ext.declarative import AbstractConcreteBase
class Base(DeclarativeBase):
    pass
class Employee(AbstractConcreteBase, Base):
    pass
class Manager(Employee):
    __tablename__ = 'manager'
    employee_id = Column(Integer, primary_key=True)
    name = Column(String(50))
    manager_data = Column(String(40))
    __mapper_args__ = {
        'polymorphic_identity':'manager',
        'concrete':True
    }
Base.registry.configure()

The abstract base class is handled by declarative in a special way; at class configuration time, it behaves like a declarative mixin or an __abstract__ base class. Once classes are configured and mappings are produced, it then gets mapped itself, but after all of its descendants. This is a very unique system of mapping not found in any other SQLAlchemy API feature.

from sqlalchemy.ext.declarative import AbstractConcreteBase
class Company(Base):
    __tablename__ = 'company'
    id = Column(Integer, primary_key=True)
class Employee(AbstractConcreteBase, Base):
    strict_attrs = True
    def company_id(cls):
        return Column(ForeignKey('company.id'))
    @declared_attr
    def company(cls):
        return relationship("Company")
class Manager(Employee):
    __tablename__ = 'manager'
    name = Column(String(50))
    manager_data = Column(String(40))
    __mapper_args__ = {
        'polymorphic_identity':'manager',
        'concrete':True
    }
Base.registry.configure()

When we make use of our mappings however, both Manager and Employee will have an independently usable .company attribute:

Parameters:

strict_attrs –

when specified on the base class, “strict” attribute mode is enabled which attempts to limit ORM mapped attributes on the base class to only those that are immediately present, while still preserving “polymorphic” loading behavior.

New in version 2.0.

See also

ConcreteBase

Abstract Concrete Classes

Class signature

class (sqlalchemy.ext.declarative.extensions.ConcreteBase)

class sqlalchemy.ext.declarative.ConcreteBase

A helper class for ‘concrete’ declarative mappings.

will use the polymorphic_union() function automatically, against all tables mapped as a subclass to this class. The function is called via the __declare_last__() function, which is essentially a hook for the event.

ConcreteBase produces a mapped table for the class itself. Compare to , which does not.

Example:

from sqlalchemy.ext.declarative import ConcreteBase
class Employee(ConcreteBase, Base):
    __tablename__ = 'employee'
    employee_id = Column(Integer, primary_key=True)
    name = Column(String(50))
    __mapper_args__ = {
                    'polymorphic_identity':'employee',
class Manager(Employee):
    employee_id = Column(Integer, primary_key=True)
    name = Column(String(50))
    manager_data = Column(String(40))
    __mapper_args__ = {
                    'polymorphic_identity':'manager',
                    'concrete':True}

class Employee(ConcreteBase, Base):
    _concrete_discriminator_name = '_concrete_discriminator'

New in version 1.3.19: Added the _concrete_discriminator_name attribute to ConcreteBase so that the virtual discriminator column name can be customized.

Changed in version 1.4.2: The _concrete_discriminator_name attribute need only be placed on the basemost class to take correct effect for all subclasses. An explicit error message is now raised if the mapped column names conflict with the discriminator name, whereas in the 1.3.x series there would be some warnings and then a non-useful query would be generated.

See also

Concrete Table Inheritance

class sqlalchemy.ext.declarative.DeferredReflection

A helper class for construction of mappings based on a deferred reflection step.

Normally, declarative can be used with reflection by setting a object using autoload_with=engine as the __table__ attribute on a declarative class. The caveat is that the Table must be fully reflected, or at the very least have a primary key column, at the point at which a normal declarative mapping is constructed, meaning the must be available at class declaration time.

The DeferredReflection mixin moves the construction of mappers to be at a later point, after a specific method is called which first reflects all objects created so far. Classes can define it as such:

Above, MyClass is not yet mapped. After a series of classes have been defined in the above fashion, all tables can be reflected and mappings created using prepare():

engine = create_engine("someengine://...")
DeferredReflection.prepare(engine)

The mixin can be applied to individual classes, used as the base for the declarative base itself, or used in a custom abstract class. Using an abstract base allows that only a subset of classes to be prepared for a particular prepare step, which is necessary for applications that use more than one engine. For example, if an application has two engines, you might use two bases, and prepare each separately, e.g.:

class ReflectedOne(DeferredReflection, Base):
    __abstract__ = True
class ReflectedTwo(DeferredReflection, Base):
    __abstract__ = True
class MyClass(ReflectedOne):
    __tablename__ = 'mytable'
class MyOtherClass(ReflectedOne):
    __tablename__ = 'myothertable'
class YetAnotherClass(ReflectedTwo):
    __tablename__ = 'yetanothertable'
# ... etc.

Above, the class hierarchies for ReflectedOne and can be configured separately:

Members

prepare()