sqlalchemy.sql.sqltypes.ARRAY.Comparator

class documentation

class Comparator(Indexable.Comparator[Sequence[Any]], Concatenable.Comparator[Sequence[Any]]): (source)

Known subclasses: sqlalchemy.dialects.postgresql.ARRAY.Comparator

Define comparison operations for :class:`_types.ARRAY`. More operators are available on the dialect-specific form of this type. See :class:`.postgresql.ARRAY.Comparator`.

Method	`all`	Return ``other operator ALL (array)`` clause.
Method	`any`	Return ``other operator ANY (array)`` clause.
Method	`contains`	Implement the 'contains' operator.
Class Variable	`__slots__`	Undocumented
Class Variable	`type`	Undocumented
Method	`_setup_getitem`	Undocumented

Inherited from Comparator:

Method __getitem__ Implement the [] operator.

Inherited from Comparator (via Comparator):

Method _adapt_expression evaluate the return type of <self> <op> <othertype>, and apply any adaptations to the given operator.

Inherited from Comparator (via Comparator, Comparator):

Method	`__clause_element__`	Undocumented
Method	`__init__`	Undocumented
Method	`__reduce__`	Undocumented
Method	`operate`	Operate on an argument.
Method	`reverse_operate`	Reverse operate on an argument.
Instance Variable	`expr`	Undocumented

Inherited from ColumnOperators (via Comparator, Comparator, Comparator):

Method	`__add__`	Implement the ``+`` operator.
Method	`__contains__`	Undocumented
Method	`__eq__`	Implement the ``==`` operator.
Method	`__floordiv__`	Implement the ``//`` operator.
Method	`__ge__`	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	`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 Comparator, Comparator, Comparator, 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.

@util.preload_module('sqlalchemy.sql.elements')
def all(self, other, operator=None): (source) ¶

Return ``other operator ALL (array)`` clause. .. note:: This method is an :class:`_types.ARRAY` - specific construct that is now superseded by the :func:`_sql.any_` function, which features a different calling style. The :func:`_sql.any_` function is also mirrored at the method level via the :meth:`_sql.ColumnOperators.any_` method. Usage of array-specific :meth:`_types.ARRAY.Comparator.all` is as follows:: from sqlalchemy.sql import operators conn.execute( select(table.c.data).where( table.c.data.all(7, operator=operators.lt) ) ) :param other: expression to be compared :param operator: an operator object from the :mod:`sqlalchemy.sql.operators` package, defaults to :func:`.operators.eq`. .. seealso:: :func:`_expression.all_` :meth:`.types.ARRAY.Comparator.any`

@util.preload_module('sqlalchemy.sql.elements')
def any(self, other, operator=None): (source) ¶

Return ``other operator ANY (array)`` clause. .. note:: This method is an :class:`_types.ARRAY` - specific construct that is now superseded by the :func:`_sql.any_` function, which features a different calling style. The :func:`_sql.any_` function is also mirrored at the method level via the :meth:`_sql.ColumnOperators.any_` method. Usage of array-specific :meth:`_types.ARRAY.Comparator.any` is as follows:: from sqlalchemy.sql import operators conn.execute( select(table.c.data).where( table.c.data.any(7, operator=operators.lt) ) ) :param other: expression to be compared :param operator: an operator object from the :mod:`sqlalchemy.sql.operators` package, defaults to :func:`.operators.eq`. .. seealso:: :func:`_expression.any_` :meth:`.types.ARRAY.Comparator.all`

def contains(self, *arg, **kw): (source) ¶

overrides sqlalchemy.sql.operators.ColumnOperators.contains

overridden in sqlalchemy.dialects.postgresql.ARRAY.Comparator

Implement the 'contains' operator. Produces a LIKE expression that tests against a match for the middle of a string value:: column LIKE '%' || <other> || '%' E.g.:: stmt = select(sometable).\ where(sometable.c.column.contains("foobar")) Since the operator uses ``LIKE``, wildcard characters ``"%"`` and ``"_"`` that are present inside the <other> expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.contains.autoescape` flag may be set to ``True`` to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the :paramref:`.ColumnOperators.contains.escape` parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string. :param other: expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters ``%`` and ``_`` are not escaped by default unless the :paramref:`.ColumnOperators.contains.autoescape` flag is set to True. :param autoescape: boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of ``"%"``, ``"_"`` and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression. An expression such as:: somecolumn.contains("foo%bar", autoescape=True) Will render as:: somecolumn LIKE '%' || :param || '%' ESCAPE '/' With the value of ``:param`` as ``"foo/%bar"``. :param escape: a character which when given will render with the ``ESCAPE`` keyword to establish that character as the escape character. This character can then be placed preceding occurrences of ``%`` and ``_`` to allow them to act as themselves and not wildcard characters. An expression such as:: somecolumn.contains("foo/%bar", escape="^") Will render as:: somecolumn LIKE '%' || :param || '%' ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.contains.autoescape`:: somecolumn.contains("foo%bar^bat", escape="^", autoescape=True) Where above, the given literal parameter will be converted to ``"foo^%bar^^bat"`` before being passed to the database. .. seealso:: :meth:`.ColumnOperators.startswith` :meth:`.ColumnOperators.endswith` :meth:`.ColumnOperators.like`

__slots__: tuple = (source) ¶

overrides sqlalchemy.sql.sqltypes.Indexable.Comparator.__slots__

Undocumented

type: ARRAY = (source) ¶

overrides sqlalchemy.sql.type_api.TypeEngine.Comparator.type

Undocumented

def _setup_getitem(self, index): (source) ¶

overrides sqlalchemy.sql.sqltypes.Indexable.Comparator._setup_getitem

Undocumented