0x1998 - MANAGER
Düzenlenen Dosya: operators.cpython-37.pyc
B ��4]� � j @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ dd lm Z dd lm Z dd lm Z dd lm Z dd lm Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ej�r ddlmZ neZG dd� de�ZG dd� de�ZG d d � d e�Z eeeehZ eee eee hZ d d � Z d d!� Z d"d#� Z!e d$d%� �Z"d&d'� Z#d(d)� Z$d*d+� Z%d,d-� Z&e d.d/� �Z'e d0d1� �Z(e d2d3� �Z)e d4d5� �Z*d6d7� Z+d8d9� Z,e d�d;d<��Z-e d�d=d>��Z.e d�d?d@��Z/e d�dAdB��Z0e d�dDdE��Z1e d�dFdG��Z2e dHdI� �Z3e dJdK� �Z4dLdM� Z5dNdO� Z6dPdQ� Z7dRdS� Z8e d�dTdU��Z9e d�dVdW��Z:e d�dXdY��Z;e d�dZd[��Z<e d�d\d]��Z=e d�d^d_��Z>e d`da� �Z?e dbdc� �Z@ddde� ZAe dfdg� �ZBe dhdi� �ZCdjdk� ZDdldm� ZEdndo� ZFdpdq� ZGdrds� ZHdtdu� ZIdvdw� ZJdxdy� ZKdzd{� ZLd|d}� ZMd~d� ZNd�d�� ZOe e%e&eefZPd�d�� ZQee ee e ee eiZRd�d�� ZSe �TeEeeg��Ueeg�ZVeV�TeeJeKg�ZWejXd�d�d��ZYejXd�d�d��ZZejXd�d�d��Z[e!d�e"d�e6d�e7d�ed�eJd�eKd�ed�ed�ed�e d�ed�ed�ed�eEd�eDd�e?d�e@d�e/d�e0d�e-d�e.d�e3d�e4d�e)d�e*d�ed�ed�e'd�e(d�eBd�eCd�ed�e d�ed�e d�e1d�e2d�e5d�e d�e%d�e&d�ed�edeAd�eFd�eGd�e+d�e#d�e$deYd�eZeZe[e[i5Z\d�d�� Z]d:S )�z*Defines operators used in SQL expressions.� )�add)�and_)�contains)�eq)�ge)�getitem)�gt)�inv)�le)�lshift)�lt)�mod)�mul)�ne)�neg)�or_)�rshift)�sub)�truediv� )�util)�divc @ sP e Zd ZdZdZdd� Zdd� Zdd� Zdd d �Zddd�Z dd� Z dd� Z d S )� Operatorsa� 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`. � c C s | � 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 )�self�otherr r �K/opt/alt/python37/lib64/python3.7/site-packages/sqlalchemy/sql/operators.py�__and__; s zOperators.__and__c C s | � 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) )r r )r r r r r �__or__S s zOperators.__or__c C s | � 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) )r r )r r r r � __invert__k s zOperators.__invert__r FNc s t ||||�� � �fdd�}|S )a! produce a generic operator function. e.g.:: somecolumn.op("*")(5) produces:: somecolumn * 5 This function can also be used to make bitwise operators explicit. For example:: somecolumn.op('&')(0xff) is a bitwise AND of the value in ``somecolumn``. :param operator: a string which will be output as the infix operator between this element and the expression passed to the generated function. :param precedence: precedence to apply to the operator, when parenthesizing expressions. A lower number will cause the expression to be parenthesized when applied against another operator with higher precedence. The default value of ``0`` is lower than all operators except for the comma (``,``) and ``AS`` operators. A value of 100 will be higher or equal to all operators, and -100 will be lower than or equal to all operators. :param is_comparison: if True, the operator will be considered as a "comparison" operator, that is which evaluates to a boolean true/false value, like ``==``, ``>``, etc. This flag should be set so that ORM relationships can establish that the operator is a comparison operator when used in a custom join condition. .. versionadded:: 0.9.2 - added the :paramref:`.Operators.op.is_comparison` flag. :param return_type: a :class:`.TypeEngine` class or object that will force the return type of an expression produced by this operator to be of that type. By default, operators that specify :paramref:`.Operators.op.is_comparison` will resolve to :class:`.Boolean`, and those that do not will be of the same type as the left-hand operand. .. versionadded:: 1.2.0b3 - added the :paramref:`.Operators.op.return_type` argument. .. seealso:: :ref:`types_operators` :ref:`relationship_custom_operator` c s � �| �S )Nr )r )�operatorr r r �against� s z Operators.op.<locals>.against)� custom_op)r �opstring� precedence� is_comparison� return_typer" r )r! r r �op| s :z Operators.opc C s | j ||dd�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. .. versionadded:: 1.2.0b3 .. seealso:: :meth:`.Operators.op` T)r% r& )r( )r r$ r% r r r �bool_op� s zOperators.bool_opc O s t t|���dS )a3 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): return op(func.lower(self), func.lower(other)) :param op: Operator callable. :param \*other: the 'other' side of the operation. Will be a single scalar for most operations. :param \**kwargs: modifiers. These may be passed by special operators such as :meth:`ColumnOperators.contains`. N)�NotImplementedError�str)r r( r �kwargsr r r r � s zOperators.operatec K s t t|���dS )zXReverse operate on an argument. Usage is the same as :meth:`operate`. N)r* r+ )r r( r r, r r r �reverse_operate� s zOperators.reverse_operate)r FN)r ) �__name__� __module__� __qualname__�__doc__� __slots__r r r r( r) r r- r r r r r * s @ r c @ s6 e Zd ZdZd Z d dd�Zdd� Zd d � Zd d � ZdS )r# 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` r FNc C s6 || _ || _|| _|| _|| _|r,|�|�nd | _d S )N)r$ r% r& �natural_self_precedent�eager_groupingZ _to_instancer' )r r$ r% r& r' r3 r4 r r r �__init__ s zcustom_op.__init__c C s t |t�o|j| jkS )N)� isinstancer# r$ )r r r r r �__eq__ s zcustom_op.__eq__c C s t | �S )N)�id)r r r r �__hash__" s zcustom_op.__hash__c K s |j | |f|�S )N)r )r �left�right�kwr r r �__call__% s zcustom_op.__call__)r FNFF)r. r/ r0 r1 r5 r7 r9 r= r r r r r# � s r# c @ s� e Zd ZdZdZdZdd� Zdd� Zej Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zdcd d!�Zddd"d#�Zd$d%� Zd&d'� Zded(d)�Zdfd*d+�Zd,d-� Z d.d/� Z d0d1� Z d2d3� Z d4d5� Z d6d7� Z!d8d9� Z"d:d;� Z#d<d=� Z$d>d?� Z%d@dA� Z&dBdC� Z'dDdE� Z(dFdG� Z)dHdI� Z*dJdK� Z+dgdMdN�Z,dOdP� Z-dQdR� Z.dSdT� Z/dUdV� Z0dWdX� Z1dYdZ� Z2d[d\� Z3d]d^� Z4d_d`� Z5dadb� Z6dS )h�ColumnOperatorsa Defines boolean, comparison, and other operators for :class:`.ColumnElement` expressions. By default, all methods call down to :meth:`.operate` or :meth:`.reverse_operate`, passing in the appropriate operator function from the Python builtin ``operator`` module or a SQLAlchemy-specific operator function from :mod:`sqlalchemy.expression.operators`. For example the ``__eq__`` function:: def __eq__(self, other): return self.operate(operators.eq, other) Where ``operators.eq`` is essentially:: def eq(a, b): return a == b The core column expression unit :class:`.ColumnElement` overrides :meth:`.Operators.operate` and others to return further :class:`.ColumnElement` constructs, so that the ``==`` operation above is replaced by a clause construct. .. seealso:: :ref:`types_operators` :attr:`.TypeEngine.comparator_factory` :class:`.ColumnOperators` :class:`.PropComparator` r Nc C s | � t|�S )zdImplement the ``<`` operator. In a column context, produces the clause ``a < b``. )r r )r r r r r �__lt__T s zColumnOperators.__lt__c C s | � t|�S )zfImplement the ``<=`` operator. In a column context, produces the clause ``a <= b``. )r r )r r r r r �__le__\ s zColumnOperators.__le__c C s | � t|�S )z�Implement the ``==`` operator. In a column context, produces the clause ``a = b``. If the target is ``None``, produces ``a IS NULL``. )r r )r r r r r r7 f s zColumnOperators.__eq__c C s | � 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``. )r r )r r r r r �__ne__o s zColumnOperators.__ne__c C s | � 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". .. versionadded:: 1.1 )r �is_distinct_from)r r r r r rB x s z ColumnOperators.is_distinct_fromc C s | � t|�S )z�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". .. versionadded:: 1.1 )r �isnot_distinct_from)r r r r r rC � s z#ColumnOperators.isnot_distinct_fromc C s | � t|�S )zdImplement the ``>`` operator. In a column context, produces the clause ``a > b``. )r r )r r r r r �__gt__� s zColumnOperators.__gt__c C s | � t|�S )zfImplement the ``>=`` operator. In a column context, produces the clause ``a >= b``. )r r )r r r r r �__ge__� s zColumnOperators.__ge__c C s | � t�S )zaImplement the ``-`` operator. In a column context, produces the clause ``-a``. )r r )r r r r �__neg__� s zColumnOperators.__neg__c C s | � t|�S )N)r r )r r r r r � __contains__� s z ColumnOperators.__contains__c C s | � t|�S )z�Implement the [] operator. This can be used by some database-specific types such as PostgreSQL ARRAY and HSTORE. )r r )r �indexr r r � __getitem__� s zColumnOperators.__getitem__c C s | � 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. )r r )r r r r r � __lshift__� s zColumnOperators.__lshift__c C s | � 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. )r r )r r r r r � __rshift__� s zColumnOperators.__rshift__c C s | � t|�S )z�Implement the 'concat' operator. In a column context, produces the clause ``a || b``, or uses the ``concat()`` operator on MySQL. )r � concat_op)r r r r r �concat� s zColumnOperators.concatc C s | j t||d�S )a� Implement the ``like`` operator. In a column context, produces the expression:: a LIKE other E.g.:: stmt = select([sometable]).\ where(sometable.c.column.like("%foobar%")) :param other: expression to be compared :param escape: optional escape character, renders the ``ESCAPE`` keyword, e.g.:: somecolumn.like("foo/%bar", escape="/") .. seealso:: :meth:`.ColumnOperators.ilike` )�escape)r �like_op)r r rN r r r �like� s zColumnOperators.likec C s | j t||d�S )a� Implement the ``ilike`` operator, e.g. case insensitive LIKE. In a column context, produces an expression either of the form:: lower(a) LIKE lower(other) Or on backends that support the ILIKE operator:: a ILIKE other E.g.:: stmt = select([sometable]).\ where(sometable.c.column.ilike("%foobar%")) :param other: expression to be compared :param escape: optional escape character, renders the ``ESCAPE`` keyword, e.g.:: somecolumn.ilike("foo/%bar", escape="/") .. seealso:: :meth:`.ColumnOperators.like` )rN )r �ilike_op)r r rN r r r �ilike� s zColumnOperators.ilikec C s | � 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:: WHERE COL IN (?, ?, ?) * An empty list, e.g.:: stmt.where(column.in_([])) In this calling form, the expression renders a "false" expression, e.g.:: WHERE 1 != 1 This "false" expression has historically had different behaviors in older SQLAlchemy versions, see :paramref:`.create_engine.empty_in_strategy` for behavioral options. .. versionchanged:: 1.2 simplified the behavior of "empty in" expressions * A bound parameter, e.g. :func:`.bindparam`, may be used if it includes the :paramref:`.bindparam.expanding` flag:: stmt.where(column.in_(bindparam('value', expanding=True))) In this calling form, the expression renders a special non-SQL placeholder expression that looks like:: WHERE COL IN ([EXPANDING_value]) This placeholder expression is intercepted at statement execution time to be converted into the variable number of bound parameter form illustrated earlier. If the statement were executed as:: connection.execute(stmt, {"value": [1, 2, 3]}) The database would be passed a bound parameter for each value:: WHERE COL IN (?, ?, ?) .. versionadded:: 1.2 added "expanding" bound parameters If an empty list is passed, a special "empty list" expression, which is specific to the database in use, is rendered. On SQLite this would be:: WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1) .. versionadded:: 1.3 "expanding" bound parameters now support empty lists * a :func:`.select` construct, which is usually a correlated scalar select:: stmt.where( column.in_( select([othertable.c.y]). where(table.c.x == othertable.c.x) ) ) In this calling form, :meth:`.ColumnOperators.in_` renders as given:: WHERE COL IN (SELECT othertable.y FROM othertable WHERE othertable.x = table.x) :param other: a list of literals, a :func:`.select` construct, or a :func:`.bindparam` construct that includes the :paramref:`.bindparam.expanding` flag set to True. )r �in_op)r r r r r �in_ s SzColumnOperators.in_c C s | � 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:`.create_engine.empty_in_strategy` may be used to alter this behavior. .. versionchanged:: 1.2 The :meth:`.ColumnOperators.in_` and :meth:`.ColumnOperators.notin_` operators now produce a "static" expression for an empty IN sequence by default. .. seealso:: :meth:`.ColumnOperators.in_` )r �notin_op)r r r r r �notin_X s zColumnOperators.notin_c C s | j t||d�S )z�implement the ``NOT LIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``. .. seealso:: :meth:`.ColumnOperators.like` )rN )r � notlike_op)r r rN r r r �notlikep s zColumnOperators.notlikec C s | j t||d�S )z�implement the ``NOT ILIKE`` operator. This is equivalent to using negation with :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``. .. seealso:: :meth:`.ColumnOperators.ilike` )rN )r � notilike_op)r r rN r r r �notilike} s zColumnOperators.notilikec C s | � t|�S )aV 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.isnot` )r �is_)r r r r r r[ � s zColumnOperators.is_c C s | � t|�S )a` Implement the ``IS NOT`` operator. Normally, ``IS NOT`` is generated automatically when comparing to a value of ``None``, which resolves to ``NULL``. However, explicit usage of ``IS NOT`` may be desirable if comparing to boolean values on certain platforms. .. seealso:: :meth:`.ColumnOperators.is_` )r �isnot)r r r r r r\ � s zColumnOperators.isnotc K s | j t|f|�S )a� Implement the ``startswith`` operator. Produces a LIKE expression that tests against a match for the start of a string value:: 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:: somecolumn LIKE :param || '%' ESCAPE '/' With the value of :param as ``"foo/%bar"``. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The :paramref:`.ColumnOperators.startswith.autoescape` parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the :paramref:`.ColumnOperators.startswith.escape` parameter. :param escape: a character which when given will render with the ``ESCAPE`` keyword to establish that character as the escape character. This character can then be placed preceding occurrences of ``%`` and ``_`` to allow them to act as themselves and not wildcard characters. An expression such as:: somecolumn.startswith("foo/%bar", escape="^") Will render as:: somecolumn LIKE :param || '%' ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.startswith.autoescape`:: somecolumn.startswith("foo%bar^bat", escape="^", autoescape=True) Where above, the given literal parameter will be converted to ``"foo^%bar^^bat"`` before being passed to the database. .. seealso:: :meth:`.ColumnOperators.endswith` :meth:`.ColumnOperators.contains` :meth:`.ColumnOperators.like` )r � startswith_op)r r r, r r r � startswith� s VzColumnOperators.startswithc K s | j t|f|�S )a� Implement the 'endswith' operator. Produces a LIKE expression that tests against a match for the end of a string value:: 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:: somecolumn LIKE '%' || :param ESCAPE '/' With the value of :param as ``"foo/%bar"``. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The :paramref:`.ColumnOperators.endswith.autoescape` parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the :paramref:`.ColumnOperators.endswith.escape` parameter. :param escape: a character which when given will render with the ``ESCAPE`` keyword to establish that character as the escape character. This character can then be placed preceding occurrences of ``%`` and ``_`` to allow them to act as themselves and not wildcard characters. An expression such as:: somecolumn.endswith("foo/%bar", escape="^") Will render as:: somecolumn LIKE '%' || :param ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.endswith.autoescape`:: somecolumn.endswith("foo%bar^bat", escape="^", autoescape=True) Where above, the given literal parameter will be converted to ``"foo^%bar^^bat"`` before being passed to the database. .. seealso:: :meth:`.ColumnOperators.startswith` :meth:`.ColumnOperators.contains` :meth:`.ColumnOperators.like` )r � endswith_op)r r r, r r r �endswith� s VzColumnOperators.endswithc K s | j t|f|�S )a� Implement the 'contains' operator. Produces a LIKE expression that tests against a match for the middle of a string value:: column LIKE '%' || <other> || '%' E.g.:: stmt = select([sometable]).\ where(sometable.c.column.contains("foobar")) Since the operator uses ``LIKE``, wildcard characters ``"%"`` and ``"_"`` that are present inside the <other> expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.contains.autoescape` flag may be set to ``True`` to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the :paramref:`.ColumnOperators.contains.escape` parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string. :param other: expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters ``%`` and ``_`` are not escaped by default unless the :paramref:`.ColumnOperators.contains.autoescape` flag is set to True. :param autoescape: boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of ``"%"``, ``"_"`` and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression. An expression such as:: somecolumn.contains("foo%bar", autoescape=True) Will render as:: somecolumn LIKE '%' || :param || '%' ESCAPE '/' With the value of :param as ``"foo/%bar"``. .. versionadded:: 1.2 .. versionchanged:: 1.2.0 The :paramref:`.ColumnOperators.contains.autoescape` parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the :paramref:`.ColumnOperators.contains.escape` parameter. :param escape: a character which when given will render with the ``ESCAPE`` keyword to establish that character as the escape character. This character can then be placed preceding occurrences of ``%`` and ``_`` to allow them to act as themselves and not wildcard characters. An expression such as:: somecolumn.contains("foo/%bar", escape="^") Will render as:: somecolumn LIKE '%' || :param || '%' ESCAPE '^' The parameter may also be combined with :paramref:`.ColumnOperators.contains.autoescape`:: somecolumn.contains("foo%bar^bat", escape="^", autoescape=True) Where above, the given literal parameter will be converted to ``"foo^%bar^^bat"`` before being passed to the database. .. seealso:: :meth:`.ColumnOperators.startswith` :meth:`.ColumnOperators.endswith` :meth:`.ColumnOperators.like` )r � contains_op)r r r, r r r r T s WzColumnOperators.containsc K s | j t|f|�S )aY Implements a database-specific 'match' operator. :meth:`~.ColumnOperators.match` attempts to resolve to a MATCH-like function or operator provided by the backend. Examples include: * PostgreSQL - renders ``x @@ to_tsquery(y)`` * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)`` * Oracle - renders ``CONTAINS(x, y)`` * other backends may provide special implementations. * Backends without any special implementation will emit the operator as "MATCH". This is compatible with SQLite, for example. )r �match_op)r r r, r r r �match� s zColumnOperators.matchc C s | � t�S )zMProduce a :func:`~.expression.desc` clause against the parent object.)r �desc_op)r r r r �desc� s zColumnOperators.descc C s | � t�S )zLProduce a :func:`~.expression.asc` clause against the parent object.)r �asc_op)r r r r �asc� s zColumnOperators.ascc C s | � t�S )zSProduce a :func:`~.expression.nullsfirst` clause against the parent object.)r � nullsfirst_op)r r r r � nullsfirst� s zColumnOperators.nullsfirstc C s | � t�S )zRProduce a :func:`~.expression.nullslast` clause against the parent object.)r � nullslast_op)r r r r � nullslast� s zColumnOperators.nullslastc C s | � t|�S )z�Produce a :func:`~.expression.collate` clause against the parent object, given the collation string. .. seealso:: :func:`~.expression.collate` )r �collate)r Z collationr r r rl � s zColumnOperators.collatec C s | � t|�S )zaImplement the ``+`` operator in reverse. See :meth:`.ColumnOperators.__add__`. )r- r )r r r r r �__radd__� s zColumnOperators.__radd__c C s | � t|�S )zaImplement the ``-`` operator in reverse. See :meth:`.ColumnOperators.__sub__`. )r- r )r r r r r �__rsub__� s zColumnOperators.__rsub__c C s | � t|�S )zaImplement the ``*`` operator in reverse. See :meth:`.ColumnOperators.__mul__`. )r- r )r r r r r �__rmul__� s zColumnOperators.__rmul__c C s | � t|�S )zaImplement the ``/`` operator in reverse. See :meth:`.ColumnOperators.__div__`. )r- r )r r r r r �__rdiv__� s zColumnOperators.__rdiv__c C s | � t|�S )zaImplement the ``%`` operator in reverse. See :meth:`.ColumnOperators.__mod__`. )r- r )r r r r r �__rmod__� s zColumnOperators.__rmod__Fc C s | j t|||d�S )z{Produce a :func:`~.expression.between` clause against the parent object, given the lower and upper range. )� symmetric)r � between_op)r ZcleftZcrightrr r r r �between s zColumnOperators.betweenc C s | � t�S )z[Produce a :func:`~.expression.distinct` clause against the parent object. )r � distinct_op)r r r r �distinct s zColumnOperators.distinctc C s | � t�S )a� Produce a :func:`~.expression.any_` clause against the parent object. This operator is only appropriate against a scalar subquery object, or for some backends an column expression that is against the ARRAY type, e.g.:: # postgresql '5 = ANY (somearray)' expr = 5 == mytable.c.somearray.any_() # mysql '5 = ANY (SELECT value FROM table)' expr = 5 == select([table.c.value]).as_scalar().any_() .. seealso:: :func:`~.expression.any_` - standalone version :func:`~.expression.all_` - ALL operator .. versionadded:: 1.1 )r �any_op)r r r r �any_ s zColumnOperators.any_c C s | � t�S )a� Produce a :func:`~.expression.all_` clause against the parent object. This operator is only appropriate against a scalar subquery object, or for some backends an column expression that is against the ARRAY type, e.g.:: # postgresql '5 = ALL (somearray)' expr = 5 == mytable.c.somearray.all_() # mysql '5 = ALL (SELECT value FROM table)' expr = 5 == select([table.c.value]).as_scalar().all_() .. seealso:: :func:`~.expression.all_` - standalone version :func:`~.expression.any_` - ANY operator .. versionadded:: 1.1 )r �all_op)r r r r �all_- s zColumnOperators.all_c C s | � 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`. )r r )r r r r r �__add__F s zColumnOperators.__add__c C s | � t|�S )zdImplement the ``-`` operator. In a column context, produces the clause ``a - b``. )r r )r r r r r �__sub__R s zColumnOperators.__sub__c C s | � t|�S )zdImplement the ``*`` operator. In a column context, produces the clause ``a * b``. )r r )r r r r r �__mul__Z s zColumnOperators.__mul__c C s | � t|�S )zdImplement the ``/`` operator. In a column context, produces the clause ``a / b``. )r r )r r r r r �__div__b s zColumnOperators.__div__c C s | � t|�S )zdImplement the ``%`` operator. In a column context, produces the clause ``a % b``. )r r )r r r r r �__mod__j s zColumnOperators.__mod__c C s | � t|�S )zeImplement the ``//`` operator. In a column context, produces the clause ``a / b``. )r r )r r r r r � __truediv__r s zColumnOperators.__truediv__c C s | � t|�S )zfImplement the ``//`` operator in reverse. See :meth:`.ColumnOperators.__truediv__`. )r- r )r r r r r � __rtruediv__z s z ColumnOperators.__rtruediv__)N)N)N)N)F)7r. r/ r0 r1 r2 � timetupler? r@ r r9 r7 rA rB rC rD rE rF rG rI rJ rK rM rP rR rT rV rX rZ r[ r\ r^ r` r rc re rg ri rk rl rm rn ro rp rq rt rv rx rz r{ r| r} r~ r r� r� r r r r r> ) sf $ U XXY r> c C s t �| � | S )N)� _commutativer )�fnr r r �commutative_op� s r� c C s t �| � | S )N)� _comparisonr )r� r r r � comparison_op� s r� c C s t � �d S )N)r* r r r r �from_� s r� c C s t � �d S )N)r* r r r r �function_as_comparison_op� s r� c C s t � �d S )N)r* r r r r �as_� s r� c C s t � �d S )N)r* r r r r �exists� s r� c C s t � �d S )N)r* )�ar r r �istrue� s r� c C s t � �d S )N)r* )r� r r r �isfalse� s r� c C s | � |�S )N)rB )r� �br r r rB � s rB c C s | � |�S )N)rC )r� r� r r r rC � s rC c C s | � |�S )N)r[ )r� r� r r r r[ � s r[ c C s | � |�S )N)r\ )r� r� r r r r\ � s r\ c C s | � |�S )N)rl )r� r� r r r rl � s rl c C s | � |�|�S )N)r( )r� r$ r� r r r r( � s r( Nc C s | j ||d�S )N)rN )rP )r� r� rN r r r rO � s rO c C s | j ||d�S )N)rN )rX )r� r� rN r r r rW � s rW c C s | j ||d�S )N)rN )rR )r� r� rN r r r rQ � s rQ c C s | j ||d�S )N)rN )rZ )r� r� rN r r r rY � s rY Fc C s | j |||d�S )N)rr )rt )r� r� �crr r r r rs � s rs c C s | j |||d�S )N)rr )Z notbetween)r� r� r� rr r r r � notbetween_op� s r� c C s | � |�S )N)rT )r� r� r r r rS � s rS c C s | � |�S )N)rV )r� r� r r r rU � s rU c C s | � � S )N)rv )r� r r r ru � s ru c C s | � � S )N)rx )r� r r r rw � s rw c C s | � � S )N)rz )r� r r r ry � s ry c C sx |rl|dk rt �d� |d kr"d}t|t jj�s8td��|dkrP|�||| �}|�d|d ��d|d �}| ||d�S ) NTz;The autoescape parameter is now a simple boolean True/False�/z*String value expected when autoescape=True)�%�_r� r� )rN )r �warnr6 �compat� string_types� TypeError�replace)r� r rN � autoescaper r r �_escaped_like_impl� s r� c C s t | j|||�S )N)r� r^ )r� r� rN r� r r r r] s r] c C s t | j|||� S )N)r� r^ )r� r� rN r� r r r �notstartswith_op s r� c C s t | j|||�S )N)r� r` )r� r� rN r� r r r r_ s r_ c C s t | j|||� S )N)r� r` )r� r� rN r� r r r �notendswith_op s r� c C s t | j|||�S )N)r� r )r� r� rN r� r r r ra " s ra c C s t | j|||� S )N)r� r )r� r� rN r� r r r �notcontains_op' s r� c K s | j |f|�S )N)rc )r� r� r< r r r rb , s rb c K s | j |f|�S )N)Znotmatch)r� r� r< r r r � notmatch_op1 s r� c C s t � �d S )N)r* )r� r� r r r �comma_op6 s r� c C s t � �d S )N)r* )r� r� r r r � empty_in_op: s r� c C s t � �d S )N)r* )r� r� r r r �empty_notin_op? s r� c C s t � �d S )N)r* )r� r� r r r � filter_opD s r� c C s | � |�S )N)rM )r� r� r r r rL H s rL c C s | � � S )N)re )r� r r r rd L s rd c C s | � � S )N)rg )r� r r r rf P s rf c C s | � � S )N)ri )r� r r r rh T s rh c C s | � � S )N)rk )r� r r r rj X s rj c C s t � �d S )N)r* )r� r� r r r �json_getitem_op\ s r� c C s t � �d S )N)r* )r� r� r r r �json_path_getitem_op` s r� c C s | t kpt| t�o| jS )N)r� r6 r# r& )r( r r r r& d s r& c C s | t kS )N)r� )r( r r r �is_commutativeh s r� c C s | t tttfkS )N)rf rd rh rj )r( r r r �is_ordering_modifierl s r� c C s | t kpt| t�o| jS )N)�_natural_self_precedentr6 r# r3 )r( r r r �is_natural_self_precedentp s r� c C s t | �p| tkS )N)r& � _booleans)r( r r r � is_boolean{ s r� c C s t �| | �S )z[rotate a comparison operator 180 degrees. Note this is not the same as negation. )�_mirror�get)r( r r r �mirror� s r� �_asbooli����)� canonical� _smallesti�����_largest�d � � � � � � ���� c C s@ | |krt | �rdS t�| t| dt��t�|t|dt��kS d S )NFr% )r� � _PRECEDENCEr� �getattrr� r� )r! r" r r r � is_precedent� s r� )N)N)N)N)F)F)NF)NF)NF)NF)NF)NF)^r1 r! r r r r r r r r r r r r r r r r r r r � r Zpy2kr �objectr r# r> r� r� r� r� r� r� r� r� r� r� rB rC r[ r\ rl r( rO rW rQ rY rs r� rS rU ru rw ry r� r] r� r_ r� ra r� rb r� r� r� r� r� rL rd rf rh rj r� r� r& r� r� r� r� r� r� r� �union� differenceZ _associativer� �symbolr� r� r� r� r� r r r r �<module> s@ H8 `
geri dön