` feature of SQLAlchemy
is typically preferred instead of synonyms, which is a more legacy
feature.
.. seealso::
:ref:`synonyms` - Overview of synonyms
:func:`_orm.synonym` - the mapper-level function
:ref:`mapper_hybrids` - The Hybrid Attribute extension provides an
updated approach to augmenting attribute behavior more flexibly than
can be achieved with synonyms.
c ( t | S )N)
map_column
descriptor) _orm_synonym)fnrE names r' decoratez synonym_for..decoratey s DZBGGGGr) rB )rI rE rJ s `` r' synonym_forrK V s0 FH H H H H H Or) c fd}|S )a( Decorator, allow a Python @property to be used in query criteria.
This is a decorator front end to
:func:`~sqlalchemy.orm.comparable_property` that passes
through the comparator_factory and the function being decorated::
@comparable_using(MyComparatorType)
@property
def prop(self):
return 'special sauce'
The regular ``comparable_property()`` is also usable directly in a
declarative setting and may be convenient for read/write properties::
prop = comparable_property(MyComparatorType)
c $ t | S r: r )rH comparator_factorys r' rJ z"comparable_using..decorate s "#5r:::r) rB )rN rJ s ` r' comparable_usingrO s# &; ; ; ; ; Or) c V e Zd ZdZd fd Zd Zed Zed Z xZ
S )
declared_attraF Mark a class-level method as representing the definition of
a mapped property or special declarative member name.
@declared_attr turns the attribute into a scalar-like
property that can be invoked from the uninstantiated class.
Declarative treats attributes specifically marked with
@declared_attr as returning a construct that is specific
to mapping or declarative table configuration. The name
of the attribute is that of what the non-dynamic version
of the attribute would be.
@declared_attr is more often than not applicable to mixins,
to define relationships that are to be applied to different
implementors of the class::
class ProvidesUser(object):
"A mixin that adds a 'user' relationship to classes."
@declared_attr
def user(self):
return relationship("User")
It also can be applied to mapped classes, such as to provide
a "polymorphic" scheme for inheritance::
class Employee(Base):
id = Column(Integer, primary_key=True)
type = Column(String(50), nullable=False)
@declared_attr
def __tablename__(cls):
return cls.__name__.lower()
@declared_attr
def __mapper_args__(cls):
if cls.__name__ == 'Employee':
return {
"polymorphic_on":cls.type,
"polymorphic_identity":"Employee"
}
else:
return {"polymorphic_identity":cls.__name__}
Fc ~ t t | | |j | _ || _ d S r: )superrQ r4 __doc__
_cascading)selffget cascading __class__s r' r4 zdeclared_attr.__init__ s5
mT""++D111| #r) c n |j dd }|qt j d| j j s=t
j | )t j d| j j d|j | | S | |v r|| S | | x|| < }|S )N_sa_declared_attr_regz^__.+__$z*Unmanaged access of declarative attribute z from non-mapped class )
r! getrematchrW r$ r manager_of_classr warn)descrV r% regobjs r' __get__zdeclared_attr.__get__ s l 6== ;H[$)*<==
/44< -1Y-?-?-? O 99S>> !
S[[t9 "iinn ,CIJr) c t di |S NrB )_stateful_declared_attrr% r8 s r' _statefulzdeclared_attr._stateful s &,,,,,r) c . | d S )a Mark a :class:`.declared_attr` as cascading.
This is a special-use modifier which indicates that a column
or MapperProperty-based declared attribute should be configured
distinctly per mapped subclass, within a mapped-inheritance scenario.
.. warning::
The :attr:`.declared_attr.cascading` modifier has several
limitations:
* The flag **only** applies to the use of :class:`.declared_attr`
on declarative mixin classes and ``__abstract__`` classes; it
currently has no effect when used on a mapped class directly.
* The flag **only** applies to normally-named attributes, e.g.
not any special underscore attributes such as ``__tablename__``.
On these attributes it has **no** effect.
* The flag currently **does not allow further overrides** down
the class hierarchy; if a subclass tries to override the
attribute, a warning is emitted and the overridden attribute
is skipped. This is a limitation that it is hoped will be
resolved at some point.
Below, both MyClass as well as MySubClass will have a distinct
``id`` Column object established::
class HasIdMixin(object):
@declared_attr.cascading
def id(cls):
if has_inherited_table(cls):
return Column(
ForeignKey('myclass.id'), primary_key=True
)
else:
return Column(Integer, primary_key=True)
class MyClass(HasIdMixin, Base):
__tablename__ = 'myclass'
# ...
class MySubClass(MyClass):
""
# ...
The behavior of the above configuration is that ``MySubClass``
will refer to both its own ``id`` column as well as that of
``MyClass`` underneath the attribute named ``some_id``.
.. seealso::
:ref:`declarative_inheritance`
:ref:`mixin_inheritance_columns`
T)rX )ri r% s r' rX zdeclared_attr.cascading s x }}t},,,r) F) r$ r@ rA rT r4 rd r ri r rX
__classcell__)rY s @r' rQ rQ s + +Z$ $ $ $ $ $
$ - - \- ;- ;- ^;- ;- ;- ;- ;-r) rQ c e Zd Zd Zd Zd ZdS )rg c || _ d S r: )r8 )rV r8 s r' r4 z _stateful_declared_attr.__init__! s
r) c v | j }| | t di |S rf )r8 copyupdaterg )rV r8 new_kws r' ri z!_stateful_declared_attr._stateful$ s7
b&00000r) c & t |fi | j S r: )rQ r8 )rV rH s r' __call__z _stateful_declared_attr.__call__) s R++47+++r) N)r$ r@ rA r4 ri ru rB r) r' rg rg sA 1 1 1
, , , , ,r) rg Basec * |p
t }| r| |_ |t j }t |t
r|fp|} t
|| }
t |t r
|j |
d< |r||
d< |r||
d< ||| |
S )aT
Construct a base class for declarative class definitions.
The new base class will be given a metaclass that produces
appropriate :class:`~sqlalchemy.schema.Table` objects and makes
the appropriate :func:`~sqlalchemy.orm.mapper` calls based on the
information provided declaratively in the class and any subclasses
of the class.
:param bind: An optional
:class:`~sqlalchemy.engine.Connectable`, will be assigned
the ``bind`` attribute on the :class:`~sqlalchemy.schema.MetaData`
instance.
:param metadata:
An optional :class:`~sqlalchemy.schema.MetaData` instance. All
:class:`~sqlalchemy.schema.Table` objects implicitly declared by
subclasses of the base will share this MetaData. A MetaData instance
will be created if none is provided. The
:class:`~sqlalchemy.schema.MetaData` instance will be available via the
`metadata` attribute of the generated declarative base class.
:param mapper:
An optional callable, defaults to :func:`~sqlalchemy.orm.mapper`. Will
be used to map subclasses to their Tables.
:param cls:
Defaults to :class:`object`. A type to use as the base for the generated
declarative base class. May be a class or tuple of classes.
:param name:
Defaults to ``Base``. The display name for the generated
class. Customizing this is not required, but can improve clarity in
tracebacks and debugging.
:param constructor:
Defaults to
:func:`~sqlalchemy.ext.declarative.base._declarative_constructor`, an
__init__ implementation that assigns \**kwargs for declared
fields and relationships to an instance. If ``None`` is supplied,
no __init__ will be provided and construction will fall back to
cls.__init__ by way of the normal Python semantics.
:param class_registry: optional dictionary that will serve as the
registry of class names-> mapped classes when string names
are used to identify classes inside of :func:`_orm.relationship`
and others. Allows two or more declarative base classes
to share the same registry of class names for simplified
inter-base relationships.
:param metaclass:
Defaults to :class:`.DeclarativeMeta`. A metaclass or __metaclass__
compatible callable to use as the meta type of the generated
declarative base class.
.. versionchanged:: 1.1 if :paramref:`.declarative_base.cls` is a
single class (rather than a tuple), the constructed base class will
inherit its docstring.
.. seealso::
:func:`.as_declarative`
N)r r# rT r4 __mapper_cls__) r bindweakrefWeakValueDictionary
isinstancetupledictr3 rT ) ry r# mapperr% rI constructorclass_registry metaclass lcl_metadatar6
class_dicts r' declarative_baser - s R )xzzL ! 4663&& & 1C6 8SE +l J #t , #
9 -!,
:
.'-
#$ 9T5* - --r) c fd}|S )a
Class decorator for :func:`.declarative_base`.
Provides a syntactical shortcut to the ``cls`` argument
sent to :func:`.declarative_base`, allowing the base class
to be converted in-place to a "declarative" base::
from sqlalchemy.ext.declarative import as_declarative
@as_declarative()
class Base(object):
@declared_attr
def __tablename__(cls):
return cls.__name__.lower()
id = Column(Integer, primary_key=True)
class MyMappedClass(Base):
# ...
All keyword arguments passed to :func:`.as_declarative` are passed
along to :func:`.declarative_base`.
.. seealso::
:func:`.declarative_base`
c : | d< | j d< t di S )Nr% rI rB )r$ r rh s r' rJ z as_declarative..decorate s+ 5 \6
%%"%%%r) rB )r8 rJ s ` r' as_declarativer s# :& & & & &
Or) c > e Zd ZdZed Zed ZdS ) ConcreteBasea A helper class for 'concrete' declarative mappings.
:class:`.ConcreteBase` will use the :func:`.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 :meth:`.after_configured` event.
:class:`.ConcreteBase` produces a mapped
table for the class itself. Compare to :class:`.AbstractConcreteBase`,
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',
'concrete':True}
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}
The name of the discriminator column used by :func:`.polymorphic_union`
defaults to the name ``type``. To suit the use case of a mapping where an
actual column in a mapped table is already named ``type``, the
discriminator name can be configured by setting the
``_concrete_discriminator_name`` attribute::
class Employee(ConcreteBase, Base):
_concrete_discriminator_name = '_concrete_discriminator'
.. versionadded:: 1.3.19 Added the ``_concrete_discriminator_name``
attribute to :class:`_declarative.ConcreteBase` so that the
virtual discriminator column name can be customized.
.. seealso::
:class:`.AbstractConcreteBase`
:ref:`concrete_inheritance`
c R t t d |D |d S )Nc 3 2 K | ]}|j |j fV d S r: )polymorphic_identity local_table).0mps r' z9ConcreteBase._create_polymorphic_union.. s= >@(".9 r) pjoin)r r )r% mappersdiscriminator_names r' _create_polymorphic_unionz&ConcreteBase._create_polymorphic_union sE DK
r) c | j }|j rd S t | d pd}t |j }| || }| d|f | |j | d S )N _concrete_discriminator_namer3 *)
__mapper__with_polymorphicr listself_and_descendantsr _set_with_polymorphic_set_polymorphic_onc)r% mr r r s r' __declare_first__z ConcreteBase.__declare_first__ s N F
$C)G H H
q-..--g7IJJ e --- eg&8 9:::::r) N)r$ r@ rA rT classmethodr r rB r) r' r r sU 6 6p
[
;
; [
;
;
;r) r c X e Zd ZdZdZed Zed Zed ZdS )AbstractConcreteBasea7 A helper class for 'concrete' declarative mappings.
:class:`.AbstractConcreteBase` will use the :func:`.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 :meth:`.after_configured` event.
:class:`.AbstractConcreteBase` does produce a mapped class
for the base class, however it is not persisted to any table; it
is instead mapped directly to the "polymorphic" selectable directly
and is only used for selecting. Compare to :class:`.ConcreteBase`,
which does create a persisted table for the base class.
.. note::
The :class:`.AbstractConcreteBase` class does not intend to set up the
mapping for 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
:class:`.AbstractConcreteBase`, 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, invoke
:func:`.configure_mappers` once all the desired classes have been
configured::
from sqlalchemy.orm import configure_mappers
configure_mappers()
.. seealso::
:func:`_orm.configure_mappers`
Example::
from sqlalchemy.ext.declarative import AbstractConcreteBase
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}
configure_mappers()
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 system.
Using this approach, we can specify columns and properties
that will take place on mapped subclasses, in the way that
we normally do as in :ref:`declarative_mixins`::
class Company(Base):
__tablename__ = 'company'
id = Column(Integer, primary_key=True)
class Employee(AbstractConcreteBase, Base):
employee_id = Column(Integer, primary_key=True)
@declared_attr
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}
configure_mappers()
When we make use of our mappings however, both ``Manager`` and
``Employee`` will have an independently usable ``.company`` attribute::
session.query(Employee).filter(Employee.company.has(id=5))
.. versionchanged:: 1.0.0 - The mechanics of :class:`.AbstractConcreteBase`
have been reworked to support relationships established directly
on the abstract base, without any special configurational steps.
.. seealso::
:class:`.ConcreteBase`
:ref:`concrete_inheritance`
Tc . | d S r: )_sa_decl_prepare_nocascaderk s r' r z&AbstractConcreteBase.__declare_first__{ s &&(((((r) c ~
t | dd rd S t j | }g }t | }|rc| }| | t | }|| | |ct | d pd
|
|
t |j }t |j
D ]#\ }}||v rj |j |j
|< $|_ |j pt&
fd} | |_ | }
| D ]8} t | } | r%| j r | | j v r| |
9d S )Nr r r3 c < } j | d< | S )Npolymorphic_on)r )argsr m_argsr s r' mapper_argszDAbstractConcreteBase._sa_decl_prepare_nocascade..mapper_args s& 688D%*W-?%@D! "Kr) )r- r config_for_clsr __subclasses__popextendr appendr r setdeclared_columnsr itemsr r; r mapper_args_fnr~ mapconcrete __bases___set_concrete_base)r% to_mapr stackklassmn
declared_colskvr r sclssmr r r s @@@r' r z/AbstractConcreteBase._sa_decl_prepare_nocascade s 3 d + + F&5c:: S''))** #IIKKE LL--// 0 0 0 ''B~r""" #
$C)G H H
--g7IJJ F 344
*002233 6 6DAqM!!',wqu~!!$ "&.$
!, JJLL&&(( ) )D &&B
)bk
)cT^&;&;%%a((( ) )r) c X t j | dt j | z )NzClass %s is a subclass of AbstractConcreteBase and has a mapping pending until all subclasses are defined. Call the sqlalchemy.orm.configure_mappers() function after all subclasses have been defined to complete the mapping of this class.msgorm_excUnmappedClassError_safe_cls_namerk s r' _sa_raise_deferred_configz.AbstractConcreteBase._sa_raise_deferred_config s9 ( 2
$S)) *
r) N) r$ r@ rA rT __no_table__r r r r rB r) r' r r sx p pd L) ) [) 4) 4) [4)l
[
r) r c e Zd ZdZed Zed Zed Zed Zed Z dS )DeferredReflectiona A helper class for construction of mappings based on
a deferred reflection step.
Normally, declarative can be used with reflection by
setting a :class:`_schema.Table` object using autoload=True
as the ``__table__`` attribute on a declarative class.
The caveat is that the :class:`_schema.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 :class:`_engine.Engine` must be available
at class declaration time.
The :class:`.DeferredReflection` mixin moves the construction
of mappers to be at a later point, after a specific
method is called which first reflects all :class:`_schema.Table`
objects created so far. Classes can define it as such::
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.declarative import DeferredReflection
Base = declarative_base()
class MyClass(DeferredReflection, Base):
__tablename__ = 'mytable'
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
:meth:`.prepare`::
engine = create_engine("someengine://...")
DeferredReflection.prepare(engine)
The :class:`.DeferredReflection` 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
``ReflectedTwo`` can be configured separately::
ReflectedOne.prepare(engine_one)
ReflectedTwo.prepare(engine_two)
c 8 t j | }|D ]}| |j | | |j j }|j j }|j
D ]}t |t j
r|j zt |j t r | |j | Yt |j t" r*|j xj | || fz
c_ dS )zjReflect all :class:`_schema.Table` objects for all current
:class:`.DeferredReflection` subclassesN)r classes_for_base_sa_decl_preparer r r% r r. r# _propsvaluesr| r RelationshipProperty secondaryr _reflect_tabler
_resolvers_sa_deferred_table_resolver)r% enginer thingyr r# rels r' preparezDeferredReflection.prepare s
'7<< F !3V < < < JJLLLZ*F }-H }++--
sJ$CDD
1!#-77 **3=&AAAA#CM?CC
00 ; ;FH M M5 00
r) c fd}|S )Nc T t | } | |S r: )r r )r; t1r% r r# s r' _resolvez@DeferredReflection._sa_deferred_table_resolver.._resolve s- sH%%B r6 * * *Ir) rB )r% r r# r s ``` r' r z.DeferredReflection._sa_deferred_table_resolver s/
r) c : || || d S d S r: )r )r% r r s r' r z#DeferredReflection._sa_decl_prepare& s. " {F 3 3 3 3 3 # "r) c X t j | dt j | z )NzClass %s is a subclass of DeferredReflection. Mappings are not produced until the .prepare() method is called on the class hierarchy.r r rk s r' r z,DeferredReflection._sa_raise_deferred_config/ s9 ( 7 $S))*
r) c P t |j |j ddd||j d S )NTF)extend_existingautoload_replaceautoload
autoload_withschema)r rI r# r )r% tabler s r' r z!DeferredReflection._reflect_table9 s>
J N " <
r) N)
r$ r@ rA rT r r r r r r rB r) r' r r s @ @D [, [ 4 4 [4
[
[
r) r c t | }|St j | r?t j | t j | dt j | z |S )NzOClass %s has a deferred mapping on it. It is not yet usable as a mapped class.r )r r has_clsraise_unmapped_for_clsr r r )r% r s r' _inspect_decl_metar F su s # #B z ( - - ! 8 = = =,,.5.DS.I.IJ
Ir) rl )5rT r] rz baser r r r r
r clsregistryr r r r ormr r r r r r rG orm.baser r orm.utilr r r r r r r r( r/ r3 r1 rK rO _MappedAttributepropertyrQ rg objectr r r r r _inspectsr rB r) r' r s 8 7
! ! ! ! ! ! * * * * * * ' ' ' ' ' ' ) ) ) ) ) ) ( ( ( ( ( ( & & & & & & ! ! ! ! ! ! * * * * * * - - - - - - ' ' ' ' ' ' ) ) ) ) ) ) " " " " " " 5 5 5 &
!
!
!
!
!d
!
!
!& & & &R 2E- E- E- E- E-J/ E- E- E-P
,
,
,
,
,m
,
,
,
( ]. ]. ]. ].@" " "JQ; Q; Q; Q; Q;6 Q; Q; Q;hz
z
z
z
z
< z
z
z
z@
@
@
@
@
@
@
@
F o&&
'&
r)