- mapper naming/organization cleanup

- gave into peer pressure and removed all __names
- inlined polymorphic_iterator()
- moved methods into categories based on configuration, inspection, persistence, row processing.
a more extreme change would be to make separate mixin classes for these or similar.

2 files changed, 643 insertions, 578 deletions

diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py
index be1be549c..c2bb73481 100644
--- a/lib/sqlalchemy/orm/mapper.py
+++ b/lib/sqlalchemy/orm/mapper.py
@@ -18,14 +18,11 @@ import types
 import weakref
 import operator
 from itertools import chain
+deque = __import__('collections').deque
 
-from sqlalchemy import sql, util, log
-import sqlalchemy.exceptions as sa_exc
-from sqlalchemy.sql import expression, visitors, operators
-import sqlalchemy.sql.util as sqlutil
-from sqlalchemy.orm import attributes
-from sqlalchemy.orm import exc
-from sqlalchemy.orm import sync
+from sqlalchemy import sql, util, log, exc as sa_exc
+from sqlalchemy.sql import expression, visitors, operators, util as sqlutil
+from sqlalchemy.orm import attributes, exc, sync
 from sqlalchemy.orm.identity import IdentityManagedState
 from sqlalchemy.orm.interfaces import (
     MapperProperty, EXT_CONTINUE, PropComparator
@@ -35,7 +32,6 @@ from sqlalchemy.orm.util import (
      _state_mapper, class_mapper, instance_str, state_str,
      )
 
-
 __all__ = (
     'Mapper',
     '_mapper_registry',
@@ -71,8 +67,8 @@ class Mapper(object):
 
     Instances of this class should be constructed via the
     [sqlalchemy.orm#mapper()] function.
-    """
 
+    """
     def __init__(self,
                  class_,
                  local_table,
@@ -105,7 +101,6 @@ class Mapper(object):
         function.  See for details.
 
         """
-
         self.class_ = class_
         self.class_manager = None
 
@@ -137,7 +132,7 @@ class Mapper(object):
         self._validators = {}
         self._clause_adapter = None
         self._requires_row_aliasing = False
-        self.__inherits_equated_pairs = None
+        self._inherits_equated_pairs = None
 
         if not issubclass(class_, object):
             raise sa_exc.ArgumentError("Class '%s' is not a new-style class" % class_.__name__)
@@ -145,7 +140,8 @@ class Mapper(object):
         self.select_table = select_table
         if select_table:
             if with_polymorphic:
-                raise sa_exc.ArgumentError("select_table can't be used with with_polymorphic (they define conflicting settings)")
+                raise sa_exc.ArgumentError("select_table can't be used with "
+                            "with_polymorphic (they define conflicting settings)")
             self.with_polymorphic = ('*', select_table)
         else:
             if with_polymorphic == '*':
@@ -161,7 +157,8 @@ class Mapper(object):
                 self.with_polymorphic = None
 
         if isinstance(self.local_table, expression._SelectBaseMixin):
-            util.warn("mapper %s creating an alias for the given selectable - use Class attributes for queries." % self)
+            util.warn("mapper %s creating an alias for the given "
+                        "selectable - use Class attributes for queries." % self)
             self.local_table = self.local_table.alias()
 
         if self.with_polymorphic and isinstance(self.with_polymorphic[1], expression._SelectBaseMixin):
@@ -172,7 +169,9 @@ class Mapper(object):
         self.polymorphic_identity = polymorphic_identity
 
         if polymorphic_fetch:
-            util.warn_deprecated('polymorphic_fetch option is deprecated.  Unloaded columns load as deferred in all cases; loading can be controlled using the "with_polymorphic" option.')
+            util.warn_deprecated('polymorphic_fetch option is deprecated.  Unloaded columns '
+                            'load as deferred in all cases; loading can be controlled '
+                            'using the "with_polymorphic" option.')
 
         # a dictionary of 'polymorphic identity' names, associating those names with
         # Mappers that will be used to construct object instances upon a select operation.
@@ -181,257 +180,40 @@ class Mapper(object):
         else:
             self.polymorphic_map = _polymorphic_map
 
-        self.columns = self.c = util.OrderedProperties()
-
         self.include_properties = include_properties
         self.exclude_properties = exclude_properties
 
-        # a set of all mappers which inherit from this one.
-        self._inheriting_mappers = set()
-
         self.compiled = False
 
-        self.__compile_inheritance()
-        self.__compile_extensions()
-        self.__compile_class()
-        self.__compile_properties()
-        self.__compile_pks()
+        self._configure_inheritance()
+        self._configure_extensions()
+        self._configure_class_instrumentation()
+        self._configure_properties()
+        self._configure_pks()
         global _new_mappers
         _new_mappers = True
-        self.__log("constructed")
-
-    def __log(self, msg):
-        if self._should_log_info:
-            self.logger.info("(" + self.class_.__name__ + "|" + (self.local_table and self.local_table.description or str(self.local_table)) + (self.non_primary and "|non-primary" or "") + ") " + msg)
-
-    def __log_debug(self, msg):
-        if self._should_log_debug:
-            self.logger.debug("(" + self.class_.__name__ + "|" + (self.local_table and self.local_table.description or str(self.local_table)) + (self.non_primary and "|non-primary" or "") + ") " + msg)
-
-    def _is_orphan(self, state):
-        o = False
-        for mapper in self.iterate_to_root():
-            for (key, cls) in mapper.delete_orphans:
-                if attributes.manager_of_class(cls).has_parent(
-                    state, key, optimistic=_state_has_identity(state)):
-                    return False
-            o = o or bool(mapper.delete_orphans)
-        return o
-
-    def has_property(self, key):
-        return key in self.__props
-
-    def get_property(self, key, resolve_synonyms=False, raiseerr=True):
-        """return a MapperProperty associated with the given key."""
-
-        self.compile()
-        return self._get_property(key, resolve_synonyms=resolve_synonyms, raiseerr=raiseerr)
-
-    def _get_property(self, key, resolve_synonyms=False, raiseerr=True):
-        prop = self.__props.get(key, None)
-        if resolve_synonyms:
-            while isinstance(prop, SynonymProperty):
-                prop = self.__props.get(prop.name, None)
-        if prop is None and raiseerr:
-            raise sa_exc.InvalidRequestError("Mapper '%s' has no property '%s'" % (str(self), key))
-        return prop
-
-    @property
-    def iterate_properties(self):
-        """return an iterator of all MapperProperty objects."""
-        self.compile()
-        return self.__props.itervalues()
-
-    def __mappers_from_spec(self, spec, selectable):
-        """given a with_polymorphic() argument, return the set of mappers it represents.
-
-        Trims the list of mappers to just those represented within the given selectable, if present.
-        This helps some more legacy-ish mappings.
-
-        """
-        if spec == '*':
-            mappers = list(self.polymorphic_iterator())
-        elif spec:
-            mappers = [_class_to_mapper(m) for m in util.to_list(spec)]
-            for m in mappers:
-                if not m.isa(self):
-                    raise sa_exc.InvalidRequestError("%r does not inherit from %r"  % (m, self))
-        else:
-            mappers = []
-
-        if selectable:
-            tables = set(sqlutil.find_tables(selectable, include_aliases=True))
-            mappers = [m for m in mappers if m.local_table in tables]
-
-        return mappers
-
-    def __selectable_from_mappers(self, mappers):
-        """given a list of mappers (assumed to be within this mapper's inheritance hierarchy),
-        construct an outerjoin amongst those mapper's mapped tables.
-
-        """
-        from_obj = self.mapped_table
-        for m in mappers:
-            if m is self:
-                continue
-            if m.concrete:
-                raise sa_exc.InvalidRequestError("'with_polymorphic()' requires 'selectable' argument when concrete-inheriting mappers are used.")
-            elif not m.single:
-                from_obj = from_obj.outerjoin(m.local_table, m.inherit_condition)
-
-        return from_obj
-
-    @util.memoized_property
-    def _with_polymorphic_mappers(self):
-        if not self.with_polymorphic:
-            return [self]
-        return self.__mappers_from_spec(*self.with_polymorphic)
-
-    @util.memoized_property
-    def _with_polymorphic_selectable(self):
-        if not self.with_polymorphic:
-            return self.mapped_table
-
-        spec, selectable = self.with_polymorphic
-        if selectable:
-            return selectable
-        else:
-            return self.__selectable_from_mappers(self.__mappers_from_spec(spec, selectable))
-
-    def _with_polymorphic_args(self, spec=None, selectable=False):
-        if self.with_polymorphic:
-            if not spec:
-                spec = self.with_polymorphic[0]
-            if selectable is False:
-                selectable = self.with_polymorphic[1]
-
-        mappers = self.__mappers_from_spec(spec, selectable)
-        if selectable:
-            return mappers, selectable
-        else:
-            return mappers, self.__selectable_from_mappers(mappers)
-
-    def _iterate_polymorphic_properties(self, mappers=None):
-        if mappers is None:
-            mappers = self._with_polymorphic_mappers
-        return iter(util.unique_list(
-            chain(*[list(mapper.iterate_properties) for mapper in [self] + mappers])
-        ))
-
-    @property
-    def properties(self):
-        raise NotImplementedError("Public collection of MapperProperty objects is provided by the get_property() and iterate_properties accessors.")
-
-    def dispose(self):
-        # Disable any attribute-based compilation.
-        self.compiled = True
-        manager = self.class_manager
-
-        if not self.non_primary and manager.mapper is self:
-            manager.mapper = None
-            manager.events.remove_listener('on_init', _event_on_init)
-            manager.events.remove_listener('on_init_failure',
-                                           _event_on_init_failure)
-            manager.uninstall_member('__init__')
-            del manager.info[_INSTRUMENTOR]
-            attributes.unregister_class(self.class_)
-
-    def compile(self):
-        """Compile this mapper and all other non-compiled mappers.
-
-        This method checks the local compiled status as well as for
-        any new mappers that have been defined, and is safe to call
-        repeatedly.
-        """
-        global _new_mappers
-        if self.compiled and not _new_mappers:
-            return self
-
-        _COMPILE_MUTEX.acquire()
-        try:
-            global _already_compiling
-            if _already_compiling:
-                # re-entrance to compile() occurs rarely, when a class-mapped construct is
-                # used within a ForeignKey, something that is possible
-                # when using the declarative layer
-                self.__initialize_properties()
-                return
-            _already_compiling = True
-            try:
-
-                # double-check inside mutex
-                if self.compiled and not _new_mappers:
-                    return self
-
-                # initialize properties on all mappers
-                for mapper in list(_mapper_registry):
-                    if not mapper.compiled:
-                        mapper.__initialize_properties()
-
-                _new_mappers = False
-                return self
-            finally:
-                _already_compiling = False
-        finally:
-            _COMPILE_MUTEX.release()
-            
-    def __initialize_properties(self):
-        """Call the ``init()`` method on all ``MapperProperties``
-        attached to this mapper.
+        self._log("constructed")
 
-        This is a deferred configuration step which is intended
-        to execute once all mappers have been constructed.
-        """
-
-        self.__log("__initialize_properties() started")
-        l = [(key, prop) for key, prop in self.__props.iteritems()]
-        for key, prop in l:
-            if not getattr(prop, '_compiled', False):
-                self.__log("initialize prop " + key)
-                prop.init(key, self)
-        self.__log("__initialize_properties() complete")
-        self.compiled = True
-
-    def __compile_extensions(self):
-        """Go through the global_extensions list as well as the list
-        of ``MapperExtensions`` specified for this ``Mapper`` and
-        creates a linked list of those extensions.
-        """
-
-        extlist = util.OrderedSet()
-
-        extension = self.extension
-        if extension:
-            for ext_obj in util.to_list(extension):
-                # local MapperExtensions have already instrumented the class
-                extlist.add(ext_obj)
-
-        if self.inherits:
-            for ext in self.inherits.extension:
-                if ext not in extlist:
-                    extlist.add(ext)
-        else:
-            for ext in global_extensions:
-                if isinstance(ext, type):
-                    ext = ext()
-                if ext not in extlist:
-                    extlist.add(ext)
-
-        self.extension = ExtensionCarrier()
-        for ext in extlist:
-            self.extension.append(ext)
-
-    def __compile_inheritance(self):
+    # configurational / mutating methods.  not threadsafe
+    # except for compile().
+    
+    def _configure_inheritance(self):
         """Configure settings related to inherting and/or inherited mappers being present."""
 
+        # a set of all mappers which inherit from this one.
+        self._inheriting_mappers = set()
+
         if self.inherits:
             if isinstance(self.inherits, type):
                 self.inherits = class_mapper(self.inherits, compile=False)
             if not issubclass(self.class_, self.inherits.class_):
-                raise sa_exc.ArgumentError("Class '%s' does not inherit from '%s'" % (self.class_.__name__, self.inherits.class_.__name__))
+                raise sa_exc.ArgumentError(
+                        "Class '%s' does not inherit from '%s'" % 
+                        (self.class_.__name__, self.inherits.class_.__name__))
             if self.non_primary != self.inherits.non_primary:
                 np = not self.non_primary and "primary" or "non-primary"
-                raise sa_exc.ArgumentError("Inheritance of %s mapper for class '%s' is only allowed from a %s mapper" % (np, self.class_.__name__, np))
+                raise sa_exc.ArgumentError("Inheritance of %s mapper for class '%s' is "
+                        "only allowed from a %s mapper" % (np, self.class_.__name__, np))
             # inherit_condition is optional.
             if self.local_table is None:
                 self.local_table = self.inherits.local_table
@@ -452,7 +234,7 @@ class Mapper(object):
                     self.mapped_table = sql.join(self.inherits.mapped_table, self.local_table, self.inherit_condition)
 
                     fks = util.to_set(self.inherit_foreign_keys)
-                    self.__inherits_equated_pairs = sqlutil.criterion_as_pairs(self.mapped_table.onclause, consider_as_foreign_keys=fks)
+                    self._inherits_equated_pairs = sqlutil.criterion_as_pairs(self.mapped_table.onclause, consider_as_foreign_keys=fks)
             else:
                 self.mapped_table = self.local_table
 
@@ -487,21 +269,143 @@ class Mapper(object):
                             break
                     else:
                         # TODO: this exception not covered
-                        raise sa_exc.ArgumentError("Mapper '%s' specifies a polymorphic_identity of '%s', but no mapper in it's hierarchy specifies the 'polymorphic_on' column argument" % (str(self), self.polymorphic_identity))
+                        raise sa_exc.ArgumentError("Mapper '%s' specifies a polymorphic_identity of '%s', "
+                                    "but no mapper in it's hierarchy specifies "
+                                    "the 'polymorphic_on' column argument" % (self, self.polymorphic_identity))
         else:
             self._all_tables = set()
             self.base_mapper = self
             self.mapped_table = self.local_table
             if self.polymorphic_identity:
                 if self.polymorphic_on is None:
-                    raise sa_exc.ArgumentError("Mapper '%s' specifies a polymorphic_identity of '%s', but no mapper in it's hierarchy specifies the 'polymorphic_on' column argument" % (str(self), self.polymorphic_identity))
+                    raise sa_exc.ArgumentError("Mapper '%s' specifies a polymorphic_identity of '%s', but "
+                                "no mapper in it's hierarchy specifies the "
+                                "'polymorphic_on' column argument" % (self, self.polymorphic_identity))
                 self.polymorphic_map[self.polymorphic_identity] = self
             self._identity_class = self.class_
 
         if self.mapped_table is None:
-            raise sa_exc.ArgumentError("Mapper '%s' does not have a mapped_table specified.  (Are you using the return value of table.create()?  It no longer has a return value.)" % str(self))
+            raise sa_exc.ArgumentError("Mapper '%s' does not have a mapped_table specified.  "
+                            "(Are you using the return value of table.create()?  "
+                            "It no longer has a return value.)" % self)
+
+    def _configure_extensions(self):
+        """Go through the global_extensions list as well as the list
+        of ``MapperExtensions`` specified for this ``Mapper`` and
+        creates a linked list of those extensions.
+        
+        """
+        extlist = util.OrderedSet()
+
+        extension = self.extension
+        if extension:
+            for ext_obj in util.to_list(extension):
+                # local MapperExtensions have already instrumented the class
+                extlist.add(ext_obj)
+
+        if self.inherits:
+            for ext in self.inherits.extension:
+                if ext not in extlist:
+                    extlist.add(ext)
+        else:
+            for ext in global_extensions:
+                if isinstance(ext, type):
+                    ext = ext()
+                if ext not in extlist:
+                    extlist.add(ext)
+
+        self.extension = ExtensionCarrier()
+        for ext in extlist:
+            self.extension.append(ext)
 
-    def __compile_pks(self):
+    def _configure_class_instrumentation(self):
+        """If this mapper is to be a primary mapper (i.e. the
+        non_primary flag is not set), associate this Mapper with the
+        given class_ and entity name.
+
+        Subsequent calls to ``class_mapper()`` for the class_/entity
+        name combination will return this mapper.  Also decorate the
+        `__init__` method on the mapped class to include optional
+        auto-session attachment logic.
+
+        """
+        manager = attributes.manager_of_class(self.class_)
+
+        if self.non_primary:
+            if not manager or manager.mapper is None:
+                raise sa_exc.InvalidRequestError(
+                    "Class %s has no primary mapper configured.  Configure "
+                    "a primary mapper first before setting up a non primary "
+                    "Mapper.")
+            self.class_manager = manager
+            _mapper_registry[self] = True
+            return
+
+        if manager is not None:
+            if manager.class_ is not self.class_:
+                # An inherited manager.  Install one for this subclass.
+                # TODO: no coverage here
+                manager = None
+            elif manager.mapper:
+                raise sa_exc.ArgumentError(
+                    "Class '%s' already has a primary mapper defined. "
+                    "Use non_primary=True to "
+                    "create a non primary Mapper.  clear_mappers() will "
+                    "remove *all* current mappers from all classes." %
+                    self.class_)
+
+        _mapper_registry[self] = True
+
+        if manager is None:
+            manager = attributes.create_manager_for_cls(self.class_)
+
+        self.class_manager = manager
+
+        manager.mapper = self
+
+        # The remaining members can be added by any mapper, e_name None or not.
+        if manager.info.get(_INSTRUMENTOR, False):
+            return
+
+        self.extension.instrument_class(self, self.class_)
+
+        manager.instantiable = True
+        manager.instance_state_factory = IdentityManagedState
+        manager.deferred_scalar_loader = _load_scalar_attributes
+
+        event_registry = manager.events
+        event_registry.add_listener('on_init', _event_on_init)
+        event_registry.add_listener('on_init_failure', _event_on_init_failure)
+        for key, method in util.iterate_attributes(self.class_):
+            if isinstance(method, types.FunctionType):
+                if hasattr(method, '__sa_reconstructor__'):
+                    event_registry.add_listener('on_load', method)
+                elif hasattr(method, '__sa_validators__'):
+                    for name in method.__sa_validators__:
+                        self._validators[name] = method
+
+        if 'reconstruct_instance' in self.extension:
+            def reconstruct(instance):
+                self.extension.reconstruct_instance(self, instance)
+            event_registry.add_listener('on_load', reconstruct)
+
+        manager.info[_INSTRUMENTOR] = self
+
+    def dispose(self):
+        # Disable any attribute-based compilation.
+        self.compiled = True
+        manager = self.class_manager
+
+        if not self.non_primary and manager.mapper is self:
+            manager.mapper = None
+            manager.events.remove_listener('on_init', _event_on_init)
+            manager.events.remove_listener('on_init_failure',
+                                           _event_on_init_failure)
+            manager.uninstall_member('__init__')
+            del manager.info[_INSTRUMENTOR]
+            attributes.unregister_class(self.class_)
+
+    def _configure_pks(self):
 
         self.tables = sqlutil.find_tables(self.mapped_table)
 
@@ -515,8 +419,9 @@ class Mapper(object):
         pk_cols = set(c for c in all_cols if c.primary_key)
 
         # identify primary key columns which are also mapped by this mapper.
-        for t in set(self.tables + [self.mapped_table]):
-            self._all_tables.add(t)
+        tables = set(self.tables + [self.mapped_table])
+        self._all_tables.update(tables)
+        for t in tables:
             if t.primary_key and pk_cols.issuperset(t.primary_key):
                 # ordering is important since it determines the ordering of mapper.primary_key (and therefore query.get())
                 self._pks_by_table[t] = util.OrderedSet(t.primary_key).intersection(pk_cols)
@@ -537,7 +442,8 @@ class Mapper(object):
                 self._pks_by_table[k.table].add(k)
 
         if self.mapped_table not in self._pks_by_table or len(self._pks_by_table[self.mapped_table]) == 0:
-            raise sa_exc.ArgumentError("Mapper %s could not assemble any primary key columns for mapped table '%s'" % (self, self.mapped_table.description))
+            raise sa_exc.ArgumentError("Mapper %s could not assemble any primary "
+                    "key columns for mapped table '%s'" % (self, self.mapped_table.description))
 
         if self.inherits and not self.concrete and not self.primary_key_argument:
             # if inheriting, the "primary key" for this mapper is that of the inheriting (unless concrete or explicit)
@@ -553,128 +459,19 @@ class Mapper(object):
                     self._pks_by_table[self.mapped_table], ignore_nonexistent_tables=True)
 
             if len(primary_key) == 0:
-                raise sa_exc.ArgumentError("Mapper %s could not assemble any primary key columns for mapped table '%s'" % (self, self.mapped_table.description))
+                raise sa_exc.ArgumentError("Mapper %s could not assemble any primary "
+                    "key columns for mapped table '%s'" % (self, self.mapped_table.description))
 
             self.primary_key = primary_key
-            self.__log("Identified primary key columns: " + str(primary_key))
-
-    @util.memoized_property
-    def _get_clause(self):
-        """create a "get clause" based on the primary key.  this is used
-        by query.get() and many-to-one lazyloads to load this item
-        by primary key.
-
-        """
-        params = [(primary_key, sql.bindparam(None, type_=primary_key.type)) for primary_key in self.primary_key]
-        return sql.and_(*[k==v for (k, v) in params]), dict(params)
-
-    @util.memoized_property
-    def _equivalent_columns(self):
-        """Create a map of all *equivalent* columns, based on
-        the determination of column pairs that are equated to
-        one another based on inherit condition.  This is designed
-        to work with the queries that util.polymorphic_union
-        comes up with, which often don't include the columns from
-        the base table directly (including the subclass table columns
-        only).
-
-        The resulting structure is a dictionary of columns mapped
-        to lists of equivalent columns, i.e.
-
-        {
-            tablea.col1:
-                set([tableb.col1, tablec.col1]),
-            tablea.col2:
-                set([tabled.col2])
-        }
-
-        """
-
-        result = {}
-        def visit_binary(binary):
-            if binary.operator == operators.eq:
-                if binary.left in result:
-                    result[binary.left].add(binary.right)
-                else:
-                    result[binary.left] = set((binary.right,))
-                if binary.right in result:
-                    result[binary.right].add(binary.left)
-                else:
-                    result[binary.right] = set((binary.left,))
-        for mapper in self.base_mapper.polymorphic_iterator():
-            if mapper.inherit_condition:
-                visitors.traverse(mapper.inherit_condition, {}, {'binary':visit_binary})
-
-        return result
-
-    class _CompileOnAttr(PropComparator):
-        """A placeholder descriptor which triggers compilation on access."""
-
-        def __init__(self, class_, key):
-            self.class_ = class_
-            self.key = key
-            self.existing_prop = getattr(class_, key, None)
-
-        def __getattribute__(self, key):
-            cls = object.__getattribute__(self, 'class_')
-            clskey = object.__getattribute__(self, 'key')
-
-            # ugly hack
-            if key.startswith('__') and key != '__clause_element__':
-                return object.__getattribute__(self, key)
-
-            class_mapper(cls)
-
-            if cls.__dict__.get(clskey) is self:
-                # if this warning occurs, it usually means mapper
-                # compilation has failed, but operations upon the mapped
-                # classes have proceeded.
-                util.warn(
-                    ("Attribute '%s' on class '%s' was not replaced during "
-                     "mapper compilation operation") % (clskey, cls.__name__))
-                # clean us up explicitly
-                delattr(cls, clskey)
-
-            return getattr(getattr(cls, clskey), key)
-
-    def _is_userland_descriptor(self, obj):
-        return not isinstance(obj, (MapperProperty, attributes.InstrumentedAttribute)) and hasattr(obj, '__get__')
+            self._log("Identified primary key columns: " + str(primary_key))
 
-    def _should_exclude(self, name, local):
-        """determine whether a particular property should be implicitly present on the class.
-
-        This occurs when properties are propagated from an inherited class, or are
-        applied from the columns present in the mapped table.
-
-        """
-
-        # check for descriptors, either local or from
-        # an inherited class
-        if local:
-            if self.class_.__dict__.get(name, None)\
-                and self._is_userland_descriptor(self.class_.__dict__[name]):
-                return True
-        else:
-            if getattr(self.class_, name, None)\
-                and self._is_userland_descriptor(getattr(self.class_, name)):
-                return True
-
-        if (self.include_properties is not None and
-            name not in self.include_properties):
-            self.__log("not including property %s" % (name))
-            return True
-
-        if (self.exclude_properties is not None and
-            name in self.exclude_properties):
-            self.__log("excluding property %s" % (name))
-            return True
-
-        return False
-
-    def __compile_properties(self):
+    def _configure_properties(self):
+        
+        # Column and other ClauseElement objects which are mapped
+        self.columns = self.c = util.OrderedProperties()
 
         # object attribute names mapped to MapperProperty objects
-        self.__props = util.OrderedDict()
+        self._props = util.OrderedDict()
 
         # table columns mapped to lists of MapperProperty objects
         # using a list allows a single column to be defined as
@@ -688,8 +485,8 @@ class Mapper(object):
 
         # pull properties from the inherited mapper if any.
         if self.inherits:
-            for key, prop in self.inherits.__props.iteritems():
-                if key not in self.__props and not self._should_exclude(key, local=False):
+            for key, prop in self.inherits._props.iteritems():
+                if key not in self._props and not self._should_exclude(key, local=False):
                     self._adapt_inherited_property(key, prop)
 
         # create properties for each column in the mapped table,
@@ -724,8 +521,38 @@ class Mapper(object):
             self._compile_property(key, prop, init=False, setparent=False)
         # TODO: concrete properties dont adapt at all right now....will require copies of relations() etc.
 
+    class _CompileOnAttr(PropComparator):
+        """A placeholder descriptor which triggers compilation on access."""
+
+        def __init__(self, class_, key):
+            self.class_ = class_
+            self.key = key
+            self.existing_prop = getattr(class_, key, None)
+
+        def __getattribute__(self, key):
+            cls = object.__getattribute__(self, 'class_')
+            clskey = object.__getattribute__(self, 'key')
+
+            # ugly hack
+            if key.startswith('__') and key != '__clause_element__':
+                return object.__getattribute__(self, key)
+
+            class_mapper(cls)
+
+            if cls.__dict__.get(clskey) is self:
+                # if this warning occurs, it usually means mapper
+                # compilation has failed, but operations upon the mapped
+                # classes have proceeded.
+                util.warn(
+                    ("Attribute '%s' on class '%s' was not replaced during "
+                     "mapper compilation operation") % (clskey, cls.__name__))
+                # clean us up explicitly
+                delattr(cls, clskey)
+
+            return getattr(getattr(cls, clskey), key)
+
     def _compile_property(self, key, prop, init=True, setparent=True):
-        self.__log("_compile_property(%s, %s)" % (key, prop.__class__.__name__))
+        self._log("_compile_property(%s, %s)" % (key, prop.__class__.__name__))
 
         if not isinstance(prop, MapperProperty):
             # we were passed a Column or a list of Columns; generate a ColumnProperty
@@ -734,7 +561,7 @@ class Mapper(object):
             if not expression.is_column(column):
                 raise sa_exc.ArgumentError("%s=%r is not an instance of MapperProperty or Column" % (key, prop))
 
-            prop = self.__props.get(key, None)
+            prop = self._props.get(key, None)
 
             if isinstance(prop, ColumnProperty):
                 # TODO: the "property already exists" case is still not well defined here.
@@ -745,7 +572,7 @@ class Mapper(object):
                     # make a copy and append our column to it
                     prop = prop.copy()
                 prop.columns.append(column)
-                self.__log("appending to existing ColumnProperty %s" % (key))
+                self._log("appending to existing ColumnProperty %s" % (key))
             elif prop is None:
                 mapped_column = []
                 for c in columns:
@@ -797,10 +624,12 @@ class Mapper(object):
                     prop.descriptor = desc
             if getattr(prop, 'map_column', False):
                 if key not in self.mapped_table.c:
-                    raise sa_exc.ArgumentError("Can't compile synonym '%s': no column on table '%s' named '%s'"  % (prop.name, self.mapped_table.description, key))
+                    raise sa_exc.ArgumentError(
+                        "Can't compile synonym '%s': no column on table '%s' named '%s'" 
+                         % (prop.name, self.mapped_table.description, key))
                 self._compile_property(prop.name, ColumnProperty(self.mapped_table.c[key]), init=init, setparent=setparent)
 
-        self.__props[key] = prop
+        self._props[key] = prop
         prop.key = key
 
         if setparent:
@@ -816,78 +645,312 @@ class Mapper(object):
         for mapper in self._inheriting_mappers:
             mapper._adapt_inherited_property(key, prop)
 
-    def __compile_class(self):
-        """If this mapper is to be a primary mapper (i.e. the
-        non_primary flag is not set), associate this Mapper with the
-        given class_ and entity name.
+    def compile(self):
+        """Compile this mapper and all other non-compiled mappers.
+
+        This method checks the local compiled status as well as for
+        any new mappers that have been defined, and is safe to call
+        repeatedly.
 
-        Subsequent calls to ``class_mapper()`` for the class_/entity
-        name combination will return this mapper.  Also decorate the
-        `__init__` method on the mapped class to include optional
-        auto-session attachment logic.
         """
+        global _new_mappers
+        if self.compiled and not _new_mappers:
+            return self
 
-        manager = attributes.manager_of_class(self.class_)
+        _COMPILE_MUTEX.acquire()
+        try:
+            global _already_compiling
+            if _already_compiling:
+                # re-entrance to compile() occurs rarely, when a class-mapped construct is
+                # used within a ForeignKey, something that is possible
+                # when using the declarative layer
+                self._post_configure_properties()
+                return
+            _already_compiling = True
+            try:
 
-        if self.non_primary:
-            if not manager or manager.mapper is None:
-                raise sa_exc.InvalidRequestError(
-                    "Class %s has no primary mapper configured.  Configure "
-                    "a primary mapper first before setting up a non primary "
-                    "Mapper.")
-            self.class_manager = manager
-            _mapper_registry[self] = True
-            return
+                # double-check inside mutex
+                if self.compiled and not _new_mappers:
+                    return self
 
-        if manager is not None:
-            if manager.class_ is not self.class_:
-                # An inherited manager.  Install one for this subclass.
-                # TODO: no coverage here
-                manager = None
-            elif manager.mapper:
-                raise sa_exc.ArgumentError(
-                    "Class '%s' already has a primary mapper defined. "
-                    "Use non_primary=True to "
-                    "create a non primary Mapper.  clear_mappers() will "
-                    "remove *all* current mappers from all classes." %
-                    self.class_)
+                # initialize properties on all mappers
+                for mapper in list(_mapper_registry):
+                    if not mapper.compiled:
+                        mapper._post_configure_properties()
 
-        _mapper_registry[self] = True
+                _new_mappers = False
+                return self
+            finally:
+                _already_compiling = False
+        finally:
+            _COMPILE_MUTEX.release()
 
-        if manager is None:
-            manager = attributes.create_manager_for_cls(self.class_)
+    def _post_configure_properties(self):
+        """Call the ``init()`` method on all ``MapperProperties``
+        attached to this mapper.
 
-        self.class_manager = manager
+        This is a deferred configuration step which is intended
+        to execute once all mappers have been constructed.
+        
+        """
+        self._log("_post_configure_properties() started")
+        l = [(key, prop) for key, prop in self._props.iteritems()]
+        for key, prop in l:
+            if not getattr(prop, '_compiled', False):
+                self._log("initialize prop " + key)
+                prop.init(key, self)
+        self._log("_post_configure_properties() complete")
+        self.compiled = True
 
-        manager.mapper = self
+    def add_properties(self, dict_of_properties):
+        """Add the given dictionary of properties to this mapper,
+        using `add_property`.
 
-        # The remaining members can be added by any mapper, e_name None or not.
-        if manager.info.get(_INSTRUMENTOR, False):
-            return
+        """
+        for key, value in dict_of_properties.iteritems():
+            self.add_property(key, value)
 
-        self.extension.instrument_class(self, self.class_)
+    def add_property(self, key, prop):
+        """Add an individual MapperProperty to this mapper.
 
-        manager.instantiable = True
-        manager.instance_state_factory = IdentityManagedState
-        manager.deferred_scalar_loader = _load_scalar_attributes
+        If the mapper has not been compiled yet, just adds the
+        property to the initial properties dictionary sent to the
+        constructor.  If this Mapper has already been compiled, then
+        the given MapperProperty is compiled immediately.
 
-        event_registry = manager.events
-        event_registry.add_listener('on_init', _event_on_init)
-        event_registry.add_listener('on_init_failure', _event_on_init_failure)
-        for key, method in util.iterate_attributes(self.class_):
-            if isinstance(method, types.FunctionType):
-                if hasattr(method, '__sa_reconstructor__'):
-                    event_registry.add_listener('on_load', method)
-                elif hasattr(method, '__sa_validators__'):
-                    for name in method.__sa_validators__:
-                        self._validators[name] = method
+        """
+        self._init_properties[key] = prop
+        self._compile_property(key, prop, init=self.compiled)
 
-        if 'reconstruct_instance' in self.extension:
-            def reconstruct(instance):
-                self.extension.reconstruct_instance(self, instance)
-            event_registry.add_listener('on_load', reconstruct)
 
-        manager.info[_INSTRUMENTOR] = self
+    # class formatting / logging.
+    
+    def _log(self, msg):
+        if self._should_log_info:
+            self.logger.info(
+                "(" + self.class_.__name__ + 
+                "|" + 
+                (self.local_table and self.local_table.description or str(self.local_table)) +
+                (self.non_primary and "|non-primary" or "") + ") " + 
+                msg)
+
+    def _log_debug(self, msg):
+        if self._should_log_debug:
+            self.logger.debug(
+                "(" + self.class_.__name__ + 
+                "|" + 
+                (self.local_table and self.local_table.description or str(self.local_table)) + 
+                (self.non_primary and "|non-primary" or "") + ") " + 
+                msg)
+
+    def __repr__(self):
+        return '<Mapper at 0x%x; %s>' % (
+            id(self), self.class_.__name__)
+
+    def __str__(self):
+        return "Mapper|" + self.class_.__name__ + "|" + \
+                (self.local_table and self.local_table.description or str(self.local_table)) + \
+                (self.non_primary and "|non-primary" or "")
+
+    # informational / status
+    
+    def _is_orphan(self, state):
+        o = False
+        for mapper in self.iterate_to_root():
+            for (key, cls) in mapper.delete_orphans:
+                if attributes.manager_of_class(cls).has_parent(
+                    state, key, optimistic=_state_has_identity(state)):
+                    return False
+            o = o or bool(mapper.delete_orphans)
+        return o
+
+    def has_property(self, key):
+        return key in self._props
+
+    def get_property(self, key, resolve_synonyms=False, raiseerr=True):
+        """return a MapperProperty associated with the given key."""
+
+        self.compile()
+        return self._get_property(key, resolve_synonyms=resolve_synonyms, raiseerr=raiseerr)
+
+    def _get_property(self, key, resolve_synonyms=False, raiseerr=True):
+        prop = self._props.get(key, None)
+        if resolve_synonyms:
+            while isinstance(prop, SynonymProperty):
+                prop = self._props.get(prop.name, None)
+        if prop is None and raiseerr:
+            raise sa_exc.InvalidRequestError("Mapper '%s' has no property '%s'" % (str(self), key))
+        return prop
+
+    @property
+    def iterate_properties(self):
+        """return an iterator of all MapperProperty objects."""
+        self.compile()
+        return self._props.itervalues()
+
+    def _mappers_from_spec(self, spec, selectable):
+        """given a with_polymorphic() argument, return the set of mappers it represents.
+
+        Trims the list of mappers to just those represented within the given selectable, if present.
+        This helps some more legacy-ish mappings.
+
+        """
+        if spec == '*':
+            mappers = list(self.polymorphic_iterator())
+        elif spec:
+            mappers = [_class_to_mapper(m) for m in util.to_list(spec)]
+            for m in mappers:
+                if not m.isa(self):
+                    raise sa_exc.InvalidRequestError("%r does not inherit from %r"  % (m, self))
+        else:
+            mappers = []
+
+        if selectable:
+            tables = set(sqlutil.find_tables(selectable, include_aliases=True))
+            mappers = [m for m in mappers if m.local_table in tables]
+
+        return mappers
+
+    def _selectable_from_mappers(self, mappers):
+        """given a list of mappers (assumed to be within this mapper's inheritance hierarchy),
+        construct an outerjoin amongst those mapper's mapped tables.
+
+        """
+        from_obj = self.mapped_table
+        for m in mappers:
+            if m is self:
+                continue
+            if m.concrete:
+                raise sa_exc.InvalidRequestError("'with_polymorphic()' requires 'selectable' argument when concrete-inheriting mappers are used.")
+            elif not m.single:
+                from_obj = from_obj.outerjoin(m.local_table, m.inherit_condition)
+
+        return from_obj
+
+    @util.memoized_property
+    def _with_polymorphic_mappers(self):
+        if not self.with_polymorphic:
+            return [self]
+        return self._mappers_from_spec(*self.with_polymorphic)
+
+    @util.memoized_property
+    def _with_polymorphic_selectable(self):
+        if not self.with_polymorphic:
+            return self.mapped_table
+
+        spec, selectable = self.with_polymorphic
+        if selectable:
+            return selectable
+        else:
+            return self._selectable_from_mappers(self._mappers_from_spec(spec, selectable))
+
+    def _with_polymorphic_args(self, spec=None, selectable=False):
+        if self.with_polymorphic:
+            if not spec:
+                spec = self.with_polymorphic[0]
+            if selectable is False:
+                selectable = self.with_polymorphic[1]
+
+        mappers = self._mappers_from_spec(spec, selectable)
+        if selectable:
+            return mappers, selectable
+        else:
+            return mappers, self._selectable_from_mappers(mappers)
+
+    def _iterate_polymorphic_properties(self, mappers=None):
+        if mappers is None:
+            mappers = self._with_polymorphic_mappers
+        return iter(util.unique_list(
+            chain(*[list(mapper.iterate_properties) for mapper in [self] + mappers])
+        ))
+
+    @property
+    def properties(self):
+        raise NotImplementedError("Public collection of MapperProperty objects is "
+                    "provided by the get_property() and iterate_properties accessors.")
+
+    @util.memoized_property
+    def _get_clause(self):
+        """create a "get clause" based on the primary key.  this is used
+        by query.get() and many-to-one lazyloads to load this item
+        by primary key.
+
+        """
+        params = [(primary_key, sql.bindparam(None, type_=primary_key.type)) for primary_key in self.primary_key]
+        return sql.and_(*[k==v for (k, v) in params]), dict(params)
+
+    @util.memoized_property
+    def _equivalent_columns(self):
+        """Create a map of all *equivalent* columns, based on
+        the determination of column pairs that are equated to
+        one another based on inherit condition.  This is designed
+        to work with the queries that util.polymorphic_union
+        comes up with, which often don't include the columns from
+        the base table directly (including the subclass table columns
+        only).
+
+        The resulting structure is a dictionary of columns mapped
+        to lists of equivalent columns, i.e.
+
+        {
+            tablea.col1:
+                set([tableb.col1, tablec.col1]),
+            tablea.col2:
+                set([tabled.col2])
+        }
+
+        """
+
+        result = {}
+        def visit_binary(binary):
+            if binary.operator == operators.eq:
+                if binary.left in result:
+                    result[binary.left].add(binary.right)
+                else:
+                    result[binary.left] = set((binary.right,))
+                if binary.right in result:
+                    result[binary.right].add(binary.left)
+                else:
+                    result[binary.right] = set((binary.left,))
+        for mapper in self.base_mapper.polymorphic_iterator():
+            if mapper.inherit_condition:
+                visitors.traverse(mapper.inherit_condition, {}, {'binary':visit_binary})
+
+        return result
+
+    def _is_userland_descriptor(self, obj):
+        return not isinstance(obj, (MapperProperty, attributes.InstrumentedAttribute)) and hasattr(obj, '__get__')
+
+    def _should_exclude(self, name, local):
+        """determine whether a particular property should be implicitly present on the class.
+
+        This occurs when properties are propagated from an inherited class, or are
+        applied from the columns present in the mapped table.
+
+        """
+
+        # check for descriptors, either local or from
+        # an inherited class
+        if local:
+            if self.class_.__dict__.get(name, None)\
+                and self._is_userland_descriptor(self.class_.__dict__[name]):
+                return True
+        else:
+            if getattr(self.class_, name, None)\
+                and self._is_userland_descriptor(getattr(self.class_, name)):
+                return True
+
+        if (self.include_properties is not None and
+            name not in self.include_properties):
+            self._log("not including property %s" % (name))
+            return True
+
+        if (self.exclude_properties is not None and
+            name in self.exclude_properties):
+            self._log("excluding property %s" % (name))
+            return True
+
+        return False
 
     def common_parent(self, other):
         """Return true if the given mapper shares a common inherited parent as this mapper."""
@@ -923,43 +986,18 @@ class Mapper(object):
         all their inheriting mappers as well.
 
         To iterate through an entire hierarchy, use
-        ``mapper.base_mapper.polymorphic_iterator()``."""
-
-        yield self
-        for mapper in self._inheriting_mappers:
-            for m in mapper.polymorphic_iterator():
-                yield m
-
-
-    def add_properties(self, dict_of_properties):
-        """Add the given dictionary of properties to this mapper,
-        using `add_property`.
-        """
-
-        for key, value in dict_of_properties.iteritems():
-            self.add_property(key, value)
-
-    def add_property(self, key, prop):
-        """Add an individual MapperProperty to this mapper.
-
-        If the mapper has not been compiled yet, just adds the
-        property to the initial properties dictionary sent to the
-        constructor.  If this Mapper has already been compiled, then
-        the given MapperProperty is compiled immediately.
+        ``mapper.base_mapper.polymorphic_iterator()``.
+        
         """
-
-        self._init_properties[key] = prop
-        self._compile_property(key, prop, init=self.compiled)
-
-    def __repr__(self):
-        return '<Mapper at 0x%x; %s>' % (
-            id(self), self.class_.__name__)
-
-    def __str__(self):
-        return "Mapper|" + self.class_.__name__ + "|" + (self.local_table and self.local_table.description or str(self.local_table)) + (self.non_primary and "|non-primary" or "")
+        stack = deque([self])
+        while stack:
+            item = stack.popleft()
+            yield item
+            stack.extend(item._inheriting_mappers)
 
     def primary_mapper(self):
         """Return the primary mapper corresponding to this mapper's class key (class)."""
+        
         return self.class_manager.mapper
 
     def identity_key_from_row(self, row, adapter=None):
@@ -1016,7 +1054,7 @@ class Mapper(object):
         try:
             return self._columntoproperty[column]
         except KeyError:
-            prop = self.__props.get(column.key, None)
+            prop = self._props.get(column.key, None)
             if prop:
                 raise exc.UnmappedColumnError("Column '%s.%s' is not available, due to conflicting property '%s':%s" % (column.table.name, column.name, column.key, repr(prop)))
             else:
@@ -1036,6 +1074,89 @@ class Mapper(object):
     def _get_committed_state_attr_by_column(self, state, column, passive=False):
         return self._get_col_to_prop(column).getcommitted(state, column, passive=passive)
 
+    def _optimized_get_statement(self, state, attribute_names):
+        """assemble a WHERE clause which retrieves a given state by primary key, using a minimized set of tables.
+        
+        Applies to a joined-table inheritance mapper where the 
+        requested attribute names are only present on joined tables,
+        not the base table.  The WHERE clause attempts to include 
+        only those tables to minimize joins.
+        
+        """
+        props = self._props
+        tables = set(props[key].parent.local_table for key in attribute_names)
+        if self.base_mapper.local_table in tables:
+            return None
+
+        class ColumnsNotAvailable(Exception):
+            pass
+
+        def visit_binary(binary):
+            leftcol = binary.left
+            rightcol = binary.right
+            if leftcol is None or rightcol is None:
+                return
+
+            if leftcol.table not in tables:
+                leftval = self._get_committed_state_attr_by_column(state, leftcol, passive=True)
+                if leftval is attributes.PASSIVE_NORESULT:
+                    raise ColumnsNotAvailable()
+                binary.left = sql.bindparam(None, leftval, type_=binary.right.type)
+            elif rightcol.table not in tables:
+                rightval = self._get_committed_state_attr_by_column(state, rightcol, passive=True)
+                if rightval is attributes.PASSIVE_NORESULT:
+                    raise ColumnsNotAvailable()
+                binary.right = sql.bindparam(None, rightval, type_=binary.right.type)
+
+        allconds = []
+
+        try:
+            start = False
+            for mapper in reversed(list(self.iterate_to_root())):
+                if mapper.local_table in tables:
+                    start = True
+                if start and not mapper.single:
+                    allconds.append(visitors.cloned_traverse(mapper.inherit_condition, {}, {'binary':visit_binary}))
+        except ColumnsNotAvailable:
+            return None
+
+        cond = sql.and_(*allconds)
+        return sql.select(tables, cond, use_labels=True)
+
+    def cascade_iterator(self, type_, state, halt_on=None):
+        """Iterate each element and its mapper in an object graph,
+        for all relations that meet the given cascade rule.
+
+        type\_
+          The name of the cascade rule (i.e. save-update, delete,
+          etc.)
+
+        state
+          The lead InstanceState.  child items will be processed per
+          the relations defined for this object's mapper.
+
+        the return value are object instances; this provides a strong
+        reference so that they don't fall out of scope immediately.
+
+        """
+        visited_instances = util.IdentitySet()
+        visitables = [(self._props.itervalues(), 'property', state)]
+
+        while visitables:
+            iterator, item_type, parent_state = visitables[-1]
+            try:
+                if item_type == 'property':
+                    prop = iterator.next()
+                    visitables.append((prop.cascade_iterator(type_, parent_state, visited_instances, halt_on), 'mapper', None))
+                elif item_type == 'mapper':
+                    instance, instance_mapper, corresponding_state  = iterator.next()
+                    yield (instance, instance_mapper)
+                    visitables.append((instance_mapper._props.itervalues(), 'property', corresponding_state))
+            except StopIteration:
+                visitables.pop()
+
+    # persistence
+
     def _save_obj(self, states, uowtransaction, postupdate=False, post_update_cols=None, single=False):
         """Issue ``INSERT`` and/or ``UPDATE`` statements for a list of objects.
 
@@ -1051,7 +1172,7 @@ class Mapper(object):
         
         """
         if self._should_log_debug:
-            self.__log_debug("_save_obj() start, " + (single and "non-batched" or "batched"))
+            self._log_debug("_save_obj() start, " + (single and "non-batched" or "batched"))
 
         # if batch=false, call _save_obj separately for each object
         if not single and not self.batch:
@@ -1089,7 +1210,7 @@ class Mapper(object):
                 if not uowtransaction.is_deleted(existing):
                     raise exc.FlushError("New instance %s with identity key %s conflicts with persistent instance %s" % (state_str(state), str(instance_key), state_str(existing)))
                 if self._should_log_debug:
-                    self.__log_debug("detected row switch for identity %s.  will update %s, remove %s from transaction" % (instance_key, state_str(state), state_str(existing)))
+                    self._log_debug("detected row switch for identity %s.  will update %s, remove %s from transaction" % (instance_key, state_str(state), state_str(existing)))
                 uowtransaction.set_row_switch(existing)
 
         table_to_mapper = {}
@@ -1108,7 +1229,7 @@ class Mapper(object):
                 instance_key = mapper._identity_key_from_state(state)
 
                 if self._should_log_debug:
-                    self.__log_debug("_save_obj() table '%s' instance %s identity %s" % (table.name, state_str(state), str(instance_key)))
+                    self._log_debug("_save_obj() table '%s' instance %s identity %s" % (table.name, state_str(state), str(instance_key)))
 
                 isinsert = not instance_key in uowtransaction.session.identity_map and not postupdate and not has_identity
                 
@@ -1126,7 +1247,7 @@ class Mapper(object):
                                 params[col.key] = value
                         elif mapper.polymorphic_on and mapper.polymorphic_on.shares_lineage(col):
                             if self._should_log_debug:
-                                self.__log_debug("Using polymorphic identity '%s' for insert column '%s'" % (mapper.polymorphic_identity, col.key))
+                                self._log_debug("Using polymorphic identity '%s' for insert column '%s'" % (mapper.polymorphic_identity, col.key))
                             value = mapper.polymorphic_identity
                             if ((col.default is None and
                                  col.server_default is None) or
@@ -1218,8 +1339,8 @@ class Mapper(object):
                     # to multiple, equivalent columns.  it also may fire off more
                     # than needed overall.
                     for m in mapper.iterate_to_root():
-                        if m.__inherits_equated_pairs:
-                            sync.populate(state, m, state, m, m.__inherits_equated_pairs)
+                        if m._inherits_equated_pairs:
+                            sync.populate(state, m, state, m, m._inherits_equated_pairs)
 
         if not postupdate:
             for state, mapper, connection, has_identity in tups:
@@ -1249,13 +1370,8 @@ class Mapper(object):
                         mapper.extension.after_update(mapper, connection, state.obj())
 
     def _postfetch(self, uowtransaction, connection, table, state, resultproxy, params, value_params):
-        """For a given Table that has just been inserted/updated,
-        mark as 'expired' those attributes which correspond to columns
-        that are marked as 'postfetch', and populate attributes which
-        correspond to columns marked as 'prefetch' or were otherwise generated
-        within _save_obj().
+        """Expire attributes in need of newly persisted database state."""
 
-        """
         postfetch_cols = resultproxy.postfetch_cols()
         generated_cols = list(resultproxy.prefetch_cols())
 
@@ -1281,10 +1397,10 @@ class Mapper(object):
 
         This is called within the context of a UOWTransaction during a
         flush operation.
-        """
 
+        """
         if self._should_log_debug:
-            self.__log_debug("_delete_obj() start")
+            self._log_debug("_delete_obj() start")
 
         if 'connection_callable' in uowtransaction.mapper_flush_opts:
             connection_callable = uowtransaction.mapper_flush_opts['connection_callable']
@@ -1324,11 +1440,14 @@ class Mapper(object):
                 for col in mapper._pks_by_table[table]:
                     clause.clauses.append(col == sql.bindparam(col.key, type_=col.type))
                 if mapper.version_id_col and table.c.contains_column(mapper.version_id_col):
-                    clause.clauses.append(mapper.version_id_col == sql.bindparam(mapper.version_id_col.key, type_=mapper.version_id_col.type))
+                    clause.clauses.append(
+                        mapper.version_id_col == 
+                        sql.bindparam(mapper.version_id_col.key, type_=mapper.version_id_col.type))
                 statement = table.delete(clause)
                 c = connection.execute(statement, del_objects)
                 if c.supports_sane_multi_rowcount() and c.rowcount != len(del_objects):
-                    raise exc.ConcurrentModificationError("Deleted rowcount %d does not match number of objects deleted %d" % (c.rowcount, len(del_objects)))
+                    raise exc.ConcurrentModificationError("Deleted rowcount %d does not match "
+                            "number of objects deleted %d" % (c.rowcount, len(del_objects)))
 
         for state, mapper, connection in tups:
             if 'after_delete' in mapper.extension:
@@ -1340,53 +1459,23 @@ class Mapper(object):
 
         This call `register_dependencies` on all attached
         ``MapperProperty`` instances.
+        
         """
-
-        for prop in self.__props.values():
-            prop.register_dependencies(uowcommit)
-        for dep in self._dependency_processors:
+        for dep in self._props.values() + self._dependency_processors:
             dep.register_dependencies(uowcommit)
 
-    def cascade_iterator(self, type_, state, halt_on=None):
-        """Iterate each element and its mapper in an object graph,
-        for all relations that meet the given cascade rule.
-
-        type\_
-          The name of the cascade rule (i.e. save-update, delete,
-          etc.)
-
-        state
-          The lead InstanceState.  child items will be processed per
-          the relations defined for this object's mapper.
-
-        the return value are object instances; this provides a strong
-        reference so that they don't fall out of scope immediately.
-        """
-
-        visited_instances = util.IdentitySet()
-        visitables = [(self.__props.itervalues(), 'property', state)]
-
-        while visitables:
-            iterator, item_type, parent_state = visitables[-1]
-            try:
-                if item_type == 'property':
-                    prop = iterator.next()
-                    visitables.append((prop.cascade_iterator(type_, parent_state, visited_instances, halt_on), 'mapper', None))
-                elif item_type == 'mapper':
-                    instance, instance_mapper, corresponding_state  = iterator.next()
-                    yield (instance, instance_mapper)
-                    visitables.append((instance_mapper.__props.itervalues(), 'property', corresponding_state))
-            except StopIteration:
-                visitables.pop()
+    # result set conversion
 
     def _instance_processor(self, context, path, adapter, polymorphic_from=None, extension=None, only_load_props=None, refresh_state=None):
+        """Produce a mapper level row processor callable which processes rows into mapped instances."""
+        
         pk_cols = self.primary_key
 
         if polymorphic_from or refresh_state:
             polymorphic_on = None
         else:
             polymorphic_on = self.polymorphic_on
-            polymorphic_instances = util.PopulateDict(self.__configure_subclass_mapper(context, path, adapter))
+            polymorphic_instances = util.PopulateDict(self._configure_subclass_mapper(context, path, adapter))
 
         version_id_col = self.version_id_col
 
@@ -1406,7 +1495,7 @@ class Mapper(object):
 
         def populate_state(state, row, isnew, only_load_props, **flags):
             if not new_populators:
-                new_populators[:], existing_populators[:] = self.__populators(context, path, row, adapter)
+                new_populators[:], existing_populators[:] = self._populators(context, path, row, adapter)
 
             if isnew:
                 populators = new_populators
@@ -1459,14 +1548,17 @@ class Mapper(object):
                 state = attributes.instance_state(instance)
 
                 if self._should_log_debug:
-                    self.__log_debug("_instance(): using existing instance %s identity %s" % (instance_str(instance), str(identitykey)))
+                    self._log_debug("_instance(): using existing instance %s identity %s" % (instance_str(instance), identitykey))
 
                 isnew = state.runid != context.runid
                 currentload = not isnew
                 loaded_instance = False
 
-                if not currentload and version_id_col and context.version_check and self._get_state_attr_by_column(state, self.version_id_col) != row[version_id_col]:
-                    raise exc.ConcurrentModificationError("Instance '%s' version of %s does not match %s" % (state_str(state), self._get_state_attr_by_column(state, self.version_id_col), row[version_id_col]))
+                if not currentload and version_id_col and context.version_check and \
+                        self._get_state_attr_by_column(state, self.version_id_col) != row[version_id_col]:
+                    raise exc.ConcurrentModificationError(
+                            "Instance '%s' version of %s does not match %s" 
+                            % (state_str(state), self._get_state_attr_by_column(state, self.version_id_col), row[version_id_col]))
             elif refresh_state:
                 # out of band refresh_state detected (i.e. its not in the session.identity_map)
                 # honor it anyway.  this can happen if a _get() occurs within save_obj(), such as
@@ -1478,7 +1570,7 @@ class Mapper(object):
                 loaded_instance = False
             else:
                 if self._should_log_debug:
-                    self.__log_debug("_instance(): identity key %s not in session" % str(identitykey))
+                    self._log_debug("_instance(): identity key %s not in session" % str(identitykey))
 
                 if self.allow_null_pks:
                     for x in identitykey[1]:
@@ -1507,7 +1599,7 @@ class Mapper(object):
                     instance = self.class_manager.new_instance()
 
                 if self._should_log_debug:
-                    self.__log_debug("_instance(): created new instance %s identity %s" % (instance_str(instance), str(identitykey)))
+                    self._log_debug("_instance(): created new instance %s identity %s" % (instance_str(instance), str(identitykey)))
 
                 state = attributes.instance_state(instance)
                 state.key = identitykey
@@ -1522,7 +1614,9 @@ class Mapper(object):
                     state.runid = context.runid
                     context.progress.add(state)
 
-                if not populate_instance or populate_instance(self, context, row, instance, only_load_props=only_load_props, instancekey=identitykey, isnew=isnew) is EXT_CONTINUE:
+                if not populate_instance or \
+                        populate_instance(self, context, row, instance, 
+                            only_load_props=only_load_props, instancekey=identitykey, isnew=isnew) is EXT_CONTINUE:
                     populate_state(state, row, isnew, only_load_props)
 
             else:
@@ -1538,21 +1632,27 @@ class Mapper(object):
                         attrs = state.unloaded
                         context.partials[state] = attrs  #<-- allow query.instances to commit the subset of attrs
 
-                    if not populate_instance or populate_instance(self, context, row, instance, only_load_props=attrs, instancekey=identitykey, isnew=isnew) is EXT_CONTINUE:
+                    if not populate_instance or \
+                            populate_instance(self, context, row, instance, 
+                                only_load_props=attrs, instancekey=identitykey, isnew=isnew) is EXT_CONTINUE:
                         populate_state(state, row, isnew, attrs, instancekey=identitykey)
 
             if loaded_instance:
                 state._run_on_load(instance)
 
-            if result is not None and (not append_result or append_result(self, context, row, instance, result, instancekey=identitykey, isnew=isnew) is EXT_CONTINUE):
+            if result is not None and \
+                        (not append_result or 
+                            append_result(self, context, row, instance, result, instancekey=identitykey, isnew=isnew) is EXT_CONTINUE):
                 result.append(instance)
 
             return instance
         return _instance
 
-    def __populators(self, context, path, row, adapter):
+    def _populators(self, context, path, row, adapter):
+        """Produce a collection of attribute level row processor callables."""
+        
         new_populators, existing_populators = [], []
-        for prop in self.__props.values():
+        for prop in self._props.values():
             newpop, existingpop = prop.create_row_processor(context, path, self, row, adapter)
             if newpop:
                 new_populators.append((prop.key, newpop))
@@ -1560,7 +1660,9 @@ class Mapper(object):
                 existing_populators.append((prop.key, existingpop))
         return new_populators, existing_populators
 
-    def __configure_subclass_mapper(self, context, path, adapter):
+    def _configure_subclass_mapper(self, context, path, adapter):
+        """Produce a mapper level row processor callable factory for mappers inheriting this one."""
+        
         def configure_subclass_mapper(discriminator):
             try:
                 mapper = self.polymorphic_map[discriminator]
@@ -1571,47 +1673,6 @@ class Mapper(object):
             return mapper._instance_processor(context, path, adapter, polymorphic_from=self)
         return configure_subclass_mapper
 
-    def _optimized_get_statement(self, state, attribute_names):
-        props = self.__props
-        tables = set(props[key].parent.local_table for key in attribute_names)
-        if self.base_mapper.local_table in tables:
-            return None
-
-        class ColumnsNotAvailable(Exception):
-            pass
-
-        def visit_binary(binary):
-            leftcol = binary.left
-            rightcol = binary.right
-            if leftcol is None or rightcol is None:
-                return
-
-            if leftcol.table not in tables:
-                leftval = self._get_committed_state_attr_by_column(state, leftcol, passive=True)
-                if leftval is attributes.PASSIVE_NORESULT:
-                    raise ColumnsNotAvailable()
-                binary.left = sql.bindparam(None, leftval, type_=binary.right.type)
-            elif rightcol.table not in tables:
-                rightval = self._get_committed_state_attr_by_column(state, rightcol, passive=True)
-                if rightval is attributes.PASSIVE_NORESULT:
-                    raise ColumnsNotAvailable()
-                binary.right = sql.bindparam(None, rightval, type_=binary.right.type)
-
-        allconds = []
-
-        try:
-            start = False
-            for mapper in reversed(list(self.iterate_to_root())):
-                if mapper.local_table in tables:
-                    start = True
-                if start and not mapper.single:
-                    allconds.append(visitors.cloned_traverse(mapper.inherit_condition, {}, {'binary':visit_binary}))
-        except ColumnsNotAvailable:
-            return None
-
-        cond = sql.and_(*allconds)
-        return sql.select(tables, cond, use_labels=True)
-
 log.class_logger(Mapper)
 
 
@@ -1676,10 +1737,13 @@ def _sort_states(states):
     return sorted(states, key=operator.attrgetter('sort_key'))
 
 def _load_scalar_attributes(state, attribute_names):
+    """initiate a column-based attribute refresh operation."""
+    
     mapper = _state_mapper(state)
     session = _state_session(state)
     if not session:
-        raise sa_exc.UnboundExecutionError("Instance %s is not bound to a Session; attribute refresh operation cannot proceed" % (state_str(state)))
+        raise sa_exc.UnboundExecutionError("Instance %s is not bound to a Session; "
+                    "attribute refresh operation cannot proceed" % (state_str(state)))
 
     has_key = _state_has_identity(state)
 
diff --git a/lib/sqlalchemy/util.py b/lib/sqlalchemy/util.py
index 01d2c738d..1a153ce55 100644
--- a/lib/sqlalchemy/util.py
+++ b/lib/sqlalchemy/util.py
@@ -96,6 +96,7 @@ except ImportError:
             return 'defaultdict(%s, %s)' % (self.default_factory,
                                             dict.__repr__(self))
 
+        
 def to_list(x, default=None):
     if x is None:
         return default