Commits

Mike Bayer committed 0ca155a

- for the moment, the default comparisons don't need the ColumnOperator interface.
Still a little concerned about the "self.expr" vs. "expr passed in" thing.

Comments (0)

Files changed (1)

lib/sqlalchemy/sql/expression.py

 def and_(*clauses):
     """Join a list of clauses together using the ``AND`` operator.
 
-    The ``&`` operator is also overloaded on all
-    :class:`CompareMixin` subclasses to produce the
+    The ``&`` operator is also overloaded on all :class:`.ColumnElement`
+    subclasses to produce the
     same result.
 
     """
     """Join a list of clauses together using the ``OR`` operator.
 
     The ``|`` operator is also overloaded on all
-    :class:`CompareMixin` subclasses to produce the
+    :class:`.ColumnElement` subclasses to produce the
     same result.
 
     """
     """Return a negation of the given clause, i.e. ``NOT(clause)``.
 
     The ``~`` operator is also overloaded on all
-    :class:`CompareMixin` subclasses to produce the
+    :class:`.ColumnElement` subclasses to produce the
     same result.
 
     """
     Equivalent of SQL ``clausetest BETWEEN clauseleft AND clauseright``.
 
     The :func:`between()` method on all
-    :class:`CompareMixin` subclasses provides
+    :class:`.ColumnElement` subclasses provides
     similar functionality.
 
     """
 
     Literal clauses are created automatically when non- :class:`.ClauseElement`
     objects (such as strings, ints, dates, etc.) are used in a comparison
-    operation with a :class:`CompareMixin`
+    operation with a :class:`.ColumnElement`
     subclass, such as a :class:`~sqlalchemy.schema.Column` object.
     Use this function to force the
     generation of a literal clause, which will be created as a
         return self
 
 
-class _DefaultColumnComparator(ColumnOperators):
+class _DefaultColumnComparator(object):
     """Defines comparison and math operations.
 
-    The :class:`.CompareMixin` is part of the interface provided
-    by the :class:`.ColumnElement` class, which provides the base class
-    for all SQL expression units.
-
     See :class:`.ColumnOperators` and :class:`.Operators` for descriptions
     of all operations.
 
     ``NULL``, literals, etc.  :class:`.ColumnElement` is the ultimate base
     class for all such elements.
 
-    A :class:`.ColumnElement`, by subclassing the :class:`.CompareMixin` mixin
-    class, provides the ability to generate new :class:`.ClauseElement`
+    A :class:`.ColumnElement` provides the ability to generate new :class:`.ClauseElement`
     objects using Python expressions.  This means that Python operators
     such as ``==``, ``!=`` and ``<`` are overloaded to mimic SQL operations,
     and allow the construction of :class:`.ColumnElement` constructs which
     """Represent an expression that is ``LEFT <operator> RIGHT``.
 
     A :class:`.BinaryExpression` is generated automatically
-    whenever two objects that subclass the :class:`.CompareMixin`
-    mixin are used in a Python binary expresion::
+    whenever two column expressions are used in a Python binary expresion::
 
         >>> from sqlalchemy.sql import column
         >>> column('a') + column('b')