؄_@dZddlmZddlmZddlmZddlmZddlmZddlmZddlmZdd lm Z dd lm Z dd lm Z dd lm Z dd lm Z ddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZejrddlmZneZGddeZGddeZGddeZeeeehZeee eee hZdZdZ d Z!e d!Z"d"Z#d#Z$d$Z%d%Z&e d&Z'e d'Z(e d(Z)e d)Z*d*Z+d+Z,e dcd-Z-e dcd.Z.e dcd/Z/e dcd0Z0e ddd2Z1e ddd3Z2e d4Z3e d5Z4d6Z5d7Z6d8Z7d9Z8e ded:Z9e ded;Z:e ded<Z;e ded=ZZ=e ded?Z>e d@Z?e dAZ@dBZAe dCZBe dDZCdEZDdFZEdGZFdHZGdIZHdJZIdKZJdLZKdMZLdNZMdOZNdPZOe e%e&eefZPdQZQee ee e ee eiZRdRZSeTeEeegUeegZVeVTeeJeKgZW ejXdSdTUZYejXdVdWUZZejXdXdYUZ[ie!dZe"dZe6dZe7dZedZeJdZeKdZed[ed[ed[e d[ed[ed\ed\eEd]eDd]e?d^ie@d^e/d^e0d^e-d^e.d^e3d^e4d^e)d^e*d^ed^ed^e'd^e(d^eBd^eCd^ed^e d^ied^e d^e1d^e2d^e5d^e d^e%d^e&d^ed_edeAd`eFd_eGd_e+dae#d`e$deYdTeZeZe[e[iZ\dbZ]d,S)fz*Defines operators used in SQL expressions.)add)and_)contains)eq)ge)getitem)gt)inv)le)lshift)lt)mod)mul)ne)neg)or_)rshift)sub)truediv)util)divcFeZdZdZdZdZdZdZ d d Zdd Z d Z d Z dS) OperatorsaBase 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`. c8|t|S)a-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) )operaterselfothers ]/var/www/book.euthymeo.com/html/venv/lib/python3.11/site-packages/sqlalchemy/sql/operators.py__and__zOperators.__and__;s,||D%(((c8|t|S)a)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) )rrrs r!__or__zOperators.__or__Ss,||C'''r#c6|tS)aImplement 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) )rr rs r! __invert__zOperators.__invert__ks||C   r#rFNc:t||||fd}|S)a!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 operator: a string which will be output as the infix operator between this element and the expression passed to the generated function. :param precedence: precedence to apply to the operator, when parenthesizing expressions. 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. :param is_comparison: 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 should be set so that ORM relationships can establish that the operator is a comparison operator when used in a custom join condition. .. versionadded:: 0.9.2 - added the :paramref:`.Operators.op.is_comparison` flag. :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. .. versionadded:: 1.2.0b3 - added the :paramref:`.Operators.op.return_type` argument. .. seealso:: :ref:`types_operators` :ref:`relationship_custom_operator` c|SNr)r operatorrs r!againstzOperators.op..againsts8D%(( (r#) custom_op)ropstring precedence is_comparison return_typer-r,s` @r!opz Operators.op|s?tXz=+NN ) ) ) ) ) )r#c2|||dS)a+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. .. versionadded:: 1.2.0b3 .. seealso:: :meth:`.Operators.op` T)r0r1r3)rr/r0s r!bool_opzOperators.bool_opswwxJdwKKKr#c:tt|)a3Operate 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): return op(func.lower(self), func.lower(other)) :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`. NotImplementedErrorstrrr3r kwargss r!rzOperators.operates0"#b''***r#c :tt|)zXReverse operate on an argument. Usage is the same as :meth:`operate`. r8r;s r!reverse_operatezOperators.reverse_operates "#b''***r#)rFN)r) __name__ __module__ __qualname____doc__ __slots__r"r%r(r3r6rr>rr#r!rr*s  I)))0(((0!!!$HL????BLLLL"+++4+++++r#rc:eZdZdZdZ d dZdZdZdZdS) r.aRepresent 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` rFNc||_||_||_||_||_|r||nd|_dSr+)r/r0r1natural_self_precedenteager_grouping _to_instancer2)rr/r0r1r2rFrGs r!__init__zcustom_op.__init__ sS! $*&<#,5@ JK $ $[ 1 1 1d r#cLt|to|j|jkSr+) isinstancer.r/rs r!__eq__zcustom_op.__eq__s %++O$-0OOr#c t|Sr+)idr's r!__hash__zcustom_op.__hash__"s $xxr#c |j||fi|Sr+)r)rleftrightkws r!__call__zcustom_op.__call__%st|D%..2...r#)rFNFF)r?r@rArBrIrLrOrTrr#r!r.r.sz2H $    $PPP/////r#r.cNeZdZdZdZdZ dZdZej Z dZ dZ dZ d Z d Zd Zd Zd ZdZdZdZdZd4dZd4dZdZdZd4dZd4dZdZdZdZdZdZ dZ!dZ"dZ#d Z$d!Z%d"Z&d#Z'd$Z(d%Z)d&Z*d'Z+d5d)Z,d*Z-d+Z.d,Z/d-Z0d.Z1d/Z2d0Z3d1Z4d2Z5d3Z6dS)6ColumnOperatorsa"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` rNc8|t|S)zdImplement the ``<`` operator. In a column context, produces the clause ``a < b``. )rr rs r!__lt__zColumnOperators.__lt__T ||B&&&r#c8|t|S)zfImplement the ``<=`` operator. In a column context, produces the clause ``a <= b``. )rr rs r!__le__zColumnOperators.__le__\rYr#c8|t|S)zImplement the ``==`` operator. In a column context, produces the clause ``a = b``. If the target is ``None``, produces ``a IS NULL``. )rrrs r!rLzColumnOperators.__eq__f||B&&&r#c8|t|S)zImplement the ``!=`` operator. In a column context, produces the clause ``a != b``. If the target is ``None``, produces ``a IS NOT NULL``. )rrrs r!__ne__zColumnOperators.__ne__or]r#c8|t|S)zImplement 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". .. versionadded:: 1.1 )ris_distinct_fromrs r!raz ColumnOperators.is_distinct_fromxs||,e444r#c8|t|S)zImplement 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". .. versionadded:: 1.1 )risnot_distinct_fromrs r!rcz#ColumnOperators.isnot_distinct_froms||/777r#c8|t|S)zdImplement the ``>`` operator. In a column context, produces the clause ``a > b``. )rr rs r!__gt__zColumnOperators.__gt__rYr#c8|t|S)zfImplement the ``>=`` operator. In a column context, produces the clause ``a >= b``. )rrrs r!__ge__zColumnOperators.__ge__rYr#c6|tS)zaImplement the ``-`` operator. In a column context, produces the clause ``-a``. )rrr's r!__neg__zColumnOperators.__neg__s ||C   r#c8|t|Sr+)rrrs r! __contains__zColumnOperators.__contains__s||He,,,r#c8|t|S)zImplement the [] operator. This can be used by some database-specific types such as PostgreSQL ARRAY and HSTORE. )rr)rindexs r! __getitem__zColumnOperators.__getitem__s||GU+++r#c8|t|S)zimplement the << operator. Not used by SQLAlchemy core, this is provided for custom operator systems which want to use << as an extension point. )rr rs r! __lshift__zColumnOperators.__lshift__||FE***r#c8|t|S)zimplement the >> operator. Not used by SQLAlchemy core, this is provided for custom operator systems which want to use >> as an extension point. )rrrs r! __rshift__zColumnOperators.__rshift__rqr#c8|t|S)zImplement the 'concat' operator. In a column context, produces the clause ``a || b``, or uses the ``concat()`` operator on MySQL. )r concat_oprs r!concatzColumnOperators.concats||Iu---r#c<|t||S)aImplement the ``like`` operator. In a column context, produces the expression:: 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` escape)rlike_oprr rys r!likezColumnOperators.likes.||GU6|:::r#c<|t||S)aImplement the ``ilike`` operator, e.g. case insensitive LIKE. In a column context, produces an expression either of the form:: lower(a) LIKE lower(other) Or on backends that support the ILIKE operator:: 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` rx)rilike_opr{s r!ilikezColumnOperators.ilikes6||HeF|;;;r#c8|t|S)a Implement the ``in`` operator. In a column context, produces the clause ``column IN ``. The given parameter ``other`` may be: * A list of literal values, e.g.:: stmt.where(column.in_([1, 2, 3])) In this calling form, the list of items is converted to a set of bound parameters the same length as the list given:: WHERE COL IN (?, ?, ?) * A list of tuples may be provided if the comparison is against a :func:`.tuple_` containing multiple expressions:: from sqlalchemy import tuple_ stmt.where(tuple_(col1, col2).in_([(1, 10), (2, 20), (3, 30)])) * An empty list, e.g.:: stmt.where(column.in_([])) In this calling form, the expression renders a "false" expression, e.g.:: WHERE 1 != 1 This "false" expression has historically had different behaviors in older SQLAlchemy versions, see :paramref:`_sa.create_engine.empty_in_strategy` for behavioral options. .. versionchanged:: 1.2 simplified the behavior of "empty in" expressions * A bound parameter, e.g. :func:`.bindparam`, may be used if it includes the :paramref:`.bindparam.expanding` flag:: stmt.where(column.in_(bindparam('value', expanding=True))) In this calling form, the expression renders a special non-SQL placeholder expression that looks like:: WHERE COL IN ([EXPANDING_value]) This placeholder expression is intercepted at statement execution time to be converted into the variable number of bound parameter form illustrated earlier. If the statement were executed as:: connection.execute(stmt, {"value": [1, 2, 3]}) The database would be passed a bound parameter for each value:: WHERE COL IN (?, ?, ?) .. versionadded:: 1.2 added "expanding" bound parameters If an empty list is passed, a special "empty list" expression, which is specific to the database in use, is rendered. On SQLite this would be:: WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1) .. versionadded:: 1.3 "expanding" bound parameters now support empty lists * a :func:`_expression.select` construct, which is usually a correlated scalar select:: stmt.where( column.in_( select([othertable.c.y]). where(table.c.x == othertable.c.x) ) ) In this calling form, :meth:`.ColumnOperators.in_` renders as given:: WHERE COL IN (SELECT othertable.y FROM othertable WHERE othertable.x = table.x) :param other: a list of literals, a :func:`_expression.select` construct, or a :func:`.bindparam` construct that includes the :paramref:`.bindparam.expanding` flag set to True. )rin_oprs r!in_zColumnOperators.in_sx||E5)))r#c8|t|S)aimplement the ``NOT IN`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.in_`, i.e. ``~x.in_(y)``. In the case that ``other`` is an empty sequence, the compiler produces an "empty not in" expression. This defaults to the expression "1 = 1" to produce true in all cases. The :paramref:`_sa.create_engine.empty_in_strategy` may be used to alter this behavior. .. versionchanged:: 1.2 The :meth:`.ColumnOperators.in_` and :meth:`.ColumnOperators.notin_` operators now produce a "static" expression for an empty IN sequence by default. .. seealso:: :meth:`.ColumnOperators.in_` )rnotin_oprs r!notin_zColumnOperators.notin_as,||He,,,r#c<|t||S)zimplement the ``NOT LIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``. .. seealso:: :meth:`.ColumnOperators.like` rx)r notlike_opr{s r!notlikezColumnOperators.notlikeys||Jf|===r#c<|t||S)zimplement the ``NOT ILIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``. .. seealso:: :meth:`.ColumnOperators.ilike` rx)r notilike_opr{s r!notilikezColumnOperators.notilikes||Kv|>>>r#c8|t|S)aVImplement the ``IS`` operator. Normally, ``IS`` is generated automatically when comparing to a value of ``None``, which resolves to ``NULL``. However, explicit usage of ``IS`` may be desirable if comparing to boolean values on certain platforms. .. seealso:: :meth:`.ColumnOperators.isnot` )ris_rs r!rzColumnOperators.is_s||C'''r#c8|t|S)a`Implement the ``IS NOT`` operator. Normally, ``IS NOT`` is generated automatically when comparing to a value of ``None``, which resolves to ``NULL``. However, explicit usage of ``IS NOT`` may be desirable if comparing to boolean values on certain platforms. .. seealso:: :meth:`.ColumnOperators.is_` )risnotrs r!rzColumnOperators.isnots||E5)))r#c *|jt|fi|S)a Implement the ``startswith`` operator. Produces a LIKE expression that tests against a match for the start of a string value:: column LIKE || '%' E.g.:: stmt = select([sometable]).\ where(sometable.c.column.startswith("foobar")) Since the operator uses ``LIKE``, wildcard characters ``"%"`` and ``"_"`` that are present inside the expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.startswith.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.startswith.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.startswith.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.startswith("foo%bar", autoescape=True) Will render as:: somecolumn LIKE :param || '%' ESCAPE '/' With the value of ``:param`` as ``"foo/%bar"``. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The :paramref:`.ColumnOperators.startswith.autoescape` parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the :paramref:`.ColumnOperators.startswith.escape` parameter. :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.startswith("foo/%bar", escape="^") Will render as:: somecolumn LIKE :param || '%' ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.startswith.autoescape`:: somecolumn.startswith("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.endswith` :meth:`.ColumnOperators.contains` :meth:`.ColumnOperators.like` )r startswith_oprr r<s r! startswithzColumnOperators.startswiths!lt|M5;;F;;;r#c *|jt|fi|S)a Implement the 'endswith' operator. Produces a LIKE expression that tests against a match for the end of a string value:: column LIKE '%' || E.g.:: stmt = select([sometable]).\ where(sometable.c.column.endswith("foobar")) Since the operator uses ``LIKE``, wildcard characters ``"%"`` and ``"_"`` that are present inside the expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.endswith.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.endswith.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.endswith.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.endswith("foo%bar", autoescape=True) Will render as:: somecolumn LIKE '%' || :param ESCAPE '/' With the value of ``:param`` as ``"foo/%bar"``. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The :paramref:`.ColumnOperators.endswith.autoescape` parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the :paramref:`.ColumnOperators.endswith.escape` parameter. :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.endswith("foo/%bar", escape="^") Will render as:: somecolumn LIKE '%' || :param ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.endswith.autoescape`:: somecolumn.endswith("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.contains` :meth:`.ColumnOperators.like` )r endswith_oprs r!endswithzColumnOperators.endswiths!lt|K99&999r#c *|jt|fi|S)a Implement the 'contains' operator. Produces a LIKE expression that tests against a match for the middle of a string value:: column LIKE '%' || || '%' E.g.:: stmt = select([sometable]).\ where(sometable.c.column.contains("foobar")) Since the operator uses ``LIKE``, wildcard characters ``"%"`` and ``"_"`` that are present inside the 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"``. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The :paramref:`.ColumnOperators.contains.autoescape` parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the :paramref:`.ColumnOperators.contains.escape` parameter. :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` )r contains_oprs r!rzColumnOperators.contains]s!nt|K99&999r#c *|jt|fi|S)aYImplements a database-specific 'match' operator. :meth:`~.ColumnOperators.match` attempts to resolve to a MATCH-like function or operator provided by the backend. Examples include: * PostgreSQL - renders ``x @@ to_tsquery(y)`` * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)`` * Oracle - renders ``CONTAINS(x, y)`` * other backends may provide special implementations. * Backends without any special implementation will emit the operator as "MATCH". This is compatible with SQLite, for example. )rmatch_oprs r!matchzColumnOperators.matchs t|He66v666r#c6|tS)zLProduce a :func:`_expression.desc` clause against the parent object.)rdesc_opr's r!desczColumnOperators.descs||G$$$r#c6|tS)zKProduce a :func:`_expression.asc` clause against the parent object.)rasc_opr's r!asczColumnOperators.ascs||F###r#c6|tS)zRProduce a :func:`_expression.nullsfirst` clause against the parent object.)r nullsfirst_opr's r! nullsfirstzColumnOperators.nullsfirsts||M***r#c6|tS)zQProduce a :func:`_expression.nullslast` clause against the parent object.)r nullslast_opr's r! nullslastzColumnOperators.nullslasts||L)))r#c8|t|S)zProduce a :func:`_expression.collate` clause against the parent object, given the collation string. .. seealso:: :func:`_expression.collate` )rcollate)r collations r!rzColumnOperators.collates||GY///r#c8|t|S)zaImplement the ``+`` operator in reverse. See :meth:`.ColumnOperators.__add__`. )r>rrs r!__radd__zColumnOperators.__radd__ ##C///r#c8|t|S)zaImplement the ``-`` operator in reverse. See :meth:`.ColumnOperators.__sub__`. )r>rrs r!__rsub__zColumnOperators.__rsub__rr#c8|t|S)zaImplement the ``*`` operator in reverse. See :meth:`.ColumnOperators.__mul__`. )r>rrs r!__rmul__zColumnOperators.__rmul__rr#c8|t|S)zaImplement the ``/`` operator in reverse. See :meth:`.ColumnOperators.__div__`. )r>rrs r!__rdiv__zColumnOperators.__rdiv__rr#c8|t|S)zaImplement the ``%`` operator in reverse. See :meth:`.ColumnOperators.__mod__`. )r>rrs r!__rmod__zColumnOperators.__rmod__rr#Fc>|t|||S)zzProduce a :func:`_expression.between` clause against the parent object, given the lower and upper range.  symmetric)r between_op)rcleftcrightrs r!betweenzColumnOperators.betweens ||Jv|KKKr#c6|tS)zZProduce a :func:`_expression.distinct` clause against the parent object. )r distinct_opr's r!distinctzColumnOperators.distincts ||K(((r#c6|tS)aProduce a :func:`_expression.any_` clause against the parent object. This operator is only appropriate against a scalar subquery object, or for some backends an column expression that is against the ARRAY type, e.g.:: # postgresql '5 = ANY (somearray)' expr = 5 == mytable.c.somearray.any_() # mysql '5 = ANY (SELECT value FROM table)' expr = 5 == select([table.c.value]).as_scalar().any_() .. seealso:: :func:`_expression.any_` - standalone version :func:`_expression.all_` - ALL operator .. versionadded:: 1.1 )rany_opr's r!any_zColumnOperators.any_.||F###r#c6|tS)aProduce a :func:`_expression.all_` clause against the parent object. This operator is only appropriate against a scalar subquery object, or for some backends an column expression that is against the ARRAY type, e.g.:: # postgresql '5 = ALL (somearray)' expr = 5 == mytable.c.somearray.all_() # mysql '5 = ALL (SELECT value FROM table)' expr = 5 == select([table.c.value]).as_scalar().all_() .. seealso:: :func:`_expression.all_` - standalone version :func:`_expression.any_` - ANY operator .. versionadded:: 1.1 )rall_opr's r!all_zColumnOperators.all_6rr#c8|t|S)a4Implement the ``+`` operator. In a column context, produces the clause ``a + b`` if the parent object has non-string affinity. If the parent object has a string affinity, produces the concatenation operator, ``a || b`` - see :meth:`.ColumnOperators.concat`. )rrrs r!__add__zColumnOperators.__add__Os||C'''r#c8|t|S)zdImplement the ``-`` operator. In a column context, produces the clause ``a - b``. )rrrs r!__sub__zColumnOperators.__sub__[ ||C'''r#c8|t|S)zdImplement the ``*`` operator. In a column context, produces the clause ``a * b``. )rrrs r!__mul__zColumnOperators.__mul__crr#c8|t|S)zdImplement the ``/`` operator. In a column context, produces the clause ``a / b``. )rrrs r!__div__zColumnOperators.__div__krr#c8|t|S)zdImplement the ``%`` operator. In a column context, produces the clause ``a % b``. )rrrs r!__mod__zColumnOperators.__mod__srr#c8|t|S)zeImplement the ``//`` operator. In a column context, produces the clause ``a / b``. )rrrs r! __truediv__zColumnOperators.__truediv__{s ||GU+++r#c8|t|S)zfImplement the ``//`` operator in reverse. See :meth:`.ColumnOperators.__truediv__`. )r>rrs r! __rtruediv__zColumnOperators.__rtruediv__s ##GU333r#r+F)7r?r@rArBrC timetuplerXr[rrOrLr_rarcrergrirkrnrprsrvr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr#r!rVrV)s&##JIIB''''''!H'''''' 5 5 5 8 8 8''''''!!!---,,,++++++...;;;;2<<<<:\*\*\*|---0 > > > > ? ? ? ? ( ( ( * * *V<V<V|||Sr+r5)rr/rs r!r3r3s 144>>!  r#Nc0|||SNrx)r|rrrys r!rzrzs 66!F6 # ##r#c0|||Sr)rrs r!rrs 99Qv9 & &&r#c0|||Sr)rrs r!r~r~s 771V7 $ $$r#c0|||Sr)rrs r!rrs ::a: ' ''r#Fc2||||SNr)rrrcrs r!rrs 99QY9 / //r#c2||||Sr) notbetweenrs r! notbetween_oprs <<1 < 2 22r#c,||Sr+)rrs r!rrrr#c,||Sr+)rrs r!rrs 88A;;r#c*|Sr+)rrs r!rrs ::<<r#c*|Sr+)rrs r!rr 6688Or#c*|Sr+)rrs r!rrr r#cN|r|durtjd|d}t|tjjst d|dvr||||z}|d|dzd|dz}|||S) NTz;The autoescape parameter is now a simple boolean True/False/z*String value expected when autoescape=True)%_rrrx)rwarnrKcompat string_types TypeErrorreplace)rr ry autoescapes r!_escaped_like_implrsL T ! ! IM    >F%!9:: JHII I  # #MM&&6/::E c6C<0088fslKK 2eF # # ##r#c0t|j|||Sr+rrrrryrs r!rrs alAvz B BBr#c2t|j|||Sr+rrs r!notstartswith_oprs q|Q C C CCr#c0t|j|||Sr+rrrs r!rr! aj!VZ @ @@r#c2t|j|||Sr+rrs r!notendswith_opr!& qz1fj A A AAr#c0t|j|||Sr+rrrs r!rr+rr#c2t|j|||Sr+r$rs r!notcontains_opr&0r"r#c |j|fi|Sr+)rrrrSs r!rr5s 171    r#c |j|fi|Sr+)notmatchr(s r! notmatch_opr+:s 1:a  2  r#ctr+rrs r!comma_opr-?rr#ctr+rrs r! empty_in_opr/Crr#ctr+rrs r!empty_notin_opr1Hrr#ctr+rrs r! filter_opr3Mrr#c,||Sr+)rvrs r!ruruQs 88A;;r#c*|Sr+)rrs r!rrUr r#c*|Sr+)rrs r!rrYs 5577Nr#c*|Sr+)rrs r!rr]s <<>>r#c*|Sr+)rrs r!rras ;;==r#ctr+rrs r!json_getitem_opr:err#ctr+rrs r!json_path_getitem_opr<irr#cL|tvpt|to|jSr+)rrKr.r1r5s r!r1r1ms$   N 2y 9 9 Nb>NNr#c|tvSr+)rr5s r!is_commutativer?qs  r#c:|ttttfvSr+)rrrrr5s r!is_ordering_modifierrAus &'=,? ??r#cL|tvpt|to|jSr+)_natural_self_precedentrKr.rFr5s r!is_natural_self_precedentrDys- %% & b) $ $ &  %r#c2t|p|tvSr+)r1 _booleansr5s r! is_booleanrGs    /i/r#c8t||S)z[rotate a comparison operator 180 degrees. Note this is not the same as negation. )_mirrorgetr5s r!mirrorrKs ;;r2  r#_asbooli) canonical _smallesti_largestdc ||urt|rdSt|t|dtt|t|dt kS)NFr0)rD _PRECEDENCErJgetattrrNrO)r,r-s r! is_precedentr\sk78BBu gh i@@  __Wgg|X&N&N O OP Pr#r+r)NF)^rBr,rrrrrrr r r r r rrrrrrrrrpy2krobjectrr.rVrrrrrrrrrrrarcrrrr3rzrr~rrrrrrrrrrrrr!rr&rr+r-r/r1r3rurrrrr:r<r1r?rArDrFrGrIrKunion difference _associativerCsymbolrLrNrOrZr\rr#r!rdsU 109 CD+D+D+D+D+D+D+D+N5/5/5/5/5/5/5/5/p` 4` 4` 4` 4` 4i` 4` 4` 4FBS! 2r2r2&                     !!!$$$$$$$''''%%%%((((00003333$$$(CCCCDDDDAAAABBBBAAAABBBB                  OOO@@@&'4 - 000 r2r2r2r *!!9dC"899DDb"XNN &,, o34 $+i3 / / / DK t 4 4 4 4;zS 1 1 16 26r6 B6 B 6  R 6 R 6"66 Q666666q6 q!6" a#66$%6& a'6()6* Q+6,-6. 1/60 a162364 156676896:a;6<=6>?6@AA6BC6DE666FG6HI6JK6L1M6NO6PQ6R AS6T QU6V !W6XY6Z b[6\ Q]6^ A_6` Qa6bc6d Ae6f Sg66hy hk66 rPPPPPr#