- A large refactoring of the ``sqlalchemy.sql`` package has reorganized

the import structure of many core modules.
``sqlalchemy.schema`` and ``sqlalchemy.types``
remain in the top-level package, but are now just lists of names
that pull from within ``sqlalchemy.sql``.  Their implementations
are now broken out among ``sqlalchemy.sql.type_api``, ``sqlalchemy.sql.sqltypes``,
``sqlalchemy.sql.schema`` and ``sqlalchemy.sql.ddl``, the last of which was
moved from ``sqlalchemy.engine``.  ``sqlalchemy.sql.expression`` is also
a namespace now which pulls implementations mostly from ``sqlalchemy.sql.elements``,
``sqlalchemy.sql.selectable``, and ``sqlalchemy.sql.dml``.
Most of the "factory" functions
used to create SQL expression objects have been moved to classmethods
or constructors, which are exposed in ``sqlalchemy.sql.expression``
using a programmatic system.  Care has been taken such that all the
original import namespaces remain intact and there should be no impact
on any existing applications.   The rationale here was to break out these
very large modules into smaller ones, provide more manageable lists
of function names, to greatly reduce "import cycles" and clarify the
up-front importing of names, and to remove the need for redundant
functions and documentation throughout the expression package.

1 files changed, 7 insertions, 14 deletions

diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py
index fac8a3c6f..39ddaa7b8 100644
--- a/lib/sqlalchemy/orm/strategies.py
+++ b/lib/sqlalchemy/orm/strategies.py
@@ -111,6 +111,7 @@ class UninstrumentedColumnLoader(LoaderStrategy):
         return None, None, None
 
 
+@log.class_logger
 class ColumnLoader(LoaderStrategy):
     """Provide loading behavior for a :class:`.ColumnProperty`."""
 
@@ -156,9 +157,8 @@ class ColumnLoader(LoaderStrategy):
             return expire_for_non_present_col, None, None
 
 
-log.class_logger(ColumnLoader)
-
 
+@log.class_logger
 class DeferredColumnLoader(LoaderStrategy):
     """Provide loading behavior for a deferred :class:`.ColumnProperty`."""
 
@@ -251,8 +251,6 @@ class DeferredColumnLoader(LoaderStrategy):
         return attributes.ATTR_WAS_SET
 
 
-log.class_logger(DeferredColumnLoader)
-
 
 class LoadDeferredColumns(object):
     """serializable loader object used by DeferredColumnLoader"""
@@ -304,6 +302,7 @@ class AbstractRelationshipLoader(LoaderStrategy):
 
 
 
+@log.class_logger
 class NoLoader(AbstractRelationshipLoader):
     """Provide loading behavior for a :class:`.RelationshipProperty`
     with "lazy=None".
@@ -325,9 +324,8 @@ class NoLoader(AbstractRelationshipLoader):
         return invoke_no_load, None, None
 
 
-log.class_logger(NoLoader)
-
 
+@log.class_logger
 class LazyLoader(AbstractRelationshipLoader):
     """Provide loading behavior for a :class:`.RelationshipProperty`
     with "lazy=True", that is loads when first accessed.
@@ -629,8 +627,6 @@ class LazyLoader(AbstractRelationshipLoader):
             return reset_for_lazy_callable, None, None
 
 
-log.class_logger(LazyLoader)
-
 
 class LoadLazyAttribute(object):
     """serializable loader object used by LazyLoader"""
@@ -666,6 +662,7 @@ class ImmediateLoader(AbstractRelationshipLoader):
         return None, None, load_immediate
 
 
+@log.class_logger
 class SubqueryLoader(AbstractRelationshipLoader):
     def __init__(self, parent):
         super(SubqueryLoader, self).__init__(parent)
@@ -983,9 +980,8 @@ class SubqueryLoader(AbstractRelationshipLoader):
         return load_scalar_from_subq, None, None
 
 
-log.class_logger(SubqueryLoader)
-
 
+@log.class_logger
 class JoinedLoader(AbstractRelationshipLoader):
     """Provide loading behavior for a :class:`.RelationshipProperty`
     using joined eager loading.
@@ -1201,7 +1197,7 @@ class JoinedLoader(AbstractRelationshipLoader):
             # by the Query propagates those columns outward.
             # This has the effect
             # of "undefering" those columns.
-            for col in sql_util.find_columns(
+            for col in sql_util._find_columns(
                                 self.parent_property.primaryjoin):
                 if localparent.mapped_table.c.contains_column(col):
                     if adapter:
@@ -1335,9 +1331,6 @@ class JoinedLoader(AbstractRelationshipLoader):
                 None, load_scalar_from_joined_exec
 
 
-log.class_logger(JoinedLoader)
-
-
 class EagerLazyOption(StrategizedOption):
     def __init__(self, key, lazy=True, chained=False,
                     propagate_to_loaders=True