�
���ec@sdZd
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
d	l
m	Z	
d
d
l
m
Z

d
dl
mZ
d
dl
mZ
d
d
l
m
Z

d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
d
dl
mZ
ddlmZ
ejrb
d
dl
mZ
neZdef
d��YZdef
d��YZdef
d��YZeeeehZeeeeee
hZd�Zd�Z d �Z!e d!��
Z"d"�Z#d#�Z$d$�Z%e%Z&d%�Z'e'Z(e d&��
Z)e d'��
Z*e*Z+e d(��
Z,e d)��
Z-e-Z.d*�Z/d+�Z0e e1d,�
�
Z2e e1d-�
�
Z3e3Z4e e1d.�
�
Z5e e1d/�
�
Z6e6Z7e e8d0�
�
Z9e e8d1�
�
Z:e:Z;e d2��
Z<e d3��
Z=e=Z>d4�Z?d5�Z@d6�ZAd7�ZBe e1e8d8��
ZCe e1e8d9��
ZDeDZEe e1e8d:��
ZFe e1e8d;��
ZGeGZHe e1e8d<��
ZIe e1e8d=��
ZJeJZKe d>��
ZLe e1d?�
�
ZMe e1d@�
�
ZNe1dA�
ZOe dB��
ZPePZQdC�ZRdD�ZSdE�ZTdF�ZUdG�ZVdH�ZWeWZXdI�ZYeYZZdJ�Z[dK�Z\dL�Z]dM�Z^dN�Z_dO�Z`e	e%e'eefZadP�Zbiee6e
e6ee6ee
6ZcdQ�ZdejeeTeeg�
jfeeg�
ZgdR�Zhegjeee[e\g�
ZiejjdSdTdU�

ZkejjdVdTdW�

ZlejjdXdTdY�

Zmi6dZe!6dZe"6dZe@6dZeA6dZe6dZe[6dZe\6d[e6d[e6d[e6d[e
6d[e6d\e6d\e6d]eT6d]eS6d^eL6d^eP6d^eM6d^eN6d^eO6d^e56d^e66d^e26d^e36d^e<6d^e=6d^e,6d^e-6d^e6d^e6d^e)6d^e*6d^e6d^e6d^e6d^e
6d^e96d^e:6d^e?6d^e	6d^e%6d^e'6d_e6de6d
eR6d_eU6d_eV6d`e/6d
e#6dae$6dUek6elel6emem6Zndb�ZodcS(ds*Defines operators used in SQL expressions.i����(
tadd(
tand_(
tcontains(
teq(
tge(
tgetitem(
tgt(
tinv(
tle(
tlshift(
tlt(
tmod(
tmul(
tne(
tneg(
tor_(
trshift(
tsub(
ttruedivi(
tutil(
tdivt	OperatorscBs_eZ
dZd	Zd
�Zd�Zd�Zded
d�Z	dd�
Z
d�Zd�ZRS(s�
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`.

    cCs|jt
|
�S(
s-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)

        (toperateR
(tselftother((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__and__;scCs|jt
|
�S(
s)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)

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__or__Ssc

Cs
|jt
�
S(
s
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)

        (RR(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
__invert__ksics+t|
|||����
fd
�}|S(s�	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 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.  In SQLAlchemy 2.0 it
         will also provide for improved typing support.

        :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.

        .. seealso::

            :meth:`.Operators.bool_op`

            :ref:`types_operators`

            :ref:`relationship_custom_operator`

        c

s
��
|�S(
N((
R(toperatorR(sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytagainst�s
(
t	custom_op(Rtopstringt
precedencet
is_comparisontreturn_typeR((RRsI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytop|sBcCs|j|
d
|dt
�
S(s�
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`

        R R!(R#tTrue(RRR ((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytbool_op�scOstt
|
�
�
�
d
S(sGOperate 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`.


        N(tNotImplementedErrortstr(RR#Rtkwargs((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR�scKstt
|
�
�
�
d
S(sXReverse operate on an argument.

        Usage is the same as :meth:`operate`.

        N(R&R'(RR#RR(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytreverse_operate�s(N(
t__name__t
__module__t__doc__t	__slots__RRRtFalsetNoneR#R%RR)(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR*s
			H	RcBsPeZ
dZd
Zdedeed�Zd�Zd�Zd�Zd�Z	RS(	s�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`

    RicCsO|
|_||_
||_||_||_|rB|j|�
nd|_dS(
N(RR R!tnatural_self_precedentteager_groupingt_to_instanceR/R"(RRR R!R"R0R1((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__init__
s		
	
	
	
	cCs%t|
t
�o$|
j�|j�kS(
N(t
isinstanceRt	_hash_key(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__eq__'
s
c

Cst|j
��
S(
N(thashR5(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__hash__-
s
c

Cs@|j|j
|j|j|j|j|jr9|jjndfS(
N(	t	__class__RR R!R0R1R"t_static_cache_keyR/(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR50
s





cKs|
j|||�S(
N(
R(Rtlefttrighttkw((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__call__;
s
N(
R*R+R,R.R/R3R6R8R5R>(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR�s



			tColumnOperatorscBs$eZ
dZd3Zd4Zd
�Zd�Zej	Z	d�Z
d�Zd�Zd�Z
e
Zd�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd4d�
Zd4d�
Zd�Zd�ZeZd4d�
ZeZd4d�
ZeZ d�Z!d�Z"e"Z#d�Z$d�Z%d�Z&d�Z'd4d�
Z(d4d�
Z)d�Z*d�Z+d �Z,e,Z-d!�Z.e.Z/d"�Z0d#�Z1d$�Z2d%�Z3d&�Z4d'�Z5e6d(�
Z7d)�Z8d*�Z9d+�Z:d,�Z;d-�Z<d.�Z=d/�Z>d0�Z?d1�Z@d2�ZARS(5s"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`

    cCs|jt
|
�S(
sdImplement the ``<`` operator.

        In a column context, produces the clause ``a < b``.

        (RR
(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__lt__j
scCs|jt
|
�S(
sfImplement the ``<=`` operator.

        In a column context, produces the clause ``a <= b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__le__r
scCs|jt
|
�S(
s�Implement the ``==`` operator.

        In a column context, produces the clause ``a = b``.
        If the target is ``None``, produces ``a IS NULL``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR6|
scCs|jt
|
�S(
s�Implement the ``!=`` operator.

        In a column context, produces the clause ``a != b``.
        If the target is ``None``, produces ``a IS NOT NULL``.

        (RR
(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__ne__�
scCs|jt
|
�S(
s�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

        (Rtis_distinct_from(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRC�
s	cCs|jt
|
�S(
s�
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.

        .. versionadded:: 1.1

        (Rtis_not_distinct_from(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRD�
s
cCs|jt
|
�S(
sdImplement the ``>`` operator.

        In a column context, produces the clause ``a > b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__gt__�
scCs|jt
|
�S(
sfImplement the ``>=`` operator.

        In a column context, produces the clause ``a >= b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__ge__�
sc

Cs
|jt
�
S(
saImplement the ``-`` operator.

        In a column context, produces the clause ``-a``.

        (RR(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__neg__�
scCs|jt
|
�S(
N(RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__contains__�
s
cCs|jt
|
�S(
s�Implement the [] operator.

        This can be used by some database-specific types
        such as PostgreSQL ARRAY and HSTORE.

        (RR(Rtindex((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__getitem__�
scCs|jt
|
�S(
s�implement the << operator.

        Not used by SQLAlchemy core, this is provided
        for custom operator systems which want to use
        << as an extension point.
        (RR	(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
__lshift__�
scCs|jt
|
�S(
s�implement the >> operator.

        Not used by SQLAlchemy core, this is provided
        for custom operator systems which want to use
        >> as an extension point.
        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
__rshift__�
scCs|jt
|
�S(
s�Implement the 'concat' operator.

        In a column context, produces the clause ``a || b``,
        or uses the ``concat()`` operator on MySQL.

        (Rt	concat_op(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytconcat�
scCs|jt
|
�S(
s|Implement an 'rconcat' operator.

        this is for internal use at the moment

        .. versionadded:: 1.4.40

        (R)RM(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt_rconcat�
scCs|jt
|
d
|�
S(s�
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`

        tescape(Rtlike_op(RRRP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytlike�
scCs|jt
|
d
|�
S(s�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`

        RP(Rtilike_op(RRRP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytilike
scCs|jt
|
�S(
s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 (?, ?, ?)

        * 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::

            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::

            WHERE COL IN ([EXPANDING_value])

          This placeholder expression is intercepted at statement execution
          time to be converted into the variable number of bound parameter
          form illustrated earlier.   If the statement were executed as::

            connection.execute(stmt, {"value": [1, 2, 3]})

          The database would be passed a bound parameter for each value::

            WHERE COL IN (?, ?, ?)

          .. versionadded:: 1.2 added "expanding" bound parameters

          If an empty list is passed, a special "empty list" expression,
          which is specific to the database in use, is rendered.  On
          SQLite this would be::

            WHERE COL IN (SELECT 1 FROM (SELECT 1) WHERE 1!=1)

          .. versionadded:: 1.3 "expanding" bound parameters now support
             empty lists

        * a :func:`_expression.select` construct, which is usually a
          correlated scalar select::

            stmt.where(
                column.in_(
                    select(othertable.c.y).
                    where(table.c.x == othertable.c.x)
                )
            )

          In this calling form, :meth:`.ColumnOperators.in_` renders as given::

            WHERE COL IN (SELECT othertable.y
            FROM othertable WHERE othertable.x = table.x)

        :param other: a list of literals, a :func:`_expression.select`
         construct, or a :func:`.bindparam` construct that includes the
         :paramref:`.bindparam.expanding` flag set to True.

        (Rtin_op(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytin_*sWcCs|jt
|
�S(
s�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_op(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_in�scCs|jt
|
d
|�
S(s�
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`

        RP(Rt
notlike_op(RRRP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_like�scCs|jt
|
d
|�
S(s�
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`

        RP(Rtnotilike_op(RRRP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt	not_ilike�scCs|jt
|
�S(
sW
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`

        (Rtis_(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR]�scCs|jt
|
�S(
s%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_`

        (Rtis_not(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR^�scKs|jt
|
|�S(
sSImplement 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"``.

        :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`

        (Rt
startswith_op(RRR(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
startswith�sMcKs|jt
|
|�S(
s?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"``.

        :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`

        (Rtendswith_op(RRR(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytendswith:sMcKs|jt
|
|�S(
sXImplement 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"``.

        :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`


        (Rtcontains_op(RRR(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR�sNcKs|jt
|
|�S(
s�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 @@ to_tsquery(y)``
        * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)``

          .. seealso::

                :class:`_mysql.match` - MySQL specific construct with
                additional features.

        * 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.

        (Rtmatch_op(RRR(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytmatch�scCs|jt
|
d
|�
S(s�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 - 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,
        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`


        tflags(Rtregexp_match_op(RtpatternRf((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytregexp_match�s6cCs|jt
|
d
|d|�S(sImplements a database-specific 'regexp replace' operator.

        E.g.::

            stmt = select(
                table.c.some_column.regexp_replace(
                    'b(..)',
                    'X
Y',
                    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, 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`

        treplacementRf(Rtregexp_replace_op(RRhRjRf((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytregexp_replace)s/
c

Cs
|jt
�
S(
sLProduce a :func:`_expression.desc` clause against the
        parent object.(Rtdesc_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytdesc\sc

Cs
|jt
�
S(
sKProduce a :func:`_expression.asc` clause against the
        parent object.(Rtasc_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytascasc

Cs
|jt
�
S(
s*
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.
        (Rtnulls_first_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnulls_firstfsc

Cs
|jt
�
S(
s'
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_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
nulls_lastsscCs|jt
|
�S(
s�Produce a :func:`_expression.collate` clause against
        the parent object, given the collation string.

        .. seealso::

            :func:`_expression.collate`

        (Rtcollate(Rt	collation((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRu�s	cCs|jt
|
�S(
saImplement the ``+`` operator in reverse.

        See :meth:`.ColumnOperators.__add__`.

        (R)R(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__radd__�scCs|jt
|
�S(
saImplement the ``-`` operator in reverse.

        See :meth:`.ColumnOperators.__sub__`.

        (R)R(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__rsub__�scCs|jt
|
�S(
saImplement the ``*`` operator in reverse.

        See :meth:`.ColumnOperators.__mul__`.

        (R)R(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__rmul__�scCs|jt
|
�S(
saImplement the ``/`` operator in reverse.

        See :meth:`.ColumnOperators.__div__`.

        (R)R(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__rdiv__�scCs|jt
|
�S(
saImplement the ``%`` operator in reverse.

        See :meth:`.ColumnOperators.__mod__`.

        (R)R(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__rmod__�scCs|jt
|
|d
|�
S(szProduce a :func:`_expression.between` clause against
        the parent object, given the lower and upper range.

        t	symmetric(Rt
between_op(RtclefttcrightR|((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytbetween�sc

Cs
|jt
�
S(
sZProduce a :func:`_expression.distinct` clause against the
        parent object.

        (Rtdistinct_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytdistinct�sc

Cs
|jt
�
S(
s�
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 its older
            :class:`_types.ARRAY`-specific counterpart, the
            :meth:`_types.ARRAY.Comparator.any` method, which a different
            calling syntax and usage pattern.

        .. versionadded:: 1.1

        (Rtany_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytany_�sc

Cs
|jt
�
S(
s�
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 its older
            :class:`_types.ARRAY`-specific counterpart, the
            :meth:`_types.ARRAY.Comparator.all` method, which a different
            calling syntax and usage pattern.


        .. versionadded:: 1.1

        (Rtall_op(
R((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytall_�scCs|jt
|
�S(
s4
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`.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__add__�s
cCs|jt
|
�S(
sdImplement the ``-`` operator.

        In a column context, produces the clause ``a - b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__sub__�scCs|jt
|
�S(
sdImplement the ``*`` operator.

        In a column context, produces the clause ``a * b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__mul__�scCs|jt
|
�S(
sdImplement the ``/`` operator.

        In a column context, produces the clause ``a / b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__div__scCs|jt
|
�S(
sdImplement the ``%`` operator.

        In a column context, produces the clause ``a % b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__mod__scCs|jt
|
�S(
seImplement the ``//`` operator.

        In a column context, produces the clause ``a / b``.

        (RR(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__truediv__scCs|jt
|
�S(
sfImplement the ``//`` operator in reverse.

        See :meth:`.ColumnOperators.__truediv__`.

        (R)R(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt__rtruediv__s(N(BR*R+R,R-R/t	timetupleR@RARR8R6RBRCRDtisnot_distinct_fromRERFRGRHRJRKRLRNRORRRTRVRXtnotin_RZtnotlikeR\tnotilikeR]R^tisnotR`RbRReRiRlRnRpRrt
nullsfirstRtt	nullslastRuRwRxRyRzR{R.R�R�R�R�R�R�R�R�R�R�R�(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR??
sz$																						
	Y		
		O	O	P	83																			c

Cstj
|�

|S(
N(t_commutativeR(
tfn((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytcommutative_op%s


c

Cstj
|�

|S(
N(t_comparisonR(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
comparison_op*s


c
Cs
t��
dS(
N(
R&(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytfrom_/s
c
Cs
t��
dS(
N(
R&(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytfunction_as_comparison_op3sc
Cs
t��
dS(
N(
R&(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytas_8s
c
Cs
t��
dS(
N(
R&(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytexists<s
c


Cs
t��
dS(
N(
R&(
t
a((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_true@s
c


Cs
t��
dS(
N(
R&(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_falseHs
cCs
|j|
�
S(
N(
RC(R�t
b((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRCPscCs
|j|
�
S(
N(
RD(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRDUscCs
|j|
�
S(
N(
R](R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR]^scCs
|j|
�
S(
N(
R^(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR^cscCs
|j|
�
S(
N(
Ru(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRuls
cCs|j|
�
|�
S(
N(
R#(R�RR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR#ps
cCs|j|
d
|�

S(NRP(
RR(R�R�RP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRQtscCs|j|
d
|�

S(NRP(
R�(R�R�RP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_like_opyscCs|j|
d
|�

S(NRP(
RT(R�R�RP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRS�scCs|j|
d
|�

S(NRP(
R\(R�R�RP((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_ilike_op�scCs|j|
|d
|�
S(NR|(
R�(R�R�t
cR|((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR}�scCs|j|
|d
|�
S(NR|(
R�(R�R�R�R|((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_between_op�scCs
|j|
�
S(
N(
RV(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRU�scCs
|j|
�
S(
N(
RX(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRW�sc


Cs
|j�S(
N(
R�(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR��s
c


Cs
|j�S(
N(
R�(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR��s
c


Cs
|j�S(
N(
R�(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR��s
cCs�|r�|tk	r"t
jd
�

n|dkr7d}nt|
t
jj�s[td�
�
n|dkr�|
j|||�}
n|
jd|d�jd|d�}
n||
d|�

S(Ns;The autoescape parameter is now a simple boolean True/Falset
/s*String value expected when autoescape=Truet
%t
_RP(R�R�(	R$RtwarnR/R4tcompattstring_typest	TypeErrortreplace(R�RRPt
autoescape((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt_escaped_like_impl�s





	

)cCst|j
|
||�S(
N(R�R`(R�R�RPR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR_�scCst|j
|
||�S(
N(R�R`(R�R�RPR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_startswith_op�scCst|j
|
||�S(
N(R�Rb(R�R�RPR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRa�scCst|j
|
||�S(
N(R�Rb(R�R�RPR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_endswith_op�scCst|j
|
||�S(
N(R�R(R�R�RPR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRc�scCst|j
|
||�S(
N(R�R(R�R�RPR�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_contains_op�scKs|j|
|�
S(
N(
Re(R�R�R=((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRd�scCs|j|
d
|�

S(NRf(
Ri(R�R�Rf((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRg�scCs|j|
d
|�

S(NRf(
Ri(R�R�Rf((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_regexp_match_opscCs|j|
d
|d|�
S(NRjRf(
Rl(R�R�RjRf((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRks
cKs|j|
|�
S(
N(
Re(R�R�R=((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytnot_match_op	sc
Cs
t��
dS(
N(
R&(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytcomma_ops
c
Cs
t��
dS(
N(
R&(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt	filter_ops
cCs9y
|j}Wnt
k
r*


|
j|�
SX||
�
SdS(
N(RNtAttributeErrorRO(R�R�RN((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRMs






c


Cs
|j�S(
N(
Rn(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRm#s
c


Cs
|j�S(
N(
Rp(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRo's
c


Cs
|j�S(
N(
Rr(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRq+s
c


Cs
|j�S(
N(
Rt(
R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyRs3s
c
Cs
t��
dS(
N(
R&(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytjson_getitem_op;s
c
Cs
t��
dS(
N(
R&(R�R�((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytjson_path_getitem_op?s
c

Cs"|tkp!t
|t�o!|jS(
N(R�R4RR!(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyR!Cs
c

Cs
|tkS(
N(
R�(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_commutativeGs
c

Cs|tt
ttfkS(
N(RoRmRqRs(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_ordering_modifierKs
c

Cs"|tkp!t
|t�o!|jS(
N(t_natural_self_precedentR4RR0(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_natural_self_precedentOs

c

Cst|�
p|t
kS(
N(R!t	_booleans(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt
is_booleanZs
c

Cstj
||�S(
s[rotate a comparison operator 180 degrees.

    Note this is not the same as negation.

    (t_mirrortget(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytmirrorasc

Cs
|tkS(
N(
t_associative(
R#((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_associativems
t_asboolt	canonicali����t	_smallesti����t_largestidiiiiiiiicCsZ||
krt|�
rt
Stj|t|d
t��tj|
t|
d
t��k
SdS(NR (R�R.t_PRECEDENCER�tgetattrR�R�(RR((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pytis_precedent�s




N(pR,RRR
RRRRRRRR	R
RRR
RRRRRtRtpy2kRtobjectRRR?R�R�R�R�R�R�R�R�R�tistrueR�tisfalseRCRDR�R]R^R�RuR#R/RQR�RYRSR�R[R.R}R�t
notbetween_opRURWtnotin_opR�R�R�R�R_R�tnotstartswith_opRaR�tnotendswith_opRcR�tnotcontains_opRdRgR�RkR�tnotmatch_opR�R�RMRmRoRqt
nullsfirst_opRstnullslast_opR�R�R!R�R�R�R�R�R�R�tuniont
differenceR�R�R�tsymbolR�R�R�R�R�(((sI/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/sql/operators.pyt<module>s`


















	
�F����
									





				







															"		'