Current File : //proc/self/root/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyo
�
��4]c @ s� d Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d
l m
Z
d d l m Z d d l m Z d d
l m
Z
d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z e j rbd d l m Z n e Z d e f d � � YZ d e f d � � YZ d e f d � � YZ e e e e h Z e e e e e e
h Z d � Z d � Z d � Z! e d! � � Z" d" � Z# d# � Z$ d$ � Z% d% � Z& e d& � � Z' e d' � � Z( e d( � � Z) e d) � � Z* d* � Z+ d+ � Z, e e- d, � � Z. e e- d- � � Z/ e e- d. � � Z0 e e- d/ � � Z1 e e2 d0 � � Z3 e e2 d1 � � Z4 e d2 � � Z5 e d3 � � Z6 d4 � Z7 d5 � Z8 d6 � Z9 d7 � Z: e e- e2 d8 � � Z; e e- e2 d9 � � Z< e e- e2 d: � � Z= e e- e2 d; � � Z> e e- e2 d< � � Z? e e- e2 d= � � Z@ e d> � � ZA e d? � � ZB d@ � ZC e dA � � ZD e dB � � ZE dC � ZF dD � ZG dE � ZH dF � ZI dG � ZJ dH � ZK dI � ZL dJ � ZM dK � ZN dL � ZO dM � ZP dN � ZQ e e% e& e e f ZR dO � ZS i e e 6e
e 6e e 6e e
6ZT dP � ZU e jV eG e e g � jW e e g � ZX eX jV e eL eM g � ZY e jZ dQ dR dS �Z[ e jZ dT dR dU �Z\ e jZ dV dR dW �Z] i5 dX e! 6dX e" 6dX e8 6dX e9 6dX e 6dX eL 6dX eM 6dY e 6dY e 6dY e 6dY e
6dY e 6dZ e 6dZ e 6d[ eG 6d[ eF 6d\ eA 6d\ eB 6d\ e0 6d\ e1 6d\ e. 6d\ e/ 6d\ e5 6d\ e6 6d\ e) 6d\ e* 6d\ e 6d\ e 6d\ e' 6d\ e( 6d\ eD 6d\ eE 6d\ e 6d\ e 6d\ e 6d\ e
6d\ e3 6d\ e4 6d\ e7 6d\ e 6d\ e% 6d\ e& 6d] e 6d e 6d eC 6d] eH 6d] eI 6d^ e+ 6d e# 6d_ e$ 6dS e[ 6e\ e\ 6e] e] 6Z^ d` � Z_ da S(b s* Defines operators used in SQL expressions.i����( t add( t and_( t contains( t eq( t ge( t getitem( t gt( t inv( t le( t lshift( t lt( t mod( t mul( t ne( t neg( t or_( t rshift( t sub( t truedivi ( t util( t divt Operatorsc B s_ e Z d Z d Z d � Z d � Z d � Z d e d
d � Z d d � Z
d � Z d � 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`.
c C s | j t | � 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)
( t operateR ( t selft other( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __and__; s c C s | j t | � 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)
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __or__S s c C s
| j t � 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)
( R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
__invert__k s i c s+ t | | | | � � � � f d � } | 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 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( N( ( R ( t operatorR ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt against� s ( t custom_op( R t opstringt
precedencet
is_comparisont return_typeR ( ( R R sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt op| s :c C s | j | d | d t �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.
.. versionadded:: 1.2.0b3
.. seealso::
:meth:`.Operators.op`
R R! ( R# t True( R R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt bool_op� s c O s t t | � � � d S( s3 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( t NotImplementedErrort str( R R# R t kwargs( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR � s c K s t t | � � � d S( sX Reverse operate on an argument.
Usage is the same as :meth:`operate`.
N( R& R' ( R R# R R( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt reverse_operate� s ( N(
t __name__t
__module__t __doc__t __slots__R R R t Falset NoneR# R% R R) ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR * s
@ R c B sG e Z d Z d Z d e d e e d � Z d � Z d � Z d � 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`
R i c C sO | | _ | | _ | | _ | | _ | | _ | rB | j | � n d | _ d S( N( R R R! t natural_self_precedentt eager_groupingt _to_instanceR/ R" ( R R R R! R" R0 R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __init__
s c C s t | t � o | j | j k S( N( t
isinstanceR R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __eq__ s c C s
t | � S( N( t id( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __hash__" s c K s | j | | | � S( N( R ( R t leftt rightt kw( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __call__% s N( R* R+ R, R. R/ R3 R5 R7 R; ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR � s t ColumnOperatorsc B s� e Z d Z d0 Z d1 Z d � Z d � Z e j Z d � Z
d � Z d � Z d � Z
d � Z d � Z d � Z d
� Z d � Z d � Z d
� Z d � Z d1 d � Z d1 d � Z d � Z d � Z d1 d � Z d1 d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d � Z# d � Z$ d � Z% d � Z& d � Z' d! � Z( d" � Z) d# � Z* d$ � Z+ e, d% � Z- d& � Z. d' � Z/ d( � Z0 d) � Z1 d* � Z2 d+ � Z3 d, � Z4 d- � Z5 d. � Z6 d/ � Z7 RS(2 s 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`
c C s | j t | � S( sd Implement the ``<`` operator.
In a column context, produces the clause ``a < b``.
( R R
( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __lt__T s c C s | j t | � S( sf Implement the ``<=`` operator.
In a column context, produces the clause ``a <= b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __le__\ s c C s | j t | � S( s� 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 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR5 f s c C s | j t | � S( s� 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 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __ne__o s c C s | j t | � 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
( R t is_distinct_from( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR@ x s c C s | j t | � 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".
.. versionadded:: 1.1
( R t isnot_distinct_from( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRA � s c C s | j t | � S( sd Implement the ``>`` operator.
In a column context, produces the clause ``a > b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __gt__� s c C s | j t | � S( sf Implement the ``>=`` operator.
In a column context, produces the clause ``a >= b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __ge__� s c C s
| j t � S( sa Implement the ``-`` operator.
In a column context, produces the clause ``-a``.
( R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __neg__� s c C s | j t | � S( N( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __contains__� s c C s | j t | � S( s� Implement the [] operator.
This can be used by some database-specific types
such as PostgreSQL ARRAY and HSTORE.
( R R ( R t index( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __getitem__� s c C s | j t | � 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.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
__lshift__� s c C s | j t | � 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.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
__rshift__� s c C s | j t | � S( s� Implement the 'concat' operator.
In a column context, produces the clause ``a || b``,
or uses the ``concat()`` operator on MySQL.
( R t concat_op( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt concat� s c C s | j t | 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`
t escape( R t like_op( R R RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt like� s c C s | j t | 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`
RL ( R t ilike_op( R R RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt ilike� s c C s | j t | � 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 (?, ?, ?)
* 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 t in_op( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt in_ s Sc C s | j t | � 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:`.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 t notin_op( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notin_X s c C s | j t | d | �S( s� implement the ``NOT LIKE`` operator.
This is equivalent to using negation with
:meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``.
.. seealso::
:meth:`.ColumnOperators.like`
RL ( R t
notlike_op( R R RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notlikep s c C s | j t | d | �S( s� implement the ``NOT ILIKE`` operator.
This is equivalent to using negation with
:meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``.
.. seealso::
:meth:`.ColumnOperators.ilike`
RL ( R t notilike_op( R R RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notilike} s c C s | j t | � S( sV 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 t is_( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRY � s c C s | j t | � 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.
.. seealso:: :meth:`.ColumnOperators.is_`
( R t isnot( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRZ � s c K s | j t | | � S( s� 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 t
startswith_op( R R R( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
startswith� s Vc K s | j t | | � 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"``.
.. 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 t endswith_op( R R R( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt endswith� s Vc K s | j t | | � S( s� 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 t contains_op( R R R( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR T s Wc K s | j t | | � S( sY 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 t match_op( R R R( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt match� s c C s
| j t � S( sM Produce a :func:`~.expression.desc` clause against the
parent object.( R t desc_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt desc� s c C s
| j t � S( sL Produce a :func:`~.expression.asc` clause against the
parent object.( R t asc_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt asc� s c C s
| j t � S( sS Produce a :func:`~.expression.nullsfirst` clause against the
parent object.( R t
nullsfirst_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
nullsfirst� s c C s
| j t � S( sR Produce a :func:`~.expression.nullslast` clause against the
parent object.( R t nullslast_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt nullslast� s c C s | j t | � S( s� Produce a :func:`~.expression.collate` clause against
the parent object, given the collation string.
.. seealso::
:func:`~.expression.collate`
( R t collate( R t collation( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRj � s c C s | j t | � S( sa Implement the ``+`` operator in reverse.
See :meth:`.ColumnOperators.__add__`.
( R) R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __radd__� s c C s | j t | � S( sa Implement the ``-`` operator in reverse.
See :meth:`.ColumnOperators.__sub__`.
( R) R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __rsub__� s c C s | j t | � S( sa Implement the ``*`` operator in reverse.
See :meth:`.ColumnOperators.__mul__`.
( R) R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __rmul__� s c C s | j t | � S( sa Implement the ``/`` operator in reverse.
See :meth:`.ColumnOperators.__div__`.
( R) R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __rdiv__� s c C s | j t | � S( sa Implement the ``%`` operator in reverse.
See :meth:`.ColumnOperators.__mod__`.
( R) R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __rmod__� s c C s | j t | | d | �S( s{ Produce a :func:`~.expression.between` clause against
the parent object, given the lower and upper range.
t symmetric( R t
between_op( R t cleftt crightRq ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt between s c C s
| j t � S( s[ Produce a :func:`~.expression.distinct` clause against the
parent object.
( R t distinct_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt distinct
s c C s
| j t � S( s� 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 t any_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt any_ s c C s
| j t � S( s� 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 t all_op( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt all_- s c C s | j t | � 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`.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __add__F s
c C s | j t | � S( sd Implement the ``-`` operator.
In a column context, produces the clause ``a - b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __sub__R s c C s | j t | � S( sd Implement the ``*`` operator.
In a column context, produces the clause ``a * b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __mul__Z s c C s | j t | � S( sd Implement the ``/`` operator.
In a column context, produces the clause ``a / b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __div__b s c C s | j t | � S( sd Implement the ``%`` operator.
In a column context, produces the clause ``a % b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __mod__j s c C s | j t | � S( se Implement the ``//`` operator.
In a column context, produces the clause ``a / b``.
( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __truediv__r s c C s | j t | � S( sf Implement the ``//`` operator in reverse.
See :meth:`.ColumnOperators.__truediv__`.
( R) R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt __rtruediv__z s ( N(8 R* R+ R, R- R/ t timetupleR= R> R R7 R5 R? R@ RA RB RC RD RE RG RH RI RK RN RP RR RT RV RX RY RZ R\ R^ R Ra Rc Re Rg Ri Rj Rl Rm Rn Ro Rp R. Ru Rw Ry R{ R| R} R~ R R� R� R� ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR< ) sf $ U
X X Y c C s t j | � | S( N( t _commutativeR ( t fn( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt commutative_op� s
c C s t j | � | S( N( t _comparisonR ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
comparison_op� s
c C s
t � � d S( N( R& ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt from_� s c C s
t � � d S( N( R& ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt function_as_comparison_op� s c C s
t � � d S( N( R& ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt as_� s c C s
t � � d S( N( R& ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt exists� s c C s
t � � d S( N( R& ( t a( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt istrue� s c C s
t � � d S( N( R& ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt isfalse� s c C s
| j | � S( N( R@ ( R� t b( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR@ � s c C s
| j | � S( N( RA ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRA � s c C s
| j | � S( N( RY ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRY � s c C s
| j | � S( N( RZ ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRZ � s c C s
| j | � S( N( Rj ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRj � s c C s | j | � | � S( N( R# ( R� R R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR# � s c C s | j | d | �S( NRL ( RN ( R� R� RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRM � s c C s | j | d | �S( NRL ( RV ( R� R� RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRU � s c C s | j | d | �S( NRL ( RP ( R� R� RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRO � s c C s | j | d | �S( NRL ( RX ( R� R� RL ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRW � s c C s | j | | d | �S( NRq ( Ru ( R� R� t cRq ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRr � s c C s | j | | d | �S( NRq ( t
notbetween( R� R� R� Rq ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
notbetween_op� s c C s
| j | � S( N( RR ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRQ � s c C s
| j | � S( N( RT ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRS � s c C s
| j � S( N( Rw ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRv � s c C s
| j � S( N( Ry ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRx � s c C s
| j � S( N( R{ ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRz � s c C s� | r� | t k r" t j d � n | d k r7 d } n t | t j j � s[ t d � � n | d k r� | j | | | � } n | j d | d � j d | d � } n | | d | �S( Ns; The autoescape parameter is now a simple boolean True/Falset /s* String value expected when autoescape=Truet %t _RL ( R� R� ( R$ R t warnR/ R4 t compatt string_typest TypeErrort replace( R� R RL t
autoescape( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt _escaped_like_impl� s
)c C s t | j | | | � S( N( R� R\ ( R� R� RL R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR[ s c C s t | j | | | � S( N( R� R\ ( R� R� RL R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notstartswith_op s c C s t | j | | | � S( N( R� R^ ( R� R� RL R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR] s c C s t | j | | | � S( N( R� R^ ( R� R� RL R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notendswith_op s c C s t | j | | | � S( N( R� R ( R� R� RL R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR_ " s c C s t | j | | | � S( N( R� R ( R� R� RL R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notcontains_op' s c K s | j | | � S( N( Ra ( R� R� R: ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR` , s c K s | j | | � S( N( t notmatch( R� R� R: ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt notmatch_op1 s c C s
t � � d S( N( R& ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt comma_op6 s c C s
t � � d S( N( R& ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt empty_in_op: s c C s
t � � d S( N( R& ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt empty_notin_op? s c C s
t � � d S( N( R& ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt filter_opD s c C s
| j | � S( N( RK ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRJ H s c C s
| j � S( N( Rc ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRb L s c C s
| j � S( N( Re ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRd P s c C s
| j � S( N( Rg ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRf T s c C s
| j � S( N( Ri ( R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyRh X s c C s
t � � d S( N( R& ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt json_getitem_op\ s c C s
t � � d S( N( R& ( R� R� ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt json_path_getitem_op` s c C s" | t k p! t | t � o! | j S( N( R� R4 R R! ( R# ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyR! d s c C s
| t k S( N( R� ( R# ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt is_commutativeh s c C s | t t t t f k S( N( Rd Rb Rf Rh ( R# ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt is_ordering_modifierl s c C s" | t k p! t | t � o! | j S( N( t _natural_self_precedentR4 R R0 ( R# ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt is_natural_self_precedentp s c C s t | � p | t k S( N( R! t _booleans( R# ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt
is_boolean{ s c C s t j | | � S( s[ rotate a comparison operator 180 degrees.
Note this is not the same as negation.
( t _mirrort get( R# ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt mirror� s t _asboolt canonicali����t _smallesti����t _largestid i i i i i i i i c C sZ | | k r t | � r t St j | t | d t � � t j | t | d t � � k Sd S( NR ( R� R. t _PRECEDENCER� t getattrR� R� ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt is_precedent� s
N(` R, R R R R R R R R R R R R
R R R
R R R R R t R t py2kR t objectR R R< R� R� R� R� R� R� R� R� R� R� R@ RA RY RZ Rj R# R/ RM RU RO RW R. Rr R� RQ RS Rv Rx Rz R� R[ R� R] R� R_ R� R` R� R� R� R� R� RJ Rb Rd Rf Rh R� R� R! R� R� R� R� R� R� R� t uniont
differencet _associativeR� t symbolR� R� R� R� R� ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyt <module> s: �8� � � ] " '
Mini Shell