,h+%SrSSKJr SSKJr SSKJr SSKJr SSKJ r SSKJ r SSKJr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJ r! SSKJ"r# SSKJ$r% SSKJ&r' SSKJ(r) SSKJ*r+ SSKJ,r- SSK.r.SSK.J/r/ SSK.J0r0 SSK.J1r1 SSK.J2r2 SSK.J3r3 SSK.J4r4 SSK.J5r5 SS K.J6r6 SS!K.J7r7 SS"K.J8r8 SS#K.J9r9 SS$K.J:r: SS%K.J;r; S&S'Kr> S&S)K?J@r@ S&S*K?JArA \.Rr(aS+S,KBJCrC S+S-KDJErE S+S.KFJGrG S+S/KHJIrI \:"S0\/S19rJ\:"S2\0S3\/4S19rK"S4S5\A5rL\1"\L\5r\1"\L\ 5r\1"\L\ 5r \1"\L\ 5r \1"\L\5r\1"\L\5r\1"\L\5r\1"\L\5r\1"\L\5r\1"\L\5r\1"\L\5r\1"\L\5r\1"\L\5r\1"\L\!5r \1"\L\#5r"\1"\L\%5r$\1"\L\'5r&\1"\L\)5r(\1"\L\+5r*\1"\L\-5r,"S6S75rM"S8S9\L\3\J5rN"S:S;\M5rO\ \"\\ 1rPS<\QS='\ \"\\\\1rRS<\QS>'SS?jrSSS@jrTSSAjrU\SSSBj5rV\S\USSCj55rW\SSSDj5rX\SSSEj5rY\SSSFj5rZ\9(a \SSSGj5r[O\Zr[\SSSHj5r\\9(a \SSSIj5r]O\\r]\U\SSSJj55r^\U\SSSKj55r_\9(a \SSSLj5r`O\_r`\U\SSSMj55ra\U\SSSNj55rb\9(a \SSSOj5rcO\brc\SSSPj5rd\SSSQj5re\U\SSSSRjj55rf\U\SSSSSjj55rg\9(a \SSSSTjj5rhO\grh\U\SSSSUjj55ri\U\SSSSVjj55rj\9(a \SSSSWjj5rkO\jrk\U\SSSSXjj55rl\U\SSSSYjj55rm\9(a\SSSSZjj5rnO\mrn\U\SSS[j55ro\U\SSS\j55rp\9(a \SSS]j5rqO\prq\SSS^j5rr\SSS_j5rs\SSS`j5rtSSajru\U\SSSSbjj55rv\U\SSSScjj55rw\9(a\SSSSdjj5rxO\wrx\U\SSSSejj55ry\U\SSSSfjj55rz\U\SSSSgjj55r{\U\SSSShjj55r|\9(a\SSSSijj5r}O\|r}\U\SSSSjjj55r~\U\SSSSkjj55r\U\SSSSljj55r\U\SSSSmjj55r\9(a\SSSSnjj5rO\r\U\SSSSojj55r\U\SSSSpjj55r\U\SSSqj55r\U\SSSSrjj55r\U\SSSSsjj55r\SSSStjj5r\U\SSSuj55r\9(a \SSSvj5rO\r\SSSwj5r\SSSxj5r\SSSyj5r\SSSzj5r\SSS{j5r\SSS|j5r\9(a \SSS}j5rO\r\SSS~j5r\9(a \SSSj5rO\r\SSSj5r\SSSj5r\SSSj5r\SSSj5r\SSSj5r\SSSj5r\SSSj5r\SSSj5rSSjrSSjrSSjrSSjr\\Z\\\\&4rSSjr\\\\\\\\0rSSjr\PGRI\\\&/5GRK\ \"/5rSSjrSSjr\\\\1r\GRI\\\/5r\SSSj5r"SS\5r0\VS_\WS_\sS_\tS_\S_\S_\S_\ S_\,S_\S_\S_\$S_\S_\S_\*S_\S_\S_0\S_\S_\S_\S_\S_\S_\S_\S_\S_\S_\iS_\jS_\fS_\gS_\oS_\pS_\aS_E0\bS_\ S_\"S_\^S_\_S_\S_\S_\S_\S_\lS_\mS_\rS_\S_\ZS_\\S_\S_\&S&_E\S\S\S\dS\XS\YS\S0ErS\QS'SSjrg)z*Defines operators used in SQL expressions.) annotations)IntEnum)add)and_)contains)eq)floordiv)ge)getitem)gt)inv)le)lshift)lt)mod)mul)ne)neg)or_)rshift)sub)truedivN)Any)Callable)cast)Dict)Generic)Optional)overload)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union)exc)util)Literal)Protocol)ColumnExpressionArgument) CacheConst) ColumnElement) TypeEngine_T)bound_FN.c\rSrSr%SrSrS\S'\S S Sjj5r\S S Sjj5rS S S jjrSr g) OperatorTypeBzdescribe an op() function.str__name__NcgNr6selfleftrightotherkwargss P/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/sql/operators.py__call__OperatorType.__call__I!cgr:r6r;s rArBrCRrEcgr:r6r;s rArBrC[s rEr: r=zColumnExpressionArgument[Any]r> Optional[Any]r?rr@rreturnzColumnElement[Any] r= Operatorsr>rJr?rr@rrKrM r=rr>rJr?rr@rrKrM) r8 __module__ __qualname____firstlineno____doc__ __slots____annotations__rrB__static_attributes__r6rErAr4r4Bs$IM  $!+!! !  !  !! $      $     rEr4c\rSrSrSrSrS SjrS SjrS SjrSSSjjr SSS jjr SS jr \ r SS jr Srg)rMzaBase 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`. r6c.UR[U5$)aImplement 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) )operaterr<r?s rA__and__Operators.__and__s.||D%((rEc.UR[U5$)aImplement 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) )rYrrZs rA__or__Operators.__or__s.||C''rEc,UR[5$)zImplement 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) )rYr r<s rA __invert__Operators.__invert__s ||C  rENc6^^[UUUUUS9mSUU4SjjnU$)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 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 .. seealso:: :meth:`.Operators.bool_op` :ref:`types_operators` :ref:`relationship_custom_operator` ) python_implc>T"TU5$r:r6)r?operatorr<s rAagainstOperators.op..against5sD%( (rEr?rrKrM) custom_op)r<opstring precedence is_comparison return_typererhrgs` @rAop Operators.ops0|    #   ) )rEc&URUUSUS9$)aReturn 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` T)rmrnrerp)r<rlrmres rAbool_opOperators.bool_op:s&(ww !#   rEc*[[U55e)aOperate 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`. NotImplementedErrorr7r<rpr?r@s rArYOperators.operateUs4"#b'**rEc *[[U55e)zHReverse operate on an argument. Usage is the same as :meth:`operate`. rwrys rAreverse_operateOperators.reverse_operatess"#b'**rErj)rKrM)rFNN) rlr7rmintrnboolroz7Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]]reOptional[Callable[..., Any]]rKCallable[[Any], Operators])rN)rlr7rmr~rerrKr)rpr4r?rr@rrKrM)r8rOrPrQrRrSr[r^rbrprtrY__sa_operate__r|rUr6rErArMrMzs I)2(2!*# 48iii i  i2i $i\48    2  $  6++(++7:+ +8N++'*+69+ +rErMc\rSrSrSrSrSrS SSjjrSSjrSSjrSSjr \ SSS jj5r \ SSS jj5r SSS jjr S r g)rki~a}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` )rlrmrnnatural_self_precedenteager_groupingroreNcXlX lX0lXPlX`lU(aUR U5OSUlXplgr:)rlrmrnrr _to_instancerore)r<rlrmrnrorrres rA__init__custom_op.__init__sB! $*&<#,5@K $ $[ 1d 'rEcr[U[5=(a! UR5UR5:H$r:) isinstancerk _hash_keyrZs rA__eq__custom_op.__eq__s, ui ( 6!T^^%55 rEc4[UR55$r:)hashrras rA__hash__custom_op.__hash__sDNN$%%rEcURURURURURUR UR (aUR R4$S4$r:) __class__rlrmrnrrro_static_cache_keyras rArcustom_op._hash_keysd NN MM OO     ' '   262B2BD   . .  IM  rEcgr:r6r;s rArBcustom_op.__call__rDrEcgr:r6r;s rArBrrGrEc[US5(aUR"X/UQ70UD6$UR(aUR"X/UQ70UD6$[R"SUR <S35e)NrzCustom operator zX can't be used with plain Python objects unless it includes the 'python_impl' parameter.)hasattrrYrer'InvalidRequestErrorrlr;s rArBrsx 4) * *<<>e>v> >   ##DB%B6B B))"4=="34++ rE)rrnrrlrmrero)rFNFFN)rlr7rmr~rnrroz5Optional[Union[Type[TypeEngine[_T]], TypeEngine[_T]]]rrrrrer)r?rrKrrKr~)rKz"Union[CacheConst, Tuple[Any, ...]]r:rIrLrN) r8rOrPrQrRrSrrrrrrBrUr6rErArkrk~sT0HI# ',$48''' '  '!%''2', &   $!+!! !  !  !! $      $     rErkc\rSrSr%SrSrSrS\S'\R(aSLSjr SLSjr SMS jr SMS jr \ (aSNS jrO \RrSMS jrSMS jrSMSjrSMSjr\ (aSMSjrO\rSMSjrSMSjrSOSjrSMSjrSPSjrSMSjrSMSjrSMSjrSMSjrSQSRSjjrSQSRSjjrSMSjr SMSjr!SMSjr"SOSjr#SMS jr$SMS!jr%SMS"jr&SMS#jr'\ (aSMS$jr(O\'r(SQSRS%jjr)\ (aSQSRS&jjr*O\)r*SQSRS'jjr+\ (aSQSRS(jjr,O\+r,SMS)jr-SMS*jr.\ (aSMS+jr/O\.r/SSSTS,jjr0SSSTS-jjr1SSSTS.jjr2SSSTS/jjr3SUS0jr4SUS1jr5SVS2jr6SQSWS3jjr7SQSXS4jjr8SOS5jr9SOS6jr:SOS7jr;\ (aSOS8jrO\=r>SYS;jr?SMS<jr@SMS=jrASMS>jrBSMS?jrCSZS[S@jjrDSOSAjrESOSBjrFSOSCjrGSMSDjrHSMSEjrISMSFjrJSMSGjrKSMSHjrLSMSIjrMSMSJjrNSMSKjrOSrPg)\ColumnOperatorsiaDefines 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` r6Nz Literal[None] timetuplecgr:r6rys rArYColumnOperators.operate!rEc gr:r6rys rAr|ColumnOperators.reverse_operate#rrEc.UR[U5$)zTImplement the ``<`` operator. In a column context, produces the clause ``a < b``. )rYrrZs rA__lt__ColumnOperators.__lt__' ||B&&rEc.UR[U5$)zVImplement the ``<=`` operator. In a column context, produces the clause ``a <= b``. )rYrrZs rA__le__ColumnOperators.__le__/rrEcgr:r6ras rArColumnOperators.__hash__<s3rEc.UR[U5$)zImplement the ``==`` operator. In a column context, produces the clause ``a = b``. If the target is ``None``, produces ``a IS NULL``. )rYrrZs rArColumnOperators.__eq__A||B&&rEc.UR[U5$)zImplement the ``!=`` operator. In a column context, produces the clause ``a != b``. If the target is ``None``, produces ``a IS NOT NULL``. )rYrrZs rA__ne__ColumnOperators.__ne__JrrEc.UR[U5$)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". )rYis_distinct_fromrZs rAr ColumnOperators.is_distinct_fromSs||,e44rEc.UR[U5$)a]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. )rYis_not_distinct_fromrZs rAr$ColumnOperators.is_not_distinct_from\s||0%88rEcgr:r6rZs rAisnot_distinct_from#ColumnOperators.isnot_distinct_fromlscrEc.UR[U5$)zTImplement the ``>`` operator. In a column context, produces the clause ``a > b``. )rYr rZs rA__gt__ColumnOperators.__gt__qrrEc.UR[U5$)zVImplement the ``>=`` operator. In a column context, produces the clause ``a >= b``. )rYr rZs rA__ge__ColumnOperators.__ge__yrrEc,UR[5$)zQImplement the ``-`` operator. In a column context, produces the clause ``-a``. )rYrras rA__neg__ColumnOperators.__neg__s ||C  rEc.UR[U5$r:)rYrrZs rA __contains__ColumnOperators.__contains__s||He,,rEc.UR[U5$)zsImplement the [] operator. This can be used by some database-specific types such as PostgreSQL ARRAY and HSTORE. )rYr )r<indexs rA __getitem__ColumnOperators.__getitem__s||GU++rEc.UR[U5$)zimplement the << operator. Not used by SQLAlchemy core, this is provided for custom operator systems which want to use << as an extension point. )rYrrZs rA __lshift__ColumnOperators.__lshift__||FE**rEc.UR[U5$)zimplement the >> operator. Not used by SQLAlchemy core, this is provided for custom operator systems which want to use >> as an extension point. )rYrrZs rA __rshift__ColumnOperators.__rshift__rrEc.UR[U5$)zImplement the 'concat' operator. In a column context, produces the clause ``a || b``, or uses the ``concat()`` operator on MySQL. )rY concat_oprZs rAconcatColumnOperators.concats||Iu--rEc.UR[U5$)zdImplement an 'rconcat' operator. this is for internal use at the moment .. versionadded:: 1.4.40 )r|rrZs rA_rconcatColumnOperators._rconcats##Iu55rEc*UR[XS9$)aImplement 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` escape)rYlike_opr<r?rs rAlikeColumnOperators.likes4||GU|::rEc*UR[XS9$)a;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` r)rYilike_oprs rAilikeColumnOperators.ilikes@||He|;;rEc.UR[U5$)zProduce a bitwise XOR operation, typically via the ``^`` operator, or ``#`` for PostgreSQL. .. versionadded:: 2.0.2 .. seealso:: :ref:`operators_bitwise` )rYbitwise_xor_oprZs rA bitwise_xorColumnOperators.bitwise_xor||NE22rEc.UR[U5$)zProduce a bitwise OR operation, typically via the ``|`` operator. .. versionadded:: 2.0.2 .. seealso:: :ref:`operators_bitwise` )rY bitwise_or_oprZs rA bitwise_orColumnOperators.bitwise_ors||M511rEc.UR[U5$)zProduce a bitwise AND operation, typically via the ``&`` operator. .. versionadded:: 2.0.2 .. seealso:: :ref:`operators_bitwise` )rYbitwise_and_oprZs rA bitwise_andColumnOperators.bitwise_andrrEc,UR[5$)zProduce a bitwise NOT operation, typically via the ``~`` operator. .. versionadded:: 2.0.2 .. seealso:: :ref:`operators_bitwise` )rYbitwise_not_opras rA bitwise_notColumnOperators.bitwise_not"s||N++rEc.UR[U5$)zProduce a bitwise LSHIFT operation, typically via the ``<<`` operator. .. versionadded:: 2.0.2 .. seealso:: :ref:`operators_bitwise` )rYbitwise_lshift_oprZs rAbitwise_lshiftColumnOperators.bitwise_lshift0||-u55rEc.UR[U5$)zProduce a bitwise RSHIFT operation, typically via the ``>>`` operator. .. versionadded:: 2.0.2 .. seealso:: :ref:`operators_bitwise` )rYbitwise_rshift_oprZs rAbitwise_rshiftColumnOperators.bitwise_rshift>rrEc.UR[U5$)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: .. sourcecode:: sql 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 an "empty set" expression. These expressions are tailored to individual backends and are generally trying to get an empty SELECT statement as a subquery. Such as on SQLite, the expression is: .. sourcecode:: sql WHERE col IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1) .. versionchanged:: 1.4 empty IN expressions now use an execution-time generated SELECT subquery in all cases. * 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: .. sourcecode:: sql 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: .. sourcecode:: sql 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: .. sourcecode:: sql 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: .. sourcecode:: sql 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. )rYin_oprZs rAin_ColumnOperators.in_LsF||E5))rEc.UR[U5$)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.4 The ``not_in()`` operator is renamed from ``notin_()`` in previous releases. The previous name remains available for backwards compatibility. .. versionchanged:: 1.2 The :meth:`.ColumnOperators.in_` and :meth:`.ColumnOperators.not_in` operators now produce a "static" expression for an empty IN sequence by default. .. seealso:: :meth:`.ColumnOperators.in_` )rY not_in_oprZs rAnot_inColumnOperators.not_ins4||Iu--rEcgr:r6rZs rAnotin_ColumnOperators.notin_srEc*UR[XS9$)agimplement the ``NOT LIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``. .. versionchanged:: 1.4 The ``not_like()`` operator is renamed from ``notlike()`` in previous releases. The previous name remains available for backwards compatibility. .. seealso:: :meth:`.ColumnOperators.like` r)rY not_like_oprs rAnot_likeColumnOperators.not_likes"||K|>>rEcgr:r6rs rAnotlikeColumnOperators.notlikerrEc*UR[XS9$)amimplement the ``NOT ILIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``. .. versionchanged:: 1.4 The ``not_ilike()`` operator is renamed from ``notilike()`` in previous releases. The previous name remains available for backwards compatibility. .. seealso:: :meth:`.ColumnOperators.ilike` r)rY not_ilike_oprs rA not_ilikeColumnOperators.not_ilikes"||L%|??rEcgr:r6rs rAnotilikeColumnOperators.notilikerrEc.UR[U5$)a'Implement 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.is_not` )rYis_rZs rArColumnOperators.is_s||C''rEc.UR[U5$)aImplement 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. .. versionchanged:: 1.4 The ``is_not()`` operator is renamed from ``isnot()`` in previous releases. The previous name remains available for backwards compatibility. .. seealso:: :meth:`.ColumnOperators.is_` )rYis_notrZs rArColumnOperators.is_nots||FE**rEcgr:r6rZs rAisnotColumnOperators.isnot0srEc,UR[XUS9$)a Implement the ``startswith`` operator. Produces a LIKE expression that tests against a match for the start of a string value: .. sourcecode:: sql 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: .. sourcecode:: sql 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.startswith("foo/%bar", escape="^") Will render as: .. sourcecode:: sql 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 autoescape)rY startswith_opr<r?rr%s rA startswithColumnOperators.startswith5s"n|| 5J  rEc,UR[XUS9$)a6 Implement the ``istartswith`` operator, e.g. case insensitive version of :meth:`.ColumnOperators.startswith`. Produces a LIKE expression that tests against an insensitive match for the start of a string value: .. sourcecode:: sql lower(column) LIKE lower() || '%' E.g.:: stmt = select(sometable).where(sometable.c.column.istartswith("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.istartswith.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.istartswith.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.istartswith.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.istartswith("foo%bar", autoescape=True) Will render as: .. sourcecode:: sql lower(somecolumn) LIKE lower(: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.istartswith("foo/%bar", escape="^") Will render as: .. sourcecode:: sql lower(somecolumn) LIKE lower(:param) || '%' ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.istartswith.autoescape`:: somecolumn.istartswith("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` r$)rYistartswith_opr's rA istartswithColumnOperators.istartswiths"f|| EZ  rEc,UR[XUS9$)a Implement the 'endswith' operator. Produces a LIKE expression that tests against a match for the end of a string value: .. sourcecode:: sql 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: .. sourcecode:: sql 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.endswith("foo/%bar", escape="^") Will render as: .. sourcecode:: sql 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$)rY endswith_opr's rAendswithColumnOperators.endswiths"n|| *  rEc,UR[XUS9$)a Implement the ``iendswith`` operator, e.g. case insensitive version of :meth:`.ColumnOperators.endswith`. Produces a LIKE expression that tests against an insensitive match for the end of a string value: .. sourcecode:: sql lower(column) LIKE '%' || lower() E.g.:: stmt = select(sometable).where(sometable.c.column.iendswith("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.iendswith.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.iendswith.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.iendswith.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.iendswith("foo%bar", autoescape=True) Will render as: .. sourcecode:: sql lower(somecolumn) LIKE '%' || lower(: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.iendswith("foo/%bar", escape="^") Will render as: .. sourcecode:: sql lower(somecolumn) LIKE '%' || lower(:param) ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.iendswith.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.endswith` r$)rY iendswith_opr's rA iendswithColumnOperators.iendswithBs"f|| %:  rEc 2UR"[U40UD6$)a Implement the 'contains' operator. Produces a LIKE expression that tests against a match for the middle of a string value: .. sourcecode:: sql 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: .. sourcecode:: sql 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: .. sourcecode:: sql 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` )rY contains_opr<r?kws rArColumnOperators.containssf||K5"55rEc 2UR"[U40UD6$)a6 Implement the ``icontains`` operator, e.g. case insensitive version of :meth:`.ColumnOperators.contains`. Produces a LIKE expression that tests against an insensitive match for the middle of a string value: .. sourcecode:: sql lower(column) LIKE '%' || lower() || '%' E.g.:: stmt = select(sometable).where(sometable.c.column.icontains("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.icontains.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.icontains.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.icontains.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.icontains("foo%bar", autoescape=True) Will render as: .. sourcecode:: sql lower(somecolumn) LIKE '%' || lower(: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.icontains("foo/%bar", escape="^") Will render as: .. sourcecode:: sql lower(somecolumn) LIKE '%' || lower(:param) || '%' ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.contains.autoescape`:: somecolumn.icontains("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.contains` )rY icontains_opr8s rA icontainsColumnOperators.icontainss^||L%6266rEc 2UR"[U40UD6$)a<Implements a database-specific 'match' operator. :meth:`_sql.ColumnOperators.match` attempts to resolve to a MATCH-like function or operator provided by the backend. Examples include: * PostgreSQL - renders ``x @@ plainto_tsquery(y)`` .. versionchanged:: 2.0 ``plainto_tsquery()`` is used instead of ``to_tsquery()`` for PostgreSQL now; for compatibility with other forms, see :ref:`postgresql_match`. * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)`` .. seealso:: :class:`_mysql.match` - MySQL specific construct with additional features. * Oracle Database - 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. )rYmatch_op)r<r?r@s rAmatchColumnOperators.match?s8||He6v66rEc*UR[XS9$)aImplements a database-specific 'regexp match' operator. E.g.:: stmt = select(table.c.some_column).where( table.c.some_column.regexp_match("^(b|c)") ) :meth:`_sql.ColumnOperators.regexp_match` attempts to resolve to a REGEXP-like function or operator provided by the backend, however the specific regular expression syntax and flags available are **not backend agnostic**. Examples include: * PostgreSQL - renders ``x ~ y`` or ``x !~ y`` when negated. * Oracle Database - renders ``REGEXP_LIKE(x, y)`` * SQLite - uses SQLite's ``REGEXP`` placeholder operator and calls into the Python ``re.match()`` builtin. * other backends may provide special implementations. * Backends without any special implementation will emit the operator as "REGEXP" or "NOT REGEXP". This is compatible with SQLite and MySQL, for example. Regular expression support is currently implemented for Oracle Database, PostgreSQL, MySQL and MariaDB. Partial support is available for SQLite. Support among third-party dialects may vary. :param pattern: The regular expression pattern string or column clause. :param flags: Any regular expression string flags to apply, passed as plain Python string only. These flags are backend specific. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern. When using the ignore case flag 'i' in PostgreSQL, the ignore case regexp match operator ``~*`` or ``!~*`` will be used. .. versionadded:: 1.4 .. versionchanged:: 1.4.48, 2.0.18 Note that due to an implementation error, the "flags" parameter previously accepted SQL expression objects such as column expressions in addition to plain Python strings. This implementation did not work correctly with caching and was removed; strings only should be passed for the "flags" parameter, as these flags are rendered as literal inline values within SQL expressions. .. seealso:: :meth:`_sql.ColumnOperators.regexp_replace` flags)rYregexp_match_op)r<patternrEs rA regexp_matchColumnOperators.regexp_match]sp||OW|BBrEc.UR[UUUS9$)aImplements a database-specific 'regexp replace' operator. E.g.:: stmt = select( table.c.some_column.regexp_replace("b(..)", "XY", flags="g") ) :meth:`_sql.ColumnOperators.regexp_replace` attempts to resolve to a REGEXP_REPLACE-like function provided by the backend, that usually emit the function ``REGEXP_REPLACE()``. However, the specific regular expression syntax and flags available are **not backend agnostic**. Regular expression replacement support is currently implemented for Oracle Database, PostgreSQL, MySQL 8 or greater and MariaDB. Support among third-party dialects may vary. :param pattern: The regular expression pattern string or column clause. :param pattern: The replacement string or column clause. :param flags: Any regular expression string flags to apply, passed as plain Python string only. These flags are backend specific. Some backends, like PostgreSQL and MariaDB, may alternatively specify the flags as part of the pattern. .. versionadded:: 1.4 .. versionchanged:: 1.4.48, 2.0.18 Note that due to an implementation error, the "flags" parameter previously accepted SQL expression objects such as column expressions in addition to plain Python strings. This implementation did not work correctly with caching and was removed; strings only should be passed for the "flags" parameter, as these flags are rendered as literal inline values within SQL expressions. .. seealso:: :meth:`_sql.ColumnOperators.regexp_match`  replacementrE)rYregexp_replace_op)r<rGrLrEs rAregexp_replaceColumnOperators.regexp_replaces'Z||  #   rEc,UR[5$)zDProduce a :func:`_expression.desc` clause against the parent object.)rYdesc_opras rAdescColumnOperators.descs||G$$rEc,UR[5$)zCProduce a :func:`_expression.asc` clause against the parent object.)rYasc_opras rAascColumnOperators.ascs||F##rEc,UR[5$)aProduce 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. )rYnulls_first_opras rA nulls_firstColumnOperators.nulls_firsts||N++rEcgr:r6ras rA nullsfirstColumnOperators.nullsfirstsrEc,UR[5$)zProduce 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. )rY nulls_last_opras rA nulls_lastColumnOperators.nulls_lasts||M**rEcgr:r6ras rA nullslastColumnOperators.nullslastsrEc.UR[U5$)zProduce a :func:`_expression.collate` clause against the parent object, given the collation string. .. seealso:: :func:`_expression.collate` )rYcollate)r< collations rArgColumnOperators.collates||GY//rEc.UR[U5$)zQImplement the ``+`` operator in reverse. See :meth:`.ColumnOperators.__add__`. )r|rrZs rA__radd__ColumnOperators.__radd__ ##C//rEc.UR[U5$)zQImplement the ``-`` operator in reverse. See :meth:`.ColumnOperators.__sub__`. )r|rrZs rA__rsub__ColumnOperators.__rsub__ rmrEc.UR[U5$)zQImplement the ``*`` operator in reverse. See :meth:`.ColumnOperators.__mul__`. )r|rrZs rA__rmul__ColumnOperators.__rmul__rmrEc.UR[U5$)zQImplement the ``%`` operator in reverse. See :meth:`.ColumnOperators.__mod__`. )r|rrZs rA__rmod__ColumnOperators.__rmod__rmrEc,UR[XUS9$)zjProduce a :func:`_expression.between` clause against the parent object, given the lower and upper range.  symmetric)rY between_op)r<cleftcrightrys rAbetweenColumnOperators.between$s||J|KKrEc,UR[5$)zJProduce a :func:`_expression.distinct` clause against the parent object. )rY distinct_opras rAdistinctColumnOperators.distinct-s ||K((rEc,UR[5$)aProduce an :func:`_expression.any_` clause against the parent object. See the documentation for :func:`_sql.any_` for examples. .. note:: be sure to not confuse the newer :meth:`_sql.ColumnOperators.any_` method with the **legacy** version of this method, the :meth:`_types.ARRAY.Comparator.any` method that's specific to :class:`_types.ARRAY`, which uses a different calling style. )rYany_opras rAany_ColumnOperators.any_4||F##rEc,UR[5$)aProduce an :func:`_expression.all_` clause against the parent object. See the documentation for :func:`_sql.all_` for examples. .. note:: be sure to not confuse the newer :meth:`_sql.ColumnOperators.all_` method with the **legacy** version of this method, the :meth:`_types.ARRAY.Comparator.all` method that's specific to :class:`_types.ARRAY`, which uses a different calling style. )rYall_opras rAall_ColumnOperators.all_CrrEc.UR[U5$)aImplement 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`. )rYrrZs rA__add__ColumnOperators.__add__Rs||C''rEc.UR[U5$)zTImplement the ``-`` operator. In a column context, produces the clause ``a - b``. )rYrrZs rA__sub__ColumnOperators.__sub__^ ||C''rEc.UR[U5$)zTImplement the ``*`` operator. In a column context, produces the clause ``a * b``. )rYrrZs rA__mul__ColumnOperators.__mul__frrEc.UR[U5$)zTImplement the ``%`` operator. In a column context, produces the clause ``a % b``. )rYrrZs rA__mod__ColumnOperators.__mod__nrrEc.UR[U5$)a#Implement the ``/`` operator. In a column context, produces the clause ``a / b``, and considers the result type to be numeric. .. versionchanged:: 2.0 The truediv operator against two integers is now considered to return a numeric value. Behavior on specific backends may vary. )rYrrZs rA __truediv__ColumnOperators.__truediv__vs||GU++rEc.UR[U5$)zUImplement the ``/`` operator in reverse. See :meth:`.ColumnOperators.__truediv__`. )r|rrZs rA __rtruediv__ColumnOperators.__rtruediv__s ##GU33rEc.UR[U5$)zImplement the ``//`` operator. In a column context, produces the clause ``a / b``, which is the same as "truediv", but considers the result type to be integer. .. versionadded:: 2.0 )rYr rZs rA __floordiv__ColumnOperators.__floordiv__s||He,,rEc.UR[U5$)zWImplement the ``//`` operator in reverse. See :meth:`.ColumnOperators.__floordiv__`. )r|r rZs rA __rfloordiv__ColumnOperators.__rfloordiv__s ##He44rE)rpr4r?rr@rrKr)r?rrKrr)rKr)rrrKrr:)r?rr Optional[str]rKrNF)r?rrrr%rrKr)r?rr9rrKr)r?rr@rrKr)rGrrErrKr)rGrrLrrErrKr)rhr7rKrF)r{rr|rryrrKr)Qr8rOrPrQrRrSrrTtypingr#rYr|rrrrMrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr!r(r,r0r4rr=rArHrNrRrVrZr]rardrgrkrorrrur}rrrrrrrrrrrrUr6rErArrs#JI#I}#B  "" ",/ ";> "  " "" "+. ":= "  "''&%%''5 9I3''!-,++.637;;"/; ;:37 < <"/ <  488C8C#08C 8CvFJ2 2 ),2 5B2 2 h% $ ,4! +3  00000:?LL"%L26L L) $ $ (((( ,4 -5rErzSet[Any] _commutative _comparisonc"[[U5$r:)rr4fns rA _operator_fnrs  b !!rEc0[RU5 U$r:)rrrs rAcommutative_oprsR IrEc0[RU5 U$r:)rrrs rA comparison_oprsOOB IrEc[5er:rxr6rErAfrom_r  rEc[5er:rr6rErAfunction_as_comparison_oprs   rEc[5er:rr6rErAas_rrrEc[5er:rr6rErAexistsrrrEc[5er:ras rAis_truerrrEcgr:r6rs rAistruers"rEc[5er:rrs rAis_falserrrEcgr:r6rs rAisfalsers #rEc$URU5$r:)rrbs rArrs  a  rEc$URU5$r:)rrs rArrs ! !! $$rEcgr:r6rs rArrs47rEc$URU5$r:)rrs rArr 558OrEc$URU5$r:)rrs rArr 88A;rEcgr:r6rs rAr!r! &)rEc$URU5$r:)rgrs rArgrgs 99Q<rEc0URU5"U5$r:rs)rrlrs rArprps 44>! rEc URXS9$Nr)rrrrs rArrs 66!6 ##rEc URXS9$r)rrs rAr r !s 99Q9 &&rEcgr:r6rs rA notlike_opr*sILrEc URXS9$r)rrs rArr1s 7717 $$rEc URXS9$r)rrs rArr7s ;;q; ((rEcgr:r6rs rA notilike_opr@sJMrEc"URXUS9$Nrxr}rrcrys rArzrzGs 99QY9 //rEc$URXUS9)$rrrs rAnot_between_oprMs IIaiI 0 00rEcgr:r6rs rA notbetween_oprVrEc$URU5$r:)rrs rArr_rrEc$URU5$r:)rrs rArrerrEcgr:r6rs rAnotin_oprns),rEc"UR5$r:)rrs rArrus ::<rEc"UR5$r:)rrs rArrz 668OrEc"UR5$r:)rrs rArrrrEc U(aUSLa[R"S5 UcSn[U[5(d [ S5eUS;aUR X"U-5nUR SUS-5R SUS-5nU"XS9$) NTz;The autoescape parameter is now a simple boolean True/False/z*String value expected when autoescape=True)%_rrr)r(warnrr7 TypeErrorreplace)rr?rr%s rA_escaped_like_implrs T ! IIM  >F%%%HI I  #MM&6/:E c6C<088fslK e ##rEc0[URXU5$r:rr(rrrr%s rAr&r&s allAz BBrEc2[URXU5)$r:rrs rAnot_startswith_oprs q||Q C CCrEcgr:r6rs rAnotstartswith_oprrrEc0[URXU5$r:rr,rs rAr+r+s ammQ CCrEc2[URXU5)$r:rrs rAnot_istartswith_oprs q}}a D DDrEc0[URXU5$r:rr0rs rAr/r/ ajj!Z @@rEc2[URXU5)$r:rrs rAnot_endswith_opr qzz1j A AArEcgr:r6rs rAnotendswith_opr rrEc0[URXU5$r:rr4rs rAr3r3 akk1j AArEc2[URXU5)$r:r rs rAnot_iendswith_opr q{{Az B BBrEc0[URXU5$r:rrrs rAr7r7rrEc2[URXU5)$r:rrs rAnot_contains_oprrrEcgr:r6rs rAnotcontains_opr rrEc0[URXU5$r:rr=rs rAr<r< r rEc2[URXU5)$r:rrs rAnot_icontains_opr rrEc (UR"U40UD6$r:rArrr9s rAr@r@ s 771  rEc URXS9$NrDrHrrrEs rArFrF$ s >>!> ))rEc"URXS9)$rr r!s rAnot_regexp_match_opr#* s NN1N * **rEc"URXUS9$)NrK)rN)rrrLrEs rArMrM0 s  Ae  DDrEc *UR"U40UD6)$r:rrs rA not_match_opr&7 s GGA   rEc gr:r6rs rA notmatch_opr(@ s7:rEc[5er:rrs rAcomma_opr*G rrEc[5er:rrs rA filter_opr,L rrEcnURnU"U5$![a URU5s$f=fr:)rAttributeErrorr)rrrs rArrQ s;ay zz!}s 44c"UR5$r:)rRrs rArQrQ[ rrEc"UR5$r:)rVrs rArUrU` s 557NrEc"UR5$r:)rZrs rArYrYe  ==?rEcgr:r6rs rA nullsfirst_opr4m rrEc"UR5$r:)rars rAr`r`t s <<>rEcgr:r6rs rA nullslast_opr7| s%(rEc[5er:rrs rAjson_getitem_opr9 rrEc[5er:rrs rAjson_path_getitem_opr; rrEc$URU5$r:)rrs rArr  == rEc$URU5$r:)rrs rArr s <<?rEc$URU5$r:)rrs rArr r=rEc"UR5$r:)rrs rArr r2rEc$URU5$r:)rrs rArr   A rEc$URU5$r:)rrs rArr rBrEchU[;=(d# [U[5=(a UR$r:)rrrkrnrss rArnrn s$   N 2y 9 Nb>N>NNrEcU[;$r:)rrss rAis_commutativerF  rEc4U[[[[4;$r:)rUrQrYr`rss rAis_ordering_modifierrI s &'>=A AArEchU[;=(d# [U[5=(a UR$r:)_natural_self_precedentrrkrrss rAis_natural_self_precedentrL s- %% & b) $ &  % %rEc8[U5=(d U[;$r:)rn _booleansrss rA is_booleanrO s   /i/rEc,[RX5$)zSrotate a comparison operator 180 degrees. Note this is not the same as negation. )_mirrorgetrss rAmirrorrS s ;;r rEcU[;$r:) _associativerss rAis_associativerV rGrEcU[;$r:)_order_by_modifierrss rAis_order_by_modifierrY s # ##rEc[5er:rrs rA_asboolr[ rrEc\rSrSrSrSrSrg)_OpLimiti idr6N)r8rOrPrQ _smallest_largestrUr6rErAr]r] s IHrEr]izDict[OperatorType, int] _PRECEDENCEc XLa[U5(agUcg[[RU[ US[ R 55[RU[ US[ R55:*5$)NFTrm)rLrrirRgetattrr]r_r`)rgrhs rA is_precedentrl0 st8BB  OO'(L(:L:LM ,8I8IJ   rE)rCallable[..., Any]rKr4)rr2rKr2)rKr)rrrKr)rrrrrKr)rrrlr7rrrKrr:)rrrrrrrKrr) rrrrrrryrrKr) rrmr?rrrr%rrKrr) rrrrrrr%rrKr)rrrrr9rrKr)rrrrrErrKr) rrrrrLrrErrKr)rpr4rKr)rpr4rKr4)rpOptional[OperatorType]rKr)rgr4rhrnrKr)rR __future__renumrrgr _uncast_addr _uncast_and_r_uncast_containsr _uncast_eqr _uncast_floordivr _uncast_ger _uncast_getitemr _uncast_gtr _uncast_invr _uncast_ler_uncast_lshiftr _uncast_ltr _uncast_modr _uncast_mulr _uncast_ner _uncast_negr _uncast_or_r_uncast_rshiftr _uncast_subr_uncast_truedivrrrrrrrrr r!r"r#r$r%r'r( util.typingr)r*_typingr, cache_keyr-elementsr.type_apir/r0r2r4rMrkrrrTrrrrrrrrrrrrrrrrrr!rgrprr rrrrrzrrrrrrrrrr&rrr+rr/rr r3rr7rrr<rr@rFr#rMr&r(r*r,rrQrUrYr4r`r7r9r;rrrrrrrnrFrIrLrNrOrQrSunion differencerUrVrYrXrKr[r]rirlr6rErArs1"')1%1%/%'%-%''%''-'/  !" 1%'$ T e8CH-.8D <% L,'  . / , #  . / , # |_ - , # <% , # lN + , # <% <% , # <% <% lN + <% |_ -A+A+Hq gbkqhk5ik5\-b#s+ h+RRR0 X0"            ""F  ##G !! %% 77/   )) E $$ '' LLJ %% )) MMK 00 11 27 +/  #M   ,,H$$#&$0=$KO$$, EJC CC)C>BCCC  EJD DD)D>BDDDIN  -BF  ) EJD DD)D>BDDD  EJE EE)E>BEEE  EJA AA)A>BAAA  EJB BB)B>BBBBIN  -BF  %N EJB BB)B>BBBB  EJC CC)C>BCCC  EJA AA)A>BAAA  EJB BB)B>BBBBIN  -BF  %N EJB BB)B>BBBB  EJC CC)C>BCCC   ** ++=AE EE!$E-:EEE   ::K     ))#M ((!L    OB'8T3 / 0 r2r2r2r *!!9dC"89DDb"XN $v~}E&,, o34   w ;( 2;(r;( B;( B ;(  R ;( R ;(";(;( Q;( a;(;(;(A;(;(;( A!;("1#;($A%;(&q';((q);(*q+;(,q-;(. a/;(0!1;(2Q3;(45;(6q7;(8 a9;(:!;;(< Q=;(>?;(@ 1A;(BqC;(DE;(F AG;(HI;(JK;(LaM;(N!O;(PQ;(RS;(TU;(VW;(XY;(ZA[;(\];(^_;(` Qa;(b ac;(d !e;(fg;(h b Q A Q A Su;( $;|  %;   rE