Classe « MapperEvents »

Informations générales

Héritage

builtins.object
    Events
        MapperEvents

Définition

class MapperEvents(Events):

Description _{[extrait de MapperEvents.doc]}

Define events specific to mappings.

    e.g.::

        from sqlalchemy import event

        def my_before_insert_listener(mapper, connection, target):
            # execute a stored procedure upon INSERT,
            # apply the value to the row to be inserted
            target.calculated_value = connection.execute(
                text("select my_special_function(%d)" % target.special_number)
            ).scalar()

        # associate the listener function with SomeClass,
        # to execute during the "before_insert" hook
        event.listen(
            SomeClass, 'before_insert', my_before_insert_listener)

    Available targets include:

    * mapped classes
    * unmapped superclasses of mapped or to-be-mapped classes
      (using the ``propagate=True`` flag)
    * :class:`_orm.Mapper` objects
    * the :class:`_orm.Mapper` class itself and the :func:`.mapper`
      function indicate listening for all mappers.

    Mapper events provide hooks into critical sections of the
    mapper, including those related to object instrumentation,
    object loading, and object persistence. In particular, the
    persistence methods :meth:`~.MapperEvents.before_insert`,
    and :meth:`~.MapperEvents.before_update` are popular
    places to augment the state being persisted - however, these
    methods operate with several significant restrictions. The
    user is encouraged to evaluate the
    :meth:`.SessionEvents.before_flush` and
    :meth:`.SessionEvents.after_flush` methods as more
    flexible and user-friendly hooks in which to apply
    additional database state during a flush.

    When using :class:`.MapperEvents`, several modifiers are
    available to the :func:`.event.listen` function.

    :param propagate=False: When True, the event listener should
       be applied to all inheriting mappers and/or the mappers of
       inheriting classes, as well as any
       mapper which is the target of this listener.
    :param raw=False: When True, the "target" argument passed
       to applicable event listener functions will be the
       instance's :class:`.InstanceState` management
       object, rather than the mapped instance itself.
    :param retval=False: when True, the user-defined event function
       must have a return value, the purpose of which is either to
       control subsequent event propagation, or to otherwise alter
       the operation in progress by the mapper.   Possible return
       values are:

       * ``sqlalchemy.orm.interfaces.EXT_CONTINUE`` - continue event
         processing normally.
       * ``sqlalchemy.orm.interfaces.EXT_STOP`` - cancel all subsequent
         event handlers in the chain.
       * other values - the return value specified by specific listeners.

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 attributs statiques

Nom de l'attribut	Valeur
dispatch	<sqlalchemy.event.base.MapperEventsDispatch object at 0x7f40cb852020>

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

Signature de la méthode	Description
after_configured(self)	Called after a series of mappers have been configured. _{[extrait de after_configured.__doc__]}
after_delete(self, mapper, connection, target)	Receive an object instance after a DELETE statement _{[extrait de after_delete.__doc__]}
after_insert(self, mapper, connection, target)	Receive an object instance after an INSERT statement _{[extrait de after_insert.__doc__]}
after_update(self, mapper, connection, target)	Receive an object instance after an UPDATE statement _{[extrait de after_update.__doc__]}
before_configured(self)	Called before a series of mappers have been configured. _{[extrait de before_configured.__doc__]}
before_delete(self, mapper, connection, target)	Receive an object instance before a DELETE statement _{[extrait de before_delete.__doc__]}
before_insert(self, mapper, connection, target)	Receive an object instance before an INSERT statement _{[extrait de before_insert.__doc__]}
before_mapper_configured(self, mapper, class_)	Called right before a specific mapper is to be configured. _{[extrait de before_mapper_configured.__doc__]}
before_update(self, mapper, connection, target)	Receive an object instance before an UPDATE statement _{[extrait de before_update.__doc__]}
instrument_class(self, mapper, class_)	Receive a class when the mapper is first constructed, _{[extrait de instrument_class.__doc__]}
mapper_configured(self, mapper, class_)	Called when a specific mapper has completed its own configuration _{[extrait de mapper_configured.__doc__]}