From 4a6afd469fad170868554bf28578849bf3dfd5dd Mon Sep 17 00:00:00 2001
From: Mike Bayer <mike_mp@zzzcomputing.com>
Date: Fri, 9 May 2008 16:34:10 +0000
Subject: r4695 merged to trunk; trunk now becomes 0.5. 0.4 development
 continues at /sqlalchemy/branches/rel_0_4

---
 lib/sqlalchemy/sql/expression.py | 490 +++++++++++++++++----------------------
 1 file changed, 219 insertions(+), 271 deletions(-)

(limited to 'lib/sqlalchemy/sql/expression.py')

diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index 867fdd69c..7ce637701 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -26,12 +26,12 @@ to stay the same in future releases.
 """
 
 import itertools, re
-from sqlalchemy import util, exceptions
+from sqlalchemy import util, exc
 from sqlalchemy.sql import operators, visitors
 from sqlalchemy import types as sqltypes
 
 functions, schema, sql_util = None, None, None
-DefaultDialect, ClauseAdapter = None, None
+DefaultDialect, ClauseAdapter, Annotated = None, None, None
 
 __all__ = [
     'Alias', 'ClauseElement',
@@ -503,15 +503,21 @@ def collate(expression, collation):
 
 def exists(*args, **kwargs):
     """Return an ``EXISTS`` clause as applied to a [sqlalchemy.sql.expression#Select] object.
+    
+    Calling styles are of the following forms::
+    
+        # use on an existing select()
+        s = select([<columns>]).where(<criterion>)
+        s = exists(s)
+        
+        # construct a select() at once
+        exists(['*'], **select_arguments).where(<criterion>)
+        
+        # columns argument is optional, generates "EXISTS (SELECT *)"
+        # by default.
+        exists().where(<criterion>) 
 
-    The resulting [sqlalchemy.sql.expression#_Exists] object can be executed by
-    itself or used as a subquery within an enclosing select.
-
-    \*args, \**kwargs
-      all arguments are sent directly to the [sqlalchemy.sql.expression#select()]
-      function to produce a ``SELECT`` statement.
     """
-
     return _Exists(*args, **kwargs)
 
 def union(*selects, **kwargs):
@@ -872,27 +878,36 @@ def _compound_select(keyword, *selects, **kwargs):
     return CompoundSelect(keyword, *selects, **kwargs)
 
 def _is_literal(element):
-    return not isinstance(element, ClauseElement)
+    return not isinstance(element, (ClauseElement, Operators))
+
+def _from_objects(*elements, **kwargs):
+    return itertools.chain(*[element._get_from_objects(**kwargs) for element in elements])
 
+def _labeled(element):
+    if not hasattr(element, 'name'):
+        return element.label(None)
+    else:
+        return element
+        
 def _literal_as_text(element):
-    if isinstance(element, Operators):
-        return element.expression_element()
+    if hasattr(element, '__clause_element__'):
+        return element.__clause_element__()
     elif _is_literal(element):
         return _TextClause(unicode(element))
     else:
         return element
 
 def _literal_as_column(element):
-    if isinstance(element, Operators):
-        return element.clause_element()
+    if hasattr(element, '__clause_element__'):
+        return element.__clause_element__()
     elif _is_literal(element):
         return literal_column(str(element))
     else:
         return element
 
 def _literal_as_binds(element, name=None, type_=None):
-    if isinstance(element, Operators):
-        return element.expression_element()
+    if hasattr(element, '__clause_element__'):
+        return element.__clause_element__()
     elif _is_literal(element):
         if element is None:
             return null()
@@ -902,17 +917,17 @@ def _literal_as_binds(element, name=None, type_=None):
         return element
 
 def _no_literals(element):
-    if isinstance(element, Operators):
-        return element.expression_element()
+    if hasattr(element, '__clause_element__'):
+        return element.__clause_element__()
     elif _is_literal(element):
-        raise exceptions.ArgumentError("Ambiguous literal: %r.  Use the 'text()' function to indicate a SQL expression literal, or 'literal()' to indicate a bound value." % element)
+        raise exc.ArgumentError("Ambiguous literal: %r.  Use the 'text()' function to indicate a SQL expression literal, or 'literal()' to indicate a bound value." % element)
     else:
         return element
     
 def _corresponding_column_or_error(fromclause, column, require_embedded=False):
     c = fromclause.corresponding_column(column, require_embedded=require_embedded)
     if not c:
-        raise exceptions.InvalidRequestError("Given column '%s', attached to table '%s', failed to locate a corresponding column from table '%s'" % (str(column), str(getattr(column, 'table', None)), fromclause.description))
+        raise exc.InvalidRequestError("Given column '%s', attached to table '%s', failed to locate a corresponding column from table '%s'" % (str(column), str(getattr(column, 'table', None)), fromclause.description))
     return c
 
 def _selectable(element):
@@ -921,9 +936,8 @@ def _selectable(element):
     elif isinstance(element, Selectable):
         return element
     else:
-        raise exceptions.ArgumentError("Object '%s' is not a Selectable and does not implement `__selectable__()`" % repr(element))
+        raise exc.ArgumentError("Object '%s' is not a Selectable and does not implement `__selectable__()`" % repr(element))
 
-    
 def is_column(col):
     """True if ``col`` is an instance of ``ColumnElement``."""
     return isinstance(col, ColumnElement)
@@ -941,7 +955,9 @@ class _FigureVisitName(type):
 class ClauseElement(object):
     """Base class for elements of a programmatically constructed SQL expression."""
     __metaclass__ = _FigureVisitName
-
+    _annotations = {}
+    supports_execution = False
+    
     def _clone(self):
         """Create a shallow copy of this ClauseElement.
 
@@ -976,6 +992,14 @@ class ClauseElement(object):
         """
 
         raise NotImplementedError(repr(self))
+    
+    def _annotate(self, values):
+        """return a copy of this ClauseElement with the given annotations dictionary."""
+
+        global Annotated
+        if Annotated is None:
+            from sqlalchemy.sql.util import Annotated
+        return Annotated(self, values)
 
     def unique_params(self, *optionaldict, **kwargs):
         """Return a copy with ``bindparam()`` elments replaced.
@@ -1006,14 +1030,14 @@ class ClauseElement(object):
         if len(optionaldict) == 1:
             kwargs.update(optionaldict[0])
         elif len(optionaldict) > 1:
-            raise exceptions.ArgumentError("params() takes zero or one positional dictionary argument")
+            raise exc.ArgumentError("params() takes zero or one positional dictionary argument")
 
         def visit_bindparam(bind):
             if bind.key in kwargs:
                 bind.value = kwargs[bind.key]
             if unique:
                 bind._convert_to_unique()
-        return visitors.traverse(self, visit_bindparam=visit_bindparam, clone=True)
+        return visitors.cloned_traverse(self, {}, {'bindparam':visit_bindparam})
 
     def compare(self, other):
         """Compare this ClauseElement to the given ClauseElement.
@@ -1049,11 +1073,6 @@ class ClauseElement(object):
     def self_group(self, against=None):
         return self
 
-    def supports_execution(self):
-        """Return True if this clause element represents a complete executable statement."""
-
-        return False
-
     def bind(self):
         """Returns the Engine or Connection to which this ClauseElement is bound, or None if none found."""
 
@@ -1062,7 +1081,7 @@ class ClauseElement(object):
                 return self._bind
         except AttributeError:
             pass
-        for f in self._get_from_objects():
+        for f in _from_objects(self):
             if f is self:
                 continue
             engine = f.bind
@@ -1083,7 +1102,7 @@ class ClauseElement(object):
                    'Engine for execution. Or, assign a bind to the statement '
                    'or the Metadata of its underlying tables to enable '
                    'implicit execution via this method.' % label)
-            raise exceptions.UnboundExecutionError(msg)
+            raise exc.UnboundExecutionError(msg)
         return e.execute_clauseelement(self, multiparams, params)
 
     def scalar(self, *multiparams, **params):
@@ -1159,6 +1178,12 @@ class ClauseElement(object):
                 self.__module__, self.__class__.__name__, id(self), friendly)
 
 
+class _Immutable(object):
+    """mark a ClauseElement as 'immutable' when expressions are cloned."""
+    
+    def _clone(self):
+        return self
+        
 class Operators(object):
     def __and__(self, other):
         return self.operate(operators.and_, other)
@@ -1174,9 +1199,6 @@ class Operators(object):
             return self.operate(operators.op, opstring, b)
         return op
 
-    def clause_element(self):
-        raise NotImplementedError()
-
     def operate(self, op, *other, **kwargs):
         raise NotImplementedError()
 
@@ -1216,7 +1238,7 @@ class ColumnOperators(Operators):
     def ilike(self, other, escape=None):
         return self.operate(operators.ilike_op, other, escape=escape)
 
-    def in_(self, *other):
+    def in_(self, other):
         return self.operate(operators.in_op, other)
 
     def startswith(self, other, **kwargs):
@@ -1279,18 +1301,18 @@ class _CompareMixin(ColumnOperators):
     def __compare(self, op, obj, negate=None, reverse=False, **kwargs):
         if obj is None or isinstance(obj, _Null):
             if op == operators.eq:
-                return _BinaryExpression(self.expression_element(), null(), operators.is_, negate=operators.isnot)
+                return _BinaryExpression(self, null(), operators.is_, negate=operators.isnot)
             elif op == operators.ne:
-                return _BinaryExpression(self.expression_element(), null(), operators.isnot, negate=operators.is_)
+                return _BinaryExpression(self, null(), operators.isnot, negate=operators.is_)
             else:
-                raise exceptions.ArgumentError("Only '='/'!=' operators can be used with NULL")
+                raise exc.ArgumentError("Only '='/'!=' operators can be used with NULL")
         else:
             obj = self._check_literal(obj)
 
         if reverse:
-            return _BinaryExpression(obj, self.expression_element(), op, type_=sqltypes.Boolean, negate=negate, modifiers=kwargs)
+            return _BinaryExpression(obj, self, op, type_=sqltypes.Boolean, negate=negate, modifiers=kwargs)
         else:
-            return _BinaryExpression(self.expression_element(), obj, op, type_=sqltypes.Boolean, negate=negate, modifiers=kwargs)
+            return _BinaryExpression(self, obj, op, type_=sqltypes.Boolean, negate=negate, modifiers=kwargs)
 
     def __operate(self, op, obj, reverse=False):
         obj = self._check_literal(obj)
@@ -1298,9 +1320,9 @@ class _CompareMixin(ColumnOperators):
         type_ = self._compare_type(obj)
 
         if reverse:
-            return _BinaryExpression(obj, self.expression_element(), type_.adapt_operator(op), type_=type_)
+            return _BinaryExpression(obj, self, type_.adapt_operator(op), type_=type_)
         else:
-            return _BinaryExpression(self.expression_element(), obj, type_.adapt_operator(op), type_=type_)
+            return _BinaryExpression(self, obj, type_.adapt_operator(op), type_=type_)
 
     # a mapping of operators with the method they use, along with their negated
     # operator for comparison operators
@@ -1329,17 +1351,10 @@ class _CompareMixin(ColumnOperators):
         o = _CompareMixin.operators[op]
         return o[0](self, op, other, reverse=True, *o[1:], **kwargs)
 
-    def in_(self, *other):
-        return self._in_impl(operators.in_op, operators.notin_op, *other)
-
-    def _in_impl(self, op, negate_op, *other):
-        # Handle old style *args argument passing
-        if len(other) != 1 or not isinstance(other[0], Selectable) and (not hasattr(other[0], '__iter__') or isinstance(other[0], basestring)):
-            util.warn_deprecated('passing in_ arguments as varargs is deprecated, in_ takes a single argument that is a sequence or a selectable')
-            seq_or_selectable = other
-        else:
-            seq_or_selectable = other[0]
+    def in_(self, other):
+        return self._in_impl(operators.in_op, operators.notin_op, other)
 
+    def _in_impl(self, op, negate_op, seq_or_selectable):
         if isinstance(seq_or_selectable, Selectable):
             return self.__compare( op, seq_or_selectable, negate=negate_op)
 
@@ -1348,7 +1363,7 @@ class _CompareMixin(ColumnOperators):
         for o in seq_or_selectable:
             if not _is_literal(o):
                 if not isinstance( o, _CompareMixin):
-                    raise exceptions.InvalidRequestError( "in() function accepts either a list of non-selectable values, or a selectable: "+repr(o) )
+                    raise exc.InvalidRequestError( "in() function accepts either a list of non-selectable values, or a selectable: "+repr(o) )
             else:
                 o = self._bind_param(o)
             args.append(o)
@@ -1433,22 +1448,13 @@ class _CompareMixin(ColumnOperators):
         if isinstance(other, _BindParamClause) and isinstance(other.type, sqltypes.NullType):
             other.type = self.type
             return other
-        elif isinstance(other, Operators):
-            return other.expression_element()
+        elif hasattr(other, '__clause_element__'):
+            return other.__clause_element__()
         elif _is_literal(other):
             return self._bind_param(other)
         else:
             return other
 
-    def clause_element(self):
-        """Allow ``_CompareMixins`` to return the underlying ``ClauseElement``, for non-``ClauseElement`` ``_CompareMixins``."""
-        return self
-
-    def expression_element(self):
-        """Allow ``_CompareMixins`` to return the appropriate object to be used in expressions."""
-
-        return self
-
     def _compare_type(self, obj):
         """Allow subclasses to override the type used in constructing
         ``_BinaryExpression`` objects.
@@ -1480,23 +1486,22 @@ class ColumnElement(ClauseElement, _CompareMixin):
 
     primary_key = False
     foreign_keys = []
-
+    quote = None
+    
     def base_columns(self):
-        if hasattr(self, '_base_columns'):
-            return self._base_columns
-        self._base_columns = util.Set([c for c in self.proxy_set if not hasattr(c, 'proxies')])
+        if not hasattr(self, '_base_columns'):
+            self._base_columns = util.Set([c for c in self.proxy_set if not hasattr(c, 'proxies')])
         return self._base_columns
     base_columns = property(base_columns)
 
     def proxy_set(self):
-        if hasattr(self, '_proxy_set'):
-            return self._proxy_set
-        s = util.Set([self])
-        if hasattr(self, 'proxies'):
-            for c in self.proxies:
-                s = s.union(c.proxy_set)
-        self._proxy_set = s
-        return s
+        if not hasattr(self, '_proxy_set'):
+            s = util.Set([self])
+            if hasattr(self, 'proxies'):
+                for c in self.proxies:
+                    s.update(c.proxy_set)
+            self._proxy_set = s
+        return self._proxy_set
     proxy_set = property(proxy_set)
 
     def shares_lineage(self, othercolumn):
@@ -1518,7 +1523,7 @@ class ColumnElement(ClauseElement, _CompareMixin):
             co = _ColumnClause(self.anon_label, selectable, type_=getattr(self, 'type', None))
 
         co.proxies = [self]
-        selectable.columns[name]= co
+        selectable.columns[name] = co
         return co
 
     def anon_label(self):
@@ -1613,7 +1618,7 @@ class ColumnCollection(util.OrderedProperties):
 
     def __contains__(self, other):
         if not isinstance(other, basestring):
-            raise exceptions.ArgumentError("__contains__ requires a string argument")
+            raise exc.ArgumentError("__contains__ requires a string argument")
         return util.OrderedProperties.__contains__(self, other)
 
     def contains_column(self, col):
@@ -1641,6 +1646,9 @@ class ColumnSet(util.OrderedSet):
                     l.append(c==local)
         return and_(*l)
 
+    def __hash__(self):
+        return hash(tuple(self._list))
+
 class Selectable(ClauseElement):
     """mark a class as being selectable"""
 
@@ -1648,8 +1656,9 @@ class FromClause(Selectable):
     """Represent an element that can be used within the ``FROM`` clause of a ``SELECT`` statement."""
 
     __visit_name__ = 'fromclause'
-    named_with_column=False
+    named_with_column = False
     _hide_froms = []
+    quote = None
 
     def _get_from_objects(self, **modifiers):
         return []
@@ -1694,12 +1703,12 @@ class FromClause(Selectable):
         return fromclause in util.Set(self._cloned_set)
 
     def replace_selectable(self, old, alias):
-      """replace all occurences of FromClause 'old' with the given Alias object, returning a copy of this ``FromClause``."""
+        """replace all occurences of FromClause 'old' with the given Alias object, returning a copy of this ``FromClause``."""
 
-      global ClauseAdapter
-      if ClauseAdapter is None:
-          from sqlalchemy.sql.util import ClauseAdapter
-      return ClauseAdapter(alias).traverse(self, clone=True)
+        global ClauseAdapter
+        if ClauseAdapter is None:
+            from sqlalchemy.sql.util import ClauseAdapter
+        return ClauseAdapter(alias).traverse(self)
 
     def correspond_on_equivalents(self, column, equivalents):
         col = self.corresponding_column(column, require_embedded=True)
@@ -1859,7 +1868,7 @@ class _BindParamClause(ClauseElement, _CompareMixin):
 
     def _convert_to_unique(self):
         if not self.unique:
-            self.unique=True
+            self.unique = True
             self.key = "{ANON %d %s}" % (id(self), self._orig_key or 'param')
 
     def _get_from_objects(self, **modifiers):
@@ -1910,6 +1919,7 @@ class _TextClause(ClauseElement):
     __visit_name__ = 'textclause'
 
     _bind_params_regex = re.compile(r'(?<![:\w\x5c]):(\w+)(?!:)', re.UNICODE)
+    supports_execution = True
 
     _hide_froms = []
     oid_column = None
@@ -1950,12 +1960,6 @@ class _TextClause(ClauseElement):
     def _get_from_objects(self, **modifiers):
         return []
     
-    def supports_execution(self):
-        return True
-
-    def _table_iterator(self):
-        return iter([])
-
 class _Null(ColumnElement):
     """Represent the NULL keyword in a SQL statement.
 
@@ -2042,6 +2046,7 @@ class _CalculatedClause(ColumnElement):
     __visit_name__ = 'calculatedclause'
 
     def __init__(self, name, *clauses, **kwargs):
+        ColumnElement.__init__(self)
         self.name = name
         self.type = sqltypes.to_instance(kwargs.get('type_', None))
         self._bind = kwargs.get('bind', None)
@@ -2061,7 +2066,7 @@ class _CalculatedClause(ColumnElement):
 
     def clauses(self):
         if isinstance(self.clause_expr, _Grouping):
-            return self.clause_expr.elem
+            return self.clause_expr.element
         else:
             return self.clause_expr
     clauses = property(clauses)
@@ -2239,8 +2244,13 @@ class _Exists(_UnaryExpression):
     __visit_name__ = _UnaryExpression.__visit_name__
 
     def __init__(self, *args, **kwargs):
-        kwargs['correlate'] = True
-        s = select(*args, **kwargs).as_scalar().self_group()
+        if args and isinstance(args[0], _SelectBaseMixin):
+            s = args[0]
+        else:
+            if not args:
+                args = ([literal_column('*')],)
+            s = select(*args, **kwargs).as_scalar().self_group()
+            
         _UnaryExpression.__init__(self, s, operator=operators.exists)
 
     def select(self, whereclause=None, **params):
@@ -2272,7 +2282,7 @@ class Join(FromClause):
         self.right = _selectable(right).self_group()
 
         if onclause is None:
-            self.onclause = self.__match_primaries(self.left, self.right)
+            self.onclause = self._match_primaries(self.left, self.right)
         else:
             self.onclause = onclause
         
@@ -2310,7 +2320,7 @@ class Join(FromClause):
     def get_children(self, **kwargs):
         return self.left, self.right, self.onclause
 
-    def __match_primaries(self, primary, secondary):
+    def _match_primaries(self, primary, secondary):
         global sql_util
         if not sql_util:
             from sqlalchemy.sql import util as sql_util
@@ -2359,7 +2369,7 @@ class Join(FromClause):
         return self.select(use_labels=True, correlate=False).alias(name)
 
     def _hide_froms(self):
-        return itertools.chain(*[x.left._get_from_objects() + x.right._get_from_objects() for x in self._cloned_set])
+        return itertools.chain(*[_from_objects(x.left, x.right) for x in self._cloned_set])
     _hide_froms = property(_hide_froms)
 
     def _get_from_objects(self, **modifiers):
@@ -2382,9 +2392,10 @@ class Alias(FromClause):
     def __init__(self, selectable, alias=None):
         baseselectable = selectable
         while isinstance(baseselectable, Alias):
-            baseselectable = baseselectable.selectable
+            baseselectable = baseselectable.element
         self.original = baseselectable
-        self.selectable = selectable
+        self.supports_execution = baseselectable.supports_execution
+        self.element = selectable
         if alias is None:
             if self.original.named_with_column:
                 alias = getattr(self.original, 'name', None)
@@ -2398,112 +2409,100 @@ class Alias(FromClause):
     def is_derived_from(self, fromclause):
         if fromclause in util.Set(self._cloned_set):
             return True
-        return self.selectable.is_derived_from(fromclause)
-
-    def supports_execution(self):
-        return self.original.supports_execution()
-
-    def _table_iterator(self):
-        return self.original._table_iterator()
+        return self.element.is_derived_from(fromclause)
 
     def _populate_column_collection(self):
-        for col in self.selectable.columns:
+        for col in self.element.columns:
             col._make_proxy(self)
-        if self.selectable.oid_column is not None:
-            self._oid_column = self.selectable.oid_column._make_proxy(self)
+        if self.element.oid_column is not None:
+            self._oid_column = self.element.oid_column._make_proxy(self)
 
     def _copy_internals(self, clone=_clone):
-       self._reset_exported()
-       self.selectable = _clone(self.selectable)
-       baseselectable = self.selectable
-       while isinstance(baseselectable, Alias):
-           baseselectable = baseselectable.selectable
-       self.original = baseselectable
+        self._reset_exported()
+        self.element = _clone(self.element)
+        baseselectable = self.element
+        while isinstance(baseselectable, Alias):
+            baseselectable = baseselectable.selectable
+        self.original = baseselectable
 
     def get_children(self, column_collections=True, aliased_selectables=True, **kwargs):
         if column_collections:
             for c in self.c:
                 yield c
         if aliased_selectables:
-            yield self.selectable
+            yield self.element
 
     def _get_from_objects(self, **modifiers):
         return [self]
 
     def bind(self):
-        return self.selectable.bind
+        return self.element.bind
     bind = property(bind)
 
-class _ColumnElementAdapter(ColumnElement):
-    """Adapts a ClauseElement which may or may not be a
-    ColumnElement subclass itself into an object which
-    acts like a ColumnElement.
-    """
+class _Grouping(ColumnElement):
+    """Represent a grouping within a column expression"""
 
-    def __init__(self, elem):
-        self.elem = elem
-        self.type = getattr(elem, 'type', None)
+    def __init__(self, element):
+        ColumnElement.__init__(self)
+        self.element = element
+        self.type = getattr(element, 'type', None)
 
     def key(self):
-        return self.elem.key
+        return self.element.key
     key = property(key)
 
     def _label(self):
         try:
-            return self.elem._label
+            return self.element._label
         except AttributeError:
             return self.anon_label
     _label = property(_label)
 
     def _copy_internals(self, clone=_clone):
-        self.elem = clone(self.elem)
+        self.element = clone(self.element)
 
     def get_children(self, **kwargs):
-        return self.elem,
+        return self.element,
 
     def _get_from_objects(self, **modifiers):
-        return self.elem._get_from_objects(**modifiers)
+        return self.element._get_from_objects(**modifiers)
 
     def __getattr__(self, attr):
-        return getattr(self.elem, attr)
+        return getattr(self.element, attr)
 
     def __getstate__(self):
-        return {'elem':self.elem, 'type':self.type}
+        return {'element':self.element, 'type':self.type}
 
     def __setstate__(self, state):
-        self.elem = state['elem']
+        self.element = state['element']
         self.type = state['type']
 
-class _Grouping(_ColumnElementAdapter):
-    """Represent a grouping within a column expression"""
-    pass
-
 class _FromGrouping(FromClause):
     """Represent a grouping of a FROM clause"""
     __visit_name__ = 'grouping'
 
-    def __init__(self, elem):
-        self.elem = elem
+    def __init__(self, element):
+        self.element = element
 
     def columns(self):
-        return self.elem.columns
+        return self.element.columns
     columns = c = property(columns)
 
     def _hide_froms(self):
-        return self.elem._hide_froms
+        return self.element._hide_froms
     _hide_froms = property(_hide_froms)
 
     def get_children(self, **kwargs):
-        return self.elem,
+        return self.element,
 
     def _copy_internals(self, clone=_clone):
-        self.elem = clone(self.elem)
+        self.element = clone(self.element)
 
     def _get_from_objects(self, **modifiers):
-        return self.elem._get_from_objects(**modifiers)
+        return self.element._get_from_objects(**modifiers)
 
     def __getattr__(self, attr):
-        return getattr(self.elem, attr)
+        return getattr(self.element, attr)
 
 class _Label(ColumnElement):
     """Represents a column label (AS).
@@ -2516,12 +2515,12 @@ class _Label(ColumnElement):
     ``ColumnElement`` subclasses.
     """
 
-    def __init__(self, name, obj, type_=None):
-        while isinstance(obj, _Label):
-            obj = obj.obj
-        self.name = name or "{ANON %d %s}" % (id(self), getattr(obj, 'name', 'anon'))
-        self.obj = obj.self_group(against=operators.as_)
-        self.type = sqltypes.to_instance(type_ or getattr(obj, 'type', None))
+    def __init__(self, name, element, type_=None):
+        while isinstance(element, _Label):
+            element = element.element
+        self.name = name or "{ANON %d %s}" % (id(self), getattr(element, 'name', 'anon'))
+        self.element = element.self_group(against=operators.as_)
+        self.type = sqltypes.to_instance(type_ or getattr(element, 'type', None))
 
     def key(self):
         return self.name
@@ -2532,8 +2531,9 @@ class _Label(ColumnElement):
     _label = property(_label)
 
     def _proxy_attr(name):
+        get = util.attrgetter(name)
         def attr(self):
-            return getattr(self.obj, name)
+            return get(self.element)
         return property(attr)
 
     proxies = _proxy_attr('proxies')
@@ -2542,27 +2542,24 @@ class _Label(ColumnElement):
     primary_key = _proxy_attr('primary_key')
     foreign_keys = _proxy_attr('foreign_keys')
 
-    def expression_element(self):
-        return self.obj
-
     def get_children(self, **kwargs):
-        return self.obj,
+        return self.element,
 
     def _copy_internals(self, clone=_clone):
-        self.obj = clone(self.obj)
+        self.element = clone(self.element)
 
     def _get_from_objects(self, **modifiers):
-        return self.obj._get_from_objects(**modifiers)
+        return self.element._get_from_objects(**modifiers)
 
     def _make_proxy(self, selectable, name = None):
-        if isinstance(self.obj, (Selectable, ColumnElement)):
-            e = self.obj._make_proxy(selectable, name=self.name)
+        if isinstance(self.element, (Selectable, ColumnElement)):
+            e = self.element._make_proxy(selectable, name=self.name)
         else:
             e = column(self.name)._make_proxy(selectable=selectable)
         e.proxies.append(self)
         return e
 
-class _ColumnClause(ColumnElement):
+class _ColumnClause(_Immutable, ColumnElement):
     """Represents a generic column expression from any textual string.
 
     This includes columns associated with tables, aliases and select
@@ -2602,16 +2599,7 @@ class _ColumnClause(ColumnElement):
         return self.name.encode('ascii', 'backslashreplace')
     description = property(description)
 
-    def _clone(self):
-        # ColumnClause is immutable
-        return self
-
     def _label(self):
-        """Generate a 'label' string for this column.
-        """
-
-        # for a "literal" column, we've no idea what the text is
-        # therefore no 'label' can be automatically generated
         if self.is_literal:
             return None
         if not self.__label:
@@ -2626,24 +2614,21 @@ class _ColumnClause(ColumnElement):
                     counter = 1
                     while label in self.table.c:
                         label = self.__label + "_" + str(counter)
-                        counter +=1
+                        counter += 1
                     self.__label = label
             else:
                 self.__label = self.name
         return self.__label
-
     _label = property(_label)
 
     def label(self, name):
-        # if going off the "__label" property and its None, we have
-        # no label; return self
         if name is None:
             return self
         else:
             return super(_ColumnClause, self).label(name)
 
     def _get_from_objects(self, **modifiers):
-        if self.table is not None:
+        if self.table:
             return [self.table]
         else:
             return []
@@ -2651,20 +2636,20 @@ class _ColumnClause(ColumnElement):
     def _bind_param(self, obj):
         return _BindParamClause(self.name, obj, type_=self.type, unique=True)
 
-    def _make_proxy(self, selectable, name = None):
+    def _make_proxy(self, selectable, name=None, attach=True):
         # propigate the "is_literal" flag only if we are keeping our name,
         # otherwise its considered to be a label
         is_literal = self.is_literal and (name is None or name == self.name)
         c = _ColumnClause(name or self.name, selectable=selectable, _is_oid=self._is_oid, type_=self.type, is_literal=is_literal)
         c.proxies = [self]
-        if not self._is_oid:
+        if attach and not self._is_oid:
             selectable.columns[c.name] = c
         return c
 
     def _compare_type(self, obj):
         return self.type
 
-class TableClause(FromClause):
+class TableClause(_Immutable, FromClause):
     """Represents a "table" construct.
 
     Note that this represents tables only as another syntactical
@@ -2691,10 +2676,6 @@ class TableClause(FromClause):
         return self.name.encode('ascii', 'backslashreplace')
     description = property(description)
 
-    def _clone(self):
-        # TableClause is immutable
-        return self
-
     def append_column(self, c):
         self._columns[c.name] = c
         c.table = self
@@ -2724,10 +2705,11 @@ class TableClause(FromClause):
     def _get_from_objects(self, **modifiers):
         return [self]
 
-
 class _SelectBaseMixin(object):
     """Base class for ``Select`` and ``CompoundSelects``."""
 
+    supports_execution = True
+    
     def __init__(self, use_labels=False, for_update=False, limit=None, offset=None, order_by=None, group_by=None, bind=None, autocommit=False):
         self.use_labels = use_labels
         self.for_update = for_update
@@ -2773,11 +2755,6 @@ class _SelectBaseMixin(object):
         """
         return self.as_scalar().label(name)
 
-    def supports_execution(self):
-        """part of the ClauseElement contract; returns ``True`` in all cases for this class."""
-
-        return True
-
     def autocommit(self):
         """return a new selectable with the 'autocommit' flag set to True."""
 
@@ -2860,15 +2837,15 @@ class _SelectBaseMixin(object):
 class _ScalarSelect(_Grouping):
     __visit_name__ = 'grouping'
 
-    def __init__(self, elem):
-        self.elem = elem
-        cols = list(elem.inner_columns)
+    def __init__(self, element):
+        self.element = element
+        cols = list(element.inner_columns)
         if len(cols) != 1:
-            raise exceptions.InvalidRequestError("Scalar select can only be created from a Select object that has exactly one column expression.")
+            raise exc.InvalidRequestError("Scalar select can only be created from a Select object that has exactly one column expression.")
         self.type = cols[0].type
 
     def columns(self):
-        raise exceptions.InvalidRequestError("Scalar Select expression has no columns; use this object directly within a column-level expression.")
+        raise exc.InvalidRequestError("Scalar Select expression has no columns; use this object directly within a column-level expression.")
     columns = c = property(columns)
 
     def self_group(self, **kwargs):
@@ -2893,7 +2870,7 @@ class CompoundSelect(_SelectBaseMixin, FromClause):
             if not numcols:
                 numcols = len(s.c)
             elif len(s.c) != numcols:
-                raise exceptions.ArgumentError("All selectables passed to CompoundSelect must have identical numbers of columns; select #%d has %d columns, select #%d has %d" %
+                raise exc.ArgumentError("All selectables passed to CompoundSelect must have identical numbers of columns; select #%d has %d columns, select #%d has %d" %
                     (1, len(self.selects[0].c), n+1, len(s.c))
                 )
             if s._order_by_clause:
@@ -2936,11 +2913,6 @@ class CompoundSelect(_SelectBaseMixin, FromClause):
         return (column_collections and list(self.c) or []) + \
             [self._order_by_clause, self._group_by_clause] + list(self.selects)
 
-    def _table_iterator(self):
-        for s in self.selects:
-            for t in s._table_iterator():
-                yield t
-
     def bind(self):
         if self._bind:
             return self._bind
@@ -2976,6 +2948,7 @@ class Select(_SelectBaseMixin, FromClause):
         self._distinct = distinct
 
         self._correlate = util.Set()
+        self._froms = util.OrderedSet()
 
         if columns:
             self._raw_columns = [
@@ -2983,22 +2956,23 @@ class Select(_SelectBaseMixin, FromClause):
                 for c in
                 [_literal_as_column(c) for c in columns]
             ]
+
+            self._froms.update(_from_objects(*self._raw_columns))
         else:
             self._raw_columns = []
-        
-        if from_obj:
-            self._froms = util.Set([
-                _is_literal(f) and _TextClause(f) or f
-                for f in util.to_list(from_obj)
-            ])
-        else:
-            self._froms = util.Set()
-            
+
         if whereclause:
             self._whereclause = _literal_as_text(whereclause)
+            self._froms.update(_from_objects(self._whereclause, is_where=True))
         else:
             self._whereclause = None
 
+        if from_obj:
+            self._froms.update([
+                _is_literal(f) and _TextClause(f) or f
+                for f in util.to_list(from_obj)
+            ])
+
         if having:
             self._having = _literal_as_text(having)
         else:
@@ -3020,36 +2994,28 @@ class Select(_SelectBaseMixin, FromClause):
         correlating.
         
         """
-        froms = util.OrderedSet()
-
-        for col in self._raw_columns:
-            froms.update(col._get_from_objects())
-
-        if self._whereclause is not None:
-            froms.update(self._whereclause._get_from_objects(is_where=True))
-
-        if self._froms:
-            froms.update(self._froms)
+        froms = self._froms
         
         toremove = itertools.chain(*[f._hide_froms for f in froms])
-        froms.difference_update(toremove)
+        if toremove:
+            froms = froms.difference(toremove)
 
         if len(froms) > 1 or self._correlate:
             if self._correlate:
-                froms.difference_update(_cloned_intersection(froms, self._correlate))
+                froms = froms.difference(_cloned_intersection(froms, self._correlate))
                 
             if self._should_correlate and existing_froms:
-                froms.difference_update(_cloned_intersection(froms, existing_froms))
+                froms = froms.difference(_cloned_intersection(froms, existing_froms))
                 
                 if not len(froms):
-                    raise exceptions.InvalidRequestError("Select statement '%s' returned no FROM clauses due to auto-correlation; specify correlate(<tables>) to control correlation manually." % self)
+                    raise exc.InvalidRequestError("Select statement '%s' returned no FROM clauses due to auto-correlation; specify correlate(<tables>) to control correlation manually." % self)
                     
         return froms
 
     froms = property(_get_display_froms, doc="""Return a list of all FromClause elements which will be applied to the FROM clause of the resulting statement.""")
 
     def type(self):
-        raise exceptions.InvalidRequestError("Select objects don't have a type.  Call as_scalar() on this Select object to return a 'scalar' version of this Select.")
+        raise exc.InvalidRequestError("Select objects don't have a type.  Call as_scalar() on this Select object to return a 'scalar' version of this Select.")
     type = property(type)
 
     def locate_all_froms(self):
@@ -3059,22 +3025,10 @@ class Select(_SelectBaseMixin, FromClause):
         is specifically for those FromClause elements that would actually be rendered.
         
         """
-        if hasattr(self, '_all_froms'):
-            return self._all_froms
-
-        froms = util.Set(
-            itertools.chain(*
-                [self._froms] +
-                [f._get_from_objects() for f in self._froms] +
-                [col._get_from_objects() for col in self._raw_columns]
-            )
-        )
+        if not hasattr(self, '_all_froms'):
+            self._all_froms = self._froms.union(_from_objects(*list(self._froms)))
 
-        if self._whereclause:
-            froms.update(self._whereclause._get_from_objects(is_where=True))
-
-        self._all_froms = froms
-        return froms
+        return self._all_froms
 
     def inner_columns(self):
         """an iteratorof all ColumnElement expressions which would
@@ -3092,7 +3046,7 @@ class Select(_SelectBaseMixin, FromClause):
     def is_derived_from(self, fromclause):
         if self in util.Set(fromclause._cloned_set):
             return True
-
+        
         for f in self.locate_all_froms():
             if f.is_derived_from(fromclause):
                 return True
@@ -3112,7 +3066,7 @@ class Select(_SelectBaseMixin, FromClause):
         """return child elements as per the ClauseElement specification."""
 
         return (column_collections and list(self.columns) or []) + \
-            list(self.locate_all_froms()) + \
+            list(self._froms) + \
             [x for x in (self._whereclause, self._having, self._order_by_clause, self._group_by_clause) if x is not None]
 
     def column(self, column):
@@ -3125,6 +3079,7 @@ class Select(_SelectBaseMixin, FromClause):
             column = column.self_group(against=operators.comma_op)
 
         s._raw_columns = s._raw_columns + [column]
+        s._froms = s._froms.union(_from_objects(column))
         return s
 
     def where(self, whereclause):
@@ -3185,7 +3140,7 @@ class Select(_SelectBaseMixin, FromClause):
         
         """
         s = self._generate()
-        s._should_correlate=False
+        s._should_correlate = False
         if fromclauses == (None,):
             s._correlate = util.Set()
         else:
@@ -3195,7 +3150,7 @@ class Select(_SelectBaseMixin, FromClause):
     def append_correlation(self, fromclause):
         """append the given correlation expression to this select() construct."""
         
-        self._should_correlate=False
+        self._should_correlate = False
         self._correlate = self._correlate.union([fromclause])
 
     def append_column(self, column):
@@ -3207,6 +3162,7 @@ class Select(_SelectBaseMixin, FromClause):
             column = column.self_group(against=operators.comma_op)
 
         self._raw_columns = self._raw_columns + [column]
+        self._froms = self._froms.union(_from_objects(column))
         self._reset_exported()
 
     def append_prefix(self, clause):
@@ -3221,10 +3177,13 @@ class Select(_SelectBaseMixin, FromClause):
         The expression will be joined to existing WHERE criterion via AND.
 
         """
+        whereclause = _literal_as_text(whereclause)
+        self._froms = self._froms.union(_from_objects(whereclause, is_where=True))
+        
         if self._whereclause is not None:
-            self._whereclause = and_(self._whereclause, _literal_as_text(whereclause))
+            self._whereclause = and_(self._whereclause, whereclause)
         else:
-            self._whereclause = _literal_as_text(whereclause)
+            self._whereclause = whereclause
 
     def append_having(self, having):
         """append the given expression to this select() construct's HAVING criterion.
@@ -3311,31 +3270,23 @@ class Select(_SelectBaseMixin, FromClause):
 
         return intersect_all(self, other, **kwargs)
 
-    def _table_iterator(self):
-        for t in visitors.NoColumnVisitor().iterate(self):
-            if isinstance(t, TableClause):
-                yield t
-
     def bind(self):
         if self._bind:
             return self._bind
-        for f in self._froms:
-            if f is self:
-                continue
-            e = f.bind
-            if e:
-                self._bind = e
-                return e
-        # look through the columns (largely synomous with looking
-        # through the FROMs except in the case of _CalculatedClause/_Function)
-        for c in self._raw_columns:
-            if getattr(c, 'table', None) is self:
-                continue
-            e = c.bind
+        if not self._froms:
+            for c in self._raw_columns:
+                e = c.bind
+                if e:
+                    self._bind = e
+                    return e
+        else:
+            e = list(self._froms)[0].bind
             if e:
                 self._bind = e
                 return e
+
         return None
+        
     def _set_bind(self, bind):
         self._bind = bind
     bind = property(bind, _set_bind)
@@ -3343,11 +3294,7 @@ class Select(_SelectBaseMixin, FromClause):
 class _UpdateBase(ClauseElement):
     """Form the base for ``INSERT``, ``UPDATE``, and ``DELETE`` statements."""
 
-    def supports_execution(self):
-        return True
-
-    def _table_iterator(self):
-        return iter([self.table])
+    supports_execution = True
 
     def _generate(self):
         s = self.__class__.__new__(self.__class__)
@@ -3407,7 +3354,7 @@ class Insert(_ValuesBase):
         self._bind = bind
         self.table = table
         self.select = None
-        self.inline=inline
+        self.inline = inline
         if prefixes:
             self._prefixes = [_literal_as_text(p) for p in prefixes]
         else:
@@ -3502,10 +3449,11 @@ class Delete(_UpdateBase):
         self._whereclause = clone(self._whereclause)
 
 class _IdentifiedClause(ClauseElement):
+    supports_execution = True
+    quote = None
+    
     def __init__(self, ident):
         self.ident = ident
-    def supports_execution(self):
-        return True
 
 class SavepointClause(_IdentifiedClause):
     pass
-- 
cgit v1.2.1