o y\G @sdZddlmZddlmZddlmZddlmZddlmZddlmZddlmZdd lm Z dd lm Z dd lm Z dd lm Z dd lm Z ddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZejrddlmZneZGdddeZGdddeZGdddeZddZd d!Zd"d#Zd$d%Z d&d'Z!d(d)Z"d*d+Z#d,d-Z$d.d/Z%d0d1Z&d2d3Z'dd5d6Z(dd7d8Z)dd9d:Z*dd;d<Z+dd>d?Z,dd@dAZ-dBdCZ.dDdEZ/dFdGZ0dHdIZ1dJdKZ2dLdMZ3ddNdOZ4ddPdQZ5ddRdSZ6ddTdUZ7ddVdWZ8ddXdYZ9dZd[Z:d\d]Z;d^d_ZdddeZ?dfdgZ@dhdiZAdjdkZBdldmZCdndoZDdpdqZEeeeehZFeee eee e,e(e$e%e"e#h ZGdrdsZHdtduZIdvdwZJdxdyZKe e e!eefZLdzd{ZMee ee e ee eiZNd|d}ZOeFPe?eegQeegZReRPeeDeEgZS ejTd~ddZUejTdddZVejTdddZWiede1de2dedeDdeEdededede dededede?de:de;de*die+de(de)de.de/de$de%dedede"de#de=de>dede dede die,de-de0de de de!dedede``, 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` cs |SNr)roperatorrrragainst zOperators.op..against) custom_op)ropstring precedence is_comparison return_typer)rr'rop|s:z Operators.opcCs|j||ddS)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)r-r.r0)rr,r-rrrbool_opszOperators.bool_opcO 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`. NotImplementedErrorstrrr0rkwargsrrrrs zOperators.operatecKr3)zXReverse operate on an argument. Usage is the same as :meth:`operate`. r4r7rrrreverse_operate zOperators.reverse_operate)rFN)r) __name__ __module__ __qualname____doc__ __slots__r r"r%r0r2rr9rrrrr*s A rc@s@eZdZdZdZ     d ddZddZd d Zd d ZdS)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` rFNcCs<||_||_||_||_||_|r|||_dSd|_dSr&)r,r-r.natural_self_precedenteager_grouping _to_instancer/)rr,r-r.r/r@rArrr__init__ s  zcustom_op.__init__cCst|to |j|jkSr&) isinstancer+r,rrrr__eq__szcustom_op.__eq__cCst|Sr&)idr$rrr__hash__"zcustom_op.__hash__cKs|j||fi|Sr&)r)rleftrightkwrrr__call__%szcustom_op.__call__)rFNFF)r;r<r=r>rCrErGrLrrrrr+s  r+c@seZdZdZdZdZ ddZddZej Z dd Z d d Z d d Z ddZ ddZddZddZddZddZddZddZddZdcd d!Zdcd"d#Zd$d%Zd&d'Zdcd(d)Zdcd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Z d6d7Z!d8d9Z"d:d;Z#dd?Z%d@dAZ&dBdCZ'dDdEZ(dFdGZ)dHdIZ*dJdKZ+dddMdNZ,dOdPZ-dQdRZ.dSdTZ/dUdVZ0dWdXZ1dYdZZ2d[d\Z3d]d^Z4d_d`Z5dadbZ6dS)eColumnOperatorsaDefines boolean, comparison, and other operators for :class:`.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:`.ColumnElement` overrides :meth:`.Operators.operate` and others to return further :class:`.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` rNcCr)zdImplement the ``<`` operator. In a column context, produces the clause ``a < b``. )rr rrrr__lt__Tr:zColumnOperators.__lt__cCr)zfImplement the ``<=`` operator. In a column context, produces the clause ``a <= b``. )rr rrrr__le__\r:zColumnOperators.__le__cCr)zImplement the ``==`` operator. In a column context, produces the clause ``a = b``. If the target is ``None``, produces ``a IS NULL``. )rrrrrrrEf zColumnOperators.__eq__cCr)zImplement the ``!=`` operator. In a column context, produces the clause ``a != b``. If the target is ``None``, produces ``a IS NOT NULL``. )rrrrrr__ne__orPzColumnOperators.__ne__cCr)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_fromrrrrrRx z ColumnOperators.is_distinct_fromcCr)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_fromrrrrrTrSz#ColumnOperators.isnot_distinct_fromcCr)zdImplement the ``>`` operator. In a column context, produces the clause ``a > b``. )rrrrrr__gt__r:zColumnOperators.__gt__cCr)zfImplement the ``>=`` operator. In a column context, produces the clause ``a >= b``. )rrrrrr__ge__r:zColumnOperators.__ge__cCr#)zaImplement the ``-`` operator. In a column context, produces the clause ``-a``. )rrr$rrr__neg__s zColumnOperators.__neg__cCrr&)rrrrrr __contains__s zColumnOperators.__contains__cCr)zImplement the [] operator. This can be used by some database-specific types such as PostgreSQL ARRAY and HSTORE. )rr)rindexrrr __getitem__rPzColumnOperators.__getitem__cCr)zimplement the << operator. Not used by SQLAlchemy core, this is provided for custom operator systems which want to use << as an extension point. )rr rrrr __lshift__rPzColumnOperators.__lshift__cCr)zimplement the >> operator. Not used by SQLAlchemy core, this is provided for custom operator systems which want to use >> as an extension point. )rrrrrr __rshift__rPzColumnOperators.__rshift__cCr)zImplement the 'concat' operator. In a column context, produces the clause ``a || b``, or uses the ``concat()`` operator on MySQL. )r concat_oprrrrconcatrPzColumnOperators.concatcC|jt||dS)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_oprrrarrrlikeszColumnOperators.likecCr_)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` r`)rilike_oprcrrrilikeszColumnOperators.ilikecCr)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 (?, ?, ?) * 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:`.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 The "expanding" feature in version 1.2 of SQLAlchemy does not support passing an empty list as a parameter value; however, version 1.3 does support this. * a :func:`.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:`.select` construct, or a :func:`.bindparam` construct that includes the :paramref:`.bindparam.expanding` flag set to True. )rin_oprrrrin_s NzColumnOperators.in_cCr)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:`.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_oprrrrnotin_Sr!zColumnOperators.notin_cCr_)zimplement the ``NOT LIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``. .. seealso:: :meth:`.ColumnOperators.like` r`)r notlike_oprcrrrnotlikek zColumnOperators.notlikecCr_)zimplement the ``NOT ILIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``. .. seealso:: :meth:`.ColumnOperators.ilike` r`)r notilike_oprcrrrnotilikexrmzColumnOperators.notilikecCr)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_rrrrrp zColumnOperators.is_cCr)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_` )risnotrrrrrrrqzColumnOperators.isnotcK|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_oprrr8rrr startswithVzColumnOperators.startswithcKrs)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_oprurrrendswithrwzColumnOperators.endswithcKrs)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_oprurrrrOsWzColumnOperators.containscKrs)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_oprurrrmatchszColumnOperators.matchcCr#)zMProduce a :func:`~.expression.desc` clause against the parent object.)rdesc_opr$rrrdesc zColumnOperators.desccCr#)zLProduce a :func:`~.expression.asc` clause against the parent object.)rasc_opr$rrrascrzColumnOperators.asccCr#)zSProduce a :func:`~.expression.nullsfirst` clause against the parent object.)r nullsfirst_opr$rrr nullsfirstrzColumnOperators.nullsfirstcCr#)zRProduce a :func:`~.expression.nullslast` clause against the parent object.)r nullslast_opr$rrr nullslastrzColumnOperators.nullslastcCr)zProduce a :func:`~.expression.collate` clause against the parent object, given the collation string. .. seealso:: :func:`~.expression.collate` )rcollate)r collationrrrrrSzColumnOperators.collatecCr)zaImplement the ``+`` operator in reverse. See :meth:`.ColumnOperators.__add__`. )r9rrrrr__radd__r:zColumnOperators.__radd__cCr)zaImplement the ``-`` operator in reverse. See :meth:`.ColumnOperators.__sub__`. )r9rrrrr__rsub__r:zColumnOperators.__rsub__cCr)zaImplement the ``*`` operator in reverse. See :meth:`.ColumnOperators.__mul__`. )r9rrrrr__rmul__r:zColumnOperators.__rmul__cCr)zaImplement the ``/`` operator in reverse. See :meth:`.ColumnOperators.__div__`. )r9rrrrr__rdiv__r:zColumnOperators.__rdiv__cCr)zaImplement the ``%`` operator in reverse. See :meth:`.ColumnOperators.__mod__`. )r9r rrrr__rmod__r:zColumnOperators.__rmod__FcCs|jt|||dS)z{Produce a :func:`~.expression.between` clause against the parent object, given the lower and upper range.  symmetric)r between_op)rcleftcrightrrrrbetweenszColumnOperators.betweencCr#)z[Produce a :func:`~.expression.distinct` clause against the parent object. )r distinct_opr$rrrdistincts zColumnOperators.distinctcCr#)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$rrrany_ zColumnOperators.any_cCr#)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$rrrall_(rzColumnOperators.all_cCr)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`. )rrrrrr__add__As zColumnOperators.__add__cCr)zdImplement the ``-`` operator. In a column context, produces the clause ``a - b``. )rrrrrr__sub__Mr:zColumnOperators.__sub__cCr)zdImplement the ``*`` operator. In a column context, produces the clause ``a * b``. )rrrrrr__mul__Ur:zColumnOperators.__mul__cCr)zdImplement the ``/`` operator. In a column context, produces the clause ``a / b``. )rrrrrr__div__]r:zColumnOperators.__div__cCr)zdImplement the ``%`` operator. In a column context, produces the clause ``a % b``. )rr rrrr__mod__er:zColumnOperators.__mod__cCr)zeImplement the ``//`` operator. In a column context, produces the clause ``a / b``. )rrrrrr __truediv__mr:zColumnOperators.__truediv__cCr)zfImplement the ``//`` operator in reverse. See :meth:`.ColumnOperators.__truediv__`. )r9rrrrr __rtruediv__ur:zColumnOperators.__rtruediv__r&F)7r;r<r=r>r? timetuplerNrOrrGrErQrRrTrUrVrWrXrZr[r\r^rdrfrhrjrlrorprrrvryrr|r~rrrrrrrrrrrrrrrrrrrrrrrrrM)sj%       P     XXY    rMcCtr&r5rrrrfrom_~rcCrr&rrrrras_rrcCrr&rrrrrexistsrrcCrr&rarrristruerrcCrr&rrrrrisfalserrcC ||Sr&)rRrbrrrrRr*rRcCrr&)rTrrrrrTr*rTcCrr&)rprrrrrpr*rpcCrr&)rrrrrrrrr*rrcCrr&)rrrrrrr*rcCs|||Sr&r1)rr,rrrrr0r0NcC|j||dSNr`)rdrrrarrrrbrrbcCrr)rlrrrrrkrrkcCrr)rfrrrrrerrecCrr)rorrrrrnrrnFcC|j|||dSNr)rrrcrrrrrrcCrr) notbetweenrrrr notbetween_oprrcCrr&)rhrrrrrgr*rgcCrr&)rjrrrrrir*ricC|Sr&)rrrrrrrHrcCrr&)rrrrrrrHrcCrr&)rrrrrrrHrcCsx|r6|dur td|durd}t|tjjstd|dvr(||||}|d|dd|d}|||dS) NTz;The autoescape parameter is now a simple boolean True/False/z*String value expected when autoescape=True)%_rrr`)rwarnrDcompat string_types TypeErrorreplace)fnrra autoescaperrr_escaped_like_impls rcCt|j|||Sr&rrvrrrarrrrrtrrtcCt|j|||Sr&rrrrrnotstartswith_oprcCrr&rryrrrrrxrrxcCrr&rrrrrnotendswith_oprrcCrr&rrrrrrrzrrzcCrr&rrrrrnotcontains_oprrcK|j|fi|Sr&)r|rrrKrrrr{rr{cKrr&)notmatchrrrr notmatch_oprrcCrr&rrrrrcomma_op rrcCrr&rrrrr empty_in_oprrcCrr&rrrrrempty_notin_oprrcCrr&)r^rrrrr]r*r]cCrr&)r~rrrrr}rHr}cCrr&)rrrrrrrHrcCrr&)rrrrrr"rHrcCrr&)rrrrrr&rHrcCrr&rrrrrjson_getitem_op*rrcCrr&rrrrrjson_path_getitem_op.rrcC|tvp t|to |jSr&) _comparisonrDr+r.r1rrrr.Dsr.cCs|tvSr&) _commutativer1rrris_commutativeHrHrcCs|ttttfvSr&)rr}rrr1rrris_ordering_modifierLrrcCrr&)_natural_self_precedentrDr+r@r1rrris_natural_self_precedentPs rcCst|p|tvSr&)r. _booleansr1rrr is_boolean[rrcCs t||S)z[rotate a comparison operator 180 degrees. Note this is not the same as negation. )_mirrorgetr1rrrmirrorbr:r_asbooli) canonical _smallesti_largestdcCs<||ur t|r dSt|t|dtt|t|dtkS)NFr-)r _PRECEDENCErgetattrrr)r(r)rrr is_precedents rr&r)NF)Zr>r(rrrrrrrr r r r r rrrrrrrrpy2krobjectrr+rMrrrrrrRrTrprrrr0rbrkrernrrrgrirrrrrtrrxrrzrr{rrrrr]r}rrrrrrrr.rrrrrrrunion difference _associativersymbolrrrrrrrrrs                    H8[                    !"#$%&'()*+,-./0123 7