U
|
¸ý°dJ ã @ sÐ d Z ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlm
|
Z
|
dd l m Z dd
|
l mZ dd lmZ dd lmZ dd lmZ ddlmZ er ddlmZ G dd dZG dd deZG dd dZdS )z1Public API functions and helpers for declarative.é )Ú annotationsN)ÚCallable)Ú TYPE_CHECKINGé )Úexc)Ú relationships)Ú_mapper_or_none)Ú _resolver)Ú_DeferredMapperConfig)Úpolymorphic_union©ÚTable)Ú OrderedDict)ÚMetaDatac @ s( e Zd ZdZedd Zedd 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.
|
|
.. versionchanged:: 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.
|
|
.. seealso::
|
|
:class:`.AbstractConcreteBase`
|
|
:ref:`concrete_inheritance`
|
|
|
c C s t tdd |D |dS )Nc s s | ]}|j |jfV qd S ©N)Zpolymorphic_identityÚ local_table)Ú.0Úmp© r ú\d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/declarative/extensions.pyÚ <genexpr>a s z9ConcreteBase._create_polymorphic_union.<locals>.<genexpr>Úpjoin)r r )ÚclsÚmappersÚdiscriminator_namer r r Ú_create_polymorphic_union^ s ÿûz&ConcreteBase._create_polymorphic_unionc C sX | j }|jrd S t| dd p d}t|j}| ||¡}| d|f¡ | |j| ¡ d S )NÚ _concrete_discriminator_nameÚtypeÚ*) Ú
|
__mapper__Úwith_polymorphicÚgetattrÚlistZself_and_descendantsr Z_set_with_polymorphicZ_set_polymorphic_onÚc)r Úmr r r r r r Ú__declare_first__h s ÿ
|
z ConcreteBase.__declare_first__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Ú classmethodr r& r r r r r s
|
?
|
r c @ s8 e Zd ZdZdZedd Zedd Zedd Zd S )
|
ÚAbstractConcreteBaseaº 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_first__()`` function, which is essentially
|
a hook for the :meth:`.before_configured` event.
|
|
:class:`.AbstractConcreteBase` applies :class:`_orm.Mapper` for its
|
immediately inheriting class, as would occur for any other
|
declarative mapped class. However, the :class:`_orm.Mapper` is not
|
mapped to any particular :class:`.Table` object. Instead, it's
|
mapped directly to the "polymorphic" selectable produced by
|
:func:`.polymorphic_union`, and performs no persistence operations on its
|
own. Compare to :class:`.ConcreteBase`, which maps its
|
immediately inheriting class to an actual
|
:class:`.Table` that stores rows directly.
|
|
.. note::
|
|
The :class:`.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
|
: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, once all
|
the desired classes have been configured, the
|
:meth:`_orm.registry.configure` method on the :class:`_orm.registry`
|
in use can be invoked, which is available in relation to a particular
|
declarative base class::
|
|
Base.registry.configure()
|
|
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.
|
|
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`::
|
|
from sqlalchemy.ext.declarative import AbstractConcreteBase
|
|
class Company(Base):
|
__tablename__ = 'company'
|
id = Column(Integer, primary_key=True)
|
|
class Employee(AbstractConcreteBase, Base):
|
strict_attrs = True
|
|
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
|
}
|
|
Base.registry.configure()
|
|
When we make use of our mappings however, both ``Manager`` and
|
``Employee`` will have an independently usable ``.company`` attribute::
|
|
session.execute(
|
select(Employee).filter(Employee.company.has(id=5))
|
)
|
|
:param 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.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:class:`.ConcreteBase`
|
|
:ref:`concrete_inheritance`
|
|
:ref:`abstract_concrete_base`
|
|
Tc C s | ¡ d S r )Ú_sa_decl_prepare_nocascade©r r r r r& ý s z&AbstractConcreteBase.__declare_first__c s t | dd rd S t | ¡}g }t| ¡ }|r`| ¡ }| | ¡ ¡ t|}|d k r*| |¡ q*t | dd pnd| |¡t
|
|j }dd |D t|j ¡ D ].\}}||kr¢j|j |j |< |j¡ q¢|_| j dd¡|jpît fdd } | |_| ¡ | g}|r| d
|
¡}
|
| |
|
¡ ¡ t|
|
} | r| jr| jd kr|
|
jd d
D ]$} t| } | rf| | ¡ qqfqd S ) Nr r r c S s h | ]
|
}|j qS r ©Úkey)r r$ r r r Ú <setcomp>! s zBAbstractConcreteBase._sa_decl_prepare_nocascade.<locals>.<setcomp>Ú strict_attrsFc sH } j | d< d| d< rDtj B hB | d< df| d< | S )NZpolymorphic_onTZpolymorphic_abstractZinclude_propertiesr r! )r$ ÚsetZ primary_key)Úargs©Zdeclared_col_keysr Zm_argsr r2 r r Ú mapper_args- s ÿþÿ zDAbstractConcreteBase._sa_decl_prepare_nocascade.<locals>.mapper_argsr é )r" r
|
Zconfig_for_clsr# Ú__subclasses__ÚpopÚextendr Úappendr r3 Zdeclared_columnsZ
|
propertiesÚitemsr$ r0 Úremover Ú__dict__ÚgetZmapper_args_fnÚdictÚmapZconcreteZinheritsÚ__mro__Z_set_concrete_base)r Úto_mapr ÚstackÚklassÚmnZ declared_colsÚkÚvr6 ZsclsÚsmZsup_Zsup_smr r5 r r- sJ
|
ÿ
|
|
|
|
z/AbstractConcreteBase._sa_decl_prepare_nocascadec C s t j| dt | ¡ dd S )NzíClass %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.©Úmsg©Úorm_excZUnmappedClassErrorZ_safe_cls_namer. r r r Ú_sa_raise_deferred_configK s ûþz.AbstractConcreteBase._sa_raise_deferred_configN) r' r( r) r* Z __no_table__r+ r& r- rN r r r r r, x s
|
|
Ir, c @ s@ e Zd ZdZedd ZedddddZd Zed
|
d Zd S ) ÚDeferredReflectionaN
|
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_with=engine
|
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)
|
|
.. seealso::
|
|
:ref:`orm_declarative_reflected_deferred_reflection` - in the
|
:ref:`orm_declarative_table_config_toplevel` section.
|
|
c C s t | ¡}t t¡}|D ],}|jdk r||jj|jjf |jj ¡ q|
|
¡ D}| ¡ D ] \\}}}|j |||ddd qZ| ¡ |D ]Ú}| ¡ |jj} | jj}| j ¡ D ]²}
|
t|
|
tjr®|
|
jj ¡ r®|
|
jj} t| jtr | j} || j| jf | j ¡ q®t| jt r®t |
|
j j|
|
\} }|| jd}|||jjf | j¡ | j | |¡f7 _ | | _q®q| ¡ D ]"\\}}}|j |||ddd qlW 5 Q R X dS )zjReflect all :class:`_schema.Table` objects for all current
|
:class:`.DeferredReflection` subclassesNTF)ÚonlyÚschemaZextend_existingZautoload_replace)!r
|
Zclasses_for_baseÚ collectionsÚ defaultdictr3 r ÚmetadatarQ ÚaddÚnameÚconnectr< ZreflectÚclearrA r r Úclass_Z_propsÚvaluesÚ
|
isinstancer ZRelationshipPropertyZ
|
_init_argsZ secondaryZ _is_populatedZargumentr Ústrr ÚparentZ
|
_resolversÚ_sa_deferred_table_resolver)r ZenginerC Zmetadata_to_tableZthingyÚconnrT rQ Z table_namesZmapperÚrelZ secondary_argZsecondary_tableÚ_Z resolve_argÚresolverr r r Úprepare sz
|
|
|
ÿþ û
|
ÿ
|
þþÿû ÿ
|
ÿþÿ ûzDeferredReflection.preparer zCallable[[str], Table])rT Úreturnc s ddd fdd }|S )Nr\ r )r0 rd c s
|
t | S r r r/ ©rT r r Ú_resolveõ s z@DeferredReflection._sa_deferred_table_resolver.<locals>._resolver )r rT rf r re r r^ ñ s z.DeferredReflection._sa_deferred_table_resolverTc C s t j| dt | ¡ dd S )NzClass %s is a subclass of DeferredReflection. Mappings are not produced until the .prepare() method is called on the class hierarchy.rJ rL r. r r r rN þ s ýþz,DeferredReflection._sa_raise_deferred_configN) r' r( r) r* r+ rc r^ Z_sa_decl_preparerN r r r r rO X s G
|
P
|
rO ) r* Ú
|
__future__r rR Útypingr r Zormr rM r Zorm.baser Zorm.clsregistryr Z orm.decl_baser
|
Zorm.utilr rQ r Úutilr Z
|
sql.schemar r r, rO r r r r Ú<module>
|
s$ Z a
|
