Vous êtes un professionnel et vous avez besoin d'une formation ? Calcul scientifique
avec Python Voir le programme détaillé

Module « sqlalchemy.orm »

Fonction joinedload - module sqlalchemy.orm

Signature de la fonction joinedload

def joinedload(*keys: '_AttrType', **kw: 'Any') -> '_AbstractLoad' 

Description

help(sqlalchemy.orm.joinedload)

Indicate that the given attribute should be loaded using joined
eager loading.

This function is part of the :class:`_orm.Load` interface and supports
both method-chained and standalone operation.

examples::

    # joined-load the "orders" collection on "User"
    select(User).options(joinedload(User.orders))

    # joined-load Order.items and then Item.keywords
    select(Order).options(joinedload(Order.items).joinedload(Item.keywords))

    # lazily load Order.items, but when Items are loaded,
    # joined-load the keywords collection
    select(Order).options(lazyload(Order.items).joinedload(Item.keywords))

:param innerjoin: if ``True``, indicates that the joined eager load
 should use an inner join instead of the default of left outer join::

    select(Order).options(joinedload(Order.user, innerjoin=True))

In order to chain multiple eager joins together where some may be
OUTER and others INNER, right-nested joins are used to link them::

    select(A).options(
        joinedload(A.bs, innerjoin=False).joinedload(B.cs, innerjoin=True)
    )

The above query, linking A.bs via "outer" join and B.cs via "inner"
join would render the joins as "a LEFT OUTER JOIN (b JOIN c)". When
using older versions of SQLite (< 3.7.16), this form of JOIN is
translated to use full subqueries as this syntax is otherwise not
directly supported.

The ``innerjoin`` flag can also be stated with the term ``"unnested"``.
This indicates that an INNER JOIN should be used, *unless* the join
is linked to a LEFT OUTER JOIN to the left, in which case it
will render as LEFT OUTER JOIN.  For example, supposing ``A.bs``
is an outerjoin::

    select(A).options(joinedload(A.bs).joinedload(B.cs, innerjoin="unnested"))

The above join will render as "a LEFT OUTER JOIN b LEFT OUTER JOIN c",
rather than as "a LEFT OUTER JOIN (b JOIN c)".

.. note:: The "unnested" flag does **not** affect the JOIN rendered
    from a many-to-many association table, e.g. a table configured as
    :paramref:`_orm.relationship.secondary`, to the target table; for
    correctness of results, these joins are always INNER and are
    therefore right-nested if linked to an OUTER join.

.. note::

    The joins produced by :func:`_orm.joinedload` are **anonymously
    aliased**. The criteria by which the join proceeds cannot be
    modified, nor can the ORM-enabled :class:`_sql.Select` or legacy
    :class:`_query.Query` refer to these joins in any way, including
    ordering. See :ref:`zen_of_eager_loading` for further detail.

    To produce a specific SQL JOIN which is explicitly available, use
    :meth:`_sql.Select.join` and :meth:`_query.Query.join`. To combine
    explicit JOINs with eager loading of collections, use
    :func:`_orm.contains_eager`; see :ref:`contains_eager`.

.. seealso::

    :ref:`loading_toplevel`

    :ref:`joined_eager_loading`

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