U
|
¸ý°dü ã @ sÐ d Z ddlmZ ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
|
Z
|
dd lm Z dd
|
lm Z dd lm Z dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ ddlmZ ddlm Z ddlm Z ddlm Z dd l m Z dd l m!Z! dd l m"Z" dd l m#Z# dd l m$Z$ dd!lm%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-l2m4Z5 dd.l6m7Z7 dd/l8m9Z9 dd0l:m;Z; dd1l<m=Z= d2d3lm>Z> d2d4lm?Z? d2d5lm@Z@ d2d6lAmBZB d2d7lCmDZD d2d8lEmFZF d2d9lGmHZH d2d:lImJZJ d2d;l@mKZK d2d<l@mLZL d2d=l@mZM d2d>lNmOZO d2d?lNmPZP d2d@lNmQZQ d2dAlNmRZR d2dBlNmSZS d2dClNmTZT erddDlUmVZV ddElUmWZW ddFl*mXZX ddGl mYZY ddHl mZZZ dd1l<m=Z= d2dIl[m\Z\ d2dJl]m^Z^ edKedLZ_edMedLZ`eedNf Zae
|
edNf ZbedOee)e_ eFe_ f f ZcdPdQdRdSdTZdG dUdV dVeeZfG dWdX dXefe?jge7e ZheMjie9e;e3e4e"e#e e$e!f dYG dZd[ d[ehZjG d\d] d]efe?jge7e Zkdd_dQd`dadbdcZlG ddde deZmG dfdg dgeme e_ ZnG dhdi die joe_ emZpG djdk dkepe_ ZqdldldRdmdnZrdodpdRdqdrZsG dsdt dtejduZtG dvdw dwe?jge=e ehduZudododpdxdydzZvG d{d| d|e?jge=e ZwdPd_d}dpd~ddZxddeyddde.ekddddod_d
dddodd ddZzG dd dZ{e{Z|ese{ZWdddddZ}e? ~ekeueh¡doddRddZdS )z1Public API functions and helpers for declarative.é )Ú annotationsN)ÚAny)ÚCallable)Úcast)ÚClassVar)ÚDict)Ú FrozenSet)ÚGeneric)ÚIterable)ÚIterator)ÚMapping)ÚOptional)Úoverload)ÚSet)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú
|
attributes)Ú clsregistry)Úinstrumentation)Ú
|
interfaces)Ú mapperlib)Ú composite)Údeferred)Ú mapped_column)Ú relationship)Úsynonym)ÚInstrumentedAttribute)Ú_inspect_mapped_class)Ú_is_mapped_class)ÚMapped©Ú_add_attribute)Ú_as_declarative)Ú_ClassScanMapperConfig)Ú_declarative_constructor)Ú_DeferredMapperConfig)Ú_del_attribute©Ú_mapper)Ú Composite)ÚSynonym)ÚMapper)Ú MappedColumn)ÚRelationshipProperty)Ú InstanceStateé )Úexc)Ú
|
inspection)Úutil)Úsqltypes)Ú_NoArg)ÚSQLCoreOperations)ÚMetaData)Ú
|
FromClause)Ú hybridmethod)Úhybridproperty)Útyping)ÚCallableReference)Úflatten_newtype)Ú
|
is_generic)Ú
|
is_literal)Ú
|
is_newtype)ÚLiteral)Ú_O)Ú _RegistryType)Ú_DataclassArguments)Ú ClassManager)ÚMapperProperty)Ú_TypeEngineArgument)Ú_MatchedOnTypeÚ_T)ÚboundÚ_TTz_TypeEngineArgument[Any].úType[_O]Úbool©ÚclsÚreturnc C s. | j dd
D ]}t|dddk r dS qdS )aK Given a class, return True if any of the classes it inherits from has a
|
mapped table, otherwise return False.
|
|
This is used in declarative mixins to build attributes that behave
|
differently for the base class vs. a subclass in an inheritance
|
hierarchy.
|
|
.. seealso::
|
|
:ref:`decl_mixin_inheritance`
|
|
r NÚ __table__TF)Ú__mro__Úgetattr)rR Úclass_© rX úNd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/decl_api.pyÚhas_inherited_tablei s rZ c @ s. e Zd ZddddddZddddd Zd
|
S ) Ú_DynamicAttributesTypeÚstrr ÚNone)ÚkeyÚvaluerS c C s* d| j krt| || nt | ||¡ d S ©NÚ
|
__mapper__)Ú__dict__r% ÚtypeÚ __setattr__)rR r^ r_ rX rX rY rd } s
|
z"_DynamicAttributesType.__setattr__)r^ rS c C s& d| j krt| | n t | |¡ d S r` )rb r* rc Ú __delattr__©rR r^ rX rX rY re s
|
z"_DynamicAttributesType.__delattr__N)Ú__name__Ú
|
__module__Ú __qualname__rd re rX rX rX rY r[ | s r[ c @ s e Zd ZdZdS )Ú DeclarativeAttributeInterceptzMetaclass that may be used in conjunction with the
|
:class:`_orm.DeclarativeBase` class to support addition of class
|
attributes dynamically.
|
|
N©rg rh ri Ú__doc__rX rX rX rY rj s rj ©Zfield_specifiersc @ s e Zd ZdZdS )ÚDCTransformDeclarativez-metaclass that includes @dataclass_transformsNrk rX rX rX rY rn s rn c @ s4 e Zd ZU ded< ded< dddddddd Zd
|
S ) ÚDeclarativeMetar: ÚmetadataÚ RegistryTypeÚregistryr r] )Ú classnameÚbasesÚdict_ÚkwrS c K sp | j }t| dd }|d krB| dd ¡}t|ts<t d¡n|| _| j dd¡s\t|| | t
|
| |||¡ d S )NÚ _sa_registryrr ziDeclarative base class has no 'registry' attribute, or registry is not a sqlalchemy.orm.registry() objectÚ __abstract__F) rb rV ÚgetÚ
|
isinstancerr r4 ÚInvalidRequestErrorrw r& rc Ú__init__)rR rs rt ru rv ÚregrX rX rY r| « s
|
ÿ zDeclarativeMeta.__init__N)rg rh ri Ú__annotations__r| rX rX rX rY ro ¥ s
|
ro Fr\ z,Callable[[Callable[..., Any]], Synonym[Any]])ÚnameÚ
|
map_columnrS c s ddd fdd }|S )a Decorator that produces an :func:`_orm.synonym`
|
attribute in conjunction with a Python descriptor.
|
|
The function being decorated is passed to :func:`_orm.synonym` as the
|
:paramref:`.orm.synonym.descriptor` parameter::
|
|
class MyClass(Base):
|
__tablename__ = 'my_table'
|
|
id = Column(Integer, primary_key=True)
|
_job_status = Column("job_status", String(50))
|
|
@synonym_for("job_status")
|
@property
|
def job_status(self):
|
return "Status: %s" % self._job_status
|
|
The :ref:`hybrid properties <mapper_hybrids>` feature of SQLAlchemy
|
is typically preferred instead of synonyms, which is a more legacy
|
feature.
|
|
.. seealso::
|
|
:ref:`synonyms` - Overview of synonyms
|
|
:func:`_orm.synonym` - the mapper-level function
|
|
:ref:`mapper_hybrids` - The Hybrid Attribute extension provides an
|
updated approach to augmenting attribute behavior more flexibly than
|
can be achieved with synonyms.
|
|
úCallable[..., Any]z Synonym[Any]©ÚfnrS c s t | dS )N)r Z
|
descriptor)Ú _orm_synonym)r ©r r rX rY Údecorateé s z synonym_for.<locals>.decoraterX )r r r rX r
rY Ú synonym_forÅ s $r c @ s@ e Zd ZdddddddZddd d
|
Zd d d d ddZdS )Ú_declared_attr_commonFr rP )r Ú cascadingÚquietc C s. t |tr|j}|| _|| _|| _|j| _d S ©N)rz Ú classmethodÚ__func__ÚfgetZ
|
_cascadingZ_quietrl )Úselfr r r rX rX rY r| ð s
|
z _declared_attr_common.__init__zOptional[Type[Any]]©rS c C s t | j¡ d¡S )NrS )r6 Zget_annotationsr ry ©r rX rX rY Ú_collect_return_annotation s z0_declared_attr_common._collect_return_annotationúOptional[object]r ©ÚinstanceÚownerrS c C s |}t |¡}|d krHt d| jj¡s>t d| jj|jf ¡ | |¡S |jrX| |¡S | ¡ }|d k slt
|
|j }| |kr|| S | |¡ || < }|S d S )Nz^__.+__$zEUnmanaged access of declarative attribute %s from non-mapped class %s) r Zopt_manager_of_classÚreÚmatchr rg r6 ÚwarnÚ is_mappedÚdeclarative_scanÚAssertionErrorZdeclared_attr_reg)r r r rR Úmanagerr r} ÚobjrX rX rY Ú__get__ s&
|
ÿÿ
|
|
z _declared_attr_common.__get__N)FF)rg rh ri r| r r rX rX rX rY r ï s
|
ür c @ sh e Zd ZejrdddddddZddd d
|
d d Zddd dddZdd dddZdddddZ dS )Ú_declared_directiveFzCallable[..., _T]rP ©r r c C s d S r rX ©r r r rX rX rY r| 5 s z _declared_directive.__init__r r rL r c C s d S r rX ©r r r rX rX rY r < s z_declared_directive.__get__r] ©r r_ rS c C s d S r rX ©r r r_ rX rX rY Ú__set__? s z_declared_directive.__set__©r rS c C s d S r rX ©r r rX rX rY Ú
|
__delete__B s z _declared_directive.__delete__zCallable[..., _TT]z_declared_directive[_TT]r c C s d S r rX ©r r rX rX rY Ú__call__E s z _declared_directive.__call__N)F)
|
rg rh ri r> r r| r r¦ r© r« rX rX rX rY r 0 s ýr c @ sÀ e Zd ZdZejrd%dddddZddd d
|
d d Zdd d ddZe d dddddZ
|
e ddddddZ
|
ddddddZ
|
e dddd d Z e d d d d!Ze dd d"d#Zd$S )&Ú declared_attra Mark a class-level method as representing the definition of
|
a mapped property or Declarative directive.
|
|
:class:`_orm.declared_attr` is typically applied as a decorator to a class
|
level method, turning the attribute into a scalar-like property that can be
|
invoked from the uninstantiated class. The Declarative mapping process
|
looks for these :class:`_orm.declared_attr` callables as it scans classes,
|
and assumes any attribute marked with :class:`_orm.declared_attr` will be a
|
callable that will produce an object specific to the Declarative mapping or
|
table configuration.
|
|
:class:`_orm.declared_attr` is usually applicable to
|
:ref:`mixins <orm_mixins_toplevel>`, to define relationships that are to be
|
applied to different implementors of the class. It may also be used to
|
define dynamically generated column expressions and other Declarative
|
attributes.
|
|
Example::
|
|
class ProvidesUserMixin:
|
"A mixin that adds a 'user' relationship to classes."
|
|
user_id: Mapped[int] = mapped_column(ForeignKey("user_table.id"))
|
|
@declared_attr
|
def user(cls) -> Mapped["User"]:
|
return relationship("User")
|
|
When used with Declarative directives such as ``__tablename__``, the
|
:meth:`_orm.declared_attr.directive` modifier may be used which indicates
|
to :pep:`484` typing tools that the given method is not dealing with
|
:class:`_orm.Mapped` attributes::
|
|
class CreateTableName:
|
@declared_attr.directive
|
def __tablename__(cls) -> str:
|
return cls.__name__.lower()
|
|
:class:`_orm.declared_attr` can also be applied directly to mapped
|
classes, to allow for attributes that dynamically configure themselves
|
on subclasses when using mapped inheritance schemes. Below
|
illustrates :class:`_orm.declared_attr` to create a dynamic scheme
|
for generating the :paramref:`_orm.Mapper.polymorphic_identity` parameter
|
for subclasses::
|
|
class Employee(Base):
|
__tablename__ = 'employee'
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
type: Mapped[str] = mapped_column(String(50))
|
|
@declared_attr.directive
|
def __mapper_args__(cls) -> Dict[str, Any]:
|
if cls.__name__ == 'Employee':
|
return {
|
"polymorphic_on":cls.type,
|
"polymorphic_identity":"Employee"
|
}
|
else:
|
return {"polymorphic_identity":cls.__name__}
|
|
class Engineer(Employee):
|
pass
|
|
:class:`_orm.declared_attr` supports decorating functions that are
|
explicitly decorated with ``@classmethod``. This is never necessary from a
|
runtime perspective, however may be needed in order to support :pep:`484`
|
typing tools that don't otherwise recognize the decorated function as
|
having class-level behaviors for the ``cls`` parameter::
|
|
class SomethingMixin:
|
x: Mapped[int]
|
y: Mapped[int]
|
|
@declared_attr
|
@classmethod
|
def x_plus_y(cls) -> Mapped[int]:
|
return column_property(cls.x + cls.y)
|
|
.. versionadded:: 2.0 - :class:`_orm.declared_attr` can accommodate a
|
function decorated with ``@classmethod`` to help with :pep:`484`
|
integration where needed.
|
|
|
.. seealso::
|
|
:ref:`orm_mixins_toplevel` - Declarative Mixin documentation with
|
background on use patterns for :class:`_orm.declared_attr`.
|
|
Fú_DeclaredAttrDecorated[_T]rP r¡ c C s d S r rX r¢ rX rX rY r| ¨ s zdeclared_attr.__init__r r] r¤ c C s d S r rX r¥ rX rX rY r¦ ¯ s zdeclared_attr.__set__r§ c C s d S r rX r¨ rX rX rY r© ² s zdeclared_attr.__delete__zInstrumentedAttribute[_T]r c C s d S r rX r£ rX rX rY r ¹ s zdeclared_attr.__get__ÚobjectrL c C s d S r rX r£ rX rX rY r ¿ s r z$Union[InstrumentedAttribute[_T], _T]c C s d S r rX r£ rX rX rY r à s ú_stateful_declared_attr[_T]©rv rS c K s
|
t f |S r )Ú_stateful_declared_attr)rR rv rX rX rY Ú _statefulÈ s zdeclared_attr._statefulz_declared_directive[Any]r c C s t S r )r ©rR rX rX rY Ú directiveÌ s zdeclared_attr.directivec C s | j ddS )NT)r )r² r³ rX rX rY r Ñ s zdeclared_attr.cascadingN)F)rg rh ri rl r> r r| r¦ r© r r r< r² r= r´ r rX rX rX rY r¬ J s" [ ýr¬ c @ sH e Zd ZU ded< ddddZedddd d
|
Zd d d ddZdS )r± zDict[str, Any]rv r ©rv c K s
|
|| _ d S r rµ ©r rv rX rX rY r| Ú s z _stateful_declared_attr.__init__r¯ r° c K s | j ¡ }| |¡ tf |S r )rv ÚcopyÚupdater± )r rv Znew_kwrX rX rY r² Ý s
|
|
z!_stateful_declared_attr._statefulr zdeclared_attr[_T]r c C s t |f| jS r )r¬ rv rª rX rX rY r« ã s z _stateful_declared_attr.__call__N)rg rh ri r~ r| r< r² r« rX rX rX rY r± × s
|
|
r± úType[_T]c C s | S )a, Mark a class as providing the feature of "declarative mixin".
|
|
E.g.::
|
|
from sqlalchemy.orm import declared_attr
|
from sqlalchemy.orm import declarative_mixin
|
|
@declarative_mixin
|
class MyMixin:
|
|
@declared_attr
|
def __tablename__(cls):
|
return cls.__name__.lower()
|
|
__table_args__ = {'mysql_engine': 'InnoDB'}
|
__mapper_args__= {'always_refresh': True}
|
|
id = Column(Integer, primary_key=True)
|
|
class MyModel(MyMixin, Base):
|
name = Column(String(1000))
|
|
The :func:`_orm.declarative_mixin` decorator currently does not modify
|
the given class in any way; it's current purpose is strictly to assist
|
the :ref:`Mypy plugin <mypy_toplevel>` in being able to identify
|
SQLAlchemy declarative mixin classes when no other context is present.
|
|
.. versionadded:: 1.4.6
|
|
.. seealso::
|
|
:ref:`orm_mixins_toplevel`
|
|
:ref:`mypy_declarative_mixins` - in the
|
:ref:`Mypy plugin documentation <mypy_toplevel>`
|
|
rX r³ rX rX rY Údeclarative_mixinç s 'rº ú Type[Any]r] c C s d| j kr| j d }nd }d| j kr0| j d }nd }| j dd ¡}|d k rtt|ts`t d¡q|d k rt d¡nt||d}|| _|| _d| j kr | jj| _t| dt j
|
t j
|
kr¾| jj | _
|
d S )Nrp Útype_annotation_maprr zfDeclarative base class has a 'registry' attribute that is not an instance of sqlalchemy.orm.registry()zÊDeclarative base class has both a 'registry' attribute and a type_annotation_map entry. Per-base type_annotation_maps are not supported. Please apply the type_annotation_map to this registry directly.)rp r¼ r| ) rb ry rz rr r4 r{ rw rp rV r® r| Ú constructor)rR rp r¼ r} rX rX rY Ú_setup_declarative_base s4
|
|
|
ÿÿ ÿ
|
|
r¾ c sX e Zd ZdZejejejejejejejejfdddddddddd fdd Z ZS )ÚMappedAsDataclassa Mixin class to indicate when mapping this class, also convert it to be
|
a dataclass.
|
|
.. seealso::
|
|
:ref:`orm_declarative_native_dataclasses` - complete background
|
on SQLAlchemy native dataclass mapping
|
|
.. versionadded:: 2.0
|
|
úUnion[_NoArg, bool]ú'Union[_NoArg, Callable[..., Type[Any]]]r] ) ÚinitÚreprÚeqÚorderÚ unsafe_hashÚ
|
match_argsÚkw_onlyÚdataclass_callablerS c s ||||||||d} t | drN| j t ¡ fdd| ¡ D | _}
|
n
|
| | _}
|
t ¡ t| st | ¡} t |
|
| | ¡ d S )N©r rà rÄ rÅ rÆ rÇ rÈ rÉ Ú_sa_apply_dc_transformsc s. i | ]&\}}||t jkr& |t j¡n|qS rX )r8 ÚNO_ARGry )Ú.0ÚkÚv©ÚcurrentrX rY Ú
|
<dictcomp>f s ÿ z7MappedAsDataclass.__init_subclass__.<locals>.<dictcomp>)
|
ÚhasattrrË r' Z_assert_dc_argumentsÚitemsÚsuperÚ__init_subclass__r" Z(_update_annotations_for_non_mapped_classZ _apply_dataclasses_to_any_class) rR r rà rÄ rÅ rÆ rÇ rÈ rÉ Zapply_dc_transformsZcurrent_transformsZnew_anno©Ú __class__rÐ rY rÖ G s: ø
|
|
|
þþ
|
ÿþ ÿz#MappedAsDataclass.__init_subclass__)rg rh ri rl r8 rÌ rÖ Ú __classcell__rX rX r× rY r¿ : s õr¿ )Ú metaclassc s e Zd ZU dZejrjded< ded< ded< ded< d ed
|
< d ed < d ed< d ed< d ed< d dddZdd fdd Z Z S )ÚDeclarativeBaseaÔ Base class used for declarative class definitions.
|
|
The :class:`_orm.DeclarativeBase` allows for the creation of new
|
declarative bases in such a way that is compatible with type checkers::
|
|
|
from sqlalchemy.orm import DeclarativeBase
|
|
class Base(DeclarativeBase):
|
pass
|
|
|
The above ``Base`` class is now usable as the base for new declarative
|
mappings. The superclass makes use of the ``__init_subclass__()``
|
method to set up new classes and metaclasses aren't used.
|
|
When first used, the :class:`_orm.DeclarativeBase` class instantiates a new
|
:class:`_orm.registry` to be used with the base, assuming one was not
|
provided explicitly. The :class:`_orm.DeclarativeBase` class supports
|
class-level attributes which act as parameters for the construction of this
|
registry; such as to indicate a specific :class:`_schema.MetaData`
|
collection as well as a specific value for
|
:paramref:`_orm.registry.type_annotation_map`::
|
|
from typing_extensions import Annotated
|
|
from sqlalchemy import BigInteger
|
from sqlalchemy import MetaData
|
from sqlalchemy import String
|
from sqlalchemy.orm import DeclarativeBase
|
|
bigint = Annotated[int, "bigint"]
|
my_metadata = MetaData()
|
|
class Base(DeclarativeBase):
|
metadata = my_metadata
|
type_annotation_map = {
|
str: String().with_variant(String(255), "mysql", "mariadb"),
|
bigint: BigInteger()
|
}
|
|
Class-level attributes which may be specified include:
|
|
:param metadata: optional :class:`_schema.MetaData` collection.
|
If a :class:`_orm.registry` is constructed automatically, this
|
:class:`_schema.MetaData` collection will be used to construct it.
|
Otherwise, the local :class:`_schema.MetaData` collection will supercede
|
that used by an existing :class:`_orm.registry` passed using the
|
:paramref:`_orm.DeclarativeBase.registry` parameter.
|
:param type_annotation_map: optional type annotation map that will be
|
passed to the :class:`_orm.registry` as
|
:paramref:`_orm.registry.type_annotation_map`.
|
:param registry: supply a pre-existing :class:`_orm.registry` directly.
|
|
.. versionadded:: 2.0 Added :class:`.DeclarativeBase`, so that declarative
|
base classes may be constructed in such a way that is also recognized
|
by :pep:`484` type checkers. As a result, :class:`.DeclarativeBase`
|
and other subclassing-oriented APIs should be seen as
|
superseding previous "class returned by a function" APIs, namely
|
:func:`_orm.declarative_base` and :meth:`_orm.registry.generate_base`,
|
where the base class returned cannot be recognized by type checkers
|
without using plugins.
|
|
**__init__ behavior**
|
|
In a plain Python class, the base-most ``__init__()`` method in the class
|
hierarchy is ``object.__init__()``, which accepts no arguments. However,
|
when the :class:`_orm.DeclarativeBase` subclass is first declared, the
|
class is given an ``__init__()`` method that links to the
|
:paramref:`_orm.registry.constructor` constructor function, if no
|
``__init__()`` method is already present; this is the usual declarative
|
constructor that will assign keyword arguments as attributes on the
|
instance, assuming those attributes are established at the class level
|
(i.e. are mapped, or are linked to a descriptor). This constructor is
|
**never accessed by a mapped class without being called explicitly via
|
super()**, as mapped classes are themselves given an ``__init__()`` method
|
directly which calls :paramref:`_orm.registry.constructor`, so in the
|
default case works independently of what the base-most ``__init__()``
|
method does.
|
|
.. versionchanged:: 2.0.1 :class:`_orm.DeclarativeBase` has a default
|
constructor that links to :paramref:`_orm.registry.constructor` by
|
default, so that calls to ``super().__init__()`` can access this
|
constructor. Previously, due to an implementation mistake, this default
|
constructor was missing, and calling ``super().__init__()`` would invoke
|
``object.__init__()``.
|
|
The :class:`_orm.DeclarativeBase` subclass may also declare an explicit
|
``__init__()`` method which will replace the use of the
|
:paramref:`_orm.registry.constructor` function at this level::
|
|
class Base(DeclarativeBase):
|
def __init__(self, id=None):
|
self.id = id
|
|
Mapped classes still will not invoke this constructor implicitly; it
|
remains only accessible by calling ``super().__init__()``::
|
|
class MyClass(Base):
|
def __init__(self, id=None, name=None):
|
self.name = name
|
super().__init__(id=id)
|
|
Note that this is a different behavior from what functions like the legacy
|
:func:`_orm.declarative_base` would do; the base created by those functions
|
would always install :paramref:`_orm.registry.constructor` for
|
``__init__()``.
|
|
|
úClassVar[_RegistryType]rw rr úClassVar[MetaData]rp z ClassVar[str]rg úClassVar[Mapper[Any]]ra zClassVar[FromClause]rT r Ú __tablename__Ú__mapper_args__Ú__table_args__rµ c K s d S r rX r¶ rX rX rY r| : s zDeclarativeBase.__init__r] r c s< t | jkr t| t t| nt| j| | j t ¡ d S r ) rÛ Ú __bases__Ú_check_not_declarativer¾ r& rw rb rÕ rÖ r³ r× rX rY rÖ = s
|
|
|
|
z!DeclarativeBase.__init_subclass__)
|
rg rh ri rl r> r r~ r| rÖ rÙ rX rX r× rY rÛ z s
|
o
|
|
rÛ )rR ÚbaserS c C sR | j }d|kr(t|d s(t|d dr:t| dd ¡trNt d|jd¡d S )NrT r rß z Cannot use zR directly as a declarative base class. Create a Base by creating a subclass of it.) rb ÚcallablerÓ rz ry r\ r4 r{ rg )rR rä Zcls_dictrX rX rY rã F s ÿ
|
ý üú ÿrã c @ st e Zd ZU dZded< ded< ded< ded< d ed
|
< ejrbd ed < d ed < d ed< d dddZddddZdS )ÚDeclarativeBaseNoMetazõSame as :class:`_orm.DeclarativeBase`, but does not use a metaclass
|
to intercept new attributes.
|
|
The :class:`_orm.DeclarativeBaseNoMeta` base may be used when use of
|
custom metaclasses is desirable.
|
|
.. versionadded:: 2.0
|
|
|
rÜ rw rr rÝ rp rÞ ra úOptional[FromClause]rT r rß rà rá rµ c K s d S r rX r¶ rX rX rY r| « s z DeclarativeBaseNoMeta.__init__r] r c C s. t | jkr t| t t| n | j | ¡ d S r )ræ râ rã r¾ rw Úmap_declarativelyr³ rX rX rY rÖ ® s
|
|
|
z'DeclarativeBaseNoMeta.__init_subclass__N) rg rh ri rl r~ r> r r| rÖ rX rX rX rY ræ U s
|
|
|
ræ zMapperProperty[Any])Útargetr^ ÚattrrS c C s t | || dS )a' Add a new mapped attribute to an ORM mapped class.
|
|
E.g.::
|
|
add_mapped_attribute(User, "addresses", relationship(Address))
|
|
This may be used for ORM mappings that aren't using a declarative
|
metaclass that intercepts attribute set operations.
|
|
.. versionadded:: 2.0
|
|
|
Nr$ )ré r^ rê rX rX rY Úadd_mapped_attribute¶ s rë ÚBase©rp ÚmapperrR r Úclass_registryr¼ r½ rÚ úOptional[MetaData]ú$Optional[Callable[..., Mapper[Any]]]ú&Optional[clsregistry._ClsRegistryType]ú Optional[_TypeAnnotationMapType]úCallable[(Ellipsis, None)]r ) rp rî rR r rï r¼ r½ rÚ rS c C s t | |||dj||||dS )a Construct a base class for declarative class definitions.
|
|
The new base class will be given a metaclass that produces
|
appropriate :class:`~sqlalchemy.schema.Table` objects and makes
|
the appropriate :class:`_orm.Mapper` calls based on the
|
information provided declaratively in the class and any subclasses
|
of the class.
|
|
.. versionchanged:: 2.0 Note that the :func:`_orm.declarative_base`
|
function is superseded by the new :class:`_orm.DeclarativeBase` class,
|
which generates a new "base" class using subclassing, rather than
|
return value of a function. This allows an approach that is compatible
|
with :pep:`484` typing tools.
|
|
The :func:`_orm.declarative_base` function is a shorthand version
|
of using the :meth:`_orm.registry.generate_base`
|
method. That is, the following::
|
|
from sqlalchemy.orm import declarative_base
|
|
Base = declarative_base()
|
|
Is equivalent to::
|
|
from sqlalchemy.orm import registry
|
|
mapper_registry = registry()
|
Base = mapper_registry.generate_base()
|
|
See the docstring for :class:`_orm.registry`
|
and :meth:`_orm.registry.generate_base`
|
for more details.
|
|
.. versionchanged:: 1.4 The :func:`_orm.declarative_base`
|
function is now a specialization of the more generic
|
:class:`_orm.registry` class. The function also moves to the
|
``sqlalchemy.orm`` package from the ``declarative.ext`` package.
|
|
|
:param metadata:
|
An optional :class:`~sqlalchemy.schema.MetaData` instance. All
|
:class:`~sqlalchemy.schema.Table` objects implicitly declared by
|
subclasses of the base will share this MetaData. A MetaData instance
|
will be created if none is provided. The
|
:class:`~sqlalchemy.schema.MetaData` instance will be available via the
|
``metadata`` attribute of the generated declarative base class.
|
|
:param mapper:
|
An optional callable, defaults to :class:`_orm.Mapper`. Will
|
be used to map subclasses to their Tables.
|
|
:param cls:
|
Defaults to :class:`object`. A type to use as the base for the generated
|
declarative base class. May be a class or tuple of classes.
|
|
:param name:
|
Defaults to ``Base``. The display name for the generated
|
class. Customizing this is not required, but can improve clarity in
|
tracebacks and debugging.
|
|
:param constructor:
|
Specify the implementation for the ``__init__`` function on a mapped
|
class that has no ``__init__`` of its own. Defaults to an
|
implementation that assigns \**kwargs for declared
|
fields and relationships to an instance. If ``None`` is supplied,
|
no __init__ will be provided and construction will fall back to
|
cls.__init__ by way of the normal Python semantics.
|
|
:param class_registry: optional dictionary that will serve as the
|
registry of class names-> mapped classes when string names
|
are used to identify classes inside of :func:`_orm.relationship`
|
and others. Allows two or more declarative base classes
|
to share the same registry of class names for simplified
|
inter-base relationships.
|
|
:param type_annotation_map: optional dictionary of Python types to
|
SQLAlchemy :class:`_types.TypeEngine` classes or instances. This
|
is used exclusively by the :class:`_orm.MappedColumn` construct
|
to produce column types based on annotations within the
|
:class:`_orm.Mapped` type.
|
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:ref:`orm_declarative_mapped_column_type_map`
|
|
:param metaclass:
|
Defaults to :class:`.DeclarativeMeta`. A metaclass or __metaclass__
|
compatible callable to use as the meta type of the generated
|
declarative base class.
|
|
.. seealso::
|
|
:class:`_orm.registry`
|
|
)rp rï r½ r¼ )rî rR r rÚ )rr Ú generate_baserí rX rX rY Údeclarative_baseÉ s nü÷rö c @ s~ e Zd ZU dZded< ded< ded< ded < d
|
ed < d ed < ded< ded< ded< dddeddddddddZdd d d d Zd d!d"d#d$Ze d%d&d'd(Z
|
d)d d*d+d,Z d-d d.d/d0Z e d1d2d3d4d5Ze d1d2d3d6d7Zd8d&d9d:Zd-d d;d<d=Zd>d d?d@dAZdBd dCdDdEZdrdd dGdHdIZdsdd dGdJdKZdBd dCdLdMZdedNefdOdPdQdPdRdSdTdUZeje e e e e e!e"e#e$f dVe%d>d>dWdXdYZ&e%dtdZdZdZdZdZdZdZdZd[d\d]d]d]d]d]d]d]d^d_d`
|
dadYZ&due'j(e'j(e'j(e'j(e'j(e'j(e'j(e'j(d[dbd]d]d]d]d]d]d]d^dcd`
|
dddYZ&d>d>d?dedfZ)dRdgdhdidjZ*d>dkd?dldmZ+dvd>dndRdkdodpdqZ,dS )wrr a° Generalized registry for mapping classes.
|
|
The :class:`_orm.registry` serves as the basis for maintaining a collection
|
of mappings, and provides configurational hooks used to map classes.
|
|
The three general kinds of mappings supported are Declarative Base,
|
Declarative Decorator, and Imperative Mapping. All of these mapping
|
styles may be used interchangeably:
|
|
* :meth:`_orm.registry.generate_base` returns a new declarative base
|
class, and is the underlying implementation of the
|
:func:`_orm.declarative_base` function.
|
|
* :meth:`_orm.registry.mapped` provides a class decorator that will
|
apply declarative mapping to a class without the use of a declarative
|
base class.
|
|
* :meth:`_orm.registry.map_imperatively` will produce a
|
:class:`_orm.Mapper` for a class without scanning the class for
|
declarative class attributes. This method suits the use case historically
|
provided by the ``sqlalchemy.orm.mapper()`` classical mapping function,
|
which is removed as of SQLAlchemy 2.0.
|
|
.. versionadded:: 1.4
|
|
.. seealso::
|
|
:ref:`orm_mapping_classes_toplevel` - overview of class mapping
|
styles.
|
|
z clsregistry._ClsRegistryTypeÚ_class_registryz;weakref.WeakKeyDictionary[ClassManager[Any], Literal[True]]Ú _managersz5weakref.WeakKeyDictionary[Mapper[Any], Literal[True]]Ú_non_primary_mappersr: rp z-CallableReference[Callable[(Ellipsis, None)]]r½ Ú _MutableTypeAnnotationMapTyper¼ zSet[_RegistryType]Ú _dependentsÚ _dependenciesrP Ú _new_mappersN)rp rï r¼ r½ rð rò ró rô c C s |pt }|dkrt ¡ }|| _t ¡ | _t ¡ | _|| _|| _i | _ |dk rX|
|
|¡ t | _ t | _ d| _tj dtj| < W 5 Q R X dS )aï Construct a new :class:`_orm.registry`
|
|
:param metadata:
|
An optional :class:`_schema.MetaData` instance. All
|
:class:`_schema.Table` objects generated using declarative
|
table mapping will make use of this :class:`_schema.MetaData`
|
collection. If this argument is left at its default of ``None``,
|
a blank :class:`_schema.MetaData` collection is created.
|
|
:param constructor:
|
Specify the implementation for the ``__init__`` function on a mapped
|
class that has no ``__init__`` of its own. Defaults to an
|
implementation that assigns \**kwargs for declared
|
fields and relationships to an instance. If ``None`` is supplied,
|
no __init__ will be provided and construction will fall back to
|
cls.__init__ by way of the normal Python semantics.
|
|
:param class_registry: optional dictionary that will serve as the
|
registry of class names-> mapped classes when string names
|
are used to identify classes inside of :func:`_orm.relationship`
|
and others. Allows two or more declarative base classes
|
to share the same registry of class names for simplified
|
inter-base relationships.
|
|
:param type_annotation_map: optional dictionary of Python types to
|
SQLAlchemy :class:`_types.TypeEngine` classes or instances.
|
The provided dict will update the default type mapping. This
|
is used exclusively by the :class:`_orm.MappedColumn` construct
|
to produce column types based on annotations within the
|
:class:`_orm.Mapped` type.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:ref:`orm_declarative_mapped_column_type_map`
|
|
|
NFT)r: ÚweakrefÚWeakValueDictionaryr÷ ÚWeakKeyDictionaryrø rù rp r½ r¼ Úupdate_type_annotation_mapÚsetrû rü rý r Z_CONFIGURE_MUTEXZ_mapper_registries)r rp rï r¼ r½ Z lcl_metadatarX rX rY r| o s /
|
|
|
|
zregistry.__init__Ú_TypeAnnotationMapTyper] )r¼ rS c C s | j dd | ¡ D ¡ dS )zQupdate the :paramref:`_orm.registry.type_annotation_map` with new
|
values.c S s, i | ]$\}}t j|d d dD ]
|
}||q qS )T)Z include_unionZ discard_none)Ú compat_typingZ expand_unions)rÍ ÚtypZsqltypeZsub_typerX rX rY rÒ » s ÿ þ z7registry.update_type_annotation_map.<locals>.<dictcomp>N)r¼ r¸ rÔ )r r¼ rX rX rY r ³ s
|
þÿz#registry.update_type_annotation_maprK z"Optional[sqltypes.TypeEngine[Any]])Ú python_typerS c C sØ t |r>t|r,td|}||ft|ff}qx|j}||ff}n:t|rZt|}||ff}n td|}d }dd |jD }|D ]V\}}| j |¡}|d kr¢t
|
|¡}|d k r|t
|
|¡}| |||¡}|d k r|| S q|d S )Nr» c s s | ]}||fV qd S r rX )rÍ ÚptrX rX rY Ú <genexpr>Ü s z)registry._resolve_type.<locals>.<genexpr>)rA rB r rD Ú
|
__origin__rC r@ rU r¼ ry r7 Z _type_map_getZ to_instanceZ_resolve_for_python_type) r r Zpython_type_typeÚsearchZ flattenedr Zsql_typeZ sql_type_instZresolved_sql_typerX rX rY Ú _resolve_typeÄ s8
|
þ
|
|
|
ý
|
zregistry._resolve_typezFrozenSet[Mapper[Any]]r c C s t dd | jD | j¡S )z9read only collection of all :class:`_orm.Mapper` objects.c s s | ] }|j V qd S r )rî ©rÍ r rX rX rY r ú s z#registry.mappers.<locals>.<genexpr>)Ú frozensetrø Úunionrù r rX rX rY Úmappersö s ÿzregistry.mappersrq )rr rS c C s( || kr d S |j | ¡ | j |¡ d S r )rû Úaddrü )r rr rX rX rY Ú_set_depends_onþ s zregistry._set_depends_onz Mapper[Any])rî rS c C s, d|_ | jrd S | | h¡D ]
|
}d|_q d S ©NT)Ú_ready_for_configurerý Ú_recurse_with_dependents)r rî r} rX rX rY Ú_flag_new_mapper s
|
zregistry._flag_new_mapperzSet[RegistryType]zIterator[RegistryType])Ú
|
registriesrS c c sP |}t }|rL| ¡ }| |¡ | |j |¡¡ |V | |j |¡¡ q
|
d S r )r Úpopr r¸ rû Ú
|
difference©rR r ÚtodoÚdoner} rX rX rY r s
|
z!registry._recurse_with_dependentsc c sP |}t }|rL| ¡ }| |¡ | |j |¡¡ |V | |j |¡¡ q
|
d S r )r r r r¸ rü r r rX rX rY Ú_recurse_with_dependencies s
|
z#registry._recurse_with_dependencieszIterator[Mapper[Any]]c C s, t dd t| jD dd t| jD ¡S )Nc s s* | ]"}|j r|jjs|jjr|jV qd S r )r rî Ú
|
configuredr r rX rX rY r 5 s
|
üz1registry._mappers_to_configure.<locals>.<genexpr>c s s | ]}|j s|jr|V qd S r )r r )rÍ ZnpmrX rX rY r < s þ)Ú itertoolsÚchainÚlistrø rù r rX rX rY Ú_mappers_to_configure3 s þþøz registry._mappers_to_configure)Ú np_mapperrS c C s d| j |< d S r )rù )r r" rX rX rY Ú_add_non_primary_mapperC s z registry._add_non_primary_mapperrO rQ c C s t |j|| j¡ d S r )r Z remove_classrg r÷ ©r rR rX rX rY Ú _dispose_clsF s zregistry._dispose_clszClassManager[Any])r rS c C s8 d| j |< |jr t d|j ¡|jd ks.t| |_d S )NTz1Class '%s' already has a primary mapper defined. )rø r r4 Ú ArgumentErrorrW rr r )r r rX rX rY Ú _add_managerI s
|
ÿÿzregistry._add_managerF)ÚcascaderS c C s t j| h|d dS )a] Configure all as-yet unconfigured mappers in this
|
:class:`_orm.registry`.
|
|
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.
|
|
If one or more mappers in this registry contain
|
:func:`_orm.relationship` constructs that refer to mapped classes in
|
other registries, this registry is said to be *dependent* on those
|
registries. In order to configure those dependent registries
|
automatically, the :paramref:`_orm.registry.configure.cascade` flag
|
should be set to ``True``. Otherwise, if they are not configured, an
|
exception will be raised. The rationale behind this behavior is to
|
allow an application to programmatically invoke configuration of
|
registries while controlling whether or not the process implicitly
|
reaches other registries.
|
|
As an alternative to invoking :meth:`_orm.registry.configure`, the ORM
|
function :func:`_orm.configure_mappers` function may be used to ensure
|
configuration is complete for all :class:`_orm.registry` objects in
|
memory. This is generally simpler to use and also predates the usage of
|
:class:`_orm.registry` objects overall. However, this function will
|
impact all mappings throughout the running Python process and may be
|
more memory/time consuming for an application that has many registries
|
in use for different purposes that may not be needed immediately.
|
|
.. seealso::
|
|
:func:`_orm.configure_mappers`
|
|
|
.. versionadded:: 1.4.0b2
|
|
©r( N)r Z_configure_registries©r r( rX rX rY Ú configureS s 'zregistry.configurec C s t j| h|d dS )a® Dispose of all mappers in this :class:`_orm.registry`.
|
|
After invocation, all the classes that were mapped within this registry
|
will no longer have class instrumentation associated with them. This
|
method is the per-:class:`_orm.registry` analogue to the
|
application-wide :func:`_orm.clear_mappers` function.
|
|
If this registry contains mappers that are dependencies of other
|
registries, typically via :func:`_orm.relationship` links, then those
|
registries must be disposed as well. When such registries exist in
|
relation to this one, their :meth:`_orm.registry.dispose` method will
|
also be called, if the :paramref:`_orm.registry.dispose.cascade` flag
|
is set to ``True``; otherwise, an error is raised if those registries
|
were not already disposed.
|
|
.. versionadded:: 1.4.0b2
|
|
.. seealso::
|
|
:func:`_orm.clear_mappers`
|
|
r) N)r Z_dispose_registriesr* rX rX rY Údispose| s zregistry.disposec C s8 d|j kr|j}| ¡ |j}| |¡ tj |¡ d S )Nrî )rb rî Z_set_dispose_flagsrW r% r Z_instrumentation_factoryÚ
|
unregister)r r rî rW rX rX rY Ú_dispose_manager_and_mapper s
|
|
z$registry._dispose_manager_and_mapperrì rñ r» r\ r )rî rR r rÚ rS c C s | j }t|t r|fp|}t| |d}t|tr<|j|d< | jdk rP| j|d< d|d< |rd||d< t|drd d
|
d d d d }||d< ||||S )aÍ Generate a declarative base class.
|
|
Classes that inherit from the returned class object will be
|
automatically mapped using declarative mapping.
|
|
E.g.::
|
|
from sqlalchemy.orm import registry
|
|
mapper_registry = registry()
|
|
Base = mapper_registry.generate_base()
|
|
class MyClass(Base):
|
__tablename__ = "my_table"
|
id = Column(Integer, primary_key=True)
|
|
The above dynamically generated class is equivalent to the
|
non-dynamic example below::
|
|
from sqlalchemy.orm import registry
|
from sqlalchemy.orm.decl_api import DeclarativeMeta
|
|
mapper_registry = registry()
|
|
class Base(metaclass=DeclarativeMeta):
|
__abstract__ = True
|
registry = mapper_registry
|
metadata = mapper_registry.metadata
|
|
__init__ = mapper_registry.constructor
|
|
.. versionchanged:: 2.0 Note that the
|
:meth:`_orm.registry.generate_base` method is superseded by the new
|
:class:`_orm.DeclarativeBase` class, which generates a new "base"
|
class using subclassing, rather than return value of a function.
|
This allows an approach that is compatible with :pep:`484` typing
|
tools.
|
|
The :meth:`_orm.registry.generate_base` method provides the
|
implementation for the :func:`_orm.declarative_base` function, which
|
creates the :class:`_orm.registry` and base class all at once.
|
|
See the section :ref:`orm_declarative_mapping` for background and
|
examples.
|
|
:param mapper:
|
An optional callable, defaults to :class:`_orm.Mapper`.
|
This function is used to generate new :class:`_orm.Mapper` objects.
|
|
:param cls:
|
Defaults to :class:`object`. A type to use as the base for the
|
generated declarative base class. May be a class or tuple of classes.
|
|
:param name:
|
Defaults to ``Base``. The display name for the generated
|
class. Customizing this is not required, but can improve clarity in
|
tracebacks and debugging.
|
|
:param metaclass:
|
Defaults to :class:`.DeclarativeMeta`. A metaclass or __metaclass__
|
compatible callable to use as the meta type of the generated
|
declarative base class.
|
|
.. seealso::
|
|
:ref:`orm_declarative_mapping`
|
|
:func:`_orm.declarative_base`
|
|
)rr rp rl Nr| Trx Z__mapper_cls__Ú__class_getitem__r¹ r\ )rR r^ rS c S s | S r rX rf rX rX rY r/ ÿ s z1registry.generate_base.<locals>.__class_getitem__)rp rz ÚtupleÚdictrc rl r½ rÓ ) r rî rR r rÚ rp rt Ú
|
class_dictr/ rX rX rY rõ s N
|
|
|
|
|
zregistry.generate_baserm )Ú_registry__clsrS c C s d S r rX )r r3 rX rX rY Úmapped_as_dataclass s z registry.mapped_as_dataclass.rÊ z Literal[None]rÀ rÁ z Callable[[Type[_O]], Type[_O]])
|
r3 r rà rÄ rÅ rÆ rÇ rÈ rÉ rS c
|
C s d S r rX )
|
r r3 r rà rÄ rÅ rÆ rÇ rÈ rÉ rX rX rY r4 s zOptional[Type[_O]]z/Union[Type[_O], Callable[[Type[_O]], Type[_O]]]c
|
s8 ddd f dd }
|
|r0|
|
|S |
|
S dS )a_ Class decorator that will apply the Declarative mapping process
|
to a given class, and additionally convert the class to be a
|
Python dataclass.
|
|
.. seealso::
|
|
:ref:`orm_declarative_native_dataclasses` - complete background
|
on SQLAlchemy native dataclass mapping
|
|
|
.. versionadded:: 2.0
|
|
|
rO rQ c s* d| _ t| | j | S )NrÊ )rË r& rb r³ © rÉ rÄ r rÈ rÇ rÅ rà r rÆ rX rY r F s ø
|
z.registry.mapped_as_dataclass.<locals>.decorateNrX ) r r3 r rà rÄ rÅ rÆ rÇ rÈ rÉ r rX r5 rY r4 ( s $c C s t | ||j |S )a Class decorator that will apply the Declarative mapping process
|
to a given class.
|
|
E.g.::
|
|
from sqlalchemy.orm import registry
|
|
mapper_registry = registry()
|
|
@mapper_registry.mapped
|
class Foo:
|
__tablename__ = 'some_table'
|
|
id = Column(Integer, primary_key=True)
|
name = Column(String)
|
|
See the section :ref:`orm_declarative_mapping` for complete
|
details and examples.
|
|
:param cls: class to be mapped.
|
|
:return: the class that was passed.
|
|
.. seealso::
|
|
:ref:`orm_declarative_mapping`
|
|
:meth:`_orm.registry.generate_base` - generates a base class
|
that will apply Declarative mapping to subclasses automatically
|
using a Python metaclass.
|
|
.. seealso::
|
|
:meth:`_orm.registry.mapped_as_dataclass`
|
|
)r& rb r$ rX rX rY ÚmappedY s %zregistry.mappedú Callable[[Type[_T]], Type[_T]]r° c s ddd fdd }|S )a¿
|
Class decorator which will invoke
|
:meth:`_orm.registry.generate_base`
|
for a given base class.
|
|
E.g.::
|
|
from sqlalchemy.orm import registry
|
|
mapper_registry = registry()
|
|
@mapper_registry.as_declarative_base()
|
class Base:
|
@declared_attr
|
def __tablename__(cls):
|
return cls.__name__.lower()
|
id = Column(Integer, primary_key=True)
|
|
class MyMappedClass(Base):
|
# ...
|
|
All keyword arguments passed to
|
:meth:`_orm.registry.as_declarative_base` are passed
|
along to :meth:`_orm.registry.generate_base`.
|
|
r¹ rQ c s | d< | j d< jf S )NrR r )rg rõ r³ ©rv r rX rY r s
|
z.registry.as_declarative_base.<locals>.decoraterX )r rv r rX r8 rY Úas_declarative_base s z registry.as_declarative_basez
|
Mapper[_O]c C s t | ||j |jS )aã Map a class declaratively.
|
|
In this form of mapping, the class is scanned for mapping information,
|
including for columns to be associated with a table, and/or an
|
actual table object.
|
|
Returns the :class:`_orm.Mapper` object.
|
|
E.g.::
|
|
from sqlalchemy.orm import registry
|
|
mapper_registry = registry()
|
|
class Foo:
|
__tablename__ = 'some_table'
|
|
id = Column(Integer, primary_key=True)
|
name = Column(String)
|
|
mapper = mapper_registry.map_declaratively(Foo)
|
|
This function is more conveniently invoked indirectly via either the
|
:meth:`_orm.registry.mapped` class decorator or by subclassing a
|
declarative metaclass generated from
|
:meth:`_orm.registry.generate_base`.
|
|
See the section :ref:`orm_declarative_mapping` for complete
|
details and examples.
|
|
:param cls: class to be mapped.
|
|
:return: a :class:`_orm.Mapper` object.
|
|
.. seealso::
|
|
:ref:`orm_declarative_mapping`
|
|
:meth:`_orm.registry.mapped` - more common decorator interface
|
to this function.
|
|
:meth:`_orm.registry.map_imperatively`
|
|
)r& rb ra r$ rX rX rY rè ¤ s -zregistry.map_declarativelyrç )rW Ú local_tablerv rS c K s t | |||S )a© Map a class imperatively.
|
|
In this form of mapping, the class is not scanned for any mapping
|
information. Instead, all mapping constructs are passed as
|
arguments.
|
|
This method is intended to be fully equivalent to the now-removed
|
SQLAlchemy ``mapper()`` function, except that it's in terms of
|
a particular registry.
|
|
E.g.::
|
|
from sqlalchemy.orm import registry
|
|
mapper_registry = registry()
|
|
my_table = Table(
|
"my_table",
|
mapper_registry.metadata,
|
Column('id', Integer, primary_key=True)
|
)
|
|
class MyClass:
|
pass
|
|
mapper_registry.map_imperatively(MyClass, my_table)
|
|
See the section :ref:`orm_imperative_mapping` for complete background
|
and usage examples.
|
|
:param class\_: The class to be mapped. Corresponds to the
|
:paramref:`_orm.Mapper.class_` parameter.
|
|
:param local_table: the :class:`_schema.Table` or other
|
:class:`_sql.FromClause` object that is the subject of the mapping.
|
Corresponds to the
|
:paramref:`_orm.Mapper.local_table` parameter.
|
|
:param \**kw: all other keyword arguments are passed to the
|
:class:`_orm.Mapper` constructor directly.
|
|
.. seealso::
|
|
:ref:`orm_imperative_mapping`
|
|
:ref:`orm_declarative_mapping`
|
|
r+ )r rW r: rv rX rX rY Úmap_imperativelyÔ s 6zregistry.map_imperatively)F)F).)N)N)-rg rh ri rl r~ r( r| r r Úpropertyr r r r r r r! r# r% r' r+ r, r. r® ro rõ r Údataclass_transformr0 r1 r- r. r r r r r r r4 r8 rÌ r6 r9 rè r; rX rX rX rY rr D s
|
úD2
|
) ûg÷ÿ þõ& þó$1(#3 ýrr r7 r° c K s. | dd¡| dd¡ }}t||djf | S )a¢
|
Class decorator which will adapt a given class into a
|
:func:`_orm.declarative_base`.
|
|
This function makes use of the :meth:`_orm.registry.as_declarative_base`
|
method, by first creating a :class:`_orm.registry` automatically
|
and then invoking the decorator.
|
|
E.g.::
|
|
from sqlalchemy.orm import as_declarative
|
|
@as_declarative()
|
class Base:
|
@declared_attr
|
def __tablename__(cls):
|
return cls.__name__.lower()
|
id = Column(Integer, primary_key=True)
|
|
class MyMappedClass(Base):
|
# ...
|
|
.. seealso::
|
|
:meth:`_orm.registry.as_declarative_base`
|
|
rp Nrï )rp rï )r rr r9 )rv rp rï rX rX rY Úas_declarative s
|
|
þ ÿþr> zOptional[Mapper[Any]]c C s( t | }|d kr$t | ¡r$t | ¡ |S r )r! r) Zhas_clsZraise_unmapped_for_cls)rR ÚmprX rX rY Ú_inspect_decl_meta: s
|
|
|
r@ )F)rl Ú
|
__future__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 Z_orm_constructorsr r r r r r rä r! r" r# Z decl_baser% r& r' r( r) r* r, Zdescriptor_propsr- r. r rî r/ Z
|
propertiesr0 Z relationshipsr1 Ústater2 r4 r5 r6 Zsqlr7 Zsql.baser8 Z sql.elementsr9 Z
|
sql.schemar: Zsql.selectabler; r< r= r Z util.typingr? r@ rA rB rC rD Ú_typingrE rF rG rH rI Z sql._typingrJ Z sql.type_apirK rL rN r rú Z_DeclaredAttrDecoratedrZ rc r[ Z Inspectablerj r= rn ro r r r Z_MappedAttributer¬ r± rº r¾ r¿ rÛ rã ræ rë r® rö rr rq r> Z _inspectsr@ rX rX rX rY Ú<module> s, ÿ
|
ÿ
|
÷ÿ
|
ÿ! ÿ*A *)@
|
þ Ma÷"{ N& ÿ
|
