Participer au site avec un Tip
Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn
Voir le programme détaillé
Module « sqlalchemy.ext.declarative »

Classe « DeferredReflection »

Informations générales

Héritage

builtins.object
    DeferredReflection

Définition

class DeferredReflection(builtins.object):

help(DeferredReflection)

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

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

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

    from sqlalchemy.ext.declarative import declarative_base
    from sqlalchemy.ext.declarative import DeferredReflection

    Base = declarative_base()


    class MyClass(DeferredReflection, Base):
        __tablename__ = "mytable"

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

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

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

    class ReflectedOne(DeferredReflection, Base):
        __abstract__ = True


    class ReflectedTwo(DeferredReflection, Base):
        __abstract__ = True


    class MyClass(ReflectedOne):
        __tablename__ = "mytable"


    class MyOtherClass(ReflectedOne):
        __tablename__ = "myothertable"


    class YetAnotherClass(ReflectedTwo):
        __tablename__ = "yetanothertable"


    # ... etc.

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

    ReflectedOne.prepare(engine_one)
    ReflectedTwo.prepare(engine_two)

.. seealso::

    :ref:`orm_declarative_reflected_deferred_reflection` - in the
    :ref:`orm_declarative_table_config_toplevel` section.

Constructeur(s)

Signature du constructeur Description
__init__(self, /, *args, **kwargs) Initialize self. See help(type(self)) for accurate signature. [extrait de __init__.__doc__]

Liste des opérateurs

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques Méthodes dépréciées
Signature de la méthodeDescription
prepare(bind: 'Union[Engine, Connection]', **reflect_kw: 'Any') -> 'None' Reflect all :class:`_schema.Table` objects for all current [extrait de prepare.__doc__]

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __getattribute__, __getstate__, __hash__, __init_subclass__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __str__, __subclasshook__

Vous êtes un professionnel et vous avez besoin d'une formation ? Sensibilisation à
l'Intelligence Artificielle
Voir le programme détaillé