sqlalchemy.sql.type_api.TypeEngine.Comparator

class documentation

class Comparator(ColumnOperators, Generic[_CT]): (source)

Known subclasses: sqlalchemy.sql.sqltypes.Concatenable.Comparator, sqlalchemy.sql.sqltypes.HasExpressionLookup.Comparator, sqlalchemy.sql.sqltypes.Indexable.Comparator, sqlalchemy.sql.sqltypes.NullType.Comparator, sqlalchemy.sql.type_api.TypeDecorator.Comparator

View In Hierarchy

Base class for custom comparison operations defined at the type level. See :attr:`.TypeEngine.comparator_factory`.

Method	`__clause_element__`	Undocumented
Method	`__init__`	Undocumented
Method	`__reduce__`	Undocumented
Method	`operate`	Operate on an argument.
Method	`reverse_operate`	Reverse operate on an argument.
Class Variable	`__slots__`	Undocumented
Instance Variable	`expr`	Undocumented
Instance Variable	`type`	Undocumented
Method	`_adapt_expression`	evaluate the return type of <self> <op> <othertype>, and apply any adaptations to the given operator.

Inherited from ColumnOperators:

Method	`__add__`	Implement the ``+`` operator.
Method	`__contains__`	Undocumented
Method	`__eq__`	Implement the ``==`` operator.
Method	`__floordiv__`	Implement the ``//`` operator.
Method	`__ge__`	Implement the ``>=`` operator.
Method	`__getitem__`	Implement the [] operator.
Method	`__gt__`	Implement the ``>`` operator.
Method	`__le__`	Implement the ``<=`` operator.
Method	`__lshift__`	implement the << operator.
Method	`__lt__`	Implement the ``<`` operator.
Method	`__mod__`	Implement the ``%`` operator.
Method	`__mul__`	Implement the ``*`` operator.
Method	`__ne__`	Implement the ``!=`` operator.
Method	`__neg__`	Implement the ``-`` operator.
Method	`__radd__`	Implement the ``+`` operator in reverse.
Method	`__rfloordiv__`	Implement the ``//`` operator in reverse.
Method	`__rmod__`	Implement the ``%`` operator in reverse.
Method	`__rmul__`	Implement the ``*`` operator in reverse.
Method	`__rshift__`	implement the >> operator.
Method	`__rsub__`	Implement the ``-`` operator in reverse.
Method	`__rtruediv__`	Implement the ``/`` operator in reverse.
Method	`__sub__`	Implement the ``-`` operator.
Method	`__truediv__`	Implement the ``/`` operator.
Method	`all_`	Produce an :func:`_expression.all_` clause against the parent object.
Method	`any_`	Produce an :func:`_expression.any_` clause against the parent object.
Method	`asc`	Produce a :func:`_expression.asc` clause against the parent object.
Method	`between`	Produce a :func:`_expression.between` clause against the parent object, given the lower and upper range.
Method	`bitwise_and`	Produce a bitwise AND operation, typically via the ``&`` operator.
Method	`bitwise_lshift`	Produce a bitwise LSHIFT operation, typically via the ``<<`` operator.
Method	`bitwise_not`	Produce a bitwise NOT operation, typically via the ``~`` operator.
Method	`bitwise_or`	Produce a bitwise OR operation, typically via the ``\|`` operator.
Method	`bitwise_rshift`	Produce a bitwise RSHIFT operation, typically via the ``>>`` operator.
Method	`bitwise_xor`	Produce a bitwise XOR operation, typically via the ``^`` operator, or ``#`` for PostgreSQL.
Method	`collate`	Produce a :func:`_expression.collate` clause against the parent object, given the collation string.
Method	`concat`	Implement the 'concat' operator.
Method	`contains`	Implement the 'contains' operator.
Method	`desc`	Produce a :func:`_expression.desc` clause against the parent object.
Method	`distinct`	Produce a :func:`_expression.distinct` clause against the parent object.
Method	`endswith`	Implement the 'endswith' operator.
Method	`icontains`	Implement the ``icontains`` operator, e.g. case insensitive version of :meth:`.ColumnOperators.contains`.
Method	`iendswith`	Implement the ``iendswith`` operator, e.g. case insensitive version of :meth:`.ColumnOperators.endswith`.
Method	`ilike`	Implement the ``ilike`` operator, e.g. case insensitive LIKE.
Method	`in_`	Implement the ``in`` operator.
Method	`is_`	Implement the ``IS`` operator.
Method	`is_distinct_from`	Implement the ``IS DISTINCT FROM`` operator.
Method	`is_not`	Implement the ``IS NOT`` operator.
Method	`is_not_distinct_from`	Implement the ``IS NOT DISTINCT FROM`` operator.
Method	`isnot`	Undocumented
Method	`isnot_distinct_from`	Undocumented
Method	`istartswith`	Implement the ``istartswith`` operator, e.g. case insensitive version of :meth:`.ColumnOperators.startswith`.
Method	`like`	Implement the ``like`` operator.
Method	`match`	Implements a database-specific 'match' operator.
Method	`not_ilike`	implement the ``NOT ILIKE`` operator.
Method	`not_in`	implement the ``NOT IN`` operator.
Method	`not_like`	implement the ``NOT LIKE`` operator.
Method	`notilike`	Undocumented
Method	`notin_`	Undocumented
Method	`notlike`	Undocumented
Method	`nulls_first`	Produce a :func:`_expression.nulls_first` clause against the parent object.
Method	`nulls_last`	Produce a :func:`_expression.nulls_last` clause against the parent object.
Method	`nullsfirst`	Undocumented
Method	`nullslast`	Undocumented
Method	`regexp_match`	Implements a database-specific 'regexp match' operator.
Method	`regexp_replace`	Implements a database-specific 'regexp replace' operator.
Method	`startswith`	Implement the ``startswith`` operator.
Class Variable	`timetuple`	Hack, allows datetime objects to be compared on the LHS.
Method	`_rconcat`	Implement an 'rconcat' operator.

Inherited from Operators (via ColumnOperators):

Method	`__and__`	Implement the ``&`` operator.
Method	`__invert__`	Implement the ``~`` operator.
Method	`__or__`	Implement the ``\|`` operator.
Method	`bool_op`	Return a custom boolean operator.
Method	`op`	Produce a generic operator function.

def __clause_element__(self) -> ColumnElement[_CT]: (source) ¶

Undocumented

def __init__(self, expr: ColumnElement[_CT]): (source) ¶

Undocumented

def __reduce__(self) -> Any: (source) ¶

Undocumented

@util.preload_module('sqlalchemy.sql.default_comparator')
def operate(self, op: OperatorType, *other: Any, **kwargs: Any) -> ColumnElement[_CT]: (source) ¶

overrides sqlalchemy.sql.operators.ColumnOperators.operate

overridden in sqlalchemy.sql.type_api.TypeDecorator.Comparator

Operate on an argument. This is the lowest level of operation, raises :class:`NotImplementedError` by default. Overriding this on a subclass can allow common behavior to be applied to all operations. For example, overriding :class:`.ColumnOperators` to apply ``func.lower()`` to the left and right side:: class MyComparator(ColumnOperators): def operate(self, op, other, **kwargs): return op(func.lower(self), func.lower(other), **kwargs) :param op: Operator callable. :param \*other: the 'other' side of the operation. Will be a single scalar for most operations. :param \**kwargs: modifiers. These may be passed by special operators such as :meth:`ColumnOperators.contains`.

@util.preload_module('sqlalchemy.sql.default_comparator')
def reverse_operate(self, op: OperatorType, other: Any, **kwargs: Any) -> ColumnElement[_CT]: (source) ¶

overrides sqlalchemy.sql.operators.ColumnOperators.reverse_operate

overridden in sqlalchemy.sql.type_api.TypeDecorator.Comparator

Reverse operate on an argument. Usage is the same as :meth:`operate`.

__slots__: tuple[str, ...] = (source) ¶

overrides sqlalchemy.sql.operators.ColumnOperators.__slots__

overridden in sqlalchemy.sql.sqltypes.Concatenable.Comparator, sqlalchemy.sql.sqltypes.HasExpressionLookup.Comparator, sqlalchemy.sql.sqltypes.Indexable.Comparator, sqlalchemy.sql.sqltypes.NullType.Comparator, sqlalchemy.sql.type_api.TypeDecorator.Comparator

Undocumented

expr = (source) ¶

Undocumented

type = (source) ¶

overridden in sqlalchemy.sql.sqltypes.ARRAY.Comparator, sqlalchemy.sql.sqltypes.ARRAY.Comparator, sqlalchemy.sql.sqltypes.Enum.Comparator

Undocumented

def _adapt_expression(self, op: OperatorType, other_comparator: TypeEngine.Comparator[Any]) -> Tuple[OperatorType, TypeEngine[Any]]: (source) ¶

overridden in sqlalchemy.sql.sqltypes.Concatenable.Comparator, sqlalchemy.sql.sqltypes.HasExpressionLookup.Comparator, sqlalchemy.sql.sqltypes.NullType.Comparator

evaluate the return type of <self> <op> <othertype>, and apply any adaptations to the given operator. This method determines the type of a resulting binary expression given two source types and an operator. For example, two :class:`_schema.Column` objects, both of the type :class:`.Integer`, will produce a :class:`.BinaryExpression` that also has the type :class:`.Integer` when compared via the addition (``+``) operator. However, using the addition operator with an :class:`.Integer` and a :class:`.Date` object will produce a :class:`.Date`, assuming "days delta" behavior by the database (in reality, most databases other than PostgreSQL don't accept this particular operation). The method returns a tuple of the form <operator>, <type>. The resulting operator and type will be those applied to the resulting :class:`.BinaryExpression` as the final operator and the right-hand side of the expression. Note that only a subset of operators make usage of :meth:`._adapt_expression`, including math operators and user-defined operators, but not boolean comparison or special SQL keywords like MATCH or BETWEEN.