- move ext to relative imports

1 files changed, 25 insertions, 25 deletions

diff --git a/lib/sqlalchemy/ext/compiler.py b/lib/sqlalchemy/ext/compiler.py
index 47221fa6a..d5fbec518 100644
--- a/lib/sqlalchemy/ext/compiler.py
+++ b/lib/sqlalchemy/ext/compiler.py
@@ -91,9 +91,9 @@ Produces::
 
     "INSERT INTO mytable (SELECT mytable.x, mytable.y, mytable.z FROM mytable WHERE mytable.x > :x_1)"
 
-.. note:: 
+.. note::
 
-   The above ``InsertFromSelect`` construct probably wants to have "autocommit" 
+   The above ``InsertFromSelect`` construct probably wants to have "autocommit"
    enabled.  See :ref:`enabling_compiled_autocommit` for this step.
 
 Cross Compiling between SQL and DDL compilers
@@ -118,12 +118,12 @@ Enabling Autocommit on a Construct
 
 Recall from the section :ref:`autocommit` that the :class:`.Engine`, when asked to execute
 a construct in the absence of a user-defined transaction, detects if the given
-construct represents DML or DDL, that is, a data modification or data definition statement, which 
+construct represents DML or DDL, that is, a data modification or data definition statement, which
 requires (or may require, in the case of DDL) that the transaction generated by the DBAPI be committed
-(recall that DBAPI always has a transaction going on regardless of what SQLAlchemy does).   Checking 
+(recall that DBAPI always has a transaction going on regardless of what SQLAlchemy does).   Checking
 for this is actually accomplished
 by checking for the "autocommit" execution option on the construct.    When building a construct like
-an INSERT derivation, a new DDL type, or perhaps a stored procedure that alters data, the "autocommit" 
+an INSERT derivation, a new DDL type, or perhaps a stored procedure that alters data, the "autocommit"
 option needs to be set in order for the statement to function with "connectionless" execution
 (as described in :ref:`dbengine_implicit`).
 
@@ -146,13 +146,13 @@ can be used, which already is a subclass of :class:`.Executable`, :class:`.Claus
     class MyInsertThing(UpdateBase):
         def __init__(self, ...):
             ...
-        
-        
-    
+
+
+
 
 DDL elements that subclass :class:`.DDLElement` already have the "autocommit" flag turned on.
 
-    
+
 
 
 Changing the default compilation of existing constructs
@@ -163,7 +163,7 @@ the compilation of a built in SQL construct, the @compiles decorator is invoked
 the appropriate class (be sure to use the class, i.e. ``Insert`` or ``Select``, instead of the creation function such as ``insert()`` or ``select()``).
 
 Within the new compilation function, to get at the "original" compilation routine,
-use the appropriate visit_XXX method - this because compiler.process() will call upon the 
+use the appropriate visit_XXX method - this because compiler.process() will call upon the
 overriding routine and cause an endless loop.   Such as, to add "prefix" to all insert statements::
 
     from sqlalchemy.sql.expression import Insert
@@ -205,7 +205,7 @@ A synopsis is as follows:
   expression class. Any SQL expression can be derived from this base, and is
   probably the best choice for longer constructs such as specialized INSERT
   statements.
- 
+
 * :class:`~sqlalchemy.sql.expression.ColumnElement` - The root of all
   "column-like" elements. Anything that you'd place in the "columns" clause of
   a SELECT statement (as well as order by and group by) can derive from this -
@@ -218,7 +218,7 @@ A synopsis is as follows:
 
       class timestamp(ColumnElement):
           type = TIMESTAMP()
- 
+
 * :class:`~sqlalchemy.sql.expression.FunctionElement` - This is a hybrid of a
   ``ColumnElement`` and a "from clause" like object, and represents a SQL
   function or stored procedure type of call. Since most databases support
@@ -250,7 +250,7 @@ A synopsis is as follows:
 
 * :class:`~sqlalchemy.sql.expression.Executable` - This is a mixin which should be
   used with any expression class that represents a "standalone" SQL statement that
-  can be passed directly to an ``execute()`` method.  It is already implicit 
+  can be passed directly to an ``execute()`` method.  It is already implicit
   within ``DDLElement`` and ``FunctionElement``.
 
 Further Examples
@@ -263,15 +263,15 @@ A function that works like "CURRENT_TIMESTAMP" except applies the appropriate co
 so that the time is in UTC time.   Timestamps are best stored in relational databases
 as UTC, without time zones.   UTC so that your database doesn't think time has gone
 backwards in the hour when daylight savings ends, without timezones because timezones
-are like character encodings - they're best applied only at the endpoints of an 
+are like character encodings - they're best applied only at the endpoints of an
 application (i.e. convert to UTC upon user input, re-apply desired timezone upon display).
 
 For Postgresql and Microsoft SQL Server::
-    
+
     from sqlalchemy.sql import expression
     from sqlalchemy.ext.compiler import compiles
     from sqlalchemy.types import DateTime
-    
+
     class utcnow(expression.FunctionElement):
         type = DateTime()
 
@@ -284,7 +284,7 @@ For Postgresql and Microsoft SQL Server::
         return "GETUTCDATE()"
 
 Example usage::
-    
+
     from sqlalchemy import (
                 Table, Column, Integer, String, DateTime, MetaData
             )
@@ -299,8 +299,8 @@ Example usage::
 -------------------
 
 The "GREATEST" function is given any number of arguments and returns the one that is
-of the highest value - it's equivalent to Python's ``max`` function.  A SQL 
-standard version versus a CASE based version which only accommodates two 
+of the highest value - it's equivalent to Python's ``max`` function.  A SQL
+standard version versus a CASE based version which only accommodates two
 arguments::
 
     from sqlalchemy.sql import expression
@@ -332,7 +332,7 @@ Example usage::
     Session.query(Account).\\
             filter(
                 greatest(
-                    Account.checking_balance, 
+                    Account.checking_balance,
                     Account.savings_balance) > 10000
             )
 
@@ -340,10 +340,10 @@ Example usage::
 ------------------
 
 Render a "false" constant expression, rendering as "0" on platforms that don't have a "false" constant::
-    
+
     from sqlalchemy.sql import expression
     from sqlalchemy.ext.compiler import compiles
-    
+
     class sql_false(expression.ColumnElement):
         pass
 
@@ -358,16 +358,16 @@ Render a "false" constant expression, rendering as "0" on platforms that don't h
         return "0"
 
 Example usage::
-    
+
     from sqlalchemy import select, union_all
 
     exp = union_all(
         select([users.c.name, sql_false().label("enrolled")]),
         select([customers.c.name, customers.c.enrolled])
     )
-    
+
 """
-from sqlalchemy import exc
+from .. import exc
 
 def compiles(class_, *specs):
     def decorate(fn):