[Sqlalchemy-commits] sqlalchemy: - move Operators and ColumnOperators into sqlalchemy...
Brought to you by:
zzzeek
Menu
▾
▴
[Sqlalchemy-commits] sqlalchemy: - move Operators and ColumnOperators into sqlalchemy...
|
From: <co...@sq...> - 2011-05-29 00:25:13
|
details: http://hg.sqlalchemy.org/sqlalchemy/sqlalchemy/rev/626dae1dc177 changeset: 7634:626dae1dc177 user: zzzeek date: Sat May 28 20:24:57 2011 -0400 description: - move Operators and ColumnOperators into sqlalchemy.sql.operators - since this is strictly a system of routing Python operators into functions. Keep the references available in expression.py for the near future. diffstat: doc/build/core/expression_api.rst | 4 +- lib/sqlalchemy/__init__.py | 2 +- lib/sqlalchemy/orm/interfaces.py | 4 +- lib/sqlalchemy/sql/expression.py | 425 +------------------------------------- lib/sqlalchemy/sql/operators.py | 424 +++++++++++++++++++++++++++++++++++++ 5 files changed, 430 insertions(+), 429 deletions(-) diffs (truncated from 929 to 300 lines): diff -r ef76f92ffcfe -r 626dae1dc177 doc/build/core/expression_api.rst --- a/doc/build/core/expression_api.rst Sat May 28 13:28:38 2011 -0400 +++ b/doc/build/core/expression_api.rst Sat May 28 20:24:57 2011 -0400 @@ -134,7 +134,7 @@ :members: :show-inheritance: -.. autoclass:: ColumnOperators +.. autoclass:: sqlalchemy.sql.operators.ColumnOperators :members: :undoc-members: :inherited-members: @@ -191,7 +191,7 @@ :members: :show-inheritance: -.. autoclass:: Operators +.. autoclass:: sqlalchemy.sql.expression.Operators :members: :undoc-members: diff -r ef76f92ffcfe -r 626dae1dc177 lib/sqlalchemy/__init__.py --- a/lib/sqlalchemy/__init__.py Sat May 28 13:28:38 2011 -0400 +++ b/lib/sqlalchemy/__init__.py Sat May 28 20:24:57 2011 -0400 @@ -117,6 +117,6 @@ __all__ = sorted(name for name, obj in locals().items() if not (name.startswith('_') or inspect.ismodule(obj))) -__version__ = '0.7.0' +__version__ = '0.7.1' del inspect, sys diff -r ef76f92ffcfe -r 626dae1dc177 lib/sqlalchemy/orm/interfaces.py --- a/lib/sqlalchemy/orm/interfaces.py Sat May 28 13:28:38 2011 -0400 +++ b/lib/sqlalchemy/orm/interfaces.py Sat May 28 20:24:57 2011 -0400 @@ -20,7 +20,7 @@ from sqlalchemy import exc as sa_exc from sqlalchemy import util -from sqlalchemy.sql import expression +from sqlalchemy.sql import operators deque = util.importlater('collections').deque mapperutil = util.importlater('sqlalchemy.orm', 'util') @@ -179,7 +179,7 @@ return operator(self.comparator, value) -class PropComparator(expression.ColumnOperators): +class PropComparator(operators.ColumnOperators): """Defines comparison operations for MapperProperty objects. User-defined subclasses of :class:`.PropComparator` may be created. The diff -r ef76f92ffcfe -r 626dae1dc177 lib/sqlalchemy/sql/expression.py --- a/lib/sqlalchemy/sql/expression.py Sat May 28 13:28:38 2011 -0400 +++ b/lib/sqlalchemy/sql/expression.py Sat May 28 20:24:57 2011 -0400 @@ -31,6 +31,7 @@ from sqlalchemy import util, exc from sqlalchemy.sql import operators +from sqlalchemy.sql.operators import Operators, ColumnOperators from sqlalchemy.sql.visitors import Visitable, cloned_traverse import operator @@ -1665,430 +1666,6 @@ def _clone(self): return self -class Operators(object): - """Base of comparison and logical operators. - - Implements base methods :meth:`operate` and :meth:`reverse_operate`, - as well as :meth:`__and__`, :meth:`__or__`, :meth:`__invert__`. - - Usually is used via its most common subclass - :class:`.ColumnOperators`. - - """ - def __and__(self, other): - """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) - - """ - return self.operate(operators.and_, other) - - def __or__(self, other): - """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) - - """ - return self.operate(operators.or_, other) - - def __invert__(self): - """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) - - """ - return self.operate(operators.inv) - - def op(self, opstring): - """produce a generic operator function. - - e.g.:: - - somecolumn.op("*")(5) - - produces:: - - somecolumn * 5 - - :param operator: a string which will be output as the infix operator - between this :class:`.ClauseElement` and the expression passed to the - generated function. - - 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. - - """ - def op(b): - return self.operate(operators.op, opstring, b) - return op - - def operate(self, op, *other, **kwargs): - """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`. - - - """ - raise NotImplementedError(str(op)) - - def reverse_operate(self, op, other, **kwargs): - """Reverse operate on an argument. - - Usage is the same as :meth:`operate`. - - """ - raise NotImplementedError(str(op)) - -class ColumnOperators(Operators): - """Defines comparison and math operations. - - By default all methods call down to - :meth:`Operators.operate` or :meth:`Operators.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 - - A SQLAlchemy construct like :class:`.ColumnElement` ultimately - overrides :meth:`.Operators.operate` and others - to return further :class:`.ClauseElement` constructs, - so that the ``==`` operation above is replaced by a clause - construct. - - The docstrings here will describe column-oriented - behavior of each operator. For ORM-based operators - on related objects and collections, see :class:`.RelationshipProperty.Comparator`. - - """ - - timetuple = None - """Hack, allows datetime objects to be compared on the LHS.""" - - def __lt__(self, other): - """Implement the ``<`` operator. - - In a column context, produces the clause ``a < b``. - - """ - return self.operate(operators.lt, other) - - def __le__(self, other): - """Implement the ``<=`` operator. - - In a column context, produces the clause ``a <= b``. - - """ - return self.operate(operators.le, other) - - __hash__ = Operators.__hash__ - - def __eq__(self, other): - """Implement the ``==`` operator. - - In a column context, produces the clause ``a = b``. - If the target is ``None``, produces ``a IS NULL``. - - """ - return self.operate(operators.eq, other) - - def __ne__(self, other): - """Implement the ``!=`` operator. - - In a column context, produces the clause ``a != b``. - If the target is ``None``, produces ``a IS NOT NULL``. - - """ - return self.operate(operators.ne, other) - - def __gt__(self, other): - """Implement the ``>`` operator. - - In a column context, produces the clause ``a > b``. - - """ - return self.operate(operators.gt, other) - - def __ge__(self, other): - """Implement the ``>=`` operator. - - In a column context, produces the clause ``a >= b``. - - """ - return self.operate(operators.ge, other) - - def __neg__(self): - """Implement the ``-`` operator. - - In a column context, produces the clause ``-a``. - - """ - return self.operate(operators.neg) - - def concat(self, other): - """Implement the 'concat' operator. |