U
|
¸ý°dè¦ ã @ s U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl Z ddl
|
Z
|
ddl m Z ddl m Z dd l mZ dd
|
l mZ dd l mZ dd l mZ dd l mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl m Z ddl m Z ddl m Z ddl m Z ddl Z dd l!m"Z" dd l!m#Z$ dd l!m%Z% dd l!m&Z& dd l!m'Z' dd!l!m(Z) dd"l*m+Z+ dd#l,m-Z- dd$l,m.Z. dd%l,m/Z/ dd&l,m0Z0 dd'l,m1Z1 dd(l2m3Z3 dd)l2m4Z4 dd*l2m5Z5 dd+l2m6Z6 dd,l2m7Z7 dd-l2m8Z8 dd.l2m9Z9 dd/l:m;Z; d0d1l!m<Z< d0d l!m#Z= d0d2l!m>Z> d0d3l!m?Z? d0d4l!m@Z@ d0d5l!mAZA d0d!l!m(Z( d0d6l<mBZB d0d7l<mCZC d0d8lAm,ZD d0d9lAmEZE d0d:lAmFZF d0d;lAmGZG d0d<lAmHZH d0d=lAmIZI d0d!lAm(ZJ d0d>lAmKZK d0d?lLmMZM d0d@lNmOZO d0dAlPmQZQ d0dBlPmRZR d0dClSmTZT d0dDl(mUZU d0dEl(mVZV d0dFlWmXZX e rddGl*mYZY ddHl*mZZZ ddIl*m[Z[ ddJl*m\Z\ ddKl]m^Z^ ddLl_m`Z` ddMlambZb ddNlamcZc ddOldmeZe ddPl%mfZf ddQl:mgZg ddRl'mhZh ddSlimjZj ddTlkmlZl ddUl(mmZm d0dVlnmoZo d0dWlnmpZp d0dXlqmrZr d0dYlqmsZs d0dZltmuZu d0d[lNmvZv d0d\lNmwZw d0d]lSmxZx d0d^l(myZy e d_e d`Zze dadbd`Z{e dcddd`Z|e eXde ee eXde ee dfe e f f edg f ee dfe e f f Z}e ~¡ Zdhedi< djdkdldmZdndkdodpZdqae( dr¡Z
e
|
¡ Ze>je?jG dsdt dte8e7e+ eMe5e?je>jdu eCee+
|
ZG dvdw dweZdxdy Zdzd{d|d}d~dZe( d¡dzd{d|d}ddZe( d¡dzd{d|d}ddZd
d Zdqdqddd{d{ddddZdd Zdd ZG dd ded ZdS )a5 Logic to map Python classes to and from selectables.
|
|
Defines the :class:`~sqlalchemy.orm.mapper.Mapper` class, the central
|
configurational unit which associates a class with a database table.
|
|
This is a semi-private module; the main configurational API of the ORM is
|
available in :class:`~sqlalchemy.orm.`.
|
|
é )Ú annotations)Údeque)Úreduce)ÚchainN)ÚAny)ÚCallable)Úcast)Ú
|
Collection)ÚDeque)ÚDict)Ú FrozenSet)ÚGeneric)ÚIterable)ÚIterator)ÚList)ÚMapping)ÚOptional)ÚSequence)ÚSet)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú
|
attributes)Úexc)Úinstrumentation)Úloading)Ú
|
properties)Úutil)Ú_O)Ú_class_to_mapper)Ú_parse_mapper_argument)Ú _state_mapper)Ú PassiveFlag)Ú state_str)Ú_MappedAttribute)ÚEXT_SKIP)ÚInspectionAttr)ÚMapperProperty)ÚORMEntityColumnsClauseRole)ÚORMFromClauseRole)ÚStrategizedProperty)Ú PathRegistryé )Úevent)Ú
|
inspection)Úlog)Úschema)Úsql)Ú
|
dispatcher)Ú EventTarget)Úbase)Ú coercions)Ú
|
expression)Ú operators)Úroles)Ú TableClause)Úvisitors)ÚMemoizedHasCacheKey)ÚKeyedColumnElement)ÚColumn)ÚTable)Ú LABEL_STYLE_TABLENAME_PLUS_COL)Ú HasMemoized)Ú!HasMemoized_ro_memoized_attribute)ÚLiteral)Ú_IdentityKeyType)Ú _InstanceDict)Ú_ORMColumnExprArgument)Ú _RegistryType)Úregistry)ÚDependencyProcessor)ÚCompositeProperty)ÚSynonymProperty)Ú MapperEvents)Ú ClassManager)ÚCachingEntityRegistry)ÚColumnProperty)ÚRelationshipProperty)Ú InstanceState)Ú
|
ORMAdapter)ÚRow)Ú
|
RowMapping)Ú_ColumnExpressionArgument)Ú_EquivalentColumnMap)ÚReadOnlyColumnCollection)Ú ColumnClause)Ú ColumnElement)Ú
|
FromClause)Ú
|
OrderedSetÚ_T)ÚboundÚ_MPúMapperProperty[Any]Ú_FnzCallable[..., Any]Ú*ú Mapper[Any]r\ z.weakref.WeakKeyDictionary[_RegistryType, bool]Ú_mapper_registriesz Set[registry]©Úreturnc
|
C s$ t ttW 5 Q R £ S Q R X d S ©N)Ú_CONFIGURE_MUTEXÚsetre © rk rk úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/mapper.pyÚ_all_registries s rm úIterator[Mapper[Any]]c c s t D ]} | ¡ E d H qd S rh )rm Ú_mappers_to_configure)Úregrk rk rl Ú_unconfigured_mappers s
|
rq FÚ NO_ATTRIBUTEc @ sÒ
|
e Zd ZU dZded< dZdZded< dZej ddd¥d dddddddddddddddddddd d d dddd dd d d!d"Z
|
d#d$ Z d%d& Z d
|
Z dZd'ed(< ed)d*d+d,Zed-d. Zd ed/< d ed0< d1ed2< d3ed4< d5ed6< d7ed8< d9ed:< d ed;< d<ed=< d>ed?< d@edA< dBedC< dDedE< dFedG< dHedI< dJedK< dLedM< dedN< dedO< dPedQ< dRedS< dedT< dUedV< dUedW< dXedY< dZed[< dZded\< ded]< d^ed_< d`eda< dedb< dedc< ddede< dfedg< dedh< diedj< dkedl< dkedm< eje dndo¡dpdq Zejdrd*dsdtZdudv ZddwdxdydzZd{d| Zd}d~ Zdd Z dd Z dwd*ddZ d
d
ddddZ dwd*ddZ dwd*ddZ!d¦ddZ"d Z#e$j%dd Z&e$j%dd Z'e$j%dd Z(e )d¡dd Z*e )d¡d
|
d
|
ddd
ddddddddZ+d
dd d¡d¢d£Z,d§d
ddd¤ddd d¥d¦d§Z-e )d¡d
d¨d d¡d©dªZ.ej/ 0d«e1j2¡dwd*d¬dZ3dwd*d®d¯Z4d°d± Z5d
d²dwd³d´dµZ6dwd*d¶d·Z7ed
d*d¸d¹Z8d
ddwdºd»d¼Z9d
ddwdºd½d¾Z:d
d*d¿dÀZ;d
d*dÁdÂZ<dÃddÄdÅdÆZ=d
ddÇdÈdÉZ>d¨d
dddÊdËdÌZ?dÍdÎdÏdÐdÑZ@edÒdÓ ZAdddÔdÕdÖd×ZBdØddUdÙdÚdÛZCe$j%dd*dÜdÝZDe$j%dÞdß ZEe$j%dàdá ZFe$j%dâdã ZGe$j%dÔd*dädåZHe$j%dædç ZIeJdUd*dèdéZKeHZLeJdêdë ZMe$j%dìdí ZNe$j%dîdï ZOe$j%dðdñ ZPe$j%dòdó ZQe$j%dôd*dõdöZRe$j%dôd*d÷døZSe$j%dùd*dúdûZTe$j%dùd*düdýZUe$j%dþd*dÿd ZVe$jWdd ZXejdd ZYedUd*ddZZd©ddddd d
|
d Z[e$j%d d Z\edd Z]dªddZ^e$j%dd*ddZ_d«ddZ`e$j%dd*ddZae$j%dd*d d Zbe$j%e )d¡d d*d d Zce$j%e )d¡d!d*d"d#Zded$d% Zee$j%d&d*d'd(Zfe$j%e )d)¡d*d*d+d,Zge$j%e )d¡d-d*d.d/Zhd0d1d2d3d4Zie$j%d5d6 Zje$j%d7d*d8d9Zkd
ddd:d;d<Zle$j%d=d> Zmd?d@ ZndiddAdBdCZodiddAdDdEZpdFdddGdHdIZqdiddAdJdKZrdLd*dMdNZse$j%dÔd*dOdPZtdLd*dQdRZudid*dSdTZvedid*dUdVZwd¬dWdXZxddYddZd[d\d]d^Zyd®d_dd[d`dadbZzdcd[dddedfZ{e|j}fdÃdgd[dhdidjZ~dcd_dddkdlZe$j%dmdn Ze$j%dodp Ze$j%dqdr Ze$j%dsdt Ze$j%dudv Ze|j}fdÃdwdxdgddydzd{Z
d|d} Zd~d Zdd Ze|j}fddZdd
Zdd Ze$j%dd Zdd Zdd Ze )d¡dd Ze$j%dd Zd¯d
dÃdddddZe$j%dd Ze$j%dd Ze$j%dd Zdddd d¡d¢Zejd£d¤ Zd S (° ÚMappera Defines an association between a Python class and a database table or
|
other relational structure, so that ORM operations against the class may
|
proceed.
|
|
The :class:`_orm.Mapper` object is instantiated using mapping methods
|
present on the :class:`_orm.registry` object. For information
|
about instantiating new :class:`_orm.Mapper` objects, see
|
:ref:`orm_mapping_classes_toplevel`.
|
|
zdispatcher[Mapper[_O]]ÚdispatchFr Ú_configure_failed)ú1.3a The :paramref:`.mapper.non_primary` parameter is deprecated, and will be removed in a future release. The functionality of non primary mappers is now better suited using the :class:`.AliasedClass` construct, which can also be used as the target of a :func:`_orm.relationship` in 1.3.)Ú non_primaryNTÚautoéd zType[_O]zOptional[FromClause]z+Optional[Mapping[str, MapperProperty[Any]]]z/Optional[Iterable[_ORMColumnExprArgument[Any]]]Úboolz'Optional[Union[Mapper[Any], Type[Any]]]z)Optional[_ColumnExpressionArgument[bool]]z/Optional[Sequence[_ORMColumnExprArgument[Any]]]z%Optional[_ORMColumnExprArgument[Any]]z5Optional[Union[Literal[False], Callable[[Any], Any]]]zFOptional[Union[_ORMColumnExprArgument[Any], str, MapperProperty[Any]]]z Optional[Dict[Any, Mapper[Any]]]z Optional[Any]z Optional[_WithPolymorphicArg]z)Optional[Literal[('selectin', 'inline')]]z Optional[str]zOptional[Sequence[str]]z Literal[(True, False, 'auto')]Úint) Úclass_Ú local_tabler Ú primary_keyrw ÚinheritsÚinherit_conditionÚinherit_foreign_keysÚalways_refreshÚversion_id_colÚversion_id_generatorÚpolymorphic_onÚ_polymorphic_mapÚpolymorphic_identityÚconcreteÚwith_polymorphicÚpolymorphic_abstractÚpolymorphic_loadÚallow_partial_pksÚbatchÚ column_prefixÚinclude_propertiesÚexclude_propertiesÚpassive_updatesÚpassive_deletesÚconfirm_deleted_rowsÚeager_defaultsÚlegacy_is_orphanÚ_compiled_cache_sizec C sØ t |td¡| _d| jj| jjf | _t |¡| _|| _ | | _
|
t |
|
t rV|
|
| _ d| _n |
|
dk rptjtj|
|
ddnd| _| dkrd| _n| dkrdd | _n| | _|| _d| _|dk rÀt|| _nd| _|dk ràt tj|¡| _n.| jrø| jj| _d | _nt d
|
| jj d ¡|dk r*t tj |¡| _ nd| _ || _ |rDt |ni | _ g | _!|| _"|| _#|| _$| dk r~tjtj| d dnd| _%|| _&g | _'t j(| _)|| _*|| _+| | _,d| _-d| _.d| _/i | _0| | _1d| _2|| _3| jrì| jsìd| _4n|| _4| 5|¡ || _6|| _7| dkri | _8n| | _8|dk r8t 9|¡| _:nd| _:|rRt 9|¡| _;nd| _;t<b t=d | j>j? @|| ¡ | A¡ | B¡ | C¡ | D¡ | E¡ | jF G| ¡ | Hd¡ | I¡ W 5 Q R X | j> J| | j¡ dS )a¹V Direct constructor for a new :class:`_orm.Mapper` object.
|
|
The :class:`_orm.Mapper` constructor is not called directly, and
|
is normally invoked through the
|
use of the :class:`_orm.registry` object through either the
|
:ref:`Declarative <orm_declarative_mapping>` or
|
:ref:`Imperative <orm_imperative_mapping>` mapping styles.
|
|
.. versionchanged:: 2.0 The public facing ``mapper()`` function is
|
removed; for a classical mapping configuration, use the
|
:meth:`_orm.registry.map_imperatively` method.
|
|
Parameters documented below may be passed to either the
|
:meth:`_orm.registry.map_imperatively` method, or may be passed in the
|
``__mapper_args__`` declarative class attribute described at
|
:ref:`orm_declarative_mapper_options`.
|
|
:param class\_: The class to be mapped. When using Declarative,
|
this argument is automatically passed as the declared class
|
itself.
|
|
:param local_table: The :class:`_schema.Table` or other
|
:class:`_sql.FromClause` (i.e. selectable) to which the class is
|
mapped. May be ``None`` if this mapper inherits from another mapper
|
using single-table inheritance. When using Declarative, this
|
argument is automatically passed by the extension, based on what is
|
configured via the :attr:`_orm.DeclarativeBase.__table__` attribute
|
or via the :class:`_schema.Table` produced as a result of
|
the :attr:`_orm.DeclarativeBase.__tablename__` attribute being
|
present.
|
|
:param polymorphic_abstract: Indicates this class will be mapped in a
|
polymorphic hierarchy, but not directly instantiated. The class is
|
mapped normally, except that it has no requirement for a
|
:paramref:`_orm.Mapper.polymorphic_identity` within an inheritance
|
hierarchy. The class however must be part of a polymorphic
|
inheritance scheme which uses
|
:paramref:`_orm.Mapper.polymorphic_on` at the base.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:ref:`orm_inheritance_abstract_poly`
|
|
:param always_refresh: If True, all query operations for this mapped
|
class will overwrite all data within object instances that already
|
exist within the session, erasing any in-memory changes with
|
whatever information was loaded from the database. Usage of this
|
flag is highly discouraged; as an alternative, see the method
|
:meth:`_query.Query.populate_existing`.
|
|
:param allow_partial_pks: Defaults to True. Indicates that a
|
composite primary key with some NULL values should be considered as
|
possibly existing within the database. This affects whether a
|
mapper will assign an incoming row to an existing identity, as well
|
as if :meth:`.Session.merge` will check the database first for a
|
particular primary key value. A "partial primary key" can occur if
|
one has mapped to an OUTER JOIN, for example.
|
|
:param batch: Defaults to ``True``, indicating that save operations
|
of multiple entities can be batched together for efficiency.
|
Setting to False indicates
|
that an instance will be fully saved before saving the next
|
instance. This is used in the extremely rare case that a
|
:class:`.MapperEvents` listener requires being called
|
in between individual row persistence operations.
|
|
:param column_prefix: A string which will be prepended
|
to the mapped attribute name when :class:`_schema.Column`
|
objects are automatically assigned as attributes to the
|
mapped class. Does not affect :class:`.Column` objects that
|
are mapped explicitly in the :paramref:`.Mapper.properties`
|
dictionary.
|
|
This parameter is typically useful with imperative mappings
|
that keep the :class:`.Table` object separate. Below, assuming
|
the ``user_table`` :class:`.Table` object has columns named
|
``user_id``, ``user_name``, and ``password``::
|
|
class User(Base):
|
__table__ = user_table
|
__mapper_args__ = {'column_prefix':'_'}
|
|
The above mapping will assign the ``user_id``, ``user_name``, and
|
``password`` columns to attributes named ``_user_id``,
|
``_user_name``, and ``_password`` on the mapped ``User`` class.
|
|
The :paramref:`.Mapper.column_prefix` parameter is uncommon in
|
modern use. For dealing with reflected tables, a more flexible
|
approach to automating a naming scheme is to intercept the
|
:class:`.Column` objects as they are reflected; see the section
|
:ref:`mapper_automated_reflection_schemes` for notes on this usage
|
pattern.
|
|
:param concrete: If True, indicates this mapper should use concrete
|
table inheritance with its parent mapper.
|
|
See the section :ref:`concrete_inheritance` for an example.
|
|
:param confirm_deleted_rows: defaults to True; when a DELETE occurs
|
of one more rows based on specific primary keys, a warning is
|
emitted when the number of rows matched does not equal the number
|
of rows expected. This parameter may be set to False to handle the
|
case where database ON DELETE CASCADE rules may be deleting some of
|
those rows automatically. The warning may be changed to an
|
exception in a future release.
|
|
:param eager_defaults: if True, the ORM will immediately fetch the
|
value of server-generated default values after an INSERT or UPDATE,
|
rather than leaving them as expired to be fetched on next access.
|
This can be used for event schemes where the server-generated values
|
are needed immediately before the flush completes.
|
|
The fetch of values occurs either by using ``RETURNING`` inline
|
with the ``INSERT`` or ``UPDATE`` statement, or by adding an
|
additional ``SELECT`` statement subsequent to the ``INSERT`` or
|
``UPDATE``, if the backend does not support ``RETURNING``.
|
|
The use of ``RETURNING`` is extremely performant in particular for
|
``INSERT`` statements where SQLAlchemy can take advantage of
|
:ref:`insertmanyvalues <engine_insertmanyvalues>`, whereas the use of
|
an additional ``SELECT`` is relatively poor performing, adding
|
additional SQL round trips which would be unnecessary if these new
|
attributes are not to be accessed in any case.
|
|
For this reason, :paramref:`.Mapper.eager_defaults` defaults to the
|
string value ``"auto"``, which indicates that server defaults for
|
INSERT should be fetched using ``RETURNING`` if the backing database
|
supports it and if the dialect in use supports "insertmanyreturning"
|
for an INSERT statement. If the backing database does not support
|
``RETURNING`` or "insertmanyreturning" is not available, server
|
defaults will not be fetched.
|
|
.. versionchanged:: 2.0.0rc1 added the "auto" option for
|
:paramref:`.Mapper.eager_defaults`
|
|
.. seealso::
|
|
:ref:`orm_server_defaults`
|
|
.. versionchanged:: 2.0.0 RETURNING now works with multiple rows
|
INSERTed at once using the
|
:ref:`insertmanyvalues <engine_insertmanyvalues>` feature, which
|
among other things allows the :paramref:`.Mapper.eager_defaults`
|
feature to be very performant on supporting backends.
|
|
:param exclude_properties: A list or set of string column names to
|
be excluded from mapping.
|
|
.. seealso::
|
|
:ref:`include_exclude_cols`
|
|
:param include_properties: An inclusive list or set of string column
|
names to map.
|
|
.. seealso::
|
|
:ref:`include_exclude_cols`
|
|
:param inherits: A mapped class or the corresponding
|
:class:`_orm.Mapper`
|
of one indicating a superclass to which this :class:`_orm.Mapper`
|
should *inherit* from. The mapped class here must be a subclass
|
of the other mapper's class. When using Declarative, this argument
|
is passed automatically as a result of the natural class
|
hierarchy of the declared classes.
|
|
.. seealso::
|
|
:ref:`inheritance_toplevel`
|
|
:param inherit_condition: For joined table inheritance, a SQL
|
expression which will
|
define how the two tables are joined; defaults to a natural join
|
between the two tables.
|
|
:param inherit_foreign_keys: When ``inherit_condition`` is used and
|
the columns present are missing a :class:`_schema.ForeignKey`
|
configuration, this parameter can be used to specify which columns
|
are "foreign". In most cases can be left as ``None``.
|
|
:param legacy_is_orphan: Boolean, defaults to ``False``.
|
When ``True``, specifies that "legacy" orphan consideration
|
is to be applied to objects mapped by this mapper, which means
|
that a pending (that is, not persistent) object is auto-expunged
|
from an owning :class:`.Session` only when it is de-associated
|
from *all* parents that specify a ``delete-orphan`` cascade towards
|
this mapper. The new default behavior is that the object is
|
auto-expunged when it is de-associated with *any* of its parents
|
that specify ``delete-orphan`` cascade. This behavior is more
|
consistent with that of a persistent object, and allows behavior to
|
be consistent in more scenarios independently of whether or not an
|
orphan object has been flushed yet or not.
|
|
See the change note and example at :ref:`legacy_is_orphan_addition`
|
for more detail on this change.
|
|
:param non_primary: Specify that this :class:`_orm.Mapper`
|
is in addition
|
to the "primary" mapper, that is, the one used for persistence.
|
The :class:`_orm.Mapper` created here may be used for ad-hoc
|
mapping of the class to an alternate selectable, for loading
|
only.
|
|
.. seealso::
|
|
:ref:`relationship_aliased_class` - the new pattern that removes
|
the need for the :paramref:`_orm.Mapper.non_primary` flag.
|
|
:param passive_deletes: Indicates DELETE behavior of foreign key
|
columns when a joined-table inheritance entity is being deleted.
|
Defaults to ``False`` for a base mapper; for an inheriting mapper,
|
defaults to ``False`` unless the value is set to ``True``
|
on the superclass mapper.
|
|
When ``True``, it is assumed that ON DELETE CASCADE is configured
|
on the foreign key relationships that link this mapper's table
|
to its superclass table, so that when the unit of work attempts
|
to delete the entity, it need only emit a DELETE statement for the
|
superclass table, and not this table.
|
|
When ``False``, a DELETE statement is emitted for this mapper's
|
table individually. If the primary key attributes local to this
|
table are unloaded, then a SELECT must be emitted in order to
|
validate these attributes; note that the primary key columns
|
of a joined-table subclass are not part of the "primary key" of
|
the object as a whole.
|
|
Note that a value of ``True`` is **always** forced onto the
|
subclass mappers; that is, it's not possible for a superclass
|
to specify passive_deletes without this taking effect for
|
all subclass mappers.
|
|
.. seealso::
|
|
:ref:`passive_deletes` - description of similar feature as
|
used with :func:`_orm.relationship`
|
|
:paramref:`.mapper.passive_updates` - supporting ON UPDATE
|
CASCADE for joined-table inheritance mappers
|
|
:param passive_updates: Indicates UPDATE behavior of foreign key
|
columns when a primary key column changes on a joined-table
|
inheritance mapping. Defaults to ``True``.
|
|
When True, it is assumed that ON UPDATE CASCADE is configured on
|
the foreign key in the database, and that the database will handle
|
propagation of an UPDATE from a source column to dependent columns
|
on joined-table rows.
|
|
When False, it is assumed that the database does not enforce
|
referential integrity and will not be issuing its own CASCADE
|
operation for an update. The unit of work process will
|
emit an UPDATE statement for the dependent columns during a
|
primary key change.
|
|
.. seealso::
|
|
:ref:`passive_updates` - description of a similar feature as
|
used with :func:`_orm.relationship`
|
|
:paramref:`.mapper.passive_deletes` - supporting ON DELETE
|
CASCADE for joined-table inheritance mappers
|
|
:param polymorphic_load: Specifies "polymorphic loading" behavior
|
for a subclass in an inheritance hierarchy (joined and single
|
table inheritance only). Valid values are:
|
|
* "'inline'" - specifies this class should be part of
|
the "with_polymorphic" mappers, e.g. its columns will be included
|
in a SELECT query against the base.
|
|
* "'selectin'" - specifies that when instances of this class
|
are loaded, an additional SELECT will be emitted to retrieve
|
the columns specific to this subclass. The SELECT uses
|
IN to fetch multiple subclasses at once.
|
|
.. versionadded:: 1.2
|
|
.. seealso::
|
|
:ref:`with_polymorphic_mapper_config`
|
|
:ref:`polymorphic_selectin`
|
|
:param polymorphic_on: Specifies the column, attribute, or
|
SQL expression used to determine the target class for an
|
incoming row, when inheriting classes are present.
|
|
May be specified as a string attribute name, or as a SQL
|
expression such as a :class:`_schema.Column` or in a Declarative
|
mapping a :func:`_orm.mapped_column` object. It is typically
|
expected that the SQL expression corresponds to a column in the
|
base-most mapped :class:`.Table`::
|
|
class Employee(Base):
|
__tablename__ = 'employee'
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
discriminator: Mapped[str] = mapped_column(String(50))
|
|
__mapper_args__ = {
|
"polymorphic_on":discriminator,
|
"polymorphic_identity":"employee"
|
}
|
|
It may also be specified
|
as a SQL expression, as in this example where we
|
use the :func:`.case` construct to provide a conditional
|
approach::
|
|
class Employee(Base):
|
__tablename__ = 'employee'
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
discriminator: Mapped[str] = mapped_column(String(50))
|
|
__mapper_args__ = {
|
"polymorphic_on":case(
|
(discriminator == "EN", "engineer"),
|
(discriminator == "MA", "manager"),
|
else_="employee"),
|
"polymorphic_identity":"employee"
|
}
|
|
It may also refer to any attribute using its string name,
|
which is of particular use when using annotated column
|
configurations::
|
|
class Employee(Base):
|
__tablename__ = 'employee'
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
discriminator: Mapped[str]
|
|
__mapper_args__ = {
|
"polymorphic_on": "discriminator",
|
"polymorphic_identity": "employee"
|
}
|
|
When setting ``polymorphic_on`` to reference an
|
attribute or expression that's not present in the
|
locally mapped :class:`_schema.Table`, yet the value
|
of the discriminator should be persisted to the database,
|
the value of the
|
discriminator is not automatically set on new
|
instances; this must be handled by the user,
|
either through manual means or via event listeners.
|
A typical approach to establishing such a listener
|
looks like::
|
|
from sqlalchemy import event
|
from sqlalchemy.orm import object_mapper
|
|
@event.listens_for(Employee, "init", propagate=True)
|
def set_identity(instance, *arg, **kw):
|
mapper = object_mapper(instance)
|
instance.discriminator = mapper.polymorphic_identity
|
|
Where above, we assign the value of ``polymorphic_identity``
|
for the mapped class to the ``discriminator`` attribute,
|
thus persisting the value to the ``discriminator`` column
|
in the database.
|
|
.. warning::
|
|
Currently, **only one discriminator column may be set**, typically
|
on the base-most class in the hierarchy. "Cascading" polymorphic
|
columns are not yet supported.
|
|
.. seealso::
|
|
:ref:`inheritance_toplevel`
|
|
:param polymorphic_identity: Specifies the value which
|
identifies this particular class as returned by the column expression
|
referred to by the :paramref:`_orm.Mapper.polymorphic_on` setting. As
|
rows are received, the value corresponding to the
|
:paramref:`_orm.Mapper.polymorphic_on` column expression is compared
|
to this value, indicating which subclass should be used for the newly
|
reconstructed object.
|
|
.. seealso::
|
|
:ref:`inheritance_toplevel`
|
|
:param properties: A dictionary mapping the string names of object
|
attributes to :class:`.MapperProperty` instances, which define the
|
persistence behavior of that attribute. Note that
|
:class:`_schema.Column`
|
objects present in
|
the mapped :class:`_schema.Table` are automatically placed into
|
``ColumnProperty`` instances upon mapping, unless overridden.
|
When using Declarative, this argument is passed automatically,
|
based on all those :class:`.MapperProperty` instances declared
|
in the declared class body.
|
|
.. seealso::
|
|
:ref:`orm_mapping_properties` - in the
|
:ref:`orm_mapping_classes_toplevel`
|
|
:param primary_key: A list of :class:`_schema.Column`
|
objects, or alternatively string names of attribute names which
|
refer to :class:`_schema.Column`, which define
|
the primary key to be used against this mapper's selectable unit.
|
This is normally simply the primary key of the ``local_table``, but
|
can be overridden here.
|
|
.. versionchanged:: 2.0.2 :paramref:`_orm.Mapper.primary_key`
|
arguments may be indicated as string attribute names as well.
|
|
.. seealso::
|
|
:ref:`mapper_primary_key` - background and example use
|
|
:param version_id_col: A :class:`_schema.Column`
|
that will be used to keep a running version id of rows
|
in the table. This is used to detect concurrent updates or
|
the presence of stale data in a flush. The methodology is to
|
detect if an UPDATE statement does not match the last known
|
version id, a
|
:class:`~sqlalchemy.orm.exc.StaleDataError` exception is
|
thrown.
|
By default, the column must be of :class:`.Integer` type,
|
unless ``version_id_generator`` specifies an alternative version
|
generator.
|
|
.. seealso::
|
|
:ref:`mapper_version_counter` - discussion of version counting
|
and rationale.
|
|
:param version_id_generator: Define how new version ids should
|
be generated. Defaults to ``None``, which indicates that
|
a simple integer counting scheme be employed. To provide a custom
|
versioning scheme, provide a callable function of the form::
|
|
def generate_version(version):
|
return next_version
|
|
Alternatively, server-side versioning functions such as triggers,
|
or programmatic versioning schemes outside of the version id
|
generator may be used, by specifying the value ``False``.
|
Please see :ref:`server_side_version_counter` for a discussion
|
of important points when using this option.
|
|
.. seealso::
|
|
:ref:`custom_version_counter`
|
|
:ref:`server_side_version_counter`
|
|
|
:param with_polymorphic: A tuple in the form ``(<classes>,
|
<selectable>)`` indicating the default style of "polymorphic"
|
loading, that is, which tables are queried at once. <classes> is
|
any single or list of mappers and/or classes indicating the
|
inherited classes that should be loaded at once. The special value
|
``'*'`` may be used to indicate all descending classes should be
|
loaded immediately. The second tuple argument <selectable>
|
indicates a selectable that will be used to query for multiple
|
classes.
|
|
The :paramref:`_orm.Mapper.polymorphic_load` parameter may be
|
preferable over the use of :paramref:`_orm.Mapper.with_polymorphic`
|
in modern mappings to indicate a per-subclass technique of
|
indicating polymorphic loading styles.
|
|
.. seealso::
|
|
:ref:`with_polymorphic_mapper_config`
|
|
r| z%s.%sNr ©ÚargnameFc S s | pdd S )Nr r rk )Úxrk rk rl Ú<lambda>ç ó z!Mapper.__init__.<locals>.<lambda>TzMapper[zM(None)] has None for a primary table argument and does not specify 'inherits'r
rN Z constructed)Kr Zassert_arg_typeÚtyper| Ú
|
__module__Ú__name__Ú _sort_keyÚto_listÚ_primary_key_argumentrw r Ú
|
isinstancer* Zversion_id_propr r8 Úexpectr; ZColumnArgumentOrKeyRoler r Úsingler# r ÚStrictFromClauseRoler} Úsa_excÚ ArgumentErrorZ OnClauseRoler r ÚdictÚ_init_propertiesÚ_delete_orphansr r r r
r Ú_dependency_processorsÚ
|
EMPTY_DICTÚ
|
validatorsr r r Z_clause_adapterÚ_requires_row_aliasingÚ_inherits_equated_pairsÚ_memoized_valuesr Ú_reconstructorr r Ú_set_with_polymorphicr r Úpolymorphic_mapÚto_setr r ri r rt Z_eventsZ_new_mapper_instanceÚ_configure_inheritanceÚ _configure_class_instrumentationÚ_configure_propertiesÚ _configure_polymorphic_setterÚ_configure_pksrJ Z_flag_new_mapperÚ_logÚ_expire_memoizationsZafter_mapper_constructed) Úselfr| r} r r~ rw r r r r r r r
r r r r r r r r r r r r r r r r r rk rk rl Ú__init__¿ sÔ þ
|
ûýù
|
ÿ
|
ÿ
|
ÿ
|
ûýù
|
|
|
ÿ
|
zMapper.__init__c C s. | j dkr$|jsdS || jko"|jS | j S d S )Nrx F)r Zimplicit_returningÚ_server_default_col_keysZ insert_executemany_returning)r¼ ÚdialectÚtablerk rk rl Ú_prefer_eager_defaultsZ s
|
|
þz Mapper._prefer_eager_defaultsc C s | fS rh rk )r¼ Zanon_mapZ
|
bindparamsrk rk rl Ú_gen_cache_keyf s zMapper._gen_cache_keyrI rJ ú
|
Mapper[_O]rf c C s | S )z<Part of the inspection API.
|
|
Returns self.
|
|
rk ©r¼ rk rk rl Úmappers s z Mapper.mapperc C s | j S )zDPart of the inspection API.
|
|
Returns self.class\_.
|
|
©r| rÄ rk rk rl Úentity| s z Mapper.entityr| Ú_identity_classzList[Tuple[str, Type[Any]]]rª zList[DependencyProcessor]r« z Dict[Any, Callable[[], Any]]r° z util.WeakSequence[Mapper[Any]]Ú_inheriting_mapperszSet[TableClause]Ú _all_tablesÚ_polymorphic_attr_keyz/Dict[FromClause, OrderedSet[ColumnClause[Any]]]Ú _pks_by_tablez0Dict[FromClause, OrderedSet[ColumnElement[Any]]]Ú_cols_by_tablez*util.OrderedDict[str, MapperProperty[Any]]Ú_propsz Dict[str, MapperProperty[Any]]r© Ú_ColumnMappingÚ_columntopropertyz-Optional[Callable[[InstanceState[_O]], None]]Ú_set_polymorphic_identityzHOptional[Callable[[Mapper[_O], InstanceState[_O], _InstanceDict], None]]Ú _validate_polymorphic_identityzSequence[TableClause]Útablesz3util.immutabledict[str, Tuple[str, Dict[str, Any]]]r r r z Optional[ColumnElement[Any]]r zcOptional[Tuple[Union[Literal['*'], Sequence[Union[Mapper[Any], Type[Any]]]], Optional[FromClause]]]r r r\ r} Úpersist_selectablezOptional[Mapper[Any]]r z Optional[ColumnElement[bool]]r Ú
|
configuredr zTuple[Column[Any], ...]r~ zClassManager[_O]Ú class_managerr¤ rw z!Optional[KeyedColumnElement[Any]]r
zDict[Any, Mapper[Any]]r³ r rd Ú base_mapperz*ReadOnlyColumnCollection[str, Column[Any]]ÚcolumnsÚcrv zUse .persist_selectablec C s | j S rh )rÔ rÄ rk rk rl Ú mapped_table s zMapper.mapped_tablerP c C s
|
t | ¡S rh )r. Z
|
per_mapperrÄ rk rk rl Ú_path_registry s zMapper._path_registryc
|
C s< t ¡ | _| jrØt| j| jjs>t d| jj| jjjf ¡| j
|
| jj ¡ | j | jj kr| j rhdpjd}t d|| jj|f ¡| j r| jj | _ n| j| jjk r| jrØ| j| _ | ¡ D ]}|jdk r¾d|_q¾q | jdkrÈzt | jj| j¡| _W nÊ tjk
|
rb } zD| jjdk s$t| jdk s4tt d| jjj| jjf ¡|W 5 d}~X Y nf tjk
|
rÆ } zD| jjdk st| jdk stt d| jjj| jjf ¡|W 5 d}~X Y nX | jj dk sÚtt | jj | j| j¡| _ t | j ¡}tj | j j |d | _ n| j| _ | j!dkrf| j| _"| j#s| jj$jdk rt %| d
|
| jj$j d ¡ n | jrx| j| _"n
|
| jj"| _"| j&dkr¤| jj&| _&| jj'| _'n:| jj&dk rÞ| j&| jj&k rÞt %d | j&j| jj&jf ¡ | jj(| _(| jj)| _)| jj *| ¡ | jj$| _$| jj+| _+| jj,p"| j,| _,| jj-| _-| j!dk rx| j!| j(krlt %d | j!| j(| j! | | j!f ¡ | | j(| j!< | j.r| jrt d¡| j.dkr¬| j /| ¡ n*| j.dkrºn | j.dk r t d| j. ¡nFt0 | _-| | _$| jdk söt| j| _ | j!dk r| | j(| j!< | j| _"| j dkr8t d| ¡dS )zXConfigure settings related to inheriting and/or inherited mappers
|
being present.z%Class '%s' does not inherit from '%s'Zprimaryz non-primaryzHInheritance of %s mapper for class '%s' is only allowed from a %s mapperNTa7 Can't determine the inherit condition between inherited table '%s' and inheriting table '%s'; tables have no foreign key relationships established. Please ensure the inheriting table has a foreign key relationship to the inherited table, or provide an 'on clause' using the 'inherit_condition' mapper argument.zìCan't determine the inherit condition between inherited table '%s' and inheriting table '%s'; tables have more than one foreign key relationship established. Please specify the 'on clause' using the 'inherit_condition' mapper argument.)Zconsider_as_foreign_keysz| does not indicate a 'polymorphic_identity', yet is part of an inheritance hierarchy that has a 'polymorphic_on' column of 'a' '. If this is an intermediary class that should not be instantiated, the class may either be left unmapped, or may include the 'polymorphic_abstract=True' parameter in its Mapper arguments. To leave the class unmapped when using Declarative, set the '__abstract__ = True' attribute on the class.zêInheriting version_id_col '%s' does not match inherited version_id_col '%s' and will not automatically populate the inherited versioning column. version_id_col should only be specified on the base-most mapper that includes versioning.zReassigning polymorphic association for identity %r from %r to %r: Check for duplicate use of %r as value for polymorphic_identity.zKpolymorphic_load is not currently supported with concrete table inheritanceÚinlineÚselectinz)unknown argument for polymorphic_load: %rz9Mapper '%s' does not have a persist_selectable specified.)1r Ú WeakSequencerÉ r Ú
|
issubclassr| r¦ r§ r rt Ú_updaterw r¤ rÔ r} r Úiterate_to_rootr
r® r Úsql_utilZjoin_conditionZNoForeignKeysErrorÚAssertionErrorÚ descriptionZAmbiguousForeignKeysErrorr4 Újoinr´ r Zcriterion_as_pairsZonclauser¯ r rÈ r r× Úwarnr r r³ r Úappendr r rÊ r Ú _add_with_polymorphic_subclassrj )r¼ ÚnprÅ ZnfeZafeZfksrk rk rl rµ s
|
ÿÿ þÿ
|
ÿ
|
þõÿðþùÿ ô ý þ
|
ÿ þÿ
|
|
|
|
ÿ þþûÿ
|
|
|
|
ÿ
|
|
üýÿ ÿ ÿÿ ÿÿz Mapper._configure_inheritanceÚNone)r rg c C s¶ |dkrd| _ n\t|ttfrLt|d tttfr@td|| _ ql|d f| _ n |d k rft d|¡nd | _ | j r¤| j d d k r¤| j d tj t
|
j | j d ddf| _ | j r²| ¡ d S ) Nrc )rc Nr z÷Tuple[
|
Union[
|
Literal["*"],
|
Sequence[Union["Mapper[Any]", Type[Any]]],
|
],
|
Optional["FromClause"],
|
]z&Invalid setting for with_polymorphic: r T©Z allow_select)r r¢ ÚtupleÚlistÚstrr r¦ r§ r8 r£ r; r¥ rÕ r» )r¼ r rk rk rl r² ^ s0 ø ÿýþ z Mapper._set_with_polymorphicc C sd |j }| jd kr | |f¡ nB| jd dkr`t| jd ts@t| | jd |f | jd f¡ d S )Nr rc r )r| r r² r¢ rì rã )r¼ rÅ Zsubclrk rk rl rè
s
|
ÿz%Mapper._add_with_polymorphic_subclassc C sä | j s
|
t| jrtt|ts"t|| _| jj | j¡ | jj| _| ¡ D ]}|jdk rJd|_ qJ| jj
|
| _
|
| j D ]}| jj |_ qp| jj | ¡ | jj| _| jj| _|j ¡ D ]2\}}|| jkr¬| j||ddds¬| ||d¡ q¬dS )z¹Set the given :class:`_orm.Mapper` as the 'inherits' for this
|
:class:`_orm.Mapper`, assuming this :class:`_orm.Mapper` is concrete
|
and does not already have an inherits.NTF©ÚlocalÚcolumn)r rã r r¢ rs r³ Úupdaterá r
r® r Úself_and_descendantsr× rÉ rç r rÊ rÎ ÚitemsÚ_should_excludeÚ_adapt_inherited_property)r¼ rÅ ÚmpÚkeyÚproprk rk rl Ú_set_concrete_base s.
|
|
|
|
|
|
|
|
ÿzMapper._set_concrete_basec C s || _ | d¡ d S )NT)r
r¸ )r¼ r
rk rk rl Ú_set_polymorphic_onª s zMapper._set_polymorphic_onc C s¬ t | j¡}| jrb|r |js,t d| j ¡|| _|jdk s@t |j| _|j
|
j | _ |j | ¡ dS |dksp|jszt d¡| j | | j¡ tj| j| t tj| ¡dd}|| _|jdk s¼t |j| _|j
|
dkrÒdS tj|dtdd t | j¡D ]¶\}}|dkr&t|d r&|j}t|d
|
r&|j}t |rðt|d rT|| _ tj|d t dd qðt|d rð|j }|j D ]:}|| j!krt d|| f ¡| j! "|||fi¡| _!qjqðdS )a¤ If this mapper is to be a primary mapper (i.e. the
|
non_primary flag is not set), associate this Mapper with the
|
given class and entity name.
|
|
Subsequent calls to ``class_mapper()`` for the ``class_`` / ``entity``
|
name combination will return this mapper. Also decorate the
|
`__init__` method on the mapped class to include optional
|
auto-session attachment logic.
|
|
ztClass %s has no primary mapper configured. Configure a primary mapper first before setting up a non primary Mapper.NzÊThe _mapper() function and Mapper() constructor may not be invoked directly outside of a declarative registry. Please use the sqlalchemy.orm.registry.map_imperatively() function for a classical mapping.T)rÅ Zexpired_attribute_loaderÚfinalizeÚinit)Úrawr½ Ú_sa_original_initÚ__func__Ú__sa_reconstructor__ÚloadÚ__sa_validators__zJA validation function for mapped attribute %r on mapper %s already exists.)#r Zopt_manager_of_classr| rw Z is_mappedr¦ ÚInvalidRequestErrorrÖ rJ rã rÅ rÈ Z_add_non_primary_mapperrt Úinstrument_classr Zregister_classr Úpartialr Zload_scalar_attributesr0 ÚlistenÚ_event_on_initZiterate_attributesÚhasattrrÿ r Úcallabler± Ú_event_on_loadÚ__sa_validation_opts__r r Úunion)r¼ Úmanagerrø ÚmethodZvalidation_optsÚnamerk rk rl r¶ ® sn
|
þÿ
|
ÿ ÿø
|
|
|
þÿ
|
ÿz'Mapper._configure_class_instrumentationc C s$ d| _ d| _d| _| j dd ¡ d S )NTru )rÕ Ú_ready_for_configureÚ_dispose_calledÚ__dict__ÚpoprÄ rk rk rl Ú_set_dispose_flags s zMapper._set_dispose_flagsrî z Column[Any])r rø rg c
|
C sº z| j | }W n< tk
|
rJ } z t d| d| d¡|W 5 d }~X Y nX z
|
|j}W n< tk
|
r } z t d| d| d¡|W 5 d }~X Y nX t|ts¶t d| d| d¡|S )NzCan't determine z column 'z(' - no attribute is mapped to this name.z4'; property does not refer to a single mapped Column)rÎ ÚKeyErrorr¦ r§ r9 ÚAttributeErrorr¢ r@ )r¼ r rø rù ÚerrÚexprZaerk rk rl Ú_str_arg_to_mapped_col s* ÿý
|
ÿý
|
ÿz Mapper._str_arg_to_mapped_colc sF t j¡ _ j dd jD ¡ i _i _t t
|
dd j D ¡}t dd |D ¡}t j jg¡D ]F}|jr¢| |j¡r¢t |j¡ |¡ j|< t |j¡ |¡ j|< qt jrâ fdddd jD D }nd }|r(|D ]4}|j jkrt ¡ j|j< j|j |¡ qðnl j jksLt j j dkrdt d jjf ¡n0 j jkrt jt j rt d
|
jj ¡ j r¸ j!s¸ js¸ j j _nt|rÜd d fd d|D D }nt j" j j d d}t|dkrt d jjf ¡t#| _ $d|¡ fdd j D _%d S )Nc s s | ]
|
}|V qd S rh rk )Ú.0Útrk rk rl Ú <genexpr>, s z(Mapper._configure_pks.<locals>.<genexpr>c S s g | ]
|
}|j qS rk ©Ú proxy_set©r Úcolrk rk rl Ú
|
<listcomp>2 s z)Mapper._configure_pks.<locals>.<listcomp>c s s | ]}|j r|V qd S rh ©r~ ©r rÙ rk rk rl r 5 s c s& g | ] }t |tr d |¡n|qS r# )r¢ rî r r$ rÄ rk rl r" G s þÿc s s | ]}t jtj|d dV qdS )r~ r N)r8 r£ r; ZDDLConstraintColumnRole)r Z coerce_pkrk rk rl r K s ûýr zJMapper %s could not assemble any primary key columns for mapped table '%s'zlCould not assemble any primary keys for locally mapped table '%s' - no rows will be persisted in this Table.c S s g | ]\}}|d k r|n|qS rh rk )r ÚccrÙ rk rk rl r" s ÿc 3 s | ]} j |¡|fV qd S rh )rÔ Úcorresponding_columnr$ rÄ rk rl r s ÿT)Zignore_nonexistent_tablesz"Identified primary key columns: %sc s< h | ]4} j | jkrt|d r.|j jkr j | qS ©rÀ )rÐ Ú_identity_key_propsr rÀ rÍ r rÄ rk rl Ú <setcomp> s
|
|
ûz(Mapper._configure_pks.<locals>.<setcomp>)&râ Ú find_tablesrÔ rÓ rÊ rò rÌ rÍ r Z
|
column_setr rÐ rj r r~ Ú
|
issupersetZordered_column_setÚ intersectionrÙ r¡ rÀ r] ÚaddÚlenr¦ r§ rä r} r¢ r3 rA ræ r r Zreduce_columnsrì rº Ú_readonly_props)r¼ Zall_colsÚpk_colsZfcZcoerced_pk_argÚkr~ rk rÄ rl r¹ ) s ÿÿý
|
ÿ
|
úü
|
ÿþ
|
þÿ ÿýÿÿþý
|
þþ
|
þ
|
þÿ
|
|
þzMapper._configure_pksc C s t ¡ | _| _t ¡ | _t| | _i }i }| j r¸| j
|
¡ D ]z\}}t |t s\| ||¡}n|}d}t |tjr¢|jD ]*}| jj |¡rvd}|||< ||f||< qv|r<| j||dd q<| jrH| jj
|
¡ D ]z\}}| j||dd drèqÌ| |¡} | r.| j||d| d}
|
|
|
||< | jD ]} ||
|
f|| < qqÌ|| jkrÌ| ||d¡ qÌ| jjD ]²} | |kr|| \}} | j|| dd qPn| | jkrqP| jpd| j }| j| j|| jj | ¡| drÆqP| ¡ D ] }| |jkrÎ|j| j}qÎ| j|| ddd qPd S )NTF©rý rï )Ú warn_onlyÚ incoming_propÚ ©rý Ú setparent) Úsql_baseZColumnCollectionrØ rÙ r Ú OrderedDictrÎ rÏ rÐ r© rô r¢ r* Ú_make_prop_from_columnr rQ r} Zcontains_columnÚ_configure_propertyr rõ ÚgetÚ%_reconcile_prop_with_incoming_columnsrö rÔ r rø rá )r¼ Z explicit_col_props_by_columnZexplicit_col_props_by_keyrø Úprop_argZpossible_col_propZ_map_as_property_nowZ given_colZinherited_propr4 Únew_propZinc_colrñ rù Z
|
column_keyrÅ rk rk rl r· § s
|
|
þ
|
ÿ
|
þ
|
ÿ
|
ü
|
þ
|
|
ü ÿz Mapper._configure_propertiesc
|
s d}d | j dk r®d}t| j trlz| j| j | _ W n4 tk
|
rj } zt d| j ¡|W 5 d}~X Y nX | j | jkr| j| j }nt| j tr´t| j t j
|
s¬t d¡| j }næ| j | j ¡}|dkr,d}d}| j }t|t jr0| jdks| jd dks| jd |¡dkr0t d|j ¡nd}t|dd}|rd| ||d|¡rzt d | ¡n| d
|
¡ | _ }|j}t j
|
||d }| j|||dd |jd | _ |j n|| ¡ D ]r}|j dk r¶| j |j krÞ|j | _ n| j |j ¡| _ | j dk r|j| _|j| _|j| _n d| _d| _ dS q¶| j rH| j dkrHt d¡|rz fdd} | _ fdd}
|
| | _|
|
| _n d| _d| _dS )a Configure an attribute on the mapper representing the
|
'polymorphic_on' column, if applicable, and not
|
already generated by _configure_properties (which is typical).
|
|
Also create a setter function which will assign this
|
attribute to the value of the 'polymorphic_identity'
|
upon instance construction, also if applicable. This
|
routine will run when an instance is created.
|
|
FNTzPCan't determine polymorphic_on value '%s' - no attribute is mapped to this name.zUOnly direct column-mapped property or SQL expression can be passed for polymorphic_onr zkCould not map polymorphic_on column '%s' to the mapped table - polymorphic loads will not function properlyrø z6Cannot exclude or override the discriminator column %rZ_sa_polymorphic_on)Z _instrumentr6 r z¡The Mapper.polymorphic_abstract parameter may only be used on a mapper hierarchy which includes the Mapper.polymorphic_on parameter at the base of the hierarchy.c sR | j }| jjj}|d kr8| jjjr8t d| jj d¡| ¡ | ||d ¡ d S )Nz Can't instantiate class for z,; mapper is marked polymorphic_abstract=True) r¨ r rÅ r r r¦ r Zget_implrj )ÚstateÚdict_r ©Zpolymorphic_keyrk rl rÑ ¯ s ÿÿþÿ
|
üzGMapper._configure_polymorphic_setter.<locals>._set_polymorphic_identityc s2 |kr.| | j kr.t dt|| f¡ d S )NznFlushing object %s with incompatible polymorphic identity %r; the object may not refresh and/or load correctly)Ú"_acceptable_polymorphic_identitiesr Z warn_limitedr& )rÅ r@ rA rB rk rl rÒ É s ÿÿþüzLMapper._configure_polymorphic_setter.<locals>._validate_polymorphic_identity) r
r¢ rî rÎ r r¦ r§ rÐ r* r rQ rÔ r& r3 r@ r r rä Úgetattrrõ Úlabelrø r; rØ rá rÑ rË rÒ r ) r¼ rý Úsetterr rù r! Z
|
instrumentrø rÅ rÑ rÒ rk rB rl r¸ sº þÿü ÿÿÿ
|
ÿ þÿýýÿ ÿÿ
|
ÿþ ÿÿÿ
|
ÿ ÿz$Mapper._configure_polymorphic_setterc C s | j d k r| j| j S d S d S rh )r rÐ rÄ rk rk rl Ú_version_id_propà s
|
zMapper._version_id_propc C sF t }t| g}|rB| ¡ }|j| jkr| |j¡ | |j¡ q|S rh )rj r ÚpopleftrÔ r- r ÚextendrÉ )r¼ Z
|
identitiesÚstackÚitemrk rk rl rC ç s
|
z)Mapper._acceptable_polymorphic_identitiesc C s t | j ¡ S rh )Ú frozensetrÎ ÚvaluesrÄ rk rk rl Ú _prop_setô s zMapper._prop_setz sqlalchemy.orm.descriptor_propsc C st t jj}| js"| j||ddd nN|| jkrp| j ||¡}||ksZt|t j
|
rp|j |j krp| j|| ¡ |dd d S )NFr6 T)r Ú preloadedÚorm_descriptor_propsr r; rÎ rÖ Ú_get_class_attr_mror¢ r ZInstrumentedAttributeZ _parententityÚparentÚConcreteInheritedProperty)r¼ rø rù rý Údescriptor_propsZimplementing_attributerk rk rl rö ø s,
|
ÿ ÿÿ
|
üüz Mapper._adapt_inherited_property)rý r7 Úwarn_for_existingz3Union[KeyedColumnElement[Any], MapperProperty[Any]]ra )rø r> rý r7 rU rg c C s> t jj}| d||jj¡ t|ts2| ||¡}n|}t|t j
|
rÈ| j |j d ¡}|d krÊ| jrÊ| g} | j ¡ D ]T}
|
|
|
j |j d ¡}|d k r¾| D ]} | j |¡ q| j |j d ¡} qÊ| |
|
¡ qt|d kr|j d }t| drPt|dr|j| jkrP| j |¡ n>t| drP|j| jkrP|| j|j krP| j|j |¡ t|dsz|| jkpv|j d | jk|_t|tjr| |_ |_ | j ||¡ |j D ] }|j D ]} || j | < q²q¨||_ |rà| | |¡ || j!kr"t"| j!| ddr"| j!| j#} t$ %d | ||| f ¡|| j!krt|t j
|
st| j!| t j
|
|j&fst 'd
|
| j!| | |f ¡ | j!| }| j( )|d ¡ |rÚ| j*j+ ,|d ¡d k rÚt| j! ,|d ¡|j&fsÚt 'd | j*j+| | |f ¡ || j!|< | j-sö| .| ¡ | j/D ]}| 0|||¡ qü|r*| 1¡ | 2| ¡ | j3r:| 4¡ |S ) Nz_configure_property(%s, %s)r r/ rÀ rÍ Ú _is_polymorphic_discriminatorÚ_mapped_by_synonymFzpCan't call map_column=True for synonym %r=%r, a ColumnProperty already exists keyed to the name %r for column %rzYProperty %s on %s being replaced with new property %s; the old property will be discardedziUser-placed attribute %r on %s being replaced with new property "%s"; the old attribute will be discarded)5r rO rP rº Ú __class__r r¢ r* Ú_property_from_columnr rQ rÔ r& rØ r rá r} Ú_refresh_for_new_columnrç r rÀ rÍ r/ r- r
rV r9 ZLabelrø Z _tq_key_labelr rÐ Z
|
set_parentrÎ rD rW r¦ r§ rS ræ rÛ r r| r r< rw r rÉ rö rý Úpost_instrument_classrÕ r» )r¼ rø r> rý r7 rU rT rù r! ÚpathÚmÚm2Z proxy_colÚsynZoldproprÅ rk rk rl r; sØ
|
ÿ
|
ÿÿ
|
|
ÿ
|
þÿ
|
þý þ
|
|
ÿ
|
þÿÿ
|
þþþý þÿ
|
ÿþ þýþÿ
|
|
|
|
zMapper._configure_propertyzAUnion[Sequence[KeyedColumnElement[Any]], KeyedColumnElement[Any]]zColumnProperty[Any])rø rñ rg c C s t |¡}g }|D ]j}| j |¡}|d krr| j |¡}|d k rJ| j |¡ | j |¡}|d krrt d|| |f ¡| |¡ qt j
|
| S )Nz¼When configuring property '%s' on %s, column '%s' is not represented in the mapper's table. Use the `column_property()` function to force this column to be mapped as a read-only attribute.) r r rÔ r& r} rZ r¦ r§ rç r rQ )r¼ rø rñ rØ Z mapped_columnrÙ Zmcrk rk rl r: ª s"
|
üÿ z Mapper._make_prop_from_columnz Optional[ColumnProperty[Any]])rø Ú existing_propr3 r4 Ú single_columnrg c C s |r| j st|tjs|S |jd }|r6||jkr6|S |d kr^|d k sJt|}|jd |f}n$|d ksjt|jd }||jd f}| jr|| jkrÞ| |¡sÞ|| jk rÞ|| jk rÞd|jd ||f } |rÔt
|
| ¡ n
|
t | ¡| ¡ }
|
|
|
j d|¡ | d|¡ |
|
S )Nr zImplicitly combining column %s with column %s under attribute '%s'. Please configure one or more attributes for these same-named columns explicitly.éÿÿÿÿzAinserting column to existing list in properties.ColumnProperty %s)r r¢ r rQ rØ rã r¯ Zshares_lineager r ræ r¦ r ÚcopyÚinsertrº ) r¼ rø r` r3 r4 ra Zexisting_columnZincoming_columnZequated_pair_keyÚmsgr? rk rk rl r= Ê sV ÿ
|
þ
|
|
þýûúù
|
ýüÿ
|
ýz,Mapper._reconcile_prop_with_incoming_columnszKeyedColumnElement[Any]c C st t jj}| j |¡}t|tjr8| j||||j | k dS |dksLt||j
|
rX| ||¡S t d|| |j|f ¡dS )zrgenerate/update a :class:`.ColumnProperty` given a
|
:class:`_schema.Column` or other SQL expression object.)ra r3 Na WARNING: when configuring property '%s' on %s, column '%s' conflicts with property '%r'. To resolve this, map the column to the class under a different name in the 'properties' dictionary. Or, to remove all awareness of the column entirely (including its availability as a foreign key), use the 'include_properties' or 'exclude_properties' mapper arguments to control specifically which table columns get mapped.)r rO rP rÎ r< r¢ r rQ r= rR rS r: r¦ r§ rø )r¼ rø rñ rT rù rk rk rl rY s& ü
|
ÿ øÿz Mapper._property_from_columnzThis warning originated from the `configure_mappers()` process, which was invoked automatically in response to a user-initiated operation.c C s | j jrt| j hdd d S )NT©Úcascade)rJ Ú _new_mappersÚ_configure_registriesrÄ rk rk rl Ú_check_configure2 s zMapper._check_configurec C st | d¡ dd | j ¡ D }|D ]<\}}| d|¡ |j| krN|jsN| ¡ |jr"| | ¡ q"| d¡ d| _dS )zÝCall the ``init()`` method on all ``MapperProperties``
|
attached to this mapper.
|
|
This is a deferred configuration step which is intended
|
to execute once all mappers have been constructed.
|
|
z$_post_configure_properties() startedc S s g | ]\}}||fqS rk rk )r rø rù rk rk rl r" F s z5Mapper._post_configure_properties.<locals>.<listcomp>zinitialize prop %sz%_post_configure_properties() completeTN) rº rÎ rô rR Z_configure_startedrý Z_configure_finishedr[ rÕ )r¼ Úlrø rù rk rk rl Ú_post_configure_properties< s
|
|
z!Mapper._post_configure_propertiesc C s" | ¡ D ]\}}| ||¡ qdS )z^Add the given dictionary of properties to this mapper,
|
using `add_property`.
|
|
N)rô Ú add_property)r¼ Zdict_of_propertiesrø Úvaluerk rk rl Úadd_propertiesS s zMapper.add_propertiesz'Union[Column[Any], MapperProperty[Any]])rø rù rg c C s. | j ||| jd}t|ts t|| j|< dS )aA Add an individual MapperProperty to this mapper.
|
|
If the mapper has not been configured yet, just adds the
|
property to the initial properties dictionary sent to the
|
constructor. If this Mapper has already been configured, then
|
the given MapperProperty is configured immediately.
|
|
r2 N)r; rÕ r¢ r* rã r© )r¼ rø rù rk rk rl rm [ s zMapper.add_propertyc C s | ¡ D ] }| ¡ qd S rh )rá Z_reset_memoizations©r¼ rÅ rk rk rl r» j s zMapper._expire_memoizationsc C s> d| j j d | jd k r | jjp(t| j | jr4dp6d d S )Nú(ú|z |non-primaryr5 ú))r| r r} rä rî rw rÄ rk rk rl Ú _log_descn s ÿþ
|
ÿú ø ÷ÿzMapper._log_desc)re Úargsrg c G s" | j jd| f| jf| d S ©Nz%s )ÚloggerÚinfort ©r¼ re ru rk rk rl rº } s z Mapper._logc G s" | j jd| f| jf| d S rv )rw Údebugrt ry rk rk rl Ú
|
_log_debug s zMapper._log_debugc C s dt | | jjf S )Nz<Mapper at 0x%x; %s>)Úidr| r rÄ rk rk rl Ú__repr__ s zMapper.__repr__c C s2 d| j j| jrdpd| jd k r&| jjn| jjf S )NzMapper[%s%s(%s)]z (non-primary)r5 )r| r rw r} rä rÔ rÄ rk rk rl Ú__str__ s ÿ
|
ûzMapper.__str__zInstanceState[_O])r@ rg c C st d}| ¡ D ]T}|jD ]H\}}d}t |¡j|||jd}| jrL|rL dS | js|s dS qq | jrl|S dS d S )NFT)Z
|
optimistic)rá rª r Zmanager_of_classÚ
|
has_parentZ has_identityr )r¼ r@ Zorphan_possiblerÅ rø Úclsr rk rk rl Ú
|
_is_orphan s
|
ÿ
|
|
zMapper._is_orphan)rø rg c C s
|
|| j kS rh )rÎ ©r¼ rø rk rk rl Ú has_property£ s zMapper.has_property)rø Ú_configure_mappersrg c
|
C sZ |r | ¡ z | j| W S tk
|
rT } z t d| d| d¡|W 5 d}~X Y nX dS )z6return a MapperProperty associated with the given key.zMapper 'z' has no property 'zw'. If this property was indicated from other mappers or configure events, ensure registry.configure() has been called.N)rj rÎ r r¦ r )r¼ rø r r rk rk rl Ú get_property¦ s ÿüzMapper.get_propertyzColumnElement[_T]zMapperProperty[_T])rñ rg c C s
|
| j | S )zkGiven a :class:`_schema.Column` object, return the
|
:class:`.MapperProperty` which maps this column.©rÐ )r¼ rñ rk rk rl Úget_property_by_column· s z Mapper.get_property_by_columnc C s t | j ¡ S )z1return an iterator of all MapperProperty objects.)ÚiterrÎ rM rÄ rk rk rl Úiterate_properties¿ s zMapper.iterate_propertieszSequence[Mapper[Any]])ÚspecÚ
|
selectablerg c s¾ |dkrt | j}nz|rt t |¡D ]J}t|}| | ¡sPt d|| f ¡|dkrh |
|
¡ ¡ q( |¡ q( fdd| jD }ng }|dk rºtt j |ddfdd|D }|S ) z÷given a with_polymorphic() argument, return the set of mappers it
|
represents.
|
|
Trims the list of mappers to just those represented within the given
|
selectable, if present. This helps some more legacy-ish mappings.
|
|
rc z%r does not inherit from %rNc s g | ]}| kr|qS rk rk ©r r] )Ú
|
mapper_setrk rl r" Þ s z-Mapper._mappers_from_spec.<locals>.<listcomp>T)Zinclude_aliasesc s g | ]}|j kr|qS rk )r} r )rÓ rk rl r" æ s
|
)rí ró rj r r r" Úisar¦ r rò rá r- râ r* )r¼ r r Úmappersr] rk )r rÓ rl Ú_mappers_from_specÅ s*
|
|
|
ÿ ÿzMapper._mappers_from_speczIterable[Mapper[Any]])r Ú innerjoinrg c C s\ | j }|D ]L}|| krq
|
|jr*t d¡q
|
|js
|
|rF| |j|j¡}q
|
| |j|j¡}q
|
|S )zªgiven a list of mappers (assumed to be within this mapper's
|
inheritance hierarchy), construct an outerjoin amongst those mapper's
|
mapped tables.
|
|
z^'with_polymorphic()' requires 'selectable' argument when concrete-inheriting mappers are used.) rÔ r r¦ r r¤ rå r} r Z outerjoin)r¼ r r Zfrom_objr] rk rk rl Ú_selectable_from_mappersé s& ÿ ÿ ÿz Mapper._selectable_from_mappersc C sL | j }|d krdS t|ts dS |jd k pF|jd k oF|jj oF|jj S d S )NFT)r r¢ r@ Úserver_defaultÚdefaultZ is_scalarZ is_callable)r¼ Zvid_colrk rk rl Ú!_version_id_has_server_side_value
|
s
|
|
|
|
üz(Mapper._version_id_has_server_side_valuec C sB | j r:| jr:| jd k r:| j | | d¡ dd | jD ¡S d S d S )N)Ú parententityÚ parentmapperc S s g | ]}|j s|jqS rk )r r r rk rk rl r"
|
s þz2Mapper._single_table_criterion.<locals>.<listcomp>)r¤ r r
Ú _annotateÚin_ró rÄ rk rk rl Ú_single_table_criterion
|
s ÿþý
|
z Mapper._single_table_criterionc C s | j ot| j d tjS )zÃreturn True if with_polymorphic[1] is an aliased fromclause,
|
like a subquery.
|
|
As of #8168, polymorphic adaption with ORMAdapter is used only
|
if this is present.
|
|
r )r r¢ r9 ZAliasedReturnsRowsrÄ rk rk rl Ú#_has_aliased_polymorphic_fromclause'
|
s þz*Mapper._has_aliased_polymorphic_fromclausec C s | j p| jp| jj p| jjS )a; determine if _MapperEntity or _ORMColumnEntity will need to use
|
polymorphic adaption when setting up a SELECT as well as fetching
|
rows for mapped classes and subclasses against this Mapper.
|
|
moved here from context.py for #8456 to generalize the ruleset
|
for this condition.
|
|
)r r® r× rÄ rk rk rl Ú _should_select_with_poly_adapter5
|
s +ÿþüz'Mapper._should_select_with_poly_adapterc C s | ¡ | jsg S | j| j S rh )rj r r rÄ rk rk rl Ú_with_polymorphic_mappersf
|
s z Mapper._with_polymorphic_mappersc C s | ¡ dS )zðThis hook is invoked by attribute inspection.
|
|
E.g. when Query calls:
|
|
coercions.expect(roles.ColumnsClauseRole, ent, keep_inspect=True)
|
|
This allows the inspection process run a configure mappers hook.
|
|
N)rj rÄ rk rk rl Ú _post_inspectn
|
s zMapper._post_inspectc C s: | j s | jS | j \}}|d k r"|S | | ||¡d¡S d S ©NF)r rÔ r r )r¼ r r rk rk rl Ú _with_polymorphic_selectable{
|
s
|
|
ÿz#Mapper._with_polymorphic_selectablec C s dd | j ¡ D S )Nc S s$ i | ] \}}|t d d |D qS )c s s | ]}|j jr|V qd S rh )r Úshould_evaluate_noner rk rk rl r
|
s zAMapper._insert_cols_evaluating_none.<locals>.<dictcomp>.<genexpr>©rL ©r rÀ rØ rk rk rl Ú
|
<dictcomp>
|
s
|
ý ÿz7Mapper._insert_cols_evaluating_none.<locals>.<dictcomp>©rÍ rô rÄ rk rk rl Ú _insert_cols_evaluating_none
|
s üz#Mapper._insert_cols_evaluating_nonec C s dd | j ¡ D S )Nc S s$ i | ] \}}|t d d |D qS )c s s. | ]&}|j s|js|js|jjs|jV qd S rh )r~ r r r r¡ rø r rk rk rl r
|
s ûz9Mapper._insert_cols_as_none.<locals>.<dictcomp>.<genexpr>r¢ r£ rk rk rl r¤
|
s
|
ø þz/Mapper._insert_cols_as_none.<locals>.<dictcomp>r¥ rÄ rk rk rl Ú_insert_cols_as_none
|
s ÷zMapper._insert_cols_as_nonec s fdd j ¡ D S )Nc s$ i | ] \}}| fd d|D qS )c s i | ]} j | j|qS rk ©rÐ rø r rÄ rk rl r¤ ¨
|
s
|
z5Mapper._propkey_to_col.<locals>.<dictcomp>.<dictcomp>rk r£ rÄ rk rl r¤ §
|
s ÿ z*Mapper._propkey_to_col.<locals>.<dictcomp>r¥ rÄ rk rÄ rl Ú_propkey_to_col¥
|
s
|
þzMapper._propkey_to_colc C s dd | j ¡ D S )Nc S s$ i | ] \}}|t d d |D qS )c S s g | ]
|
}|j qS rk ©rø r rk rk rl r" ¯
|
s z7Mapper._pk_keys_by_table.<locals>.<dictcomp>.<listcomp>r¢ ©r rÀ Zpksrk rk rl r¤ ®
|
s ÿ z,Mapper._pk_keys_by_table.<locals>.<dictcomp>©rÌ rô rÄ rk rk rl Ú_pk_keys_by_table¬
|
s þzMapper._pk_keys_by_tablec s fdd j ¡ D S )Nc s( i | ] \}}|t fd d|D qS )c s g | ]} j | jqS rk r¨ r rÄ rk rl r" ¶
|
s z<Mapper._pk_attr_keys_by_table.<locals>.<dictcomp>.<listcomp>r¢ r« rÄ rk rl r¤ µ
|
s ÿ z1Mapper._pk_attr_keys_by_table.<locals>.<dictcomp>r¬ rÄ rk rÄ rl Ú_pk_attr_keys_by_table³
|
s
|
þz Mapper._pk_attr_keys_by_tablez+Mapping[FromClause, FrozenSet[Column[Any]]]c C s dd | j ¡ D S )Nc S s* i | ]"\}}|t d d td|D qS )c S s, g | ]$}|j d k s$|jd k r|jjr|qS rh )r r Úis_clause_elementr rk rk rl r" À
|
s
|
|
|
ûz:Mapper._server_default_cols.<locals>.<dictcomp>.<listcomp>úIterable[Column[Any]]©rL r r£ rk rk rl r¤ ¾
|
s õ þÿz/Mapper._server_default_cols.<locals>.<dictcomp>r¥ rÄ rk rk rl Ú_server_default_colsº
|
s ôzMapper._server_default_colsc C s dd | j ¡ D S )Nc S s* i | ]"\}}|t d d td|D qS )c S s, g | ]$}|j d k s$|jd k r|jjr|qS rh )Zserver_onupdateZonupdater¯ r rk rk rl r" Ó
|
s
|
|
|
ûzCMapper._server_onupdate_default_cols.<locals>.<dictcomp>.<listcomp>r° r± r£ rk rk rl r¤ Ñ
|
s õ þÿz8Mapper._server_onupdate_default_cols.<locals>.<dictcomp>r¥ rÄ rk rk rl Ú _server_onupdate_default_colsÍ
|
s ôz$Mapper._server_onupdate_default_colsz#Mapping[FromClause, FrozenSet[str]]c C s dd | j ¡ D S )Nc S s$ i | ] \}}|t d d |D qS )c s s | ]}|j d k r|j V qd S rh rª r rk rk rl r ã
|
s
|
z=Mapper._server_default_col_keys.<locals>.<dictcomp>.<genexpr>r¢ ©r rÀ Úcolsrk rk rl r¤ â
|
s ÿ z3Mapper._server_default_col_keys.<locals>.<dictcomp>)r² rô rÄ rk rk rl r¾ à
|
s þz Mapper._server_default_col_keysc C s dd | j ¡ D S )Nc S s$ i | ] \}}|t d d |D qS )c s s | ]}|j d k r|j V qd S rh rª r rk rk rl r ì
|
s
|
zFMapper._server_onupdate_default_col_keys.<locals>.<dictcomp>.<genexpr>r¢ r´ rk rk rl r¤ ë
|
s ÿ z<Mapper._server_onupdate_default_col_keys.<locals>.<dictcomp>)r³ rô rÄ rk rk rl Ú!_server_onupdate_default_col_keysç
|
s þz(Mapper._server_onupdate_default_col_keyszSet[str]c st t }| j | j ¡ D ]&\}}| fdd| ¡D ¡ q| j ¡ D ]&\}}| fdd| ¡D ¡ qH|S )Nc 3 s | ]} | j V qd S rh rª r ©Zcol_to_propertyrk rl r ö
|
s ÿz@Mapper._server_default_plus_onupdate_propkeys.<locals>.<genexpr>c 3 s | ]} | j V qd S rh rª r r· rk rl r û
|
s ÿ)rj rÐ r² rô rò r, r³ )r¼ ÚresultrÀ rØ rk r· rl Ú&_server_default_plus_onupdate_propkeysð
|
s þ
|
þ
|
z-Mapper._server_default_plus_onupdate_propkeysc C sT | | | d}| j | jk r<| j | | | d¡ d| d¡|d< | j |¡ d| d¡S )N)Úentity_namespacer r Úorm©Zcompile_state_pluginZplugin_subjectZ dml_table)rÔ r} r Ú_set_propagate_attrsr )r¼ r rk rk rl Ú__clause_element__ s ý ýÿù
|
ÿzMapper.__clause_element__c C s$ t ¡ | | | dd¡ d| d¡S )NT)rº r r Úidentity_tokenr» r¼ )r9 Únullr r½ rÄ rk rk rl Úselect_identity_token s üþ
|
öÿz Mapper.select_identity_tokenc C s | j S )a4 The :class:`_schema.FromClause` construct this
|
:class:`_orm.Mapper` selects from by default.
|
|
Normally, this is equivalent to :attr:`.persist_selectable`, unless
|
the ``with_polymorphic`` feature is in use, in which case the
|
full "polymorphic" selectable is returned.
|
|
)r rÄ rk rk rl r + s
|
zMapper.selectablez)Union[Literal[(False, None)], FromClause]z(Tuple[Sequence[Mapper[Any]], FromClause])r r r rg c C s~ |dkrt jtj|dd}| jrB|s.| jd }|dkrN| jd }n |dkrNd }| ||¡}|d k rj||fS || ||¡fS d S )Nr Trë r Fr )r8 r£ r; r¥ r r r )r¼ r r r r rk rk rl Ú_with_polymorphic_args7 s" ÿ
|
z Mapper._with_polymorphic_argsc C s t | | j¡S rh )rí Ú _iterate_polymorphic_propertiesr rÄ rk rk rl Ú_polymorphic_propertiesO s
|
ÿÿz Mapper._polymorphic_propertiesc s | j }| j fdd|D S )Nc s< g | ]4}t |tjr|jr r. j|jd n|jd qS ©r )r¢ r rQ Z_renders_in_subqueriesrØ ©r rù ©Úadapterrk rl r" \ s ýz2Mapper._all_column_expressions.<locals>.<listcomp>)rÄ Ú_polymorphic_adapter)r¼ Úpoly_propertiesrk rÇ rl Ú_all_column_expressionsW s
|
|
þz Mapper._all_column_expressionsrk c C s$ |r| |¡}n| j}dd |D S )Nc S s( g | ] }t |tjr|j|jd fqS rÅ )r¢ r rQ rø rØ rÆ rk rk rl r" k s þz-Mapper._columns_plus_keys.<locals>.<listcomp>)rà rÄ )r¼ Zpolymorphic_mappersrÊ rk rk rl Ú_columns_plus_keysc s ÿþzMapper._columns_plus_keysz Optional[orm_util.ORMAdapter]c C s* | j r"tjtjj| | j| jddS d S d S )NF)r Z equivalentsZlimit_on_entity)r Úorm_utilrT Z_TraceAdaptRoleZMAPPER_POLYMORPHIC_ADAPTERr Ú_equivalent_columnsrÄ rk rk rl rÉ q s ûzMapper._polymorphic_adapterc c s| |dkr| j }|s&| jD ]
|
}|V qnRt tdd | g| D ¡D ]2}t|ddrp| jdksD|jd | jk rpqD|V qDdS )zUReturn an iterator of MapperProperty objects which will render into
|
a SELECT.Nc S s g | ]}t |jqS rk )rí r )r rÅ rk rk rl r" s ÿz:Mapper._iterate_polymorphic_properties.<locals>.<listcomp>rV Fr )r r r Z unique_listr rD r
rØ )r¼ r rÙ rk rk rl rà ~ s&
|
|
þÿÿ ÿþz&Mapper._iterate_polymorphic_propertiesz,util.ReadOnlyProperties[MapperProperty[Any]]c C s | ¡ t | j¡S )ai A namespace of all :class:`.MapperProperty` objects
|
associated this mapper.
|
|
This is an object that provides each property based on
|
its key name. For instance, the mapper for a
|
``User`` class which has ``User.name`` attribute would
|
provide ``mapper.attrs.name``, which would be the
|
:class:`.ColumnProperty` representing the ``name``
|
column. The namespace object can also be iterated,
|
which would yield each :class:`.MapperProperty`.
|
|
:class:`_orm.Mapper` has several pre-filtered views
|
of this attribute which limit the types of properties
|
returned, including :attr:`.synonyms`, :attr:`.column_attrs`,
|
:attr:`.relationships`, and :attr:`.composites`.
|
|
.. warning::
|
|
The :attr:`_orm.Mapper.attrs` accessor namespace is an
|
instance of :class:`.OrderedProperties`. This is
|
a dictionary-like object which includes a small number of
|
named methods such as :meth:`.OrderedProperties.items`
|
and :meth:`.OrderedProperties.values`. When
|
accessing attributes dynamically, favor using the dict-access
|
scheme, e.g. ``mapper.attrs[somename]`` over
|
``getattr(mapper.attrs, somename)`` to avoid name collisions.
|
|
.. seealso::
|
|
:attr:`_orm.Mapper.all_orm_descriptors`
|
|
)rj r ÚReadOnlyPropertiesrÎ rÄ rk rk rl Úattrs s #z Mapper.attrsz'util.ReadOnlyProperties[InspectionAttr]c C s t t| j ¡ ¡S )ay A namespace of all :class:`.InspectionAttr` attributes associated
|
with the mapped class.
|
|
These attributes are in all cases Python :term:`descriptors`
|
associated with the mapped class or its superclasses.
|
|
This namespace includes attributes that are mapped to the class
|
as well as attributes declared by extension modules.
|
It includes any Python descriptor type that inherits from
|
:class:`.InspectionAttr`. This includes
|
:class:`.QueryableAttribute`, as well as extension types such as
|
:class:`.hybrid_property`, :class:`.hybrid_method` and
|
:class:`.AssociationProxy`.
|
|
To distinguish between mapped attributes and extension attributes,
|
the attribute :attr:`.InspectionAttr.extension_type` will refer
|
to a constant that distinguishes between different extension types.
|
|
The sorting of the attributes is based on the following rules:
|
|
1. Iterate through the class and its superclasses in order from
|
subclass to superclass (i.e. iterate through ``cls.__mro__``)
|
|
2. For each class, yield the attributes in the order in which they
|
appear in ``__dict__``, with the exception of those in step
|
3 below. In Python 3.6 and above this ordering will be the
|
same as that of the class' construction, with the exception
|
of attributes that were added after the fact by the application
|
or the mapper.
|
|
3. If a certain attribute key is also in the superclass ``__dict__``,
|
then it's included in the iteration for that class, and not the
|
class in which it first appeared.
|
|
The above process produces an ordering that is deterministic in terms
|
of the order in which attributes were assigned to the class.
|
|
.. versionchanged:: 1.3.19 ensured deterministic ordering for
|
:meth:`_orm.Mapper.all_orm_descriptors`.
|
|
When dealing with a :class:`.QueryableAttribute`, the
|
:attr:`.QueryableAttribute.property` attribute refers to the
|
:class:`.MapperProperty` property, which is what you get when
|
referring to the collection of mapped properties via
|
:attr:`_orm.Mapper.attrs`.
|
|
.. warning::
|
|
The :attr:`_orm.Mapper.all_orm_descriptors`
|
accessor namespace is an
|
instance of :class:`.OrderedProperties`. This is
|
a dictionary-like object which includes a small number of
|
named methods such as :meth:`.OrderedProperties.items`
|
and :meth:`.OrderedProperties.values`. When
|
accessing attributes dynamically, favor using the dict-access
|
scheme, e.g. ``mapper.all_orm_descriptors[somename]`` over
|
``getattr(mapper.all_orm_descriptors, somename)`` to avoid name
|
collisions.
|
|
.. seealso::
|
|
:attr:`_orm.Mapper.attrs`
|
|
)r rÏ r¨ rÖ Z_all_sqla_attributesrÄ rk rk rl Úall_orm_descriptorsÀ s B ÿzMapper.all_orm_descriptorszDict[str, str]c s2 t jj dd | jD fdd| j ¡ D S )z~return a dictionary of {syn_attribute_name: pk_attr_name} for
|
all synonyms that refer to primary key columns
|
|
c S s h | ]
|
}|j qS rk rª rÆ rk rk rl r) s z&Mapper._pk_synonyms.<locals>.<setcomp>c s0 i | ](\}}t | jr|jkr|j|jqS rk )r¢ rM r rø )r r1 r_ ©rT Zpk_keysrk rl r¤ s
|
|
ý z'Mapper._pk_synonyms.<locals>.<dictcomp>)r rO rP r( rÎ rô rÄ rk rÒ rl Ú _pk_synonyms s
|
þzMapper._pk_synonymsz-util.ReadOnlyProperties[SynonymProperty[Any]]c C s t jj}| |j¡S )zûReturn a namespace of all :class:`.Synonym`
|
properties maintained by this :class:`_orm.Mapper`.
|
|
.. seealso::
|
|
:attr:`_orm.Mapper.attrs` - namespace of all
|
:class:`.MapperProperty`
|
objects.
|
|
)r rO rP Ú_filter_propertiesrM )r¼ rT rk rk rl Úsynonyms s zMapper.synonymsc C s | j S rh rÆ rÄ rk rk rl rº ) s zMapper.entity_namespacez,util.ReadOnlyProperties[ColumnProperty[Any]]c C s | tj¡S )a Return a namespace of all :class:`.ColumnProperty`
|
properties maintained by this :class:`_orm.Mapper`.
|
|
.. seealso::
|
|
:attr:`_orm.Mapper.attrs` - namespace of all
|
:class:`.MapperProperty`
|
objects.
|
|
)rÔ r rQ rÄ rk rk rl Ú column_attrs- s zMapper.column_attrsz sqlalchemy.orm.relationshipsz2util.ReadOnlyProperties[RelationshipProperty[Any]]c C s | tjjj¡S )aD A namespace of all :class:`.Relationship` properties
|
maintained by this :class:`_orm.Mapper`.
|
|
.. warning::
|
|
the :attr:`_orm.Mapper.relationships` accessor namespace is an
|
instance of :class:`.OrderedProperties`. This is
|
a dictionary-like object which includes a small number of
|
named methods such as :meth:`.OrderedProperties.items`
|
and :meth:`.OrderedProperties.values`. When
|
accessing attributes dynamically, favor using the dict-access
|
scheme, e.g. ``mapper.relationships[somename]`` over
|
``getattr(mapper.relationships, somename)`` to avoid name
|
collisions.
|
|
.. seealso::
|
|
:attr:`_orm.Mapper.attrs` - namespace of all
|
:class:`.MapperProperty`
|
objects.
|
|
)rÔ r rO Zorm_relationshipsrR rÄ rk rk rl Ú relationships; s ÿzMapper.relationshipsz/util.ReadOnlyProperties[CompositeProperty[Any]]c C s | tjjj¡S )zýReturn a namespace of all :class:`.Composite`
|
properties maintained by this :class:`_orm.Mapper`.
|
|
.. seealso::
|
|
:attr:`_orm.Mapper.attrs` - namespace of all
|
:class:`.MapperProperty`
|
objects.
|
|
)rÔ r rO rP rL rÄ rk rk rl Ú
|
compositesZ s ÿzMapper.compositesz Type[_MP]z util.ReadOnlyProperties[_MP])Útype_rg c s, | ¡ t t fdd| j ¡ D ¡¡S )Nc 3 s$ | ] \}}t | r||fV qd S rh )r¢ ©r r1 Úv©rÙ rk rl r p s
|
z,Mapper._filter_properties.<locals>.<genexpr>)rj r rÏ r9 rÎ rô )r¼ rÙ rk rÜ rl rÔ k s ÿÿzMapper._filter_propertiesc C s4 dd t | jdD }tjdd |D t |¡fS )z¢create a "get clause" based on the primary key. this is used
|
by query.get() and many-to-one lazyloads to load this item
|
by primary key.
|
|
c S s( g | ] \}}|t jd | |jdfqS )zpk_%drÜ )r4 Ú bindparamr )r Úidxr~ rk rk rl r" | s ýþz&Mapper._get_clause.<locals>.<listcomp>r c S s g | ]\}}||kqS rk rk rÚ rk rk rl r" s )Ú enumerater~ r4 Úand_r Z column_dict)r¼ Úparamsrk rk rl Ú _get_clauseu s
|
ûþzMapper._get_clauserX c s@ i fdd}| j jD ]"}|jdk rt |ji d|i¡ q S )a© Create a map of all equivalent columns, based on
|
the determination of column pairs that are equated to
|
one another based on inherit condition. This is designed
|
to work with the queries that util.polymorphic_union
|
comes up with, which often don't include the columns from
|
the base table directly (including the subclass table columns
|
only).
|
|
The resulting structure is a dictionary of columns mapped
|
to lists of equivalent columns, e.g.::
|
|
{
|
tablea.col1:
|
{tableb.col1, tablec.col1},
|
tablea.col2:
|
{tabled.col2}
|
}
|
|
c sh | j tjkrd| j kr* | j | j¡ n| jh | j< | j krV | j | j¡ n| jh | j< d S rh )Úoperatorr: ÚeqÚleftr- Úright)Úbinary©r¸ rk rl Ú visit_binary s
|
|
z0Mapper._equivalent_columns.<locals>.visit_binaryNrç )r× ró r r= Útraverse)r¼ ré rÅ rk rè rl rÎ s
|
ÿzMapper._equivalent_columns)Ú assigned_nameÚobjrg c C s& t |ttjtjfrdS || jkS d S r )r¢ r' r rO r9 r[ Ú_dataclass_fields)r¼ rë rì rk rk rl Ú_is_userland_descriptor² s ýþz Mapper._is_userland_descriptorc C s dd t | j¡D S )Nc S s g | ]
|
}|j qS rk )r )r Úfrk rk rl r" Á s z,Mapper._dataclass_fields.<locals>.<listcomp>)r Zdataclass_fieldsr| rÄ rk rk rl rí ¿ s zMapper._dataclass_fieldsc C sâ |dk rt |¡rdS |rH| jj |d¡dk rn| || jj| ¡rndS n&| j |d¡}|dk rn| ||¡rndS | jdk r¦|| jkr¦|dks|| jkr¦| d| ¡ dS | j
|
dk rÞ|| j
|
ksÌ|dk rÞ|| j
|
krÞ| d| ¡ dS dS )zödetermine whether a particular property should be implicitly
|
present on the class.
|
|
This occurs when properties are propagated from an inherited class, or
|
are applied from the columns present in the mapped table.
|
|
NTznot including property %szexcluding property %sF) r8 Z_never_select_columnr| r r< rî rÖ rQ r rº r )r¼ r rë rð rñ Úattrrk rk rl rõ Ã sR ÿþ
|
ÿþ ÿÿþýý
|
ÿþþzMapper._should_exclude)Úotherrg c C s | j |j kS )zXReturn true if the given mapper shares a
|
common inherited parent as this mapper.)r× ©r¼ rñ rk rk rl Ú common_parentñ s zMapper.common_parentc C s$ | j |j ko"| |¡ o"| | ¡ S )z{return true if the other mapper is an inheriting sibling to this
|
one. common parent but different branch
|
|
)r× r rò rk rk rl Ú
|
is_sibling÷ s
|
|
ÿ
|
ýzMapper.is_siblingzInstanceState[Any])r@ Úallow_subtypesrg c C s4 | ¡ }| jd k s|r$t| |¡S t||kS d S rh )Úprimary_mapperr
r$ r )r¼ r@ rõ Úsrk rk rl Ú_canload s zMapper._canloadc C s | }|r||k r|j }qt|S )z>Return True if the this mapper inherits from the given mapper.)r rz )r¼ rñ r] rk rk rl r s z
|
Mapper.isarn c c s | }|r|V |j }qd S rh )r )r¼ r] rk rk rl rá s zMapper.iterate_to_rootc C s< g }t | g}|r2| ¡ }| |¡ | |j¡ qt |¡S )z¿The collection including this mapper and all descendant mappers.
|
|
This includes not just the immediately inheriting mappers but
|
all their inheriting mappers as well.
|
|
)r rH rç rI rÉ r rÞ )r¼ Z descendantsrJ rK rk rk rl ró s
|
|
zMapper.self_and_descendantsc C s
|
t | jS )aC Iterate through the collection including this mapper and
|
all descendant mappers.
|
|
This includes not just the immediately inheriting mappers but
|
all their inheriting mappers as well.
|
|
To iterate through an entire hierarchy, use
|
``mapper.base_mapper.polymorphic_iterator()``.
|
|
)r ró rÄ rk rk rl Úpolymorphic_iterator) s zMapper.polymorphic_iteratorc C s | j jS )zSReturn the primary mapper corresponding to this mapper's class key
|
(class).)rÖ rÅ rÄ rk rk rl rö 6 s zMapper.primary_mapperc C s
|
| j jjS rh )rÖ rÅ r× rÄ rk rk rl Úprimary_base_mapper< s zMapper.primary_base_mapperc s@ | j } r fdd|D }| ¡ }|D ]}||kr( dS q(dS )Nc s g | ]} j | qS rk ©rØ r$ rÇ rk rl r" C s z3Mapper._result_has_identity_key.<locals>.<listcomp>FT)r~ Úkeys)r¼ r¸ rÈ r0 Zrkr! rk rÇ rl Ú_result_has_identity_key@ s z Mapper._result_has_identity_keyz%Optional[Union[Row[Any], RowMapping]]zOptional[ORMAdapter]z_IdentityKeyType[_O])Úrowr¿ rÈ rg c sV | j } r fdd|D }t|dr.|jn
|
td|| jtfdd|D |fS )a
Return an identity-map key for use in storing/retrieving an
|
item from the identity map.
|
|
:param row: A :class:`.Row` or :class:`.RowMapping` produced from a
|
result set that selected from the ORM mapped primary key columns.
|
|
.. versionchanged:: 2.0
|
:class:`.Row` or :class:`.RowMapping` are accepted
|
for the "row" argument
|
|
c s g | ]} j | qS rk rû r$ rÇ rk rl r" ^ s z0Mapper.identity_key_from_row.<locals>.<listcomp>Ú_mappingzMapping[Any, Any]c 3 s | ]} | V qd S rh rk )r rñ )Úmappingrk rl r g s z/Mapper.identity_key_from_row.<locals>.<genexpr>)r~ r rÿ r rÈ rì )r¼ rþ r¿ rÈ r0 rk )rÈ r rl Úidentity_key_from_rowK s
|
|
ýz Mapper.identity_key_from_rowzTuple[Any, ...])r~ r¿ rg c C s | j t||fS )z±Return an identity-map key for use in storing/retrieving an
|
item from an identity map.
|
|
:param primary_key: A list of values indicating the identifier.
|
|
)rÈ rì )r¼ r~ r¿ rk rk rl Ú identity_key_from_primary_keyk s ýz$Mapper.identity_key_from_primary_keyr! )Úinstancerg c C s t |¡}| |tj¡S )aÈ Return the identity key for the given instance, based on
|
its primary key attributes.
|
|
If the instance's state is expired, calling this method
|
will result in a database check to see if the object has been deleted.
|
If the row no longer exists,
|
:class:`~sqlalchemy.orm.exc.ObjectDeletedError` is raised.
|
|
This value is typically also found on the instance state under the
|
attribute name `key`.
|
|
©r Úinstance_stateÚ_identity_key_from_stater% Ú PASSIVE_OFF)r¼ r r@ rk rk rl Úidentity_key_from_instance| s
|
z!Mapper.identity_key_from_instancer% )r@ Úpassiverg c s4 j j| jt fdd| jD jfS )Nc s" g | ]}|j j ¡qS rk )rø Úimplr< rÆ ©rA r r r@ rk rl r" s ÿz3Mapper._identity_key_from_state.<locals>.<listcomp>)r¨ r rÈ rì r( r¿ )r¼ r@ r rk r rl r s þÿøz Mapper._identity_key_from_statec C s t |¡}| |tj¡}|d S )aG Return the list of primary key values for the given
|
instance.
|
|
If the instance's state is expired, calling this method
|
will result in a database check to see if the object has been deleted.
|
If the row no longer exists,
|
:class:`~sqlalchemy.orm.exc.ObjectDeletedError` is raised.
|
|
r r )r¼ r r@ Z identity_keyrk rk rl Úprimary_key_from_instance s
|
|
ÿz Mapper.primary_key_from_instancec s: dd | j D t d g¡r. fdd}ndd }|S )Nc S s g | ] }|j jqS rk )r Zsort_key_functionr rk rk rl r" ° s z1Mapper._persistent_sortkey_fn.<locals>.<listcomp>c s t dd t | jd D S )Nc s s& | ] \}}|d k r||n|V qd S rh rk )r Zkey_fnÚvalrk rk rl r µ s ÿz=Mapper._persistent_sortkey_fn.<locals>.key.<locals>.<genexpr>r )rì Úziprø ©r@ ©Zkey_fnsrk rl rø ´ s þz*Mapper._persistent_sortkey_fn.<locals>.keyc S s
|
| j d S ©Nr rª r rk rk rl rø ¼ s )r~ rj Ú
|
differencer rk r rl Ú_persistent_sortkey_fn® s
|
z Mapper._persistent_sortkey_fnc s fdd j D S )Nc s g | ]} j | qS rk r r rÄ rk rl r" Ã s z.Mapper._identity_key_props.<locals>.<listcomp>r# rÄ rk rÄ rl r( Á s zMapper._identity_key_propsc C s& t }| jD ]}| | j| ¡ q |S rh )rj rÓ rò rÌ )r¼ Z
|
collectionrÀ rk rk rl Ú _all_pk_colsÅ s
|
zMapper._all_pk_colsc C s$ t | j}| jd k r | | j¡ |S rh )rj r~ r
r- )r¼ rµ rk rk rl Ú_should_undefer_in_wildcardÌ s
|
|
z"Mapper._should_undefer_in_wildcardc s fdd j D S )Nc s h | ]} j | jqS rk r¨ r rÄ rk rl r) Õ s z/Mapper._primary_key_propkeys.<locals>.<setcomp>)r rÄ rk rÄ rl Ú_primary_key_propkeysÓ s z Mapper._primary_key_propkeysrG úColumnElement[Any])r@ rA rñ r rg c C s$ | j | }|j|j jj|||dS ©N©r )rÐ r rø r
|
r< ©r¼ r@ rA rñ r rù rk rk rl Ú_get_state_attr_by_column× s
|
z Mapper._get_state_attr_by_columnc C s& | j | }|j|j j |||¡ d S rh )rÐ r rø r
|
Zset_committed_value©r¼ r@ rA rñ rn rù rk rk rl Ú#_set_committed_state_attr_by_columná s
|
z*Mapper._set_committed_state_attr_by_columnc C s( | j | }|j|j j |||d ¡ d S rh )rÐ r rø r
|
rj r rk rk rl Ú_set_state_attr_by_columnå s
|
z Mapper._set_state_attr_by_columnc C s( t |¡}t |¡}| j|||tjdS r )r r Ú instance_dictÚ#_get_committed_state_attr_by_columnr% r )r¼ rì rñ r@ rA rk rk rl Ú _get_committed_attr_by_columné s
|
|
ÿz$Mapper._get_committed_attr_by_columnc C s$ | j | }|j|j jj|||dS r )rÐ r rø r
|
Zget_committed_valuer rk rk rl r ð s
|
ÿz*Mapper._get_committed_state_attr_by_columnc sX j t| jj ¡ ¡}tt fdd|D jjkrFdS fdd}g }d}t t
|
¡ D ]l}|jkrd}nt |jt js dS |rn|jsn|jsªt|jr´t|jdk sÂt| |j¡ |j¡ qnzt |d i d |i¡}W n tk
|
r Y dS X ||d< tj| } g }
|
|D ]} |
|
| j ¡ q*tj |
|
| ¡ t ¡S )
|
al assemble a WHERE clause which retrieves a given state by primary
|
key, using a minimized set of tables.
|
|
Applies to a joined-table inheritance mapper where the
|
requested attribute names are only present on joined tables,
|
not the base table. The WHERE clause attempts to include
|
only those tables to minimize joins.
|
|
c s* g | ]"} | j D ]}tj|d dqqS )T)Z check_columns)rØ râ r* )r rø rÙ )Úpropsrk rl r"
|
s þz3Mapper._optimized_get_statement.<locals>.<listcomp>Nc s² | j }| j}|d ks |d kr d S |jkrh jj|tjd}|tjkrPt t
|
j d || jj d| _ nF|jkr® jj|tjd}|tjkrt t
|
j d || jj d| _d S )Nr rÜ ) rå ræ rÀ r r¨ r% ZPASSIVE_NO_INITIALIZErÍ Z _none_setÚ_OptGetColumnsNotAvailabler4 rÝ r )rç ZleftcolZrightcolZleftvalZrightval)r¼ r@ rÓ rk rl ré s@
|
ü
|
ÿ
|
|
ü
|
ÿz5Mapper._optimized_get_statement.<locals>.visit_binaryFTr rç )!rÎ rj r, rÅ rÖ rü r r× r} Úreversedrí rá r¢ r9 r< r¤ r rã r r rç r- r= Zcloned_traverser# r4 rà rI rØ ÚselectÚwhereÚset_label_stylerB ) r¼ r@ Zattribute_namesZcol_attribute_namesré ZallcondsÚstartrÅ Z
|
_traversedZcondrµ rø rk )r" r¼ r@ rÓ rl Ú_optimized_get_statementù s\
|
|
ÿ
|
þÿÿ
|
|
|
|
|
ÿ
|
|
ÿþÿz Mapper._optimized_get_statementc c sL | |¡rH| }| ¡ D ]0}|V ||k r6||jkr6 qH|}||kr qHqd S rh )r rá r )r¼ rÅ Úprevr] rk rk rl Ú_iterate_to_target_viawpoly_ s
|
z"Mapper._iterate_to_target_viawpolyc C s i S rh rk rÄ rk rk rl Ú&_would_selectinload_combinations_cachel s z-Mapper._would_selectinload_combinations_cachec C sn | j }z
|
|| W S tk
|
r$ Y nX | |¡s4t|}| |¡D ]}|jdkrB||k} qbqBd}|||< |S )aÓ return True if this mapper would "selectin" polymorphic load based
|
on the given super mapper, and not from a setting from a subclass.
|
|
given::
|
|
class A:
|
...
|
|
class B(A):
|
__mapper_args__ = {"polymorphic_load": "selectin"}
|
|
class C(B):
|
...
|
|
class D(B):
|
__mapper_args__ = {"polymorphic_load": "selectin"}
|
|
``inspect(C)._would_selectin_load_only_from_given_mapper(inspect(B))``
|
returns True, because C does selectin loading because of B's setting.
|
|
OTOH, ``inspect(D)
|
._would_selectin_load_only_from_given_mapper(inspect(B))``
|
returns False, because D does selectin loading because of its own
|
setting; when we are doing a selectin poly load from B, we want to
|
filter out D because it would already have its own selectin poly load
|
set up separately.
|
|
Added as part of #9373.
|
|
rÝ F)r, r r rã r+ r )r¼ Z super_mapperÚcacherÅ r] Úretvalrk rk rl Ú+_would_selectin_load_only_from_given_mapperp s
|
|
z2Mapper._would_selectin_load_only_from_given_mapperc C s |s,|}| |¡D ]}|jdkr| S qndt|}dd |D }| |g¡D ]@}|j}| |¡D ]*}|jdksx||krb| ||¡ S qbqNd S )NrÝ c S s i | ] }|j |qS rk ©rÅ )r Úerk rk rl r¤ ± s z0Mapper._should_selectin_load.<locals>.<dictcomp>)r+ r rj r rÅ r< )r¼ Zenabled_via_optÚpolymorphic_fromrÅ r] Zenabled_via_opt_mappersrÇ rk rk rl Ú_should_selectin_load§ s
|
ÿþz Mapper._should_selectin_loadz sqlalchemy.orm.strategy_optionsc sà t jj}| jst| jdk r:| j| j }t|g| j }n
|
t| j}| ¡}| ¡}| h}| j} | dk r| |k r| j
|
dkr| | ¡ | j} qd| j D ]t}
|
|
|
j | jkr¨q|
|
j|ksº|
|
|krêt|
|
tsÆq|jt j|
|
j ft|
|
jdd}q|jt j|
|
j fddidd}qdd | jD } t| d kr6tj| } n| d
|
} jr¦ j | ksVtt ¡ t ¡} j !| ¡} fd d| D } | "| #tj$d dd ¡¡j%| } n0t | ¡ t ¡} | "| #tj$d dd ¡¡j%| } | ||fS )zbAssemble a that can load the columns local to
|
this subclass as a SELECT with IN.
|
|
NrÝ T)Z_reconcile_to_otherZ
|
do_nothingFc S s g | ]}t |d di¡qS )Z
|
_orm_adaptT)râ Z_deep_annotate)r Úpkrk rk rl r" ý s ÿz0Mapper._subclass_load_via_in.<locals>.<listcomp>r r c s g | ]} j |¡qS rk )Ú_adapterrê )r r1 ©rÇ rk rl r" s Z primary_keys)Z expanding)&r rO Zorm_strategy_optionsr rã r
rÐ rj r( ÚLoadr r- rÐ rø rÖ rR r¢ r- Z_set_generic_strategyrD rº r¨ Z strategy_keyr~ r. r4 Útuple_Zis_aliased_classrÅ r% r' rB r5 rê r& r rÝ Zorder_by)r¼ rÇ r2 Zstrategy_optionsZpolymorphic_propZ
|
keep_propsZ disable_optZ
|
enable_optZclasses_to_includer] rù r~ Zin_exprÚqrk r6 rl Ú_subclass_load_via_in½ sz
|
|
|
|
|
ÿþý
|
|
|
ú ú þ
|
ÿ ÿþ
|
ÿÿþz Mapper._subclass_load_via_inc C s | | | j¡S rh )r: r× rÄ rk rk rl Ú _subclass_load_via_in_mapper s z#Mapper._subclass_load_via_in_mapperz.Optional[Callable[[InstanceState[Any]], bool]]zGIterator[Tuple[object, Mapper[Any], InstanceState[Any], _InstanceDict]])rÙ r@ Úhalt_onrg c c s t }t t }}|j | ¡s$ttt|jj ¡ |||jfg}|r|d \}} }
|
} |sh| ¡ qD| |krÐ|
|
¡ } | j rD|| j krqD|
|
dk st| dk s¢tt| ||
|
| ||¡} | rÎ| | |ddf¡ qD| |krD|
|
¡ \}}}}||||fV | t|j ¡ |||f¡ qDdS )a. Iterate each element and its mapper in an object graph,
|
for all relationships that meet the given cascade rule.
|
|
:param type\_:
|
The name of the cascade rule (i.e. ``"save-update"``, ``"delete"``,
|
etc.).
|
|
.. note:: the ``"all"`` cascade is not accepted here. For a generic
|
object traversal function, see :ref:`faq_walk_objects`.
|
|
:param state:
|
The lead InstanceState. child items will be processed per
|
the relationships defined for this object's mapper.
|
|
:return: the method yields individual object instances.
|
|
.. seealso::
|
|
:ref:`unitofwork_cascades`
|
|
:ref:`faq_walk_objects` - illustrates a generic function to
|
traverse all objects without relying on cascades.
|
|
rb N)rj ÚobjectrÅ r rã r rÎ rM r¨ r rH rg Úcascade_iteratorrç )r¼ rÙ r@ r< Zvisited_statesZprpZmppZ
|
visitablesÚiteratorZ item_typeZ parent_stateZ parent_dictrù Úqueuer Zinstance_mapperZcorresponding_stateZcorresponding_dictrk rk rl r> % s^ ÿ ûÿ ûü üÿzMapper.cascade_iteratorc C s t | j¡S rh )r ZLRUCacher rÄ rk rk rl Ú_compiled_cache s zMapper._compiled_cachec C s t | jdkS r )r. rÓ rÄ rk rk rl Ú _multiple_persistence_tables s z#Mapper._multiple_persistence_tablesc s¢ i | j jD ] }|jD ]} ||¡ qq g } ¡ D ],\ }|j}|r6| fdd|jD ¡ q6fdd}tj||d}t
|
¡ }|D ]}| ||< q|S )Nc s g | ] }| fqS rk rk )r Z super_tabler' rk rl r" s z)Mapper._sorted_tables.<locals>.<listcomp>c s | jj¡} | jj¡}|d k r|d k r||k r|jd k rtt |j¡}|jd k r~| t |j¡¡}| j|ko|| j|kS | j|kS dS r ) r< rR rÀ rñ r rj râ Z _find_columnsr )ZfkrR Údeprµ )Útable_to_mapperrk rl Úskip s$ ÿþýü
|
|
ÿ
|
z#Mapper._sorted_tables.<locals>.skip)Zskip_fnÚextra_dependencies) r× ró rÓ Ú
|
setdefaultrô r rI râ Z sort_tablesr r9 )r¼ rÅ r rF Zsuper_rE Zsorted_Úretrk )rÀ rD rl Ú_sorted_tables s*
|
ÿ ýzMapper._sorted_tableszCallable[[], _T]r^ )rø Ú callable_rg c C s2 || j krtt| j | S | | j |< }|S d S rh )r° r r^ )r¼ rø rJ rn rk rk rl Ú_memoÁ s
|
z Mapper._memoc C sp t t¡}dd }| jD ]R}t|j}| ¡ D ]:}|jr.| t |dd |jD ¡r.||
|
||jf¡ q.q|S )zgmemoized map of tables to collections of columns to be
|
synchronized upwards to the base mapper.c S s
|
| |¡S rh )r )r Úyrk rk rl Ú set_union× s z+Mapper._table_to_equated.<locals>.set_unionc S s g | ]\}}|j qS rk r )r rk Úrrk rk rl r" á s z,Mapper._table_to_equated.<locals>.<listcomp>) r Ú defaultdictrí rI rj rÙ rá r¯ r, r rç )r¼ r¸ rM rÀ rµ r] rk rk rl Ú_table_to_equatedÈ s ø
|
|
|
|
þÿzMapper._table_to_equated) NNNFNNNFNNNNNFNFNTTNNNTFTrx Fry )F)NN)F)NFF)rk )N)N)NN)N)N)r r Ú __qualname__Ú__doc__Ú__annotations__r ru r r Zdeprecated_paramsr½ rÁ r Z is_mapperZrepresents_outer_joinÚpropertyrÅ rÇ rÕ Znon_memoized_propertyÚ
|
deprecatedrÚ Zmemoized_propertyrÛ rµ r² rè rú rû r¶ r r r¹ r· r¸ rÒ rC Zmemoized_attributerG rC rN Úpreload_modulerö r; r: r= rY Z langhelpersZtag_method_for_warningsr¦ Z SAWarningrj rl ro rm r» rt rº r{ r} r~ r r r
r r r r r r r r r r rD r Zwith_polymorphic_mappersr¦ r§ r© r r® r² r³ r¾ r¶ r¹ Zmemoized_instancemethodr¾ rÁ r r rÄ rË rÌ rÉ rà rÐ rÑ rÓ rÕ rº rÖ r× rØ rÔ râ rÎ rî rí rõ ró rô rø r rá ró rù rö rú rý r r r r% ZPASSIVE_RETURN_NO_VALUEr r r r( r r r r r r r! r r) r+ r, r/ r3 r: r; r> rA rB rI rK rP rk rk rk rl rs ¢ sJ
|
ÿ ÜJ
|
|
|
@'
|
]~q G
|
|
|
|
ù % úC$ü ÿ
|
$
|
|
|
0
|
|
|
|
|
|
ü %E
|
|
) . ü"#ý ý û$
|
ÿ f 7
|
bü a2 rs rà c @ s e Zd ZdS )r# N)r r rQ rk rk rk rl r# é s r# c C s t t dd dS )aÀ Initialize the inter-mapper relationships of all mappers that
|
have been constructed thus far across all :class:`_orm.registry`
|
collections.
|
|
The configure step is used to reconcile and initialize the
|
:func:`_orm.relationship` linkages between mapped classes, as well as to
|
invoke configuration events such as the
|
:meth:`_orm.MapperEvents.before_configured` and
|
:meth:`_orm.MapperEvents.after_configured`, which may be used by ORM
|
extensions or user-defined extension hooks.
|
|
Mapper configuration is normally invoked automatically, the first time
|
mappings from a particular :class:`_orm.registry` are used, as well as
|
whenever mappings are used and additional not-yet-configured mappers have
|
been constructed. The automatic configuration process however is local only
|
to the :class:`_orm.registry` involving the target mapper and any related
|
:class:`_orm.registry` objects which it may depend on; this is
|
equivalent to invoking the :meth:`_orm.registry.configure` method
|
on a particular :class:`_orm.registry`.
|
|
By contrast, the :func:`_orm.configure_mappers` function will invoke the
|
configuration process on all :class:`_orm.registry` objects that
|
exist in memory, and may be useful for scenarios where many individual
|
:class:`_orm.registry` objects that are nonetheless interrelated are
|
in use.
|
|
.. versionchanged:: 1.4
|
|
As of SQLAlchemy 1.4.0b2, this function works on a
|
per-:class:`_orm.registry` basis, locating all :class:`_orm.registry`
|
objects present and invoking the :meth:`_orm.registry.configure` method
|
on each. The :meth:`_orm.registry.configure` method may be preferred to
|
limit the configuration of mappers to those local to a particular
|
:class:`_orm.registry` and/or declarative base class.
|
|
Points at which automatic configuration is invoked include when a mapped
|
class is instantiated into an instance, as well as when ORM queries
|
are emitted using :meth:`.Session.query` or :meth:`_orm.Session.execute`
|
with an ORM-enabled statement.
|
|
The mapper configure process, whether invoked by
|
:func:`_orm.configure_mappers` or from :meth:`_orm.registry.configure`,
|
provides several event hooks that can be used to augment the mapper
|
configuration step. These hooks include:
|
|
* :meth:`.MapperEvents.before_configured` - called once before
|
:func:`.configure_mappers` or :meth:`_orm.registry.configure` does any
|
work; this can be used to establish additional options, properties, or
|
related mappings before the operation proceeds.
|
|
* :meth:`.MapperEvents.mapper_configured` - called as each individual
|
:class:`_orm.Mapper` is configured within the process; will include all
|
mapper state except for backrefs set up by other mappers that are still
|
to be configured.
|
|
* :meth:`.MapperEvents.after_configured` - called once after
|
:func:`.configure_mappers` or :meth:`_orm.registry.configure` is
|
complete; at this stage, all :class:`_orm.Mapper` objects that fall
|
within the scope of the configuration operation will be fully configured.
|
Note that the calling application may still have other mappings that
|
haven't been produced yet, such as if they are in modules as yet
|
unimported, and may also have mappings that are still to be configured,
|
if they are in other :class:`_orm.registry` collections not part of the
|
current scope of configuration.
|
|
Trf N)ri rm rk rk rk rl Úconfigure_mappersí s DrW zSet[_RegistryType]rz rê )Ú
|
registriesrg rg c C s | D ]}|j r qqd S th tr0W 5 Q R £ d S dazD| D ]}|j r: q\q:W ¢,W 5 Q R £ d S tj t¡ ¡ t| | W 5 daX W 5 Q R X tj t¡ ¡ d S )NTF) rh ri Ú_already_compilingrs rt Z
|
_for_classZbefore_configuredÚ_do_configure_registriesZafter_configured)rX rg rp rk rk rl ri 4 s" ri zsqlalchemy.orm.decl_apic
|
C s" t jjj}t| }| | ¡D ]þ}d}| ¡ D ]Æ}d }|jjD ] }|||j }|t
|
kr>d} q`q>|t
|
krjq.t |ddrt d||jf ¡} |j| _| |js.z$| ¡ | ¡ |j ||j ¡ W q. tk
|
rò t ¡ d }
|
t|
|
dsì|
|
|_ Y q.X q.|sd|_|s |j |¡r t d¡q d S )NFTru zOne or more mappers failed to initialize - can't proceed with initialization of other mappers. Triggering mapper: '%s'. Original exception was: %sr zHconfigure was called with cascade=False but additional registries remain)r rO Ú orm_decl_apirJ rj Z_recurse_with_dependenciesro rt Zbefore_mapper_configuredr| r( rD r¦ r ru rÕ rl r» Zmapper_configuredÚ ExceptionÚsysÚexc_infor rh Ú _dependenciesr ) rX rg rJ Úorigrp Zhas_skiprÅ Z run_configureÚfnr1 r rk rk rl rZ W sJ
|
üÿ
|
|
ÿrZ c C s¶ t jjj}t| }| | ¡D ]}|s:|j |¡r:t d¡|j
|
rtz|j
|
¡ \}}W n t k
|
rf Y q:X | |¡ q:|j ¡ |j ¡ |jD ]}|j |¡ q|j ¡ d|_q d S )Nz^Registry has dependent registries that are not disposed; pass cascade=True to clear these alsoF)r rO r[ rJ rj Z_recurse_with_dependentsZ _dependentsr r¦ r Z _managersÚpopitemr Z_dispose_manager_and_mapperZ_non_primary_mappersÚclearr_ Údiscardrh )rX rg rJ r` rp r Ú_rC rk rk rl Ú_dispose_registries s&
|
ÿ
|
|
|
|
rf c C s
|
d| _ | S )a¹ Decorate a method as the 'reconstructor' hook.
|
|
Designates a single method as the "reconstructor", an ``__init__``-like
|
method that will be called by the ORM after the instance has been
|
loaded from the database or otherwise reconstituted.
|
|
.. tip::
|
|
The :func:`_orm.reconstructor` decorator makes use of the
|
:meth:`_orm.InstanceEvents.load` event hook, which can be
|
used directly.
|
|
The reconstructor will be invoked with no arguments. Scalar
|
(non-collection) database-mapped attributes of the instance will
|
be available for use within the function. Eagerly-loaded
|
collections are generally not yet available and will usually only
|
contain the first element. ORM state changes made to objects at
|
this stage will not be recorded for the next flush() operation, so
|
the activity within a reconstructor should be conservative.
|
|
.. seealso::
|
|
:meth:`.InstanceEvents.load`
|
|
T)r ©ra rk rk rl Ú reconstructor° s rh ©Úinclude_removesÚinclude_backrefsrî zCallable[[_Fn], _Fn])Únamesrj rk rg c s ddd fdd }|S )aÎ Decorate a method as a 'validator' for one or more named properties.
|
|
Designates a method as a validator, a method which receives the
|
name of the attribute as well as a value to be assigned, or in the
|
case of a collection, the value to be added to the collection.
|
The function can then raise validation exceptions to halt the
|
process from continuing (where Python's built-in ``ValueError``
|
and ``AssertionError`` exceptions are reasonable choices), or can
|
modify or replace the value before proceeding. The function should
|
otherwise return the given value.
|
|
Note that a validator for a collection **cannot** issue a load of that
|
collection within the validation routine - this usage raises
|
an assertion to avoid recursion overflows. This is a reentrant
|
condition which is not supported.
|
|
:param \*names: list of attribute names to be validated.
|
:param include_removes: if True, "remove" events will be
|
sent as well - the validation function must accept an additional
|
argument "is_remove" which will be a boolean.
|
|
:param include_backrefs: defaults to ``True``; if ``False``, the
|
validation function will not emit if the originator is an attribute
|
event related via a backref. This can be used for bi-directional
|
:func:`.validates` usage where only one validator should emit per
|
attribute operation.
|
|
.. seealso::
|
|
:ref:`simple_validators` - usage examples for :func:`.validates`
|
|
rb )ra rg c s | _ d| _| S )Nri )r r rg ©rk rj rl rk rl Úwrapò s
|
þzvalidates.<locals>.wraprk )rj rk rl rn rk rm rl Ú validatesÎ s $ro c C s | j j}|jr | | ¡ ¡ d S rh )r rÅ r± rì )r@ ÚctxÚinstrumenting_mapperrk rk rl r ý s r c C s( | j j}|r$| ¡ |jr$| | ¡ dS )zÀRun init_instance hooks.
|
|
This also includes mapper compilation, normally not needed
|
here but helps with some piecemeal configuration
|
scenarios (such as in the ORM tutorial).
|
|
N)r rÅ rj rÑ )r@ ru Úkwargsrq rk rk rl r s
|
r c @ s$ e Zd ZdZdZdd Zdd ZdS )rÏ z4Error reporting helper for mapper._columntoproperty.r0 c C s
|
|| _ d S rh r0 rp rk rk rl r½ s z_ColumnMapping.__init__c C sH | j j |¡}|r0t d|jj|j|j|f ¡t d|| j f ¡d S )NzDColumn '%s.%s' is not available, due to conflicting property '%s':%rz*No column %s is configured on mapper %s...)rÅ rÎ r< Úorm_excZUnmappedColumnErrorrÀ r rø )r¼ rñ rù rk rk rl Ú __missing__ s þÿÿÿz_ColumnMapping.__missing__N)r r rQ rR Ú __slots__r½ rt rk rk rk rl rÏ s rÏ )r ra )rR Ú
|
__future__r Ú collectionsr Ú functoolsr Ú itertoolsr r] Ú threadingÚtypingr r r r r
|
r r r r r r r r r r r r r r r Úweakrefr5 r r rs r r r r rÍ Ú_typingr! r7 r" r# r$ r% r& Z
|
interfacesr' r( r) r* r+ r, r- Z path_registryr. r0 r¦ r1 r2 r3 r4 r5 r6 r8 r8 r9 r: r; r< râ r= Z sql.cache_keyr> Z sql.elementsr? Z
|
sql.schemar@ rA Zsql.selectablerB rC rD Z util.typingrE rF rG rH rI Zdecl_apirJ Ú
|
dependencyrK rT rL rM ÚeventsrN rO rP rQ r× rR r@ rS rT ZenginerU rV Z sql._typingrW rX Zsql.baserY rZ r[ r\ r] r^ r` rb Z_WithPolymorphicArgÚWeakKeyDictionaryre rS rm rq rY Úsymbolrr ÚRLockri Z_self_inspectsZ class_loggerZ
|
IdentifiedZ Inspectablers r\ r# rW ri rV rZ rf rh ro r r rÏ rk rk rk rl Ú<module> sZ ÿÿûÿ þ
|
|
|
ø cG#5" ÿ/
|
