Vous êtes un professionnel et vous avez besoin d'une formation ? Deep Learning avec Python
et Keras et Tensorflow Voir le programme détaillé

Classe « scoped_session »

Méthode sqlalchemy.orm.scoped_session.get_bind

Signature de la méthode get_bind

def get_bind(self, mapper: 'Optional[_EntityBindKey[_O]]' = None, *, clause: 'Optional[ClauseElement]' = None, bind: 'Optional[_SessionBind]' = None, _sa_skip_events: 'Optional[bool]' = None, _sa_skip_for_implicit_returning: 'bool' = False, **kw: 'Any') -> 'Union[Engine, Connection]' 

Description

help(scoped_session.get_bind)

Return a "bind" to which this :class:`.Session` is bound.

.. container:: class_bases

    Proxied for the :class:`_orm.Session` class on
    behalf of the :class:`_orm.scoping.scoped_session` class.

The "bind" is usually an instance of :class:`_engine.Engine`,
except in the case where the :class:`.Session` has been
explicitly bound directly to a :class:`_engine.Connection`.

For a multiply-bound or unbound :class:`.Session`, the
``mapper`` or ``clause`` arguments are used to determine the
appropriate bind to return.

Note that the "mapper" argument is usually present
when :meth:`.Session.get_bind` is called via an ORM
operation such as a :meth:`.Session.query`, each
individual INSERT/UPDATE/DELETE operation within a
:meth:`.Session.flush`, call, etc.

The order of resolution is:

1. if mapper given and :paramref:`.Session.binds` is present,
   locate a bind based first on the mapper in use, then
   on the mapped class in use, then on any base classes that are
   present in the ``__mro__`` of the mapped class, from more specific
   superclasses to more general.
2. if clause given and ``Session.binds`` is present,
   locate a bind based on :class:`_schema.Table` objects
   found in the given clause present in ``Session.binds``.
3. if ``Session.binds`` is present, return that.
4. if clause given, attempt to return a bind
   linked to the :class:`_schema.MetaData` ultimately
   associated with the clause.
5. if mapper given, attempt to return a bind
   linked to the :class:`_schema.MetaData` ultimately
   associated with the :class:`_schema.Table` or other
   selectable to which the mapper is mapped.
6. No bind can be found, :exc:`~sqlalchemy.exc.UnboundExecutionError`
   is raised.

Note that the :meth:`.Session.get_bind` method can be overridden on
a user-defined subclass of :class:`.Session` to provide any kind
of bind resolution scheme.  See the example at
:ref:`session_custom_partitioning`.

:param mapper:
  Optional mapped class or corresponding :class:`_orm.Mapper` instance.
  The bind can be derived from a :class:`_orm.Mapper` first by
  consulting the "binds" map associated with this :class:`.Session`,
  and secondly by consulting the :class:`_schema.MetaData` associated
  with the :class:`_schema.Table` to which the :class:`_orm.Mapper` is
  mapped for a bind.

:param clause:
    A :class:`_expression.ClauseElement` (i.e.
    :func:`_expression.select`,
    :func:`_expression.text`,
    etc.).  If the ``mapper`` argument is not present or could not
    produce a bind, the given expression construct will be searched
    for a bound element, typically a :class:`_schema.Table`
    associated with
    bound :class:`_schema.MetaData`.

.. seealso::

     :ref:`session_partitioning`

     :paramref:`.Session.binds`

     :meth:`.Session.bind_mapper`

     :meth:`.Session.bind_table`

Vous êtes un professionnel et vous avez besoin d'une formation ? RAG (Retrieval-Augmented Generation)
et Fine Tuning d'un LLM Voir le programme détaillé