- apply an import refactoring to the ORM as well

- rework the event system so that event modules load after their
targets, dependencies are reversed
- create an improved strategy lookup system for the ORM
- rework the ORM to have very few import cycles
- move out "importlater" to just util.dependency
- other tricks to cross-populate modules in as clear a way as possible

7 files changed, 80 insertions, 44 deletions

diff --git a/lib/sqlalchemy/sql/__init__.py b/lib/sqlalchemy/sql/__init__.py
index 3503f8c97..e1497e9fa 100644
--- a/lib/sqlalchemy/sql/__init__.py
+++ b/lib/sqlalchemy/sql/__init__.py
@@ -64,10 +64,16 @@ from .expression import (
 
 from .visitors import ClauseVisitor
 
-__tmp = list(locals().keys())
-__all__ = sorted([i for i in __tmp if not i.startswith('__')])
 
-def __go():
+def __go(lcls):
+    global __all__
+    from .. import util as _sa_util
+
+    import inspect as _inspect
+
+    __all__ = sorted(name for name, obj in lcls.items()
+                 if not (name.startswith('_') or _inspect.ismodule(obj)))
+
     from .annotation import _prepare_annotations, Annotated
     from .elements import AnnotatedColumnElement, ClauseList
     from .selectable import AnnotatedFromClause
@@ -75,6 +81,7 @@ def __go():
     _prepare_annotations(FromClause, AnnotatedFromClause)
     _prepare_annotations(ClauseList, Annotated)
 
-    from .. import util as _sa_util
-    _sa_util.importlater.resolve_all("sqlalchemy.sql")
-__go()
\ No newline at end of file
+    _sa_util.dependencies.resolve_all("sqlalchemy.sql")
+
+__go(locals())
+
diff --git a/lib/sqlalchemy/sql/base.py b/lib/sqlalchemy/sql/base.py
index e7d83627d..2a3176d04 100644
--- a/lib/sqlalchemy/sql/base.py
+++ b/lib/sqlalchemy/sql/base.py
@@ -152,6 +152,24 @@ class Executable(Generative):
             return None
 
 
+class SchemaEventTarget(object):
+    """Base class for elements that are the targets of :class:`.DDLEvents`
+    events.
+
+    This includes :class:`.SchemaItem` as well as :class:`.SchemaType`.
+
+    """
+
+    def _set_parent(self, parent):
+        """Associate with this SchemaEvent's parent object."""
+
+        raise NotImplementedError()
+
+    def _set_parent_with_dispatch(self, parent):
+        self.dispatch.before_parent_attach(self, parent)
+        self._set_parent(parent)
+        self.dispatch.after_parent_attach(self, parent)
+
 class SchemaVisitor(ClauseVisitor):
     """Define the visiting for ``SchemaItem`` objects."""
 
diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py
index 1867df123..17fb40628 100644
--- a/lib/sqlalchemy/sql/elements.py
+++ b/lib/sqlalchemy/sql/elements.py
@@ -9,7 +9,6 @@
 
 """
 
-
 from __future__ import unicode_literals
 
 from .. import util, exc, inspection
diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index ee4d81f6e..bbbe0b235 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -56,37 +56,37 @@ from .dml import Insert, Update, Delete
 # the functions to be available in the sqlalchemy.sql.* namespace and
 # to be auto-cross-documenting from the function to the class itself.
 
-bindparam = public_factory(BindParameter)
-select = public_factory(Select)
-text = public_factory(TextClause)
-table = public_factory(TableClause)
-column = public_factory(ColumnClause)
-over = public_factory(Over)
-label = public_factory(Label)
-case = public_factory(Case)
-cast = public_factory(Cast)
-extract = public_factory(Extract)
-tuple_ = public_factory(Tuple)
-except_ = public_factory(CompoundSelect._create_except)
-except_all = public_factory(CompoundSelect._create_except_all)
-intersect = public_factory(CompoundSelect._create_intersect)
-intersect_all = public_factory(CompoundSelect._create_intersect_all)
-union = public_factory(CompoundSelect._create_union)
-union_all = public_factory(CompoundSelect._create_union_all)
-exists = public_factory(Exists)
-nullsfirst = public_factory(UnaryExpression._create_nullsfirst)
-nullslast = public_factory(UnaryExpression._create_nullslast)
-asc = public_factory(UnaryExpression._create_asc)
-desc = public_factory(UnaryExpression._create_desc)
-distinct = public_factory(UnaryExpression._create_distinct)
-true = public_factory(True_)
-false = public_factory(False_)
-null = public_factory(Null)
-join = public_factory(Join._create_join)
-outerjoin = public_factory(Join._create_outerjoin)
-insert = public_factory(Insert)
-update = public_factory(Update)
-delete = public_factory(Delete)
+bindparam = public_factory(BindParameter, ".expression.bindparam")
+select = public_factory(Select, ".expression.select")
+text = public_factory(TextClause, ".expression.tet")
+table = public_factory(TableClause, ".expression.table")
+column = public_factory(ColumnClause, ".expression.column")
+over = public_factory(Over, ".expression.over")
+label = public_factory(Label, ".expression.label")
+case = public_factory(Case, ".expression.case")
+cast = public_factory(Cast, ".expression.cast")
+extract = public_factory(Extract, ".expression.extract")
+tuple_ = public_factory(Tuple, ".expression.tuple_")
+except_ = public_factory(CompoundSelect._create_except, ".expression.except_")
+except_all = public_factory(CompoundSelect._create_except_all, ".expression.except_all")
+intersect = public_factory(CompoundSelect._create_intersect, ".expression.intersect")
+intersect_all = public_factory(CompoundSelect._create_intersect_all, ".expression.intersect_all")
+union = public_factory(CompoundSelect._create_union, ".expression.union")
+union_all = public_factory(CompoundSelect._create_union_all, ".expression.union_all")
+exists = public_factory(Exists, ".expression.exists")
+nullsfirst = public_factory(UnaryExpression._create_nullsfirst, ".expression.nullsfirst")
+nullslast = public_factory(UnaryExpression._create_nullslast, ".expression.nullslast")
+asc = public_factory(UnaryExpression._create_asc, ".expression.asc")
+desc = public_factory(UnaryExpression._create_desc, ".expression.desc")
+distinct = public_factory(UnaryExpression._create_distinct, ".expression.distinct")
+true = public_factory(True_, ".expression.true")
+false = public_factory(False_, ".expression.false")
+null = public_factory(Null, ".expression.null")
+join = public_factory(Join._create_join, ".expression.join")
+outerjoin = public_factory(Join._create_outerjoin, ".expression.outerjoin")
+insert = public_factory(Insert, ".expression.insert")
+update = public_factory(Update, ".expression.update")
+delete = public_factory(Delete, ".expression.delete")
 
 
 
@@ -101,7 +101,6 @@ from .elements import _literal_as_text, _clause_element_as_expr,\
 from .selectable import _interpret_as_from
 
 
-
 # old names for compatibility
 _Executable = Executable
 _BindParamClause = BindParameter
diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py
index 183b30077..ccab31991 100644
--- a/lib/sqlalchemy/sql/schema.py
+++ b/lib/sqlalchemy/sql/schema.py
@@ -31,7 +31,7 @@ as components in SQL expressions.
 import re
 import inspect
 from .. import exc, util, event, inspection
-from ..events import SchemaEventTarget
+from .base import SchemaEventTarget
 from . import visitors
 from . import type_api
 from .base import _bind_or_error, ColumnCollection
@@ -2509,7 +2509,18 @@ class Index(ColumnCollectionMixin, SchemaItem):
         :param name:
           The name of the index
 
+<<<<<<< HEAD
+        :param \*expressions:
+          Column expressions to include in the index.   The expressions
+          are normally instances of :class:`.Column`, but may also
+          be arbitrary SQL expressions which ultmately refer to a
+          :class:`.Column`.
+
+          .. versionadded:: 0.8 :class:`.Index` supports SQL expressions as
+             well as plain columns.
+=======
         :param \*expressions: Column or SQL expressions.
+>>>>>>> master
 
         :param unique:
             Defaults to False: create a unique index.
diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py
index c7b210be6..38e0d1bd3 100644
--- a/lib/sqlalchemy/sql/sqltypes.py
+++ b/lib/sqlalchemy/sql/sqltypes.py
@@ -14,9 +14,9 @@ import codecs
 from .type_api import TypeEngine, TypeDecorator, to_instance
 from .default_comparator import _DefaultColumnComparator
 from .. import exc, util, processors
-from .base import _bind_or_error
+from .base import _bind_or_error, SchemaEventTarget
 from . import operators
-from .. import events, event
+from .. import event
 from ..util import pickle
 import decimal
 
@@ -817,7 +817,7 @@ class Binary(LargeBinary):
 
 
 
-class SchemaType(events.SchemaEventTarget):
+class SchemaType(SchemaEventTarget):
     """Mark a type as possibly requiring schema-level DDL for usage.
 
     Supports types that must be explicitly created/dropped (i.e. PG ENUM type)
diff --git a/lib/sqlalchemy/sql/util.py b/lib/sqlalchemy/sql/util.py
index a9bd22cc6..b927f1b3c 100644
--- a/lib/sqlalchemy/sql/util.py
+++ b/lib/sqlalchemy/sql/util.py
@@ -19,7 +19,9 @@ from .elements import BindParameter, ColumnClause, ColumnElement, \
 from .selectable import ScalarSelect, Join, FromClause, FromGrouping
 from .schema import Column
 
-join_condition = util.langhelpers.public_factory(Join._join_condition)
+join_condition = util.langhelpers.public_factory(
+                            Join._join_condition,
+                            ".sql.util.join_condition")
 
 # names that are still being imported from the outside
 from .annotation import _shallow_annotate, _deep_annotate, _deep_deannotate