# sql/operators.py

# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors

# <see AUTHORS file>

#

# This module is part of SQLAlchemy and is released under

# the MIT License: https://www.opensource.org/licenses/mit-license.php

# This module is part of SQLAlchemy and is released under

# the MIT License: https://www.opensource.org/licenses/mit-license.php

"""Defines operators used in SQL expressions."""

from __future__ import annotations

from enum import auto

from enum import Flag

from enum import IntEnum

from operator import add as _uncast_add

from operator import and_ as _uncast_and_

from operator import contains as _uncast_contains

from operator import eq as _uncast_eq

from operator import floordiv as _uncast_floordiv

from operator import ge as _uncast_ge

from operator import getitem as _uncast_getitem

from operator import gt as _uncast_gt

from operator import inv as _uncast_inv

from operator import le as _uncast_le

from operator import lshift as _uncast_lshift

from operator import lt as _uncast_lt

from operator import matmul as _uncast_matmul

from operator import mod as _uncast_mod

from operator import mul as _uncast_mul

from operator import ne as _uncast_ne

from operator import neg as _uncast_neg

from operator import or_ as _uncast_or_

from operator import pow as _uncast_pow

from operator import rshift as _uncast_rshift

from operator import sub as _uncast_sub

from operator import truediv as _uncast_truediv

import typing

from typing import Any

from typing import Callable

from typing import cast

from typing import Dict

from typing import Generic

from typing import Hashable

from typing import Literal

from typing import Optional

from typing import overload

from typing import Protocol

from typing import Set

from typing import Tuple

from typing import Type

from typing import TYPE_CHECKING

from typing import TypeVar

from typing import Union

from .. import exc

from .. import util

if typing.TYPE_CHECKING:

from ._typing import ColumnExpressionArgument

from .cache_key import CacheConst

from .elements import ColumnElement

from .type_api import TypeEngine

_T = TypeVar("_T", bound=Any)

_FN = TypeVar("_FN", bound=Callable[..., Any])

class OperatorClass(Flag):

"""Describes a class of SQLAlchemy built-in operators that should be

available on a particular type.

The :class:`.OperatorClass` should be present on the

:attr:`.TypeEngine.operator_classes` attribute of any particular type.

The enums here can be ORed together to provide sets of operators merged

together.

.. versionadded:: 2.1

"""

UNSPECIFIED = auto()

BASE = auto()

BOOLEAN_ALGEBRA = auto()

COMPARISON = auto()

INDEXABLE = auto() # noqa: F811

CONTAINS = auto()

CONCATENABLE = auto()

STRING_MATCH = auto()

MATH = auto()

BITWISE = auto()

DATE_ARITHEMETIC = auto()

JSON_GETITEM = auto()

STRING = (

BASE | COMPARISON | STRING_MATCH | CONTAINS | CONCATENABLE | INDEXABLE

)

INTEGER = BASE | COMPARISON | MATH | BITWISE

NUMERIC = BASE | COMPARISON | MATH | BITWISE

BOOLEAN = BASE | COMPARISON | BOOLEAN_ALGEBRA | COMPARISON

BINARY = BASE | COMPARISON | CONTAINS | CONCATENABLE | INDEXABLE

DATETIME = BASE | COMPARISON | DATE_ARITHEMETIC

JSON = BASE | COMPARISON | INDEXABLE | JSON_GETITEM

ARRAY = BASE | COMPARISON | CONTAINS | CONCATENABLE | INDEXABLE

TUPLE = BASE | COMPARISON | CONTAINS | CONCATENABLE | INDEXABLE

ANY = (

STRING

| INTEGER

| NUMERIC

| BOOLEAN

| DATETIME

| BINARY

| JSON

| ARRAY

| TUPLE

)

class OperatorType(Hashable, Protocol):

"""describe an op() function."""

__slots__ = ()

__name__: str

@overload

def __call__(

self,

left: ColumnExpressionArgument[Any],

right: Optional[Any] = None,

*other: Any,

**kwargs: Any,

) -> ColumnElement[Any]: ...

@overload

def __call__(

self,

left: Operators,

right: Optional[Any] = None,

*other: Any,

**kwargs: Any,

) -> Operators: ...

def __call__(

self,

left: Any,

right: Optional[Any] = None,

*other: Any,

**kwargs: Any,

) -> Operators: ...

add = cast(OperatorType, _uncast_add)

and_ = cast(OperatorType, _uncast_and_)

contains = cast(OperatorType, _uncast_contains)

eq = cast(OperatorType, _uncast_eq)

floordiv = cast(OperatorType, _uncast_floordiv)

ge = cast(OperatorType, _uncast_ge)

getitem = cast(OperatorType, _uncast_getitem)

gt = cast(OperatorType, _uncast_gt)

inv = cast(OperatorType, _uncast_inv)

le = cast(OperatorType, _uncast_le)

lshift = cast(OperatorType, _uncast_lshift)

lt = cast(OperatorType, _uncast_lt)

matmul = cast(OperatorType, _uncast_matmul)

mod = cast(OperatorType, _uncast_mod)

mul = cast(OperatorType, _uncast_mul)

ne = cast(OperatorType, _uncast_ne)

neg = cast(OperatorType, _uncast_neg)

or_ = cast(OperatorType, _uncast_or_)

pow_ = cast(OperatorType, _uncast_pow)

rshift = cast(OperatorType, _uncast_rshift)

sub = cast(OperatorType, _uncast_sub)

truediv = cast(OperatorType, _uncast_truediv)

class Operators:

"""Base of comparison and logical operators.

Implements base methods

:meth:`~sqlalchemy.sql.operators.Operators.operate` and

:meth:`~sqlalchemy.sql.operators.Operators.reverse_operate`, as well as

:meth:`~sqlalchemy.sql.operators.Operators.__and__`,

:meth:`~sqlalchemy.sql.operators.Operators.__or__`,

:meth:`~sqlalchemy.sql.operators.Operators.__invert__`.

Usually is used via its most common subclass

:class:`.ColumnOperators`.

"""

__slots__ = ()

def __and__(self, other: Any) -> Operators:

"""Implement the ``&`` operator.

When used with SQL expressions, results in an

AND operation, equivalent to

:func:`_expression.and_`, that is::

a & b

is equivalent to::

from sqlalchemy import and_

and_(a, b)

Care should be taken when using ``&`` regarding

operator precedence; the ``&`` operator has the highest precedence.

The operands should be enclosed in parenthesis if they contain

further sub expressions::

(a == 2) & (b == 4)

"""

return self.operate(and_, other)

def __or__(self, other: Any) -> Operators:

"""Implement the ``|`` operator.

When used with SQL expressions, results in an

OR operation, equivalent to

:func:`_expression.or_`, that is::

a | b

is equivalent to::

from sqlalchemy import or_

or_(a, b)

Care should be taken when using ``|`` regarding

operator precedence; the ``|`` operator has the highest precedence.

The operands should be enclosed in parenthesis if they contain

further sub expressions::

(a == 2) | (b == 4)

"""

return self.operate(or_, other)

def __invert__(self) -> Operators:

"""Implement the ``~`` operator.

When used with SQL expressions, results in a

NOT operation, equivalent to

:func:`_expression.not_`, that is::

~a

is equivalent to::

from sqlalchemy import not_

not_(a)

"""

return self.operate(inv)

def _null_operate(self, other: Any) -> Operators:

"""A 'null' operation available on all types, used for testing."""

return self.operate(null_op, other)

def op(

self,

opstring: str,

precedence: int = 0,

is_comparison: bool = False,

return_type: Optional[

Union[Type[TypeEngine[Any]], TypeEngine[Any]]

] = None,

python_impl: Optional[Callable[..., Any]] = None,

operator_class: OperatorClass = OperatorClass.BASE,

visit_name: Optional[str] = None,

) -> Callable[[Any], Operators]:

"""Produce a generic operator function.

e.g.::

somecolumn.op("*")(5)

produces::

somecolumn * 5

This function can also be used to make bitwise operators explicit. For

example::

somecolumn.op("&")(0xFF)

is a bitwise AND of the value in ``somecolumn``.

:param opstring: a string which will be output as the infix operator

between this element and the expression passed to the

generated function.

:param precedence: precedence which the database is expected to apply

to the operator in SQL expressions. This integer value acts as a hint

for the SQL compiler to know when explicit parenthesis should be

rendered around a particular operation. A lower number will cause the

expression to be parenthesized when applied against another operator

with higher precedence. The default value of ``0`` is lower than all

operators except for the comma (``,``) and ``AS`` operators. A value

of 100 will be higher or equal to all operators, and -100 will be

lower than or equal to all operators.

.. seealso::

:ref:`faq_sql_expression_op_parenthesis` - detailed description

of how the SQLAlchemy SQL compiler renders parenthesis

:param is_comparison: legacy; if True, the operator will be considered

as a "comparison" operator, that is which evaluates to a boolean

true/false value, like ``==``, ``>``, etc. This flag is provided

so that ORM relationships can establish that the operator is a

comparison operator when used in a custom join condition.

Using the ``is_comparison`` parameter is superseded by using the

:meth:`.Operators.bool_op` method instead; this more succinct

operator sets this parameter automatically, but also provides

correct :pep:`484` typing support as the returned object will

express a "boolean" datatype, i.e. ``BinaryExpression[bool]``.

:param return_type: a :class:`.TypeEngine` class or object that will

force the return type of an expression produced by this operator

to be of that type. By default, operators that specify

:paramref:`.Operators.op.is_comparison` will resolve to

:class:`.Boolean`, and those that do not will be of the same

type as the left-hand operand.

:param python_impl: an optional Python function that can evaluate

two Python values in the same way as this operator works when

run on the database server. Useful for in-Python SQL expression

evaluation functions, such as for ORM hybrid attributes, and the

ORM "evaluator" used to match objects in a session after a multi-row

update or delete.

e.g.::

>>> expr = column("x").op("+", python_impl=lambda a, b: a + b)("y")

The operator for the above expression will also work for non-SQL

left and right objects::

>>> expr.operator(5, 10)

15

.. versionadded:: 2.0

:param operator_class: optional :class:`.OperatorClass` which will be

applied to the :class:`.custom_op` created, which provides hints

as to which datatypes are appropriate for this operator. Defaults

to :attr:`.OperatorClass.BASE` which is appropriate for all

datatypes.

.. versionadded:: 2.1

.. seealso::

:meth:`.Operators.bool_op`

:ref:`types_operators`

:ref:`relationship_custom_operator`

:param visit_name: string name indicating a series of methods that

maybe be implemented by a :class:`.Dialect`, specifically using its

:class:`.SQLCompiler` implementation. The naming scheme is

``visit_<visit_name>_op_[binary|unary]``; e.g. using the visit name

``hstore`` means that a binary expression using the operator will

attempt to locate a method ``visit_hstore_op_binary()`` on the

target dialect's compiler class, which can then provide a compilation

string for the full binary expression.

.. versionadded:: 2.1

"""

operator = custom_op(

opstring,

precedence=precedence,

is_comparison=is_comparison,

return_type=return_type,

python_impl=python_impl,

operator_class=operator_class,

visit_name=visit_name,

)

def against(other: Any) -> Operators:

return operator(self, other)

return against

def bool_op(

self,

opstring: str,

precedence: int = 0,

python_impl: Optional[Callable[..., Any]] = None,

) -> Callable[[Any], Operators]:

"""Return a custom boolean operator.

This method is shorthand for calling

:meth:`.Operators.op` and passing the

:paramref:`.Operators.op.is_comparison`

flag with True. A key advantage to using :meth:`.Operators.bool_op`

is that when using column constructs, the "boolean" nature of the

returned expression will be present for :pep:`484` purposes.

.. seealso::

:meth:`.Operators.op`

"""

return self.op(

opstring,

precedence=precedence,

is_comparison=True,

python_impl=python_impl,

)

def operate(

self, op: OperatorType, *other: Any, **kwargs: Any

) -> Operators:

r"""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`.

"""

raise NotImplementedError(str(op))

__sa_operate__ = operate

def reverse_operate(

self, op: OperatorType, other: Any, **kwargs: Any

) -> Operators:

"""Reverse operate on an argument.

Usage is the same as :meth:`operate`.

"""

raise NotImplementedError(str(op))

class custom_op(OperatorType, Generic[_T]):

"""Represent a 'custom' operator.

:class:`.custom_op` is normally instantiated when the

:meth:`.Operators.op` or :meth:`.Operators.bool_op` methods

are used to create a custom operator callable. The class can also be

used directly when programmatically constructing expressions. E.g.

to represent the "factorial" operation::

from sqlalchemy.sql import UnaryExpression

from sqlalchemy.sql import operators

from sqlalchemy import Numeric

unary = UnaryExpression(

table.c.somecolumn, modifier=operators.custom_op("!"), type_=Numeric

)

.. seealso::

:meth:`.Operators.op`

:meth:`.Operators.bool_op`

""" # noqa: E501

__name__ = "custom_op"

__slots__ = (

"opstring",

"precedence",

"is_comparison",

"natural_self_precedent",

"eager_grouping",

"return_type",

"python_impl",

"operator_class",

"visit_name",

)

def __init__(

self,

opstring: str,

*,

precedence: int = 0,

is_comparison: bool = False,

return_type: Optional[

Union[Type[TypeEngine[_T]], TypeEngine[_T]]

] = None,

natural_self_precedent: bool = False,

eager_grouping: bool = False,

python_impl: Optional[Callable[..., Any]] = None,

operator_class: OperatorClass = OperatorClass.BASE,

visit_name: Optional[str] = None,

):

"""Create a new :class:`.custom_op`.

See :meth:`.Operators.op` for parameter information.

"""

self.opstring = opstring

self.precedence = precedence

self.is_comparison = is_comparison

self.natural_self_precedent = natural_self_precedent

self.eager_grouping = eager_grouping

self.return_type = (

return_type._to_instance(return_type) if return_type else None

)

self.python_impl = python_impl

self.operator_class = operator_class

self.visit_name = visit_name

def __eq__(self, other: Any) -> bool:

return (

isinstance(other, custom_op)

and other._hash_key() == self._hash_key()

)

def __hash__(self) -> int:

return hash(self._hash_key())

def _hash_key(self) -> Union[CacheConst, Tuple[Any, ...]]:

return (

self.__class__,

self.opstring,

self.precedence,

self.is_comparison,

self.natural_self_precedent,

self.eager_grouping,

self.return_type._static_cache_key if self.return_type else None,

self.operator_class,

)

@overload

def __call__(

self,

left: ColumnExpressionArgument[Any],

right: Optional[Any] = None,

*other: Any,

**kwargs: Any,

) -> ColumnElement[Any]: ...

@overload

def __call__(

self,

left: Operators,

right: Optional[Any] = None,

*other: Any,

**kwargs: Any,

) -> Operators: ...

def __call__(

self,

left: Any,

right: Optional[Any] = None,

*other: Any,

**kwargs: Any,

) -> Operators:

if hasattr(left, "__sa_operate__"):

return left.operate(self, right, *other, **kwargs) # type: ignore

elif self.python_impl:

return self.python_impl(left, right, *other, **kwargs) # type: ignore # noqa: E501

else:

raise exc.InvalidRequestError(

f"Custom operator {self.opstring!r} can't be used with "

"plain Python objects unless it includes the "

"'python_impl' parameter."

)

class OrderingOperators(Operators):

"""defines ORDER BY operators, which can operate as single expressions

or comma-separated lists

"""

__slots__ = ()

if typing.TYPE_CHECKING:

def operate(

self, op: OperatorType, *other: Any, **kwargs: Any

) -> OrderingOperators: ...

def reverse_operate(

self, op: OperatorType, other: Any, **kwargs: Any

) -> OrderingOperators: ...

def desc(self) -> OrderingOperators:

"""Produce a :func:`_expression.desc` clause against the

parent object."""

return self.operate(desc_op)

def asc(self) -> OrderingOperators:

"""Produce a :func:`_expression.asc` clause against the

parent object."""

return self.operate(asc_op)

def nulls_first(self) -> OrderingOperators:

"""Produce a :func:`_expression.nulls_first` clause against the

parent object.

.. versionchanged:: 1.4 The ``nulls_first()`` operator is

renamed from ``nullsfirst()`` in previous releases.

The previous name remains available for backwards compatibility.

"""

return self.operate(nulls_first_op)

# deprecated 1.4; see #5435

if TYPE_CHECKING:

def nullsfirst(self) -> OrderingOperators: ...

else:

nullsfirst = nulls_first

def nulls_last(self) -> OrderingOperators:

"""Produce a :func:`_expression.nulls_last` clause against the

parent object.

.. versionchanged:: 1.4 The ``nulls_last()`` operator is

renamed from ``nullslast()`` in previous releases.

The previous name remains available for backwards compatibility.

"""

return self.operate(nulls_last_op)

# deprecated 1.4; see #5429

if TYPE_CHECKING:

def nullslast(self) -> OrderingOperators: ...

else:

nullslast = nulls_last

class ColumnOperators(OrderingOperators):

"""Defines boolean, comparison, and other operators for

:class:`_expression.ColumnElement` expressions.

By default, all methods call down to

:meth:`.operate` or :meth:`.reverse_operate`,

passing in the appropriate operator function from the

Python builtin ``operator`` module or

a SQLAlchemy-specific operator function from

:mod:`sqlalchemy.expression.operators`. For example

the ``__eq__`` function::

def __eq__(self, other):

return self.operate(operators.eq, other)

Where ``operators.eq`` is essentially::

def eq(a, b):

return a == b

The core column expression unit :class:`_expression.ColumnElement`

overrides :meth:`.Operators.operate` and others

to return further :class:`_expression.ColumnElement` constructs,

so that the ``==`` operation above is replaced by a clause

construct.

.. seealso::

:ref:`types_operators`

:attr:`.TypeEngine.comparator_factory`

:class:`.ColumnOperators`

:class:`.PropComparator`

"""

__slots__ = ()

timetuple: Literal[None] = None

"""Hack, allows datetime objects to be compared on the LHS."""

if typing.TYPE_CHECKING:

def operate(

self, op: OperatorType, *other: Any, **kwargs: Any

) -> ColumnOperators: ...

def reverse_operate(

self, op: OperatorType, other: Any, **kwargs: Any

) -> ColumnOperators: ...

def __lt__(self, other: Any) -> ColumnOperators:

"""Implement the ``<`` operator.

In a column context, produces the clause ``a < b``.

"""

return self.operate(lt, other)

def __le__(self, other: Any) -> ColumnOperators:

"""Implement the ``<=`` operator.

In a column context, produces the clause ``a <= b``.

"""

return self.operate(le, other)

# ColumnOperators defines an __eq__ so it must explicitly declare also

# an hash or it's set to None by python:

# https://docs.python.org/3/reference/datamodel.html#object.__hash__

if TYPE_CHECKING:

def __hash__(self) -> int: ...

else:

__hash__ = Operators.__hash__

def __eq__(self, other: Any) -> ColumnOperators: # type: ignore[override]

"""Implement the ``==`` operator.

In a column context, produces the clause ``a = b``.

If the target is ``None``, produces ``a IS NULL``.

"""

return self.operate(eq, other)

def __ne__(self, other: Any) -> ColumnOperators: # type: ignore[override]

"""Implement the ``!=`` operator.

In a column context, produces the clause ``a != b``.

If the target is ``None``, produces ``a IS NOT NULL``.

"""

return self.operate(ne, other)

def is_distinct_from(self, other: Any) -> ColumnOperators:

"""Implement the ``IS DISTINCT FROM`` operator.

Renders "a IS DISTINCT FROM b" on most platforms;

on some such as SQLite may render "a IS NOT b".

"""

return self.operate(is_distinct_from, other)

def is_not_distinct_from(self, other: Any) -> ColumnOperators:

"""Implement the ``IS NOT DISTINCT FROM`` operator.

Renders "a IS NOT DISTINCT FROM b" on most platforms;

on some such as SQLite may render "a IS b".

.. versionchanged:: 1.4 The ``is_not_distinct_from()`` operator is

renamed from ``isnot_distinct_from()`` in previous releases.

The previous name remains available for backwards compatibility.

"""

return self.operate(is_not_distinct_from, other)

# deprecated 1.4; see #5435

if TYPE_CHECKING:

def isnot_distinct_from(self, other: Any) -> ColumnOperators: ...

else:

isnot_distinct_from = is_not_distinct_from

def __gt__(self, other: Any) -> ColumnOperators:

"""Implement the ``>`` operator.

In a column context, produces the clause ``a > b``.

"""

return self.operate(gt, other)

def __ge__(self, other: Any) -> ColumnOperators:

"""Implement the ``>=`` operator.

In a column context, produces the clause ``a >= b``.

"""

return self.operate(ge, other)

def __neg__(self) -> ColumnOperators:

"""Implement the ``-`` operator.

In a column context, produces the clause ``-a``.

"""

return self.operate(neg)

def __contains__(self, other: Any) -> ColumnOperators:

return self.operate(contains, other)

def __getitem__(self, index: Any) -> ColumnOperators:

"""Implement the [] operator.

This can be used by some database-specific types

such as PostgreSQL ARRAY and HSTORE.

"""

return self.operate(getitem, index)

def __lshift__(self, other: Any) -> ColumnOperators:

"""Implement the ``<<`` operator.

Not used by SQLAlchemy core, this is provided

for custom operator systems which want to use

<< as an extension point.

"""

return self.operate(lshift, other)

def __rlshift__(self, other: Any) -> ColumnOperators:

"""Implement the ``<<`` operator in reverse.

Not used by SQLAlchemy core, this is provided

for custom operator systems which want to use

<< as an extension point.

"""

return self.reverse_operate(lshift, other)

def __rshift__(self, other: Any) -> ColumnOperators:

"""Implement the ``>>`` operator.

Not used by SQLAlchemy core, this is provided

for custom operator systems which want to use

>> as an extension point.

"""

return self.operate(rshift, other)

def __rrshift__(self, other: Any) -> ColumnOperators:

"""Implement the ``>>`` operator in reverse.

Not used by SQLAlchemy core, this is provided

for custom operator systems which want to use

>> as an extension point.

"""

return self.reverse_operate(rshift, other)

def __matmul__(self, other: Any) -> ColumnOperators:

"""Implement the ``@`` operator.

Not used by SQLAlchemy core, this is provided

for custom operator systems which want to use

@ as an extension point.

"""

return self.operate(matmul, other)

def __rmatmul__(self, other: Any) -> ColumnOperators:

"""Implement the ``@`` operator in reverse.

Not used by SQLAlchemy core, this is provided

for custom operator systems which want to use

@ as an extension point.

"""

return self.reverse_operate(matmul, other)

def concat(self, other: Any) -> ColumnOperators:

"""Implement the 'concat' operator.

In a column context, produces the clause ``a || b``,

or uses the ``concat()`` operator on MySQL.

"""

return self.operate(concat_op, other)

def _rconcat(self, other: Any) -> ColumnOperators:

"""Implement an 'rconcat' operator.

this is for internal use at the moment

.. versionadded:: 1.4.40

"""

return self.reverse_operate(concat_op, other)

def like(

self, other: Any, escape: Optional[str] = None

) -> ColumnOperators:

r"""Implement the ``like`` operator.

In a column context, produces the expression:

.. sourcecode:: sql

a LIKE other

E.g.::

stmt = select(sometable).where(sometable.c.column.like("%foobar%"))

:param other: expression to be compared

:param escape: optional escape character, renders the ``ESCAPE``

keyword, e.g.::

somecolumn.like("foo/%bar", escape="/")

.. seealso::

:meth:`.ColumnOperators.ilike`

"""

return self.operate(like_op, other, escape=escape)

def ilike(

self, other: Any, escape: Optional[str] = None

) -> ColumnOperators:

r"""Implement the ``ilike`` operator, e.g. case insensitive LIKE.

In a column context, produces an expression either of the form:

.. sourcecode:: sql

lower(a) LIKE lower(other)

Or on backends that support the ILIKE operator:

.. sourcecode:: sql

a ILIKE other

E.g.::

stmt = select(sometable).where(sometable.c.column.ilike("%foobar%"))

:param other: expression to be compared

:param escape: optional escape character, renders the ``ESCAPE``

keyword, e.g.::

somecolumn.ilike("foo/%bar", escape="/")

.. seealso::

:meth:`.ColumnOperators.like`

""" # noqa: E501

return self.operate(ilike_op, other, escape=escape)

def bitwise_xor(self, other: Any) -> ColumnOperators:

"""Produce a bitwise XOR operation, typically via the ``^``

operator, or ``#`` for PostgreSQL.

.. versionadded:: 2.0.2

.. seealso::

:ref:`operators_bitwise`

"""

return self.operate(bitwise_xor_op, other)

def bitwise_or(self, other: Any) -> ColumnOperators:

"""Produce a bitwise OR operation, typically via the ``|``

operator.

.. versionadded:: 2.0.2

.. seealso::

:ref:`operators_bitwise`

"""

return self.operate(bitwise_or_op, other)

def bitwise_and(self, other: Any) -> ColumnOperators:

"""Produce a bitwise AND operation, typically via the ``&``

operator.

.. versionadded:: 2.0.2

.. seealso::

:ref:`operators_bitwise`

"""

return self.operate(bitwise_and_op, other)