Commits

Mike Bayer committed ecdbada

- changed "BooleanExpression" to subclass from "BinaryExpression", so that boolean
expressions can also follow column-clause behaviors (i.e. label(), etc).
- query.select() had to become more picky about what it considers to be a full "selectable"
and what it considers to be a fragment that represents a WHERE criterion - looks for the presence
of a FromClause now (which is still pretty liberal, since i originally intended the check to be
for select() only). the previous exception-catch method also added a little stack tracing
overhead anyway.

Comments (0)

Files changed (3)

   non-ambiguous.
 - sql:
   - added "fetchmany()" support to ResultProxy
+  - changed "BooleanExpression" to subclass from "BinaryExpression", so that boolean
+  expressions can also follow column-clause behaviors (i.e. label(), etc).
   - fix to correlation of subqueries when the column list of the select statement
   is constructed with individual calls to append_column(); this fixes an ORM
   bug whereby nested select statements were not getting correlated with the 

lib/sqlalchemy/orm/query.py

         ret = self.extension.select(self, arg=arg, **kwargs)
         if ret is not mapper.EXT_PASS:
             return ret
-        try:
-            s = arg._selectable()
-        except AttributeError:
+        if isinstance(arg, sql.FromClause):
+            return self.select_statement(arg, **kwargs)
+        else:
             return self.select_whereclause(whereclause=arg, **kwargs)
-        else:
-            return self.select_statement(s, **kwargs)
 
     def select_whereclause(self, whereclause=None, params=None, **kwargs):
         """given a WHERE criterion, create a SELECT statement, execute and return the resulting instances."""

lib/sqlalchemy/sql.py

             self.left.compare(other.left) and self.right.compare(other.right)
         )
 
-class _BooleanExpression(_BinaryClause):
-    """represents a boolean expression, which is only useable in WHERE criterion."""
+class _BinaryExpression(_BinaryClause, ColumnElement):
+    """represents a binary expression, which can be in a WHERE criterion or in the column list 
+    of a SELECT.  By adding "ColumnElement" to its inherited list, it becomes a Selectable
+    unit which can be placed in the column list of a SELECT."""
+    pass
+
+class _BooleanExpression(_BinaryExpression):
+    """represents a boolean expression."""
     def __init__(self, *args, **kwargs):
         self.negate = kwargs.pop('negate', None)
         super(_BooleanExpression, self).__init__(*args, **kwargs)
         else:
             return super(_BooleanExpression, self)._negate()
         
-class _BinaryExpression(_BinaryClause, ColumnElement):
-    """represents a binary expression, which can be in a WHERE criterion or in the column list 
-    of a SELECT.  By adding "ColumnElement" to its inherited list, it becomes a Selectable
-    unit which can be placed in the column list of a SELECT."""
-    pass
-    
-        
 class Join(FromClause):
     def __init__(self, left, right, onclause=None, isouter = False):
         self.left = left._selectable()