Update SQLAlchemy

2013-06-14 11:00:06 +02:00
parent 267ecfacab
commit 4aa6700ceb
124 changed files with 6500 additions and 5207 deletions
@@ -1,5 +1,5 @@
 # engine/__init__.py
-# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2013 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
@@ -101,8 +101,8 @@ default_strategy = 'plain'
 def create_engine(*args, **kwargs):
    """Create a new :class:`.Engine` instance.

-    The standard calling form is to send the URL as the 
-    first positional argument, usually a string 
+    The standard calling form is to send the URL as the
+    first positional argument, usually a string
    that indicates database dialect and connection arguments.
    Additional keyword arguments may then follow it which
    establish various options on the resulting :class:`.Engine`
@@ -111,14 +111,14 @@ def create_engine(*args, **kwargs):

    The string form of the URL is
    ``dialect+driver://user:password@host/dbname[?key=value..]``, where
-    ``dialect`` is a database name such as ``mysql``, ``oracle``, 
-    ``postgresql``, etc., and ``driver`` the name of a DBAPI, such as 
-    ``psycopg2``, ``pyodbc``, ``cx_oracle``, etc.  Alternatively, 
+    ``dialect`` is a database name such as ``mysql``, ``oracle``,
+    ``postgresql``, etc., and ``driver`` the name of a DBAPI, such as
+    ``psycopg2``, ``pyodbc``, ``cx_oracle``, etc.  Alternatively,
    the URL can be an instance of :class:`~sqlalchemy.engine.url.URL`.

-    ``**kwargs`` takes a wide variety of options which are routed 
-    towards their appropriate components.  Arguments may be 
-    specific to the :class:`.Engine`, the underlying :class:`.Dialect`, as well as the 
+    ``**kwargs`` takes a wide variety of options which are routed
+    towards their appropriate components.  Arguments may be
+    specific to the :class:`.Engine`, the underlying :class:`.Dialect`, as well as the
    :class:`.Pool`.  Specific dialects also accept keyword arguments that
    are unique to that dialect.   Here, we describe the parameters
    that are common to most :func:`.create_engine()` usage.
@@ -136,11 +136,11 @@ def create_engine(*args, **kwargs):
    :ref:`engines_toplevel`

    :ref:`connections_toplevel`
-    
+
    :param assert_unicode:  Deprecated.  This flag
        sets an engine-wide default value for
-        the ``assert_unicode`` flag on the 
-        :class:`.String` type - see that 
+        the ``assert_unicode`` flag on the
+        :class:`.String` type - see that
        type for further details.

    :param connect_args: a dictionary of options which will be
@@ -151,16 +151,16 @@ def create_engine(*args, **kwargs):
    :param convert_unicode=False: if set to True, sets
        the default behavior of ``convert_unicode`` on the
        :class:`.String` type to ``True``, regardless
-        of a setting of ``False`` on an individual 
+        of a setting of ``False`` on an individual
        :class:`.String` type, thus causing all :class:`.String`
        -based columns
        to accommodate Python ``unicode`` objects.  This flag
-        is useful as an engine-wide setting when using a 
+        is useful as an engine-wide setting when using a
        DBAPI that does not natively support Python
        ``unicode`` objects and raises an error when
        one is received (such as pyodbc with FreeTDS).
-        
-        See :class:`.String` for further details on 
+
+        See :class:`.String` for further details on
        what this flag indicates.

    :param creator: a callable which returns a DBAPI connection.
@@ -184,43 +184,43 @@ def create_engine(*args, **kwargs):
        :ref:`dbengine_logging` for information on how to configure logging
        directly.

-    :param encoding: Defaults to ``utf-8``.  This is the string 
-        encoding used by SQLAlchemy for string encode/decode 
-        operations which occur within SQLAlchemy, **outside of 
-        the DBAPI.**  Most modern DBAPIs feature some degree of 
+    :param encoding: Defaults to ``utf-8``.  This is the string
+        encoding used by SQLAlchemy for string encode/decode
+        operations which occur within SQLAlchemy, **outside of
+        the DBAPI.**  Most modern DBAPIs feature some degree of
        direct support for Python ``unicode`` objects,
        what you see in Python 2 as a string of the form
-        ``u'some string'``.  For those scenarios where the 
+        ``u'some string'``.  For those scenarios where the
        DBAPI is detected as not supporting a Python ``unicode``
-        object, this encoding is used to determine the 
+        object, this encoding is used to determine the
        source/destination encoding.  It is **not used**
        for those cases where the DBAPI handles unicode
        directly.
-        
+
        To properly configure a system to accommodate Python
-        ``unicode`` objects, the DBAPI should be 
+        ``unicode`` objects, the DBAPI should be
        configured to handle unicode to the greatest
        degree as is appropriate - see
        the notes on unicode pertaining to the specific
-        target database in use at :ref:`dialect_toplevel`. 
-        
-        Areas where string encoding may need to be accommodated 
-        outside of the DBAPI include zero or more of: 
-        
-        * the values passed to bound parameters, corresponding to 
+        target database in use at :ref:`dialect_toplevel`.
+
+        Areas where string encoding may need to be accommodated
+        outside of the DBAPI include zero or more of:
+
+        * the values passed to bound parameters, corresponding to
          the :class:`.Unicode` type or the :class:`.String` type
          when ``convert_unicode`` is ``True``;
-        * the values returned in result set columns corresponding 
-          to the :class:`.Unicode` type or the :class:`.String` 
+        * the values returned in result set columns corresponding
+          to the :class:`.Unicode` type or the :class:`.String`
          type when ``convert_unicode`` is ``True``;
-        * the string SQL statement passed to the DBAPI's 
-          ``cursor.execute()`` method; 
-        * the string names of the keys in the bound parameter 
-          dictionary passed to the DBAPI's ``cursor.execute()`` 
+        * the string SQL statement passed to the DBAPI's
+          ``cursor.execute()`` method;
+        * the string names of the keys in the bound parameter
+          dictionary passed to the DBAPI's ``cursor.execute()``
          as well as ``cursor.setinputsizes()`` methods;
-        * the string column names retrieved from the DBAPI's 
+        * the string column names retrieved from the DBAPI's
          ``cursor.description`` attribute.
-          
+
        When using Python 3, the DBAPI is required to support
        *all* of the above values as Python ``unicode`` objects,
        which in Python 3 are just known as ``str``.  In Python 2,
@@ -236,9 +236,9 @@ def create_engine(*args, **kwargs):
    :param implicit_returning=True: When ``True``, a RETURNING-
        compatible construct, if available, will be used to
        fetch newly generated primary key values when a single row
-        INSERT statement is emitted with no existing returning() 
-        clause.  This applies to those backends which support RETURNING 
-        or a compatible construct, including Postgresql, Firebird, Oracle, 
+        INSERT statement is emitted with no existing returning()
+        clause.  This applies to those backends which support RETURNING
+        or a compatible construct, including Postgresql, Firebird, Oracle,
        Microsoft SQL Server.   Set this to ``False`` to disable
        the automatic usage of RETURNING.

@@ -248,13 +248,13 @@ def create_engine(*args, **kwargs):
        "_(counter)". If ``None``, the value of
        ``dialect.max_identifier_length`` is used instead.

-    :param listeners: A list of one or more 
-        :class:`~sqlalchemy.interfaces.PoolListener` objects which will 
+    :param listeners: A list of one or more
+        :class:`~sqlalchemy.interfaces.PoolListener` objects which will
        receive connection pool events.

    :param logging_name:  String identifier which will be used within
        the "name" field of logging records generated within the
-        "sqlalchemy.engine" logger. Defaults to a hexstring of the 
+        "sqlalchemy.engine" logger. Defaults to a hexstring of the
        object's id.

    :param max_overflow=10: the number of connections to allow in
@@ -286,8 +286,8 @@ def create_engine(*args, **kwargs):
        of pool to be used.

    :param pool_logging_name:  String identifier which will be used within
-       the "name" field of logging records generated within the 
-       "sqlalchemy.pool" logger. Defaults to a hexstring of the object's 
+       the "name" field of logging records generated within the
+       "sqlalchemy.pool" logger. Defaults to a hexstring of the object's
       id.

    :param pool_size=5: the number of connections to keep open
@@ -307,18 +307,29 @@ def create_engine(*args, **kwargs):
        server configuration as well).

    :param pool_reset_on_return='rollback': set the "reset on return"
-        behavior of the pool, which is whether ``rollback()``, 
+        behavior of the pool, which is whether ``rollback()``,
        ``commit()``, or nothing is called upon connections
        being returned to the pool.  See the docstring for
-        ``reset_on_return`` at :class:`.Pool`. (new as of 0.7.6)
+        ``reset_on_return`` at :class:`.Pool`.
+
+        .. versionadded:: 0.7.6

    :param pool_timeout=30: number of seconds to wait before giving
        up on getting a connection from the pool. This is only used
        with :class:`~sqlalchemy.pool.QueuePool`.

    :param strategy='plain': selects alternate engine implementations.
-        Currently available is the ``threadlocal``
-        strategy, which is described in :ref:`threadlocal_strategy`.
+        Currently available are:
+
+        * the ``threadlocal`` strategy, which is described in
+          :ref:`threadlocal_strategy`;
+        * the ``mock`` strategy, which dispatches all statement
+          execution to a function passed as the argument ``executor``.
+          See `example in the FAQ <http://www.sqlalchemy.org/trac/wiki/FAQ#HowcanIgettheCREATETABLEDROPTABLEoutputasastring>`_.
+
+    :param executor=None: a function taking arguments
+        ``(sql, *multiparams, **params)``, to which the ``mock`` strategy will
+        dispatch all statement execution. Used only by ``strategy='mock'``.

    """

@@ -28,7 +28,7 @@ class SchemaGenerator(DDLBase):
        if table.schema:
            self.dialect.validate_identifier(table.schema)
        return not self.checkfirst or \
-                not self.dialect.has_table(self.connection, 
+                not self.dialect.has_table(self.connection,
                                    table.name, schema=table.schema)

    def _can_create_sequence(self, sequence):
@@ -39,8 +39,8 @@ class SchemaGenerator(DDLBase):
                 (
                 not self.checkfirst or
                 not self.dialect.has_sequence(
-                            self.connection, 
-                            sequence.name, 
+                            self.connection,
+                            sequence.name,
                            schema=sequence.schema)
                 )
            )
@@ -50,9 +50,9 @@ class SchemaGenerator(DDLBase):
            tables = self.tables
        else:
            tables = metadata.tables.values()
-        collection = [t for t in sql_util.sort_tables(tables) 
+        collection = [t for t in sql_util.sort_tables(tables)
                        if self._can_create_table(t)]
-        seq_coll = [s for s in metadata._sequences.values() 
+        seq_coll = [s for s in metadata._sequences.values()
                        if s.column is None and self._can_create_sequence(s)]

        metadata.dispatch.before_create(metadata, self.connection,
@@ -95,7 +95,7 @@ class SchemaGenerator(DDLBase):

    def visit_sequence(self, sequence, create_ok=False):
        if not create_ok and not self._can_create_sequence(sequence):
-            return 
+            return
        self.connection.execute(schema.CreateSequence(sequence))

    def visit_index(self, index):
@@ -116,9 +116,9 @@ class SchemaDropper(DDLBase):
            tables = self.tables
        else:
            tables = metadata.tables.values()
-        collection = [t for t in reversed(sql_util.sort_tables(tables)) 
+        collection = [t for t in reversed(sql_util.sort_tables(tables))
                                if self._can_drop_table(t)]
-        seq_coll = [s for s in metadata._sequences.values() 
+        seq_coll = [s for s in metadata._sequences.values()
                                if s.column is None and self._can_drop_sequence(s)]

        metadata.dispatch.before_drop(metadata, self.connection,
@@ -141,7 +141,7 @@ class SchemaDropper(DDLBase):
        self.dialect.validate_identifier(table.name)
        if table.schema:
            self.dialect.validate_identifier(table.schema)
-        return not self.checkfirst or self.dialect.has_table(self.connection, 
+        return not self.checkfirst or self.dialect.has_table(self.connection,
                                            table.name, schema=table.schema)

    def _can_drop_sequence(self, sequence):
@@ -150,8 +150,8 @@ class SchemaDropper(DDLBase):
                 not sequence.optional) and
                (not self.checkfirst or
                 self.dialect.has_sequence(
-                                self.connection, 
-                                sequence.name, 
+                                self.connection,
+                                sequence.name,
                                schema=sequence.schema))
            )

@@ -1,5 +1,5 @@
 # engine/default.py
-# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2013 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
@@ -89,17 +89,13 @@ class DefaultDialect(base.Dialect):

    server_version_info = None

-    # indicates symbol names are 
+    # indicates symbol names are
    # UPPERCASEd if they are case insensitive
    # within the database.
    # if this is True, the methods normalize_name()
    # and denormalize_name() must be provided.
    requires_name_normalize = False

-    # a hook for SQLite's translation of 
-    # result column names
-    _translate_colname = None
-
    reflection_options = ()

    def __init__(self, convert_unicode=False, assert_unicode=False,
@@ -190,7 +186,7 @@ class DefaultDialect(base.Dialect):
        self.returns_unicode_strings = self._check_unicode_returns(connection)

        self.do_rollback(connection.connection)
- 
+
    def on_connect(self):
        """return a callable which sets up a newly created DBAPI connection.

@@ -220,7 +216,7 @@ class DefaultDialect(base.Dialect):
                try:
                    cursor.execute(
                        cast_to(
-                            expression.select( 
+                            expression.select(
                            [expression.cast(
                                expression.literal_column(
                                        "'test %s returns'" % formatstr), type_)
@@ -264,20 +260,20 @@ class DefaultDialect(base.Dialect):
        return insp.reflecttable(table, include_columns, exclude_columns)

    def get_pk_constraint(self, conn, table_name, schema=None, **kw):
-        """Compatiblity method, adapts the result of get_primary_keys()
+        """Compatibility method, adapts the result of get_primary_keys()
        for those dialects which don't implement get_pk_constraint().

        """
        return {
            'constrained_columns':
-                        self.get_primary_keys(conn, table_name, 
+                        self.get_primary_keys(conn, table_name,
                                                schema=schema, **kw)
        }

    def validate_identifier(self, ident):
        if len(ident) > self.max_identifier_length:
            raise exc.IdentifierError(
-                "Identifier '%s' exceeds maximum length of %d characters" % 
+                "Identifier '%s' exceeds maximum length of %d characters" %
                (ident, self.max_identifier_length)
            )

@@ -341,8 +337,8 @@ class DefaultDialect(base.Dialect):
        return False

    def reset_isolation_level(self, dbapi_conn):
-        # default_isolation_level is read from the first conenction 
-        # after the initial set of 'isolation_level', if any, so is 
+        # default_isolation_level is read from the first connection
+        # after the initial set of 'isolation_level', if any, so is
        # the configured default of this dialect.
        self.set_isolation_level(dbapi_conn, self.default_isolation_level)

@@ -355,9 +351,15 @@ class DefaultExecutionContext(base.ExecutionContext):
    result_map = None
    compiled = None
    statement = None
+    postfetch_cols = None
+    prefetch_cols = None
    _is_implicit_returning = False
    _is_explicit_returning = False

+    # a hook for SQLite's translation of
+    # result column names
+    _translate_colname = None
+
    @classmethod
    def _init_ddl(cls, dialect, connection, dbapi_connection, compiled_ddl):
        """Initialize execution context for a DDLElement construct."""
@@ -449,8 +451,8 @@ class DefaultExecutionContext(base.ExecutionContext):

        processors = compiled._bind_processors

-        # Convert the dictionary of bind parameter values 
-        # into a dict or list to be sent to the DBAPI's 
+        # Convert the dictionary of bind parameter values
+        # into a dict or list to be sent to the DBAPI's
        # execute() or executemany() method.
        parameters = []
        if dialect.positional:
@@ -513,7 +515,7 @@ class DefaultExecutionContext(base.ExecutionContext):
                            for d in parameters
                        ] or [{}]
        else:
-            self.parameters = [dialect.execute_sequence_format(p) 
+            self.parameters = [dialect.execute_sequence_format(p)
                                    for p in parameters]

        self.executemany = len(parameters) > 1
@@ -550,10 +552,10 @@ class DefaultExecutionContext(base.ExecutionContext):

    @util.memoized_property
    def should_autocommit(self):
-        autocommit = self.execution_options.get('autocommit', 
-                                                not self.compiled and 
+        autocommit = self.execution_options.get('autocommit',
+                                                not self.compiled and
                                                self.statement and
-                                                expression.PARSE_AUTOCOMMIT 
+                                                expression.PARSE_AUTOCOMMIT
                                                or False)

        if autocommit is expression.PARSE_AUTOCOMMIT:
@@ -586,7 +588,7 @@ class DefaultExecutionContext(base.ExecutionContext):
        if type_ is not None:
            # apply type post processors to the result
            proc = type_._cached_result_processor(
-                        self.dialect, 
+                        self.dialect,
                        self.cursor.description[0][1]
                    )
            if proc:
@@ -623,7 +625,7 @@ class DefaultExecutionContext(base.ExecutionContext):
        and when no explicit id value was bound to the
        statement.

-        The function is called once, directly after 
+        The function is called once, directly after
        post_exec() and before the transaction is committed
        or ResultProxy is generated.   If the post_exec()
        method assigns a value to `self._lastrowid`, the
@@ -672,7 +674,7 @@ class DefaultExecutionContext(base.ExecutionContext):
            self.inserted_primary_key = [
                c is autoinc_col and lastrowid or v
                for c, v in zip(
-                                    table.primary_key, 
+                                    table.primary_key,
                                    self.inserted_primary_key)
            ]

@@ -698,7 +700,7 @@ class DefaultExecutionContext(base.ExecutionContext):
        style of ``setinputsizes()`` on the cursor, using DB-API types
        from the bind parameter's ``TypeEngine`` objects.

-        This method only called by those dialects which require it, 
+        This method only called by those dialects which require it,
        currently cx_oracle.

        """
@@ -743,7 +745,7 @@ class DefaultExecutionContext(base.ExecutionContext):
        elif default.is_callable:
            return default.arg(self)
        elif default.is_clause_element:
-            # TODO: expensive branching here should be 
+            # TODO: expensive branching here should be
            # pulled into _exec_scalar()
            conn = self.connection
            c = expression.select([default.arg]).compile(bind=conn)
@@ -809,7 +811,7 @@ class DefaultExecutionContext(base.ExecutionContext):

            if self.isinsert:
                self.inserted_primary_key = [
-                                self.compiled_parameters[0].get(c.key, None) 
+                                self.compiled_parameters[0].get(c.key, None)
                                        for c in self.compiled.\
                                                statement.table.primary_key
                                ]
@@ -1,5 +1,5 @@
 # engine/reflection.py
-# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2013 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
@@ -38,8 +38,8 @@ def cache(fn, self, con, *args, **kw):
    if info_cache is None:
        return fn(self, con, *args, **kw)
    key = (
-            fn.__name__, 
-            tuple(a for a in args if isinstance(a, basestring)), 
+            fn.__name__,
+            tuple(a for a in args if isinstance(a, basestring)),
            tuple((k, v) for k, v in kw.iteritems() if isinstance(v, (basestring, int, float)))
        )
    ret = info_cache.get(key)
@@ -72,9 +72,9 @@ class Inspector(object):
    def __init__(self, bind):
        """Initialize a new :class:`.Inspector`.

-        :param bind: a :class:`~sqlalchemy.engine.base.Connectable`, 
-          which is typically an instance of 
-          :class:`~sqlalchemy.engine.base.Engine` or 
+        :param bind: a :class:`~sqlalchemy.engine.base.Connectable`,
+          which is typically an instance of
+          :class:`~sqlalchemy.engine.base.Engine` or
          :class:`~sqlalchemy.engine.base.Connection`.

        For a dialect-specific instance of :class:`.Inspector`, see
@@ -101,9 +101,9 @@ class Inspector(object):
    def from_engine(cls, bind):
        """Construct a new dialect-specific Inspector object from the given engine or connection.

-        :param bind: a :class:`~sqlalchemy.engine.base.Connectable`, 
-          which is typically an instance of 
-          :class:`~sqlalchemy.engine.base.Engine` or 
+        :param bind: a :class:`~sqlalchemy.engine.base.Connectable`,
+          which is typically an instance of
+          :class:`~sqlalchemy.engine.base.Engine` or
          :class:`~sqlalchemy.engine.base.Connection`.

        This method differs from direct a direct constructor call of :class:`.Inspector`
@@ -320,7 +320,7 @@ class Inspector(object):
    def reflecttable(self, table, include_columns, exclude_columns=()):
        """Given a Table object, load its internal constructs based on introspection.

-        This is the underlying method used by most dialects to produce 
+        This is the underlying method used by most dialects to produce
        table reflection.  Direct usage is like::

            from sqlalchemy import create_engine, MetaData, Table
@@ -379,7 +379,7 @@ class Inspector(object):

            coltype = col_d['type']
            col_kw = {
-                'nullable':col_d['nullable'],
+                'nullable': col_d['nullable'],
            }
            for k in ('autoincrement', 'quote', 'info', 'key'):
                if k in col_d:
@@ -414,11 +414,11 @@ class Inspector(object):
        # Primary keys
        pk_cons = self.get_pk_constraint(table_name, schema, **tblkw)
        if pk_cons:
-            pk_cols = [table.c[pk] 
-                        for pk in pk_cons['constrained_columns'] 
+            pk_cols = [table.c[pk]
+                        for pk in pk_cons['constrained_columns']
                        if pk in table.c and pk not in exclude_columns
                    ] + [pk for pk in table.primary_key if pk.key in exclude_columns]
-            primary_key_constraint = sa_schema.PrimaryKeyConstraint(name=pk_cons.get('name'), 
+            primary_key_constraint = sa_schema.PrimaryKeyConstraint(name=pk_cons.get('name'),
                *pk_cols
            )

@@ -452,7 +452,7 @@ class Inspector(object):
            table.append_constraint(
                sa_schema.ForeignKeyConstraint(constrained_columns, refspec,
                                               conname, link_to_name=True))
-        # Indexes 
+        # Indexes
        indexes = self.get_indexes(table_name, schema)
        for index_d in indexes:
            name = index_d['name']
@@ -465,5 +465,5 @@ class Inspector(object):
                    "Omitting %s KEY for (%s), key covers omitted columns." %
                    (flavor, ', '.join(columns)))
                continue
-            sa_schema.Index(name, *[table.columns[c] for c in columns], 
+            sa_schema.Index(name, *[table.columns[c] for c in columns],
                         **dict(unique=unique))
@@ -1,5 +1,5 @@
 # engine/strategies.py
-# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2013 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
@@ -24,7 +24,7 @@ strategies = {}


 class EngineStrategy(object):
-    """An adaptor that processes input arguements and produces an Engine.
+    """An adaptor that processes input arguments and produces an Engine.

    Provides a ``create`` method that receives input arguments and
    produces an instance of base.Engine or a subclass.
@@ -41,7 +41,7 @@ class EngineStrategy(object):


 class DefaultEngineStrategy(EngineStrategy):
-    """Base class for built-in stratgies."""
+    """Base class for built-in strategies."""

    def create(self, name_or_url, **kwargs):
        # create url.URL object
@@ -80,7 +80,7 @@ class DefaultEngineStrategy(EngineStrategy):
                    return dialect.connect(*cargs, **cparams)
                except Exception, e:
                    # Py3K
-                    #raise exc.DBAPIError.instance(None, None, 
+                    #raise exc.DBAPIError.instance(None, None,
                    #                   e, dialect.dbapi.Error,
                    #                   connection_invalidated=
                    #                       dialect.is_disconnect(e, None, None)
@@ -180,7 +180,7 @@ PlainEngineStrategy()


 class ThreadLocalEngineStrategy(DefaultEngineStrategy):
-    """Strategy for configuring an Engine with thredlocal behavior."""
+    """Strategy for configuring an Engine with threadlocal behavior."""

    name = 'threadlocal'
    engine_cls = threadlocal.TLEngine
@@ -245,8 +245,8 @@ class MockEngineStrategy(EngineStrategy):
            from sqlalchemy.engine import ddl
            ddl.SchemaDropper(self.dialect, self, **kwargs).traverse_single(entity)

-        def _run_visitor(self, visitorcallable, element, 
-                                        connection=None, 
+        def _run_visitor(self, visitorcallable, element,
+                                        connection=None,
                                        **kwargs):
            kwargs['checkfirst'] = False
            visitorcallable(self.dialect, self,
@@ -1,5 +1,5 @@
 # engine/threadlocal.py
-# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2013 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
@@ -7,7 +7,7 @@
 """Provides a thread-local transactional wrapper around the root Engine class.

 The ``threadlocal`` module is invoked when using the ``strategy="threadlocal"`` flag
-with :func:`~sqlalchemy.engine.create_engine`.  This module is semi-private and is 
+with :func:`~sqlalchemy.engine.create_engine`.  This module is semi-private and is
 invoked automatically when the threadlocal engine strategy is used.
 """

@@ -1,5 +1,5 @@
 # engine/url.py
-# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
+# Copyright (C) 2005-2013 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
@@ -110,7 +110,7 @@ class URL(object):
                module = self._load_entry_point()
                if module is None:
                    raise exc.ArgumentError(
-                        "Could not determine dialect for '%s'." % 
+                        "Could not determine dialect for '%s'." %
                        self.drivername)

            return module.dialect