| Dir : /opt/hc_python/lib/python3.12/site-packages/sqlalchemy/sql/__pycache__/ |
| Server: Linux premium279.web-hosting.com 4.18.0-553.45.1.lve.el8.x86_64 #1 SMP Wed Mar 26 12:08:09 UTC 2025 x86_64 IP: 66.29.132.192 |
| Dir : //opt/hc_python/lib/python3.12/site-packages/sqlalchemy/sql/__pycache__/operators.cpython-312.pyc |
�
���g�+ � �( � U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlm
Z ddlm Z
ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZ ddlmZ ddlm Z ddlm Z ddlm Z! ddlm"Z# ddlm$Z% ddlm&Z' ddlm(Z) ddlm*Z+ ddlm,Z- ddl.Z.ddl.m/Z/ ddl.m0Z0 ddl.m1Z1 dd l.m2Z2 dd l.m3Z3 dd l.m4Z4 dd l.m5Z5 dd l.m6Z6 dd!l.m7Z7 dd"l.m8Z8 dd#l.m9Z9 dd$l.m:Z: dd%l.m;Z; d&d'l<m=Z= d&d(l<m>Z> d&d)l?m@Z@ d&d*l?mAZA e.jr rd+d,lBmCZC d+d-lDmEZE d+d.lFmGZG d+d/lHmIZI e:d0e/�1� ZJ e:d2e0d3e/f �1� ZK G d4� d5eA� ZL e1eLe� Z e1eLe � Z e1eLe � Z
e1eLe
� Z e1eLe� Z e1eLe� Z e1eLe� Z e1eLe� Z e1eLe� Z e1eLe� Z e1eLe� Z e1eLe � Z e1eLe � Z e1eLe!� Z e1eLe#� Z" e1eLe%� Z$ e1eLe'� Z& e1eLe)� Z( e1eLe+� Z* e1eLe-� Z, G d6� d7� ZM G d8� d9eLe3eJ � ZN G d:� d;eM� ZOe e"ee hZPd<eQd=< e e"e eeehZRd<eQd>< d�d?�ZSd�d@�ZTd�dA�ZUeSd�dB�� ZVeSeUd�dC�� � ZWeSd�dD�� ZXeSd�dE�� ZYeSd�dF�� ZZe9r
eSd�dG�� Z[neZZ[eSd�dH�� Z\e9r
eSd�dI�� Z]ne\Z]eUeSd�dJ�� � Z^eUeSd�dK�� � Z_e9r
eSd�dL�� Z`ne_Z`eUeSd�dM�� � ZaeUeSd�dN�� � Zbe9r
eSd�dO�� ZcnebZceSd�dP�� ZdeSd�dQ�� ZeeUeSd�d�dR�� � ZfeUeSd�d�dS�� � Zge9r eSd�d�dT�� ZhnegZheUeSd�d�dU�� � ZieUeSd�d�dV�� � Zje9r eSd�d�dW�� ZknejZkeUeSd�d�dX�� � ZleUeSd�d�dY�� � Zme9reS d� d�dZ�� ZnnemZneUeSd�d[�� � ZoeUeSd�d\�� � Zpe9r
eSd�d]�� ZqnepZqeSd�d^�� ZreSd�d_�� ZseSd�d`�� Zt d�da�ZueUeS d� d�db�� � ZveUeS d� d�dc�� � Zwe9reS d� d�dd�� ZxnewZxeUeS d� d�de�� � ZyeUeS d� d�df�� � ZzeUeS d� d�dg�� � Z{eUeS d� d�dh�� � Z|e9reS d� d�di�� Z}ne|Z}eUeS d� d�dj�� � Z~eUeS d� d�dk�� � ZeUeS d� d�dl�� � Z�eUeS d� d�dm�� � Z�e9reS d� d�dn�� Z�ne�Z�eUeS d� d�do�� � Z�eUeS d� d�dp�� � Z�eUeSd�dq�� � Z�eUeSd�d�dr�� � Z�eUeSd�d�ds�� � Z�eS d� d�dt�� Z�eUeSd�du�� � Z�e9r
eSd�dv�� Z�ne�Z�eSd�dw�� Z�eSd�dx�� Z�eSd�dy�� Z�eSd�dz�� Z�eSd�d{�� Z�eSd�d|�� Z�e9r
eSd�d}�� Z�ne�Z�eSd�d~�� Z�e9r
eSd�d�� Z�ne�Z�eSd�d��� Z�eSd�d��� Z�eSd�d��� Z�eSd�d��� Z�eSd�d��� Z�eSd�d��� Z�eSd�d��� Z�eSd�d��� Z�d�d��Z�d�d��Z�d�d��Z�d�d��Z�eeZe\ee&fZ�d�d��Z�ee eee eeeiZ�d�d��Z�eP�jI e�ee&g� �jK e e"g� Z�d�d��Z�d�d��Z�e�e�e�e�hZ�e��jI ee�e�g� Z� eSd�d��� Z� G d�� d�e� Z�i eVd��eWd��esd��etd��ed��e�d��e�d��e d��e,d��ed��e d��e$d��e�d��ed��e*d��e�d��e�d��i e�d��e�d��e�d��e�d��e�d��e�d��e�d��e�d��e�d��e�d��eid��ejd��efd��egd��eod��epd��ead���i ebd��e d��e"d��e^d��e_d��ed��e d��ed��ed��eld��emd��erd��ed��eZd��e\d��ed��e&d&��e�d�e�d�e�d�edd�eXd�eYde�d�i�Z�d�eQd�< d�d��Z�y)�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 � � e Zd ZU dZdZded< e d d
d�� Ze d d d�� Z d d d�Zy)
� OperatorTypezdescribe an op() function.� �str�__name__Nc � � y �Nr5 ��self�left�right�other�kwargss �I/opt/hc_python/lib64/python3.12/site-packages/sqlalchemy/sql/operators.py�__call__zOperatorType.__call__I � � � !� c � � y r9 r5 r: s r@ rA zOperatorType.__call__R � � � rC c � � y r9 r5 r: s r@ rA zOperatorType.__call__[ s � � rC r9 �
r< z ColumnExpressionArgument[Any]r= �
Optional[Any]r> r r? r �returnzColumnElement[Any]�
r< � Operatorsr= rH r> r r? r rI rK �
r< r r= rH r> r r? r rI rK )r7 �
__module__� __qualname__�__doc__� __slots__�__annotations__r rA r5 rC r@ r4 r4 B s� � �$��I��M�
� $�!�+�!� �!� � !�
� !�
�
!� �!� � $���� �� � �
� �
�
� �� $���� �� � �
� �
�
rC r4 c � � e Zd ZdZdZd d�Zd d�Zd d�Z d
dd�Z d dd�Z dd �Z
e
Z dd
�Z y)rK a� Base of comparison and logical operators.
Implements base methods
:meth:`~sqlalchemy.sql.operators.Operators.operate` and
:meth:`~sqlalchemy.sql.operators.Operators.reverse_operate`, as well as
:meth:`~sqlalchemy.sql.operators.Operators.__and__`,
:meth:`~sqlalchemy.sql.operators.Operators.__or__`,
:meth:`~sqlalchemy.sql.operators.Operators.__invert__`.
Usually is used via its most common subclass
:class:`.ColumnOperators`.
r5 c �. � | j 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)
)�operater �r; r> s r@ �__and__zOperators.__and__� s � �. �|�|�D�%�(�(rC c �. � | j 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)
)rT r rU s r@ �__or__zOperators.__or__� s � �. �|�|�C��'�'rC c �, � | j t � S )a Implement the ``~`` operator.
When used with SQL expressions, results in a
NOT operation, equivalent to
:func:`_expression.not_`, that is::
~a
is equivalent to::
from sqlalchemy import not_
not_(a)
)rT r
�r; s r@ �
__invert__zOperators.__invert__� s � � �|�|�C� � rC Nc �8 � �� t |||||�� �d�� 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 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 � �� ��| � S r9 r5 )r> �operatorr; s ��r@ �againstz Operators.op.<locals>.against5 s �� ��D�%�(� (rC �r> r rI rK )� custom_op)r; �opstring�
precedence�
is_comparison� return_typer] r` r_ s ` @r@ �opz Operators.op� s+ �� �| � � � � �#�
�� )� �rC c �, � | j ||d|�� S )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. 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)rd re r] �rg )r; rc rd r] s r@ �bool_opzOperators.bool_op: s& � �( �w�w� �!� �#� �
�
rC c �* � t t |� � �)aG Operate on an argument.
This is the lowest level of operation, raises
:class:`NotImplementedError` by default.
Overriding this on a subclass can allow common
behavior to be applied to all operations.
For example, overriding :class:`.ColumnOperators`
to apply ``func.lower()`` to the left and right
side::
class MyComparator(ColumnOperators):
def operate(self, op, other, **kwargs):
return op(func.lower(self), func.lower(other), **kwargs)
:param op: Operator callable.
:param \*other: the 'other' side of the operation. Will
be a single scalar for most operations.
:param \**kwargs: modifiers. These may be passed by special
operators such as :meth:`ColumnOperators.contains`.
��NotImplementedErrorr6 �r; rg r> r? s r@ rT zOperators.operateU s � �4 "�#�b�'�*�*rC c �* � t t |� � �)zXReverse operate on an argument.
Usage is the same as :meth:`operate`.
rl rn s r@ �reverse_operatezOperators.reverse_operates s � � "�#�b�'�*�*rC ra )rI rK )r FNN) rc r6 rd �intre �boolrf z7Optional[Union[Type[TypeEngine[Any]], TypeEngine[Any]]]r] � Optional[Callable[..., Any]]rI �Callable[[Any], Operators])r N)rc r6 rd rq r] rs rI rt )rg r4 r> r r? r rI rK )
r7 rM rN rO rP rV rX r[ rg rj rT �__sa_operate__rp r5 rC r@ rK rK z s� � � � �I�)�2(�2!�* � #�
�48�i��i� �i� � i�
� i� 2�i�
$�i�\ �48�
��
� �
� 2�
�
$�
�6+� �+�(+�+�7:�+� �+�8 �N�+� �+�'*�+�69�+� �+rC rK c �� � e Zd ZdZd Z dZ d d d�Zd
d�Zdd�Zdd�Ze d dd�� Z
e d dd �� Z
d dd
�Z
y)rb 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`
)rc rd re �natural_self_precedent�eager_groupingrf r] Nc � � || _ || _ || _ || _ || _ |r|j |� nd | _ || _ y r9 )rc rd re rw rx � _to_instancerf r] )r; rc rd re rf rw rx r] s r@ �__init__zcustom_op.__init__� sN � � !��
�$��� *���&<��#� ,���5@�K� $� $�[� 1�d�
�� '��rC c �h � t |t � xr! |j � | j � k( S r9 )�
isinstancerb � _hash_keyrU s r@ �__eq__zcustom_op.__eq__� s, � � �u�i� (�
6����!�T�^�^�%5�5�
rC c �4 � t | j � � S r9 )�hashr~ rZ s r@ �__hash__zcustom_op.__hash__� s � ��D�N�N�$�%�%rC c �� � | j | j | j | j | j | j
| j r| j j fS d fS r9 )� __class__rc rd re rw rx rf �_static_cache_keyrZ s r@ r~ zcustom_op._hash_key� sd � � �N�N� �M�M� �O�O� � � � � '� '� � � �26�2B�2B�D� � � .� .�
�
� IM�
�
rC c � � y r9 r5 r: s r@ rA zcustom_op.__call__� rB rC c � � y r9 r5 r: s r@ rA zcustom_op.__call__� rE rC c �� � t |d� r |j | |g|��i |��S | j r | j ||g|��i |��S t j d| j
�d�� �)Nru zCustom operator zX can't be used with plain Python objects unless it includes the 'python_impl' parameter.)�hasattrrT r] r' �InvalidRequestErrorrc r: s r@ rA zcustom_op.__call__� s} � � �4�)� *� �4�<�<��e�>�e�>�v�>� >�
�
�
�#�4�#�#�D�%�B�%�B�6�B� B��)�)�"�4�=�=�"3� 4+� +��
rC )r FNFFN)rc r6 rd rq re rr rf z5Optional[Union[Type[TypeEngine[_T]], TypeEngine[_T]]]rw rr rx rr r] rs )r> r rI rr �rI rq )rI z"Union[CacheConst, Tuple[Any, ...]]r9 rG rJ rL ) r7 rM rN rO rP r{ r r� r~ r rA r5 rC r@ rb rb ~ sO � ��0 �H��I� � #�
�',� $�48�'��'� �'� � '�
� '� !%�'� �'� 2�'�,
� &�
� � $�!�+�!� �!� � !�
� !�
�
!� �!� � $���� �� � �
� �
�
� �� $���� �� � �
� �
�
rC rb c � � e Zd ZU dZdZdZded< ej r dKd�Z dKd�Z
dLd�Z dLd �Z erdMd
�Z
n ej Z
dLd �ZdLd �ZdLd
�ZdLd�ZerdLd�ZneZdLd�ZdLd�ZdNd�ZdLd�ZdOd�ZdLd�ZdLd�ZdLd�ZdLd�Z dP dQd�Z dP dQd�Z dLd�Z dLd �Z dLd �Z!dNd �Z"dLd �Z#dLd �Z$dLd!�Z%dLd"�Z&erdLd#�Z'ne&Z' dP dQd$�Z(er dP dQd%�Z)ne(Z) dP dQd&�Z*er dP dQd'�Z+ne*Z+dLd(�Z,dLd)�Z-erdLd*�Z.ne-Z. dR dSd+�Z/ dR dSd,�Z0 dR dSd-�Z1 dR dSd.�Z2dTd/�Z3dTd0�Z4dUd1�Z5 dP dVd2�Z6 dP dWd3�Z7dNd4�Z8dNd5�Z9dNd6�Z:erdNd7�Z;ne:Z;dNd8�Z<erdNd9�Z=ne<Z=dXd:�Z>dLd;�Z?dLd<�Z@dLd=�ZAdLd>�ZB dY dZd?�ZCdNd@�ZDdNdA�ZEdNdB�ZFdLdC�ZGdLdD�ZHdLdE�ZIdLdF�ZJdLdG�ZKdLdH�ZLdLdI�ZMdLdJ�ZNy)[�ColumnOperatorsa" 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`
r5 Nz
Literal[None]� timetuplec � � y r9 r5 rn s r@ rT zColumnOperators.operate � � � !rC c � � y r9 r5 rn s r@ rp z ColumnOperators.reverse_operate# r� rC c �. � | j t |� S )zdImplement the ``<`` operator.
In a column context, produces the clause ``a < b``.
)rT r rU s r@ �__lt__zColumnOperators.__lt__' � � � �|�|�B��&�&rC c �. � | j t |� S )zfImplement the ``<=`` operator.
In a column context, produces the clause ``a <= b``.
)rT r rU s r@ �__le__zColumnOperators.__le__/ r� rC c � � y r9 r5 rZ s r@ r� zColumnOperators.__hash__< s � �3rC c �. � | j t |� S )z�Implement the ``==`` operator.
In a column context, produces the clause ``a = b``.
If the target is ``None``, produces ``a IS NULL``.
)rT r rU s r@ r zColumnOperators.__eq__A � � � �|�|�B��&�&rC c �. � | j t |� S )z�Implement the ``!=`` operator.
In a column context, produces the clause ``a != b``.
If the target is ``None``, produces ``a IS NOT NULL``.
)rT r rU s r@ �__ne__zColumnOperators.__ne__J r� rC c �. � | j t |� S )z�Implement the ``IS DISTINCT FROM`` operator.
Renders "a IS DISTINCT FROM b" on most platforms;
on some such as SQLite may render "a IS NOT b".
)rT �is_distinct_fromrU s r@ r� z ColumnOperators.is_distinct_fromS s � � �|�|� ,�e�4�4rC c �. � | j t |� S )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.
)rT �is_not_distinct_fromrU s r@ r� z$ColumnOperators.is_not_distinct_from\ s � � �|�|� 0�%�8�8rC c � � y r9 r5 rU s r@ �isnot_distinct_fromz#ColumnOperators.isnot_distinct_froml s � �crC c �. � | j t |� S )zdImplement the ``>`` operator.
In a column context, produces the clause ``a > b``.
)rT r rU s r@ �__gt__zColumnOperators.__gt__q r� rC c �. � | j t |� S )zfImplement the ``>=`` operator.
In a column context, produces the clause ``a >= b``.
)rT r
rU s r@ �__ge__zColumnOperators.__ge__y r� rC c �, � | j t � S )zaImplement the ``-`` operator.
In a column context, produces the clause ``-a``.
)rT r rZ s r@ �__neg__zColumnOperators.__neg__� s � � �|�|�C� � rC c �. � | j t |� S r9 )rT r rU s r@ � __contains__z ColumnOperators.__contains__� s � ��|�|�H�e�,�,rC c �. � | j t |� S )z�Implement the [] operator.
This can be used by some database-specific types
such as PostgreSQL ARRAY and HSTORE.
)rT r )r; �indexs r@ � __getitem__zColumnOperators.__getitem__� s � � �|�|�G�U�+�+rC c �. � | j t |� S )z�implement the << operator.
Not used by SQLAlchemy core, this is provided
for custom operator systems which want to use
<< as an extension point.
)rT r rU s r@ �
__lshift__zColumnOperators.__lshift__� � � � �|�|�F�E�*�*rC c �. � | j t |� S )z�implement the >> operator.
Not used by SQLAlchemy core, this is provided
for custom operator systems which want to use
>> as an extension point.
)rT r rU s r@ �
__rshift__zColumnOperators.__rshift__� r� rC c �. � | j t |� S )z�Implement the 'concat' operator.
In a column context, produces the clause ``a || b``,
or uses the ``concat()`` operator on MySQL.
)rT � concat_oprU s r@ �concatzColumnOperators.concat� s � � �|�|�I�u�-�-rC c �. � | j t |� S )z|Implement an 'rconcat' operator.
this is for internal use at the moment
.. versionadded:: 1.4.40
)rp r� rU s r@ �_rconcatzColumnOperators._rconcat� s � � �#�#�I�u�5�5rC c �2 � | j t ||�� S )a Implement the ``like`` operator.
In a column context, produces the expression:
.. sourcecode:: sql
a LIKE other
E.g.::
stmt = select(sometable).where(sometable.c.column.like("%foobar%"))
:param other: expression to be compared
:param escape: optional escape character, renders the ``ESCAPE``
keyword, e.g.::
somecolumn.like("foo/%bar", escape="/")
.. seealso::
:meth:`.ColumnOperators.ilike`
��escape)rT �like_op�r; r> r� s r@ �likezColumnOperators.like� s � �4 �|�|�G�U�6�|�:�:rC c �2 � | j t ||�� S )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� )rT �ilike_opr� s r@ �ilikezColumnOperators.ilike� s � �@ �|�|�H�e�F�|�;�;rC c �. � | j t |� S )z�Produce a bitwise XOR operation, typically via the ``^``
operator, or ``#`` for PostgreSQL.
.. versionadded:: 2.0.2
.. seealso::
:ref:`operators_bitwise`
)rT �bitwise_xor_oprU s r@ � bitwise_xorzColumnOperators.bitwise_xor� � � � �|�|�N�E�2�2rC c �. � | j t |� S )z�Produce a bitwise OR operation, typically via the ``|``
operator.
.. versionadded:: 2.0.2
.. seealso::
:ref:`operators_bitwise`
)rT �
bitwise_or_oprU s r@ �
bitwise_orzColumnOperators.bitwise_or s � � �|�|�M�5�1�1rC c �. � | j t |� S )z�Produce a bitwise AND operation, typically via the ``&``
operator.
.. versionadded:: 2.0.2
.. seealso::
:ref:`operators_bitwise`
)rT �bitwise_and_oprU s r@ � bitwise_andzColumnOperators.bitwise_and r� rC c �, � | j t � S )z�Produce a bitwise NOT operation, typically via the ``~``
operator.
.. versionadded:: 2.0.2
.. seealso::
:ref:`operators_bitwise`
)rT �bitwise_not_oprZ s r@ � bitwise_notzColumnOperators.bitwise_not" s � � �|�|�N�+�+rC c �. � | j t |� S )z�Produce a bitwise LSHIFT operation, typically via the ``<<``
operator.
.. versionadded:: 2.0.2
.. seealso::
:ref:`operators_bitwise`
)rT �bitwise_lshift_oprU s r@ �bitwise_lshiftz ColumnOperators.bitwise_lshift0 � � � �|�|� -�u�5�5rC c �. � | j t |� S )z�Produce a bitwise RSHIFT operation, typically via the ``>>``
operator.
.. versionadded:: 2.0.2
.. seealso::
:ref:`operators_bitwise`
)rT �bitwise_rshift_oprU s r@ �bitwise_rshiftz ColumnOperators.bitwise_rshift> r� rC c �. � | j t |� S )a� Implement the ``in`` operator.
In a column context, produces the clause ``column IN <other>``.
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.
)rT �in_oprU s r@ �in_zColumnOperators.in_L s � �F �|�|�E�5�)�)rC c �. � | j t |� S )a� implement 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_`
)rT � not_in_oprU s r@ �not_inzColumnOperators.not_in� s � �4 �|�|�I�u�-�-rC c � � y r9 r5 rU s r@ �notin_zColumnOperators.notin_� s � �rC c �2 � | j t ||�� S )a� implement 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� )rT � not_like_opr� s r@ �not_likezColumnOperators.not_like� s � �" �|�|�K��v�|�>�>rC c � � y r9 r5 r� s r@ �notlikezColumnOperators.notlike� r� rC c �2 � | j t ||�� S )a� implement 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� )rT � not_ilike_opr� s r@ � not_ilikezColumnOperators.not_ilike� s � �" �|�|�L�%��|�?�?rC c � � y r9 r5 r� s r@ �notilikezColumnOperators.notilike r� rC c �. � | j t |� S )aW 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`
)rT �is_rU s r@ r� zColumnOperators.is_ s � � �|�|�C��'�'rC c �. � | j 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.
.. 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_`
)rT �is_notrU s r@ r� zColumnOperators.is_not s � � �|�|�F�E�*�*rC c � � y r9 r5 rU s r@ �isnotzColumnOperators.isnot0 s � �rC c �4 � | j t |||�� S )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 <other> || '%'
E.g.::
stmt = select(sometable).where(sometable.c.column.startswith("foobar"))
Since the operator uses ``LIKE``, wildcard characters
``"%"`` and ``"_"`` that are present inside the <other> expression
will behave like wildcards as well. For literal string
values, the :paramref:`.ColumnOperators.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)rT �
startswith_op�r; r> r� r� s r@ �
startswithzColumnOperators.startswith5 s$ � �n �|�|� �5��J� �
�
rC c �4 � | j t |||�� S )a� 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(<other>) || '%'
E.g.::
stmt = select(sometable).where(sometable.c.column.istartswith("foobar"))
Since the operator uses ``LIKE``, wildcard characters
``"%"`` and ``"_"`` that are present inside the <other> expression
will behave like wildcards as well. For literal string
values, the :paramref:`.ColumnOperators.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� )rT �istartswith_opr� s r@ � istartswithzColumnOperators.istartswith� s$ � �f �|�|� �E�&�Z� �
�
rC c �4 � | j t |||�� S )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 '%' || <other>
E.g.::
stmt = select(sometable).where(sometable.c.column.endswith("foobar"))
Since the operator uses ``LIKE``, wildcard characters
``"%"`` and ``"_"`` that are present inside the <other> expression
will behave like wildcards as well. For literal string
values, the :paramref:`.ColumnOperators.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� )rT � endswith_opr� s r@ �endswithzColumnOperators.endswith� s$ � �n �|�|� ��v�*� �
�
rC c �4 � | j t |||�� S )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(<other>)
E.g.::
stmt = select(sometable).where(sometable.c.column.iendswith("foobar"))
Since the operator uses ``LIKE``, wildcard characters
``"%"`` and ``"_"`` that are present inside the <other> expression
will behave like wildcards as well. For literal string
values, the :paramref:`.ColumnOperators.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� )rT � iendswith_opr� s r@ � iendswithzColumnOperators.iendswithB s$ � �f �|�|� �%��:� �
�
rC c �2 � | j t |fi |��S )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 '%' || <other> || '%'
E.g.::
stmt = select(sometable).where(sometable.c.column.contains("foobar"))
Since the operator uses ``LIKE``, wildcard characters
``"%"`` and ``"_"`` that are present inside the <other> expression
will behave like wildcards as well. For literal string
values, the :paramref:`.ColumnOperators.contains.autoescape` flag
may be set to ``True`` to apply escaping to occurrences of these
characters within the string value so that they match as themselves
and not as wildcard characters. Alternatively, the
:paramref:`.ColumnOperators.contains.escape` parameter will establish
a given character as an escape character which can be of use when
the target expression is not a literal string.
:param other: expression to be compared. This is usually a plain
string value, but can also be an arbitrary SQL expression. LIKE
wildcard characters ``%`` and ``_`` are not escaped by default unless
the :paramref:`.ColumnOperators.contains.autoescape` flag is
set to True.
:param autoescape: boolean; when True, establishes an escape character
within the LIKE expression, then applies it to all occurrences of
``"%"``, ``"_"`` and the escape character itself within the
comparison value, which is assumed to be a literal string and not a
SQL expression.
An expression such as::
somecolumn.contains("foo%bar", autoescape=True)
Will render as:
.. 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`
)rT � contains_op�r; r> �kws r@ r zColumnOperators.contains� s � �f �t�|�|�K��5�"�5�5rC c �2 � | j t |fi |��S )a� 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(<other>) || '%'
E.g.::
stmt = select(sometable).where(sometable.c.column.icontains("foobar"))
Since the operator uses ``LIKE``, wildcard characters
``"%"`` and ``"_"`` that are present inside the <other> expression
will behave like wildcards as well. For literal string
values, the :paramref:`.ColumnOperators.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`
)rT � icontains_opr� s r@ � icontainszColumnOperators.icontains� s � �^ �t�|�|�L�%�6�2�6�6rC c �2 � | j t |fi |��S )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.
)rT �match_op)r; r> r? s r@ �matchzColumnOperators.match? s � �8 �t�|�|�H�e�6�v�6�6rC c �2 � | j t ||�� S )a Implements 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)rT �regexp_match_op)r; �patternr s r@ � regexp_matchz ColumnOperators.regexp_match] s � �p �|�|�O�W�E�|�B�BrC c �4 � | j t |||�� S )a� Implements 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`
�� replacementr )rT �regexp_replace_op)r; r r
r s r@ �regexp_replacez ColumnOperators.regexp_replace� s' � �Z �|�|� � �#�� �
�
rC c �, � | j t � S )zLProduce a :func:`_expression.desc` clause against the
parent object.)rT �desc_oprZ s r@ �desczColumnOperators.desc� s � � �|�|�G�$�$rC c �, � | j t � S )zKProduce a :func:`_expression.asc` clause against the
parent object.)rT �asc_oprZ s r@ �asczColumnOperators.asc� s � � �|�|�F�#�#rC c �, � | j t � S )a* Produce a :func:`_expression.nulls_first` clause against the
parent object.
.. versionchanged:: 1.4 The ``nulls_first()`` operator is
renamed from ``nullsfirst()`` in previous releases.
The previous name remains available for backwards compatibility.
)rT �nulls_first_oprZ s r@ � nulls_firstzColumnOperators.nulls_first� s � � �|�|�N�+�+rC c � � y r9 r5 rZ s r@ �
nullsfirstzColumnOperators.nullsfirst� s � �rC c �, � | j t � S )a' Produce a :func:`_expression.nulls_last` clause against the
parent object.
.. versionchanged:: 1.4 The ``nulls_last()`` operator is
renamed from ``nullslast()`` in previous releases.
The previous name remains available for backwards compatibility.
)rT �
nulls_last_oprZ s r@ �
nulls_lastzColumnOperators.nulls_last� s � � �|�|�M�*�*rC c � � y r9 r5 rZ s r@ � nullslastzColumnOperators.nullslast� s � �rC c �. � | j t |� S )z�Produce a :func:`_expression.collate` clause against
the parent object, given the collation string.
.. seealso::
:func:`_expression.collate`
)rT �collate)r; � collations r@ r! zColumnOperators.collate� s � � �|�|�G�Y�/�/rC c �. � | j t |� S )zaImplement the ``+`` operator in reverse.
See :meth:`.ColumnOperators.__add__`.
)rp r rU s r@ �__radd__zColumnOperators.__radd__ � � � �#�#�C��/�/rC c �. � | j t |� S )zaImplement the ``-`` operator in reverse.
See :meth:`.ColumnOperators.__sub__`.
)rp r rU s r@ �__rsub__zColumnOperators.__rsub__ r% rC c �. � | j t |� S )zaImplement the ``*`` operator in reverse.
See :meth:`.ColumnOperators.__mul__`.
)rp r rU s r@ �__rmul__zColumnOperators.__rmul__ r% rC c �. � | j t |� S )zaImplement the ``%`` operator in reverse.
See :meth:`.ColumnOperators.__mod__`.
)rp r rU s r@ �__rmod__zColumnOperators.__rmod__ r% rC c �4 � | j t |||�� S )zzProduce a :func:`_expression.between` clause against
the parent object, given the lower and upper range.
�� symmetric)rT �
between_op)r; �cleft�crightr. s r@ �betweenzColumnOperators.between$ s � � �|�|�J��v��|�K�KrC c �, � | j t � S )zZProduce a :func:`_expression.distinct` clause against the
parent object.
)rT � distinct_oprZ s r@ �distinctzColumnOperators.distinct- s � �
�|�|�K�(�(rC c �, � | j t � S )a� Produce 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.
)rT �any_oprZ s r@ �any_zColumnOperators.any_4 � � � �|�|�F�#�#rC c �, � | j t � S )a� Produce 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.
)rT �all_oprZ s r@ �all_zColumnOperators.all_C r9 rC c �. � | j t |� S )a4 Implement 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`.
)rT r rU s r@ �__add__zColumnOperators.__add__R s � � �|�|�C��'�'rC c �. � | j t |� S )zdImplement the ``-`` operator.
In a column context, produces the clause ``a - b``.
)rT r rU s r@ �__sub__zColumnOperators.__sub__^ � � � �|�|�C��'�'rC c �. � | j t |� S )zdImplement the ``*`` operator.
In a column context, produces the clause ``a * b``.
)rT r rU s r@ �__mul__zColumnOperators.__mul__f rA rC c �. � | j t |� S )zdImplement the ``%`` operator.
In a column context, produces the clause ``a % b``.
)rT r rU s r@ �__mod__zColumnOperators.__mod__n rA rC c �. � | j t |� S )aS 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.
)rT r rU s r@ � __truediv__zColumnOperators.__truediv__v s � � �|�|�G�U�+�+rC c �. � | j t |� S )zeImplement the ``/`` operator in reverse.
See :meth:`.ColumnOperators.__truediv__`.
)rp r rU s r@ � __rtruediv__z ColumnOperators.__rtruediv__� s � � �#�#�G�U�3�3rC c �. � | j t |� S )z�Implement 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
)rT r rU s r@ � __floordiv__z ColumnOperators.__floordiv__� s � � �|�|�H�e�,�,rC c �. � | j t |� S )zgImplement the ``//`` operator in reverse.
See :meth:`.ColumnOperators.__floordiv__`.
)rp r rU s r@ �
__rfloordiv__z ColumnOperators.__rfloordiv__� s � � �#�#�H�e�4�4rC )rg r4 r> r r? r rI r� )r> r rI r� r� )rI r� )r� r rI r� r9 )r> r r� �
Optional[str]rI r� �NF)r> r r� rN r� rr rI r� )r> r r� r rI r� )r> r r? r rI r� )r r r rN rI r� )r r r
r r rN rI r� )r" r6 rI r� �F)r0 r r1 r r. rr rI r� )Or7 rM rN rO rP r� rQ �typingr# rT rp r� r� r� rK r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r
r r r r r r r r! r$ r' r) r+ r2 r5 r8 r< r> r@ rC rE rG rI rK rM r5 rC r@ r� r� � s � �#�J �I� #�I�}�#�B�
��� "�"� "�,/� "�;>� "�
� "� "�"� "�+.� "�:=� "�
� "�'�'� �&� �%�%��'�'�5� 9� �I� 3��'�'�!�-�,�+�+�.�6� 37�;��;�"/�;� �;�: 37� <�� <�"/� <� � <�D 3� 2� 3� ,� 6� 6� c*�J.�: �<� �� 37�?��?�"/�?� �?�( � 7;� "� � "�&3� "�
� "�
�� 37�@��@�"/�@� �@�( � 7;� "� � "�&3� "�
� "�
�� (�+�$ �;� ��
!%� � Y
��Y
� �Y
� � Y
�
� Y
�| !%� � U
��U
� �U
� � U
�
� U
�t !%� � Y
��Y
� �Y
� � Y
�
� Y
�| !%� � U
��U
� �U
� � U
�
� U
�nS6�jO7�b 7�> 48�8C��8C�#0�8C� �8C�v FJ�2
��2
�),�2
�5B�2
� �2
�h%�
$�
,� �4� !�
�+� �3� � � 0�0�0�0�0� :?�L��L�"%�L�26�L� �L�)�
$�
$�
(�(�(�(� ,�4�
-�5rC r� zSet[Any]� _commutative� _comparisonc �" � t t | � S r9 )r r4 ��fns r@ � _operator_fnrW � s � � � �b� !�!rC c �0 � t j | � | S r9 )rR r rU s r@ �commutative_oprY � s � ����R��
�IrC c �0 � t j | � | S r9 )rS r rU s r@ �
comparison_opr[ � s � ��O�O�B��
�IrC c � � t � �r9 �rm r5 rC r@ �from_r^ � � � �
�
� rC c � � t � �r9 r] r5 rC r@ �function_as_comparison_opra � s
� � �
� rC c � � t � �r9 r] r5 rC r@ �as_rc � r_ rC c � � t � �r9 r] r5 rC r@ �existsre � r_ rC c � � t � �r9 r] ��as r@ �is_trueri � r_ rC c � � y r9 r5 rg s r@ �istruerk � s � � "rC c � � t � �r9 r] rg s r@ �is_falserm � r_ rC c � � y r9 r5 rg s r@ �isfalsero � s � � #rC c �$ � | j |� S r9 )r� �rh �bs r@ r� r� � s � �
� � �a� � rC c �$ � | j |� S r9 )r� rq s r@ r� r� � s � �
� !� !�!� $�$rC c � � y r9 r5 rq s r@ r� r� � s � �47rC c �$ � | j |� S r9 )r� rq s r@ r� r� � � � �
�5�5��8�OrC c �$ � | j |� S r9 )r� rq s r@ r� r� � � �
�8�8�A�;�rC c � � y r9 r5 rq s r@ r� r�
� � �&)rC c �$ � | j |� S r9 )r! rq s r@ r! r! s � � �9�9�Q�<�rC c �0 � | j |� |� S r9 ri )rh rc rr s r@ rg rg s � � �1�4�4��>�!� � rC c �( � | j ||�� S �Nr� )r� �rh rr r� s r@ r� r� s � �
�6�6�!�F�6� #�#rC c �( � | j ||�� S r~ )r� r s r@ r� r� ! s � �
�9�9�Q�v�9� &�&rC c � � y r9 r5 r s r@ �
notlike_opr� * s � �ILrC c �( � | j ||�� S r~ )r� r s r@ r� r� 1 s � �
�7�7�1�V�7� $�$rC c �( � | j ||�� S r~ )r� r s r@ r� r� 7 s � �
�;�;�q��;� (�(rC c � � y r9 r5 r s r@ � notilike_opr� @ s � �JMrC c �* � | j |||�� S �Nr- �r2 �rh rr �cr. s r@ r/ r/ G s � �
�9�9�Q��Y�9� /�/rC c �, � | j |||�� S r� r� r� s r@ �not_between_opr� M s � �
�I�I�a��i�I� 0� 0�0rC c � � y r9 r5 r� s r@ �
notbetween_opr� V � � � rC c �$ � | j |� S r9 )r� rq s r@ r� r� _ rv rC c �$ � | j |� S r9 )r� rq s r@ r� r� e rx rC c � � y r9 r5 rq s r@ �notin_opr� n s � �),rC c �" � | j � S r9 )r5 rg s r@ r4 r4 u s � � �:�:�<�rC c �" � | j � S r9 )r8 rg s r@ r7 r7 z �
� � �6�6�8�OrC c �" � | j � S r9 )r< rg s r@ r; r; r� rC c � � |ry|durt j d� |�d}t |t � s t d� �|dvr|j |||z � }|j d|dz � j d|dz � } | ||�� S ) NTz;The autoescape parameter is now a simple boolean True/False�/z*String value expected when autoescape=True)�%�_r� r� r� )r( �warnr} r6 � TypeError�replace)rV r> r� r� s r@ �_escaped_like_implr� � s� � � � �T� !� �I�I�M�
� �>��F��%��%�� H�I� I� �� #��M�M�&�&�6�/�:�E��
�
�c�6�C�<�0�8�8��f�s�l�K��
�e�F� #�#rC c �2 � t | j |||� S r9 �r� r� �rh rr r� r� s r@ r� r� � s � �
�a�l�l�A�v�z� B�BrC c �4 � t | j |||� S r9 r� r� s r@ �not_startswith_opr� � s � �
�q�|�|�Q��
� C� C�CrC c � � y r9 r5 r� s r@ �notstartswith_opr� � r� rC c �2 � t | j |||� S r9 �r� r� r� s r@ r� r� � s � �
�a�m�m�Q��
� C�CrC c �4 � t | j |||� S r9 r� r� s r@ �not_istartswith_opr� � s � �
�q�}�}�a��� D� D�DrC c �2 � t | j |||� S r9 �r� r� r� s r@ r� r� � � � �
�a�j�j�!�V�Z� @�@rC c �4 � t | j |||� S r9 r� r� s r@ �not_endswith_opr� � � � �
�q�z�z�1�f�j� A� A�ArC c � � y r9 r5 r� s r@ �notendswith_opr� � r� rC c �2 � t | j |||� S r9 �r� r� r� s r@ r� r� � � � �
�a�k�k�1�f�j� A�ArC c �4 � t | j |||� S r9 r� r� s r@ �not_iendswith_opr� � � � �
�q�{�{�A�v�z� B� B�BrC c �2 � t | j |||� S r9 �r� r r� s r@ r� r� � r� rC c �4 � t | j |||� S r9 r� r� s r@ �not_contains_opr� � r� rC c � � y r9 r5 r� s r@ �notcontains_opr� r� rC c �2 � t | j |||� S r9 �r� r r� s r@ r r r� rC c �4 � t | j |||� S r9 r� r� s r@ �not_icontains_opr� r� rC c �( � | j |fi |��S r9 �r �rh rr r� s r@ r r s � � �1�7�7�1� �� �rC c �( � | j ||�� S �Nr �r
�rh rr r s r@ r r $ s � �
�>�>�!�5�>� )�)rC c �* � | j ||�� S r� r� r� s r@ �not_regexp_match_opr� * s � �
�N�N�1�E�N� *� *�*rC c �* � | j |||�� S )Nr )r )rh rr r
r s r@ r r 0 s � �
� � �A�;�e� � D�DrC c �* � | j |fi |�� S r9 r� r� s r@ � not_match_opr� 7 s � �
�A�G�G�A� �� � � rC c � � y r9 r5 r� s r@ � notmatch_opr� @ s � �7:rC c � � t � �r9 r] rq s r@ �comma_opr� G r_ rC c � � t � �r9 r] rq s r@ � filter_opr� L r_ rC c �l � | j } ||� S # t $ r |j | � cY S w xY wr9 )r� �AttributeErrorr� )rh rr r� s r@ r� r� Q s; � ������ �a�y��� � ��z�z�!�}� � �s � �3�3c �" � | j � S r9 )r rg s r@ r r [ r� rC c �" � | j � S r9 )r rg s r@ r r ` s
� � �5�5�7�NrC c �" � | j � S r9 )r rg s r@ r r e � � � �=�=�?�rC c � � y r9 r5 rg s r@ �
nullsfirst_opr� m rz rC c �" � | j � S r9 )r rg s r@ r r t s � � �<�<�>�rC c � � y r9 r5 rg s r@ � nullslast_opr� | s � �%(rC c � � t � �r9 r] rq s r@ �json_getitem_opr� � r_ rC c � � t � �r9 r] rq s r@ �json_path_getitem_opr� � r_ rC c �$ � | j |� S r9 )r� rq s r@ r� r� � � � � �=�=�� �rC c �$ � | j |� S r9 )r� rq s r@ r� r� � s � � �<�<��?�rC c �$ � | j |� S r9 )r� rq s r@ r� r� � r� rC c �" � | j � S r9 )r� rg s r@ r� r� � r� rC c �$ � | j |� S r9 )r� rq s r@ r� r� � � � � � � �A� � rC c �$ � | j |� S r9 )r� rq s r@ r� r� � r� rC c �R � | t v xs t | t � xr | j S r9 )rS r} rb re ri s r@ re re � s$ � �
�� � N�
�2�y� 9� N�b�>N�>N�NrC c � � | t v S r9 )rR ri s r@ �is_commutativer� � �
� �
� � � rC c �2 � | t t t t fv S r9 )r r r r ri s r@ �is_ordering_modifierr� � s � �
�&�'�>�=�A� A�ArC c �R � | t v xs t | t � xr | j S r9 )�_natural_self_precedentr} rb rw ri s r@ �is_natural_self_precedentr� � s- � �
�%�%� &� �b�)� $� &� � %� %�rC c �, � t | � xs | t v S r9 )re � _booleansri s r@ �
is_booleanr� � s � � �� � /��i��/rC c �. � t j | | � S )z[rotate a comparison operator 180 degrees.
Note this is not the same as negation.
)�_mirror�getri s r@ �mirrorr� � s � � �;�;�r�2� � rC c � � | t v S r9 )� _associativeri s r@ �is_associativer� � r� rC c � � | t v S r9 )�_order_by_modifierri s r@ �is_order_by_modifierr � s � �
�#� #�#rC c � � t � �r9 r] rg s r@ �_asboolr � r_ rC c � � e Zd ZdZdZy)�_OpLimiti�����d N)r7 rM rN � _smallest�_largestr5 rC r@ r r � s � ��I��HrC r � � � � � � ���� i����zDict[OperatorType, int]� _PRECEDENCEc � � | |u r t | � ry|�yt t j | t | dt
j � � t j |t |dt
j � � k � S )NFTrd )r� rr r r� �getattrr r r )r_ r` s r@ � is_precedentr 0
ss � � �7�� 8�� B�� � ��� �O�O��'�(�L�(�:L�:L�M�
� ������,��8I�8I�J��
�
�
rC )rV �Callable[..., Any]rI r4 )rV r2 rI r2 )rI r )rh r rI r )rh r rr r rI r )rh r rc r6 rr r rI r r9 )rh r rr r r� rN rI r rP )
rh r rr r r� r r. rr rI r )
rV r r> r r� rN r� rr rI r rO )
rh r rr r r� rN r� rr rI r )rh r rr r r� r rI r )rh r rr r r rN rI r )
rh r rr r r
r r rN rI r )rg r4 rI rr )rg r4 rI r4 )rg �Optional[OperatorType]rI rr )r_ r4 r` r rI rr )�rO �
__future__r �enumr r_ r � _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_truedivrQ r r r r r r r r r! r" r# r$ r% � r' r( � util.typingr) r* �_typingr, � cache_keyr- �elementsr. �type_apir/ r0 r2 r4 rK rb r� rR rQ rS rW rY r[ r^ ra rc re ri rk rm ro r� r� r� r� r� r� r! rg r� r� r� r� r� r� r/ r� r� r� r� r� r4 r7 r; r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r r r� r r� r� r� r� r� r r r r� r r� r� r� r� r� r� r� r� r� re r� r� r� r� r� r� r� �union�
differencer� r� r r r� r r r r r5 rC r@ �<module>r6 s� �� 1� "� � '� )� 1� %� 1� %� /� %� '� %� -� %� '� '� %� '� '� -� '� /�
� � � � � � � � � � � � � � � � !� "� ���1�%�'�$� �T�� ��
�e�8�C��H�-�.�� �8� �D �<��%�� �L�,�'�� � � .� /�� �,�
�#�� � � .� /�� �,�
�#��
�|�_�
-�� �,�
�#��
�<��%�� �,�
�#��
�l�N� +�� �,�
�#��
�<��%��
�<��%�� �,�
�#��
�<��%��
�<��%��
�l�N� +��
�<��%��
�|�_�
-��A+� A+�Hq� �g�b�k� q�hk5�i� k5�\- �b�#�s�+� �h� +��R��R��R�0� �X� 0�"��
�
� � � � �� � � � � � � � � � � � � � � � �
��"� �"� �F� � � � �
��#� �#� �G� �
�!� � �!� �
�%� � �%�
��7� �7� /�� �
�� � �� �
�� � ��
��)� �)�
�E� �� �� � � � � �
�$� � �$� �
�'� � �'�
��L� �L� �J� �
�%� � �%� �
�)� � �)�
��M� �M� �K� �
�0� � �0� �
�1� � �1�
��27�� ���� ��+/�� �� ��
#�M� �
�� � �� �
�� � ��
��,� �,� �H� �� �� �� �� �� ��$��$�#&�$�0=�$�KO�$��$�, �
�EJ�C�
�C��C� )�C�>B�C��C� � �C� �
�EJ�D�
�D��D� )�D�>B�D��D� � �D� ��IN�� ���� -��BF�� �� ��
)�� �
�EJ�D�
�D��D� )�D�>B�D��D� � �D� �
�EJ�E�
�E��E� )�E�>B�E��E� � �E� �
�EJ�A�
�A��A� )�A�>B�A��A� � �A� �
�EJ�B�
�B��B� )�B�>B�B��B� � �B� ��IN�� ���� -��BF�� �� ��
%�N� �
�EJ�B�
�B��B� )�B�>B�B��B� � �B� �
�EJ�C�
�C��C� )�C�>B�C��C� � �C� �
�EJ�A�
�A��A� )�A�>B�A��A� � �A� �
�EJ�B�
�B��B� )�B�>B�B��B� � �B� ��IN�� ���� -��BF�� �� ��
%�N� �
�EJ�B�
�B��B� )�B�>B�B��B� � �B� �
�EJ�C�
�C��C� )�C�>B�C��C� � �C� �
� � � � � �
�*� � �*� �
�+� � �+� �=A�E�
�E��E�!$�E�-:�E��E� �E� �
� � � � �
��:� �:� �K� � � � � � � � � �� �� �� �� �� �� �� ��
��)� �)� #�M� �� ��
��(� �(� !�L� � � � � � � � � � � � � �� �� � � � � �� �� � � � � � � � �O� �B�� �'�8�T�3� /� �0� �r�2�r�2�r�2�r�
*�� � �!�!�9�d�C�"8�9�D�D�b�"�X�N� � �$� �v�~�}�E� �&�,�,� �o� 3�4�� �� � � � ��w� �
;(� �2�;(� �r�;(� �B�;(� �B� ;(�
�R� ;(� �R�
;(� �"�;(� ��;(� �Q�;(�
�a�;(� ��;(� ��;(� �A�;(� �� ;(� �� ;(� �A�!;(�" �1�#;(�$ �A�%;(�& �q�';(�( �q�);(�* �q�+;(�, �q�-;(�.
�a�/;(�0 �!�1;(�2 �Q�3;(�4 ��5;(�6 �q�7;(�8
�a�9;(�: �!�;;(�< �Q�=;(�> ��?;(�@
�1�A;(�B �q�C;(�D ��E;(�F �A�G;(�H ��I;(�J ��K;(�L �a�M;(�N �!�O;(�P ��Q;(�R ��S;(�T ��U;(�V ��W;(�X ��Y;(�Z �A�[;(�\ ��];(�^ ��_;(�` �Q�a;(�b
�a�c;(�d �!�e;(�f ��g;(�h
�b� �Q�
�A� �Q���
�A� �S�u;(� �
$� ;�|
��
�%;�
� �
rC