Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn Voir le programme détaillé

Module « sqlalchemy.orm »

Classe « PropComparator »

Informations générales

Héritage

        builtins.object
            Operators
                ColumnOperators
            builtins.object
                Generic
        builtins.object
            TypingOnly
    builtins.object
        TypingOnly
builtins.object
    Operators
        ColumnOperators
    builtins.object
        Generic
            SQLCoreOperations
                SQLORMOperations
                    PropComparator

Définition

class PropComparator(SQLORMOperations, Generic, ColumnOperators):

help(PropComparator)

Defines SQL operations for ORM mapped attributes.

SQLAlchemy allows for operators to
be redefined at both the Core and ORM level.  :class:`.PropComparator`
is the base class of operator redefinition for ORM-level operations,
including those of :class:`.ColumnProperty`,
:class:`.Relationship`, and :class:`.Composite`.

User-defined subclasses of :class:`.PropComparator` may be created. The
built-in Python comparison and math operator methods, such as
:meth:`.operators.ColumnOperators.__eq__`,
:meth:`.operators.ColumnOperators.__lt__`, and
:meth:`.operators.ColumnOperators.__add__`, can be overridden to provide
new operator behavior. The custom :class:`.PropComparator` is passed to
the :class:`.MapperProperty` instance via the ``comparator_factory``
argument. In each case,
the appropriate subclass of :class:`.PropComparator` should be used::

    # definition of custom PropComparator subclasses

    from sqlalchemy.orm.properties import (
        ColumnProperty,
        Composite,
        Relationship,
    )


    class MyColumnComparator(ColumnProperty.Comparator):
        def __eq__(self, other):
            return self.__clause_element__() == other


    class MyRelationshipComparator(Relationship.Comparator):
        def any(self, expression):
            "define the 'any' operation"
            # ...


    class MyCompositeComparator(Composite.Comparator):
        def __gt__(self, other):
            "redefine the 'greater than' operation"

            return sql.and_(
                *[
                    a > b
                    for a, b in zip(
                        self.__clause_element__().clauses,
                        other.__composite_values__(),
                    )
                ]
            )


    # application of custom PropComparator subclasses

    from sqlalchemy.orm import column_property, relationship, composite
    from sqlalchemy import Column, String


    class SomeMappedClass(Base):
        some_column = column_property(
            Column("some_column", String),
            comparator_factory=MyColumnComparator,
        )

        some_relationship = relationship(
            SomeOtherClass, comparator_factory=MyRelationshipComparator
        )

        some_composite = composite(
            Column("a", String),
            Column("b", String),
            comparator_factory=MyCompositeComparator,
        )

Note that for column-level operator redefinition, it's usually
simpler to define the operators at the Core level, using the
:attr:`.TypeEngine.comparator_factory` attribute.  See
:ref:`types_operators` for more detail.

.. seealso::

    :class:`.ColumnProperty.Comparator`

    :class:`.Relationship.Comparator`

    :class:`.Composite.Comparator`

    :class:`.ColumnOperators`

    :ref:`types_operators`

    :attr:`.TypeEngine.comparator_factory`

Constructeur(s)

Signature du constructeur	Description
__init__(self, prop: 'MapperProperty[_T]', parentmapper: '_InternalEntityType[Any]', adapt_to_entity: 'Optional[AliasedInsp[Any]]' = None)

Liste des opérateurs

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

__add__, __contains__, __eq__, __floordiv__, __ge__, __getitem__, __gt__, __le__, __lshift__, __lt__, __mod__, __mul__, __ne__, __neg__, __radd__, __rfloordiv__, __rmod__, __rmul__, __rshift__, __rsub__, __rtruediv__, __sub__, __truediv__

Liste des opérateurs

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

__and__, __invert__, __or__

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

__init_subclass__, __subclasshook__

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

all_, any_, asc, between, bitwise_and, bitwise_lshift, bitwise_not, bitwise_or, bitwise_rshift, bitwise_xor, collate, concat, contains, desc, distinct, endswith, icontains, iendswith, ilike, in_, is_, is_distinct_from, is_not, is_not_distinct_from, isnot, isnot_distinct_from, istartswith, like, match, not_ilike, not_in, not_like, notilike, notin_, notlike, nulls_first, nulls_last, nullsfirst, nullslast, regexp_match, regexp_replace, startswith

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

__sa_operate__, bool_op, op, operate, reverse_operate

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

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

Vous êtes un professionnel et vous avez besoin d'une formation ? Programmation Python
Les compléments Voir le programme détaillé