- The :class:`.DeferredReflection` class has been enhanced to provide

automatic reflection support for the "secondary" table referred
to by a :func:`.relationship`.   "secondary", when specified
either as a string table name, or as a :class:`.Table` object with
only a name and :class:`.MetaData` object will also be included
in the reflection process when :meth:`.DeferredReflection.prepare`
is called. [ticket:2865]
- clsregistry._resolver() now uses a stateful _class_resolver()
class in order to handle the work of mapping strings to
objects.   This is to provide for simpler extensibility, namely
a ._resolvers collection of ad-hoc name resolution functions;
the DeferredReflection class adds its own resolver here in order
to handle relationship(secondary) names which generate new
Table objects.

2 files changed, 75 insertions, 38 deletions

diff --git a/lib/sqlalchemy/ext/declarative/api.py b/lib/sqlalchemy/ext/declarative/api.py
index 1cb653a23..64bf7fd9f 100644
--- a/lib/sqlalchemy/ext/declarative/api.py
+++ b/lib/sqlalchemy/ext/declarative/api.py
@@ -9,15 +9,17 @@
 from ...schema import Table, MetaData
 from ...orm import synonym as _orm_synonym, mapper,\
                                 comparable_property,\
-                                interfaces
+                                interfaces, properties
 from ...orm.util import polymorphic_union
 from ...orm.base import _mapper_or_none
+from ...util import compat
 from ... import exc
 import weakref
 
 from .base import _as_declarative, \
                 _declarative_constructor,\
                 _MapperConfig, _add_attribute
+from .clsregistry import _class_resolver
 
 
 def instrument_declarative(cls, registry, metadata):
@@ -465,11 +467,31 @@ class DeferredReflection(object):
     def prepare(cls, engine):
         """Reflect all :class:`.Table` objects for all current
         :class:`.DeferredReflection` subclasses"""
+
         to_map = [m for m in _MapperConfig.configs.values()
                     if issubclass(m.cls, cls)]
         for thingy in to_map:
             cls._sa_decl_prepare(thingy.local_table, engine)
             thingy.map()
+            mapper = thingy.cls.__mapper__
+            metadata = mapper.class_.metadata
+            for rel in mapper._props.values():
+                if isinstance(rel, properties.RelationshipProperty) and \
+                    rel.secondary is not None:
+                    if isinstance(rel.secondary, Table):
+                        cls._sa_decl_prepare(rel.secondary, engine)
+                    elif isinstance(rel.secondary, _class_resolver):
+                        rel.secondary._resolvers += (
+                            cls._sa_deferred_table_resolver(engine, metadata),
+                        )
+
+    @classmethod
+    def _sa_deferred_table_resolver(cls, engine, metadata):
+        def _resolve(key):
+            t1 = Table(key, metadata)
+            cls._sa_decl_prepare(t1, engine)
+            return t1
+        return _resolve
 
     @classmethod
     def _sa_decl_prepare(cls, local_table, engine):
diff --git a/lib/sqlalchemy/ext/declarative/clsregistry.py b/lib/sqlalchemy/ext/declarative/clsregistry.py
index 8fef8f1bc..04567b32c 100644
--- a/lib/sqlalchemy/ext/declarative/clsregistry.py
+++ b/lib/sqlalchemy/ext/declarative/clsregistry.py
@@ -225,47 +225,62 @@ def _determine_container(key, value):
     return _GetColumns(value)
 
 
-def _resolver(cls, prop):
-    def resolve_arg(arg):
-        import sqlalchemy
-        from sqlalchemy.orm import foreign, remote
-
-        fallback = sqlalchemy.__dict__.copy()
-        fallback.update({'foreign': foreign, 'remote': remote})
-
-        def access_cls(key):
-            if key in cls._decl_class_registry:
-                return _determine_container(key, cls._decl_class_registry[key])
-            elif key in cls.metadata.tables:
-                return cls.metadata.tables[key]
-            elif key in cls.metadata._schemas:
-                return _GetTable(key, cls.metadata)
-            elif '_sa_module_registry' in cls._decl_class_registry and \
-                key in cls._decl_class_registry['_sa_module_registry']:
-                registry = cls._decl_class_registry['_sa_module_registry']
-                return registry.resolve_attr(key)
+class _class_resolver(object):
+    def __init__(self, cls, prop, fallback, arg):
+        self.cls = cls
+        self.prop = prop
+        self.arg = self._declarative_arg = arg
+        self.fallback = fallback
+        self._dict = util.PopulateDict(self._access_cls)
+        self._resolvers = ()
+
+    def _access_cls(self, key):
+        cls = self.cls
+        if key in cls._decl_class_registry:
+            return _determine_container(key, cls._decl_class_registry[key])
+        elif key in cls.metadata.tables:
+            return cls.metadata.tables[key]
+        elif key in cls.metadata._schemas:
+            return _GetTable(key, cls.metadata)
+        elif '_sa_module_registry' in cls._decl_class_registry and \
+            key in cls._decl_class_registry['_sa_module_registry']:
+            registry = cls._decl_class_registry['_sa_module_registry']
+            return registry.resolve_attr(key)
+        elif self._resolvers:
+            for resolv in self._resolvers:
+                value = resolv(key)
+                if value is not None:
+                    return value
+
+        return self.fallback[key]
+
+    def __call__(self):
+        try:
+            x = eval(self.arg, globals(), self._dict)
+
+            if isinstance(x, _GetColumns):
+                return x.cls
             else:
-                return fallback[key]
+                return x
+        except NameError as n:
+            raise exc.InvalidRequestError(
+                "When initializing mapper %s, expression %r failed to "
+                "locate a name (%r). If this is a class name, consider "
+                "adding this relationship() to the %r class after "
+                "both dependent classes have been defined." %
+                (self.prop.parent, self.arg, n.args[0], self.cls)
+            )
 
-        d = util.PopulateDict(access_cls)
 
-        def return_cls():
-            try:
-                x = eval(arg, globals(), d)
+def _resolver(cls, prop):
+    import sqlalchemy
+    from sqlalchemy.orm import foreign, remote
 
-                if isinstance(x, _GetColumns):
-                    return x.cls
-                else:
-                    return x
-            except NameError as n:
-                raise exc.InvalidRequestError(
-                    "When initializing mapper %s, expression %r failed to "
-                    "locate a name (%r). If this is a class name, consider "
-                    "adding this relationship() to the %r class after "
-                    "both dependent classes have been defined." %
-                    (prop.parent, arg, n.args[0], cls)
-                )
-        return return_cls
+    fallback = sqlalchemy.__dict__.copy()
+    fallback.update({'foreign': foreign, 'remote': remote})
+
+    def resolve_arg(arg):
+        return _class_resolver(cls, prop, fallback, arg)
     return resolve_arg