revert back to the 0.5 way of calling DBAPIError.instance(), but add the tback as...

usage.  sorry empty !

diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index 7daf5dbd31657feb0e554ba8634901285b2e1c9f..fb5e6c22182bf1c6a90c047e7c5ab9c183cb4448 100644 (file)
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -1046,7 +1046,7 @@ class Connection(Connectable):
         
     def _handle_dbapi_exception(self, e, statement, parameters, cursor, context):
         if getattr(self, '_reentrant_error', False):
-            raise exc.DBAPIError.instance_cls(e), (None, None, e), sys.exc_info()[2]
+            raise exc.DBAPIError.instance(statement, parameters, e), None, sys.exc_info()[2]
         self._reentrant_error = True
         try:
             if not isinstance(e, self.dialect.dbapi.Error):
@@ -1065,7 +1065,7 @@ class Connection(Connectable):
                 self._autorollback()
                 if self.__close_with_result:
                     self.close()
-            raise exc.DBAPIError.instance_cls(e), (statement, parameters, e, is_disconnect), sys.exc_info()[2]
+            raise exc.DBAPIError.instance(statement, parameters, e, connection_invalidated=is_disconnect), None, sys.exc_info()[2]
         finally:
             del self._reentrant_error
 

diff --git a/lib/sqlalchemy/engine/strategies.py b/lib/sqlalchemy/engine/strategies.py
index b1db8625f8a774df391ae7789c6a257948096a83..d31f7855457671a324f8fa23f82601ccf9542ce4 100644 (file)
--- a/lib/sqlalchemy/engine/strategies.py
+++ b/lib/sqlalchemy/engine/strategies.py
@@ -78,7 +78,7 @@ class DefaultEngineStrategy(EngineStrategy):
                     return dbapi.connect(*cargs, **cparams)
                 except Exception, e:
                     import sys
-                    raise exc.DBAPIError.instance_cls(e), (None, None, e), sys.exc_info()[2]
+                    raise exc.DBAPIError.instance(None, None, e), None, sys.exc_info()[2]
             creator = kwargs.pop('creator', connect)
 
             poolclass = (kwargs.pop('poolclass', None) or

diff --git a/lib/sqlalchemy/exc.py b/lib/sqlalchemy/exc.py
index 1beb3cdeeb0206556add2570a9d3d541ee702d67..799abbf0d3dabc5f92feb60ff40f44d19068d036 100644 (file)
--- a/lib/sqlalchemy/exc.py
+++ b/lib/sqlalchemy/exc.py
@@ -104,18 +104,18 @@ class DBAPIError(SQLAlchemyError):
     """
 
     @classmethod
-    def instance_cls(cls, orig):
+    def instance(cls, statement, params, orig, connection_invalidated=False):
         # Don't ever wrap these, just return them directly as if
         # DBAPIError didn't exist.
         if isinstance(orig, (KeyboardInterrupt, SystemExit)):
-            return type(orig)
+            return orig
 
         if orig is not None:
             name, glob = orig.__class__.__name__, globals()
             if name in glob and issubclass(glob[name], DBAPIError):
                 cls = glob[name]
 
-        return cls
+        return cls(statement, params, orig, connection_invalidated)
 
     def __init__(self, statement, params, orig, connection_invalidated=False):
         try:

diff --git a/test/base/except.py b/test/base/except.py
index 928ec690a9aa36671726d6044acf950f0c9c728a..eddd9221e29e41b2e0e0c3f8389b862fff01741e 100644 (file)
--- a/test/base/except.py
+++ b/test/base/except.py
@@ -25,23 +25,23 @@ class OutOfSpec(DatabaseError):
 class WrapTest(unittest.TestCase):
     def test_db_error_normal(self):
         try:
-            raise sa_exceptions.DBAPIError.instance_cls(OperationalError()), \
-                ('', [], OperationalError())
+            raise sa_exceptions.DBAPIError.instance(
+                '', [], OperationalError())
         except sa_exceptions.DBAPIError:
             self.assert_(True)
 
     def test_db_error_busted_dbapi(self):
         try:
-            raise sa_exceptions.DBAPIError.instance_cls(ProgrammingError()), \
-                ('', [], ProgrammingError())
+            raise sa_exceptions.DBAPIError.instance(
+                '', [], ProgrammingError())
         except sa_exceptions.DBAPIError, e:
             self.assert_(True)
             self.assert_('Error in str() of DB-API' in e.args[0])
 
     def test_db_error_noncompliant_dbapi(self):
         try:
-            raise sa_exceptions.DBAPIError.instance_cls(OutOfSpec()), \
-                ('', [], OutOfSpec())
+            raise sa_exceptions.DBAPIError.instance(
+                '', [], OutOfSpec())
         except sa_exceptions.DBAPIError, e:
             self.assert_(e.__class__ is sa_exceptions.DBAPIError)
         except OutOfSpec:
@@ -50,8 +50,8 @@ class WrapTest(unittest.TestCase):
         # Make sure the DatabaseError recognition logic is limited to
         # subclasses of sqlalchemy.exceptions.DBAPIError
         try:
-            raise sa_exceptions.DBAPIError.instance_cls(sa_exceptions.ArgumentError()), \
-                ('', [], sa_exceptions.ArgumentError())
+            raise sa_exceptions.DBAPIError.instance(
+                '', [], sa_exceptions.ArgumentError())
         except sa_exceptions.DBAPIError, e:
             self.assert_(e.__class__ is sa_exceptions.DBAPIError)
         except sa_exceptions.ArgumentError:
@@ -59,8 +59,8 @@ class WrapTest(unittest.TestCase):
 
     def test_db_error_keyboard_interrupt(self):
         try:
-            raise sa_exceptions.DBAPIError.instance_cls(KeyboardInterrupt()), \
-                ('', [], KeyboardInterrupt())
+            raise sa_exceptions.DBAPIError.instance(
+                '', [], KeyboardInterrupt())
         except sa_exceptions.DBAPIError:
             self.assert_(False)
         except KeyboardInterrupt:
@@ -68,8 +68,8 @@ class WrapTest(unittest.TestCase):
 
     def test_db_error_system_exit(self):
         try:
-            raise sa_exceptions.DBAPIError.instance_cls(SystemExit()), \
-                ('', [], SystemExit())
+            raise sa_exceptions.DBAPIError.instance(
+                '', [], SystemExit())
         except sa_exceptions.DBAPIError:
             self.assert_(False)
         except SystemExit: