Merge branch 'master' into ticket_2501ticket_2501

Conflicts:
	lib/sqlalchemy/orm/mapper.py

1 files changed, 20 insertions, 120 deletions

diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py
index 750aa2fcd..5c44933e8 100644
--- a/lib/sqlalchemy/engine/interfaces.py
+++ b/lib/sqlalchemy/engine/interfaces.py
@@ -1,13 +1,15 @@
 # engine/interfaces.py
-# Copyright (C) 2005-2013 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2014 the SQLAlchemy authors and contributors <see AUTHORS file>
 #
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 """Define core interfaces used by the engine system."""
 
-from .. import util, event, events
+from .. import util, event
 
+# backwards compat
+from ..sql.compiler import Compiled, TypeCompiler
 
 class Dialect(object):
     """Define the behavior of a specific database and DB-API combination.
@@ -191,19 +193,21 @@ class Dialect(object):
 
         pass
 
-    def reflecttable(self, connection, table, include_columns=None):
+    def reflecttable(self, connection, table, include_columns, exclude_columns):
         """Load table description from the database.
 
         Given a :class:`.Connection` and a
         :class:`~sqlalchemy.schema.Table` object, reflect its columns and
-        properties from the database.  If include_columns (a list or
-        set) is specified, limit the autoload to the given column
-        names.
+        properties from the database.
 
-        The default implementation uses the
-        :class:`~sqlalchemy.engine.reflection.Inspector` interface to
-        provide the output, building upon the granular table/column/
-        constraint etc. methods of :class:`.Dialect`.
+        The implementation of this method is provided by
+        :meth:`.DefaultDialect.reflecttable`, which makes use of
+        :class:`.Inspector` to retrieve column information.
+
+        Dialects should **not** seek to implement this method, and should
+        instead implement individual schema inspection operations such as
+        :meth:`.Dialect.get_columns`, :meth:`.Dialect.get_pk_constraint`,
+        etc.
 
         """
 
@@ -246,7 +250,7 @@ class Dialect(object):
 
         Deprecated.  This method is only called by the default
         implementation of :meth:`.Dialect.get_pk_constraint`.  Dialects should
-        instead implement this method directly.
+        instead implement the :meth:`.Dialect.get_pk_constraint` method directly.
 
         """
 
@@ -338,7 +342,7 @@ class Dialect(object):
 
         raise NotImplementedError()
 
-    def get_unique_constraints(self, table_name, schema=None, **kw):
+    def get_unique_constraints(self, connection, table_name, schema=None, **kw):
         """Return information about unique constraints in `table_name`.
 
         Given a string `table_name` and an optional string `schema`, return
@@ -769,110 +773,6 @@ class ExecutionContext(object):
         raise NotImplementedError()
 
 
-class Compiled(object):
-    """Represent a compiled SQL or DDL expression.
-
-    The ``__str__`` method of the ``Compiled`` object should produce
-    the actual text of the statement.  ``Compiled`` objects are
-    specific to their underlying database dialect, and also may
-    or may not be specific to the columns referenced within a
-    particular set of bind parameters.  In no case should the
-    ``Compiled`` object be dependent on the actual values of those
-    bind parameters, even though it may reference those values as
-    defaults.
-    """
-
-    def __init__(self, dialect, statement, bind=None,
-                compile_kwargs=util.immutabledict()):
-        """Construct a new ``Compiled`` object.
-
-        :param dialect: ``Dialect`` to compile against.
-
-        :param statement: ``ClauseElement`` to be compiled.
-
-        :param bind: Optional Engine or Connection to compile this
-          statement against.
-
-        :param compile_kwargs: additional kwargs that will be
-         passed to the initial call to :meth:`.Compiled.process`.
-
-         .. versionadded:: 0.8
-
-        """
-
-        self.dialect = dialect
-        self.bind = bind
-        if statement is not None:
-            self.statement = statement
-            self.can_execute = statement.supports_execution
-            self.string = self.process(self.statement, **compile_kwargs)
-
-    @util.deprecated("0.7", ":class:`.Compiled` objects now compile "
-                        "within the constructor.")
-    def compile(self):
-        """Produce the internal string representation of this element."""
-        pass
-
-    @property
-    def sql_compiler(self):
-        """Return a Compiled that is capable of processing SQL expressions.
-
-        If this compiler is one, it would likely just return 'self'.
-
-        """
-
-        raise NotImplementedError()
-
-    def process(self, obj, **kwargs):
-        return obj._compiler_dispatch(self, **kwargs)
-
-    def __str__(self):
-        """Return the string text of the generated SQL or DDL."""
-
-        return self.string or ''
-
-    def construct_params(self, params=None):
-        """Return the bind params for this compiled object.
-
-        :param params: a dict of string/object pairs whose values will
-                       override bind values compiled in to the
-                       statement.
-        """
-
-        raise NotImplementedError()
-
-    @property
-    def params(self):
-        """Return the bind params for this compiled object."""
-        return self.construct_params()
-
-    def execute(self, *multiparams, **params):
-        """Execute this compiled object."""
-
-        e = self.bind
-        if e is None:
-            raise exc.UnboundExecutionError(
-                        "This Compiled object is not bound to any Engine "
-                        "or Connection.")
-        return e._execute_compiled(self, multiparams, params)
-
-    def scalar(self, *multiparams, **params):
-        """Execute this compiled object and return the result's
-        scalar value."""
-
-        return self.execute(*multiparams, **params).scalar()
-
-
-class TypeCompiler(object):
-    """Produces DDL specification for TypeEngine objects."""
-
-    def __init__(self, dialect):
-        self.dialect = dialect
-
-    def process(self, type_):
-        return type_._compiler_dispatch(self)
-
-
 class Connectable(object):
     """Interface for an object which supports execution of SQL constructs.
 
@@ -884,8 +784,6 @@ class Connectable(object):
 
     """
 
-    dispatch = event.dispatcher(events.ConnectionEvents)
-
     def connect(self, **kwargs):
         """Return a :class:`.Connection` object.
 
@@ -914,7 +812,8 @@ class Connectable(object):
                      "object directly, i.e. :meth:`.Table.create`, "
                      ":meth:`.Index.create`, :meth:`.MetaData.create_all`")
     def create(self, entity, **kwargs):
-        """Emit CREATE statements for the given schema entity."""
+        """Emit CREATE statements for the given schema entity.
+        """
 
         raise NotImplementedError()
 
@@ -923,7 +822,8 @@ class Connectable(object):
                      "object directly, i.e. :meth:`.Table.drop`, "
                      ":meth:`.Index.drop`, :meth:`.MetaData.drop_all`")
     def drop(self, entity, **kwargs):
-        """Emit DROP statements for the given schema entity."""
+        """Emit DROP statements for the given schema entity.
+        """
 
         raise NotImplementedError()