- ConnectionProxy now has wrapper methods for all transaction

lifecycle events, including begin(), rollback(), commit()
begin_nested(), begin_prepared(), prepare(), release_savepoint(),
etc.

2 files changed, 80 insertions, 1 deletions

diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index 86a2a7fdb..564fa50a9 100644
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -1523,6 +1523,36 @@ def _proxy_connection_cls(cls, proxy):
         def _cursor_executemany(self, cursor, statement, parameters, context=None):
             return proxy.cursor_execute(super(ProxyConnection, self)._cursor_executemany, cursor, statement, parameters, context, True)
 
+        def _begin_impl(self):
+            return proxy.begin(self, super(ProxyConnection, self)._begin_impl)
+            
+        def _rollback_impl(self):
+            return proxy.rollback(self, super(ProxyConnection, self)._rollback_impl)
+
+        def _commit_impl(self):
+            return proxy.commit(self, super(ProxyConnection, self)._commit_impl)
+
+        def _savepoint_impl(self, name=None):
+            return proxy.savepoint(self, super(ProxyConnection, self)._savepoint_impl, name=name)
+
+        def _rollback_to_savepoint_impl(self, name, context):
+            return proxy.rollback_savepoint(self, super(ProxyConnection, self)._rollback_to_savepoint_impl, name, context)
+            
+        def _release_savepoint_impl(self, name, context):
+            return proxy.release_savepoint(self, super(ProxyConnection, self)._release_savepoint_impl, name, context)
+
+        def _begin_twophase_impl(self, xid):
+            return proxy.begin_twophase(self, super(ProxyConnection, self)._begin_twophase_impl, xid)
+
+        def _prepare_twophase_impl(self, xid):
+            return proxy.prepare_twophase(self, super(ProxyConnection, self)._prepare_twophase_impl, xid)
+
+        def _rollback_twophase_impl(self, xid, is_prepared):
+            return proxy.rollback_twophase(self, super(ProxyConnection, self)._rollback_twophase_impl, xid, is_prepared)
+
+        def _commit_twophase_impl(self, xid, is_prepared):
+            return proxy.commit_twophase(self, super(ProxyConnection, self)._commit_twophase_impl, xid, is_prepared)
+
     return ProxyConnection
 
 
diff --git a/lib/sqlalchemy/interfaces.py b/lib/sqlalchemy/interfaces.py
index e4a9adee1..c2a267d5f 100644
--- a/lib/sqlalchemy/interfaces.py
+++ b/lib/sqlalchemy/interfaces.py
@@ -152,5 +152,54 @@ class ConnectionProxy(object):
         """Intercept low-level cursor execute() events."""
         
         return execute(cursor, statement, parameters, context)
-
+    
+    def begin(self, conn, begin):
+        """Intercept begin() events."""
+        
+        return begin()
+        
+    def rollback(self, conn, rollback):
+        """Intercept rollback() events."""
+        
+        return rollback()
+        
+    def commit(self, conn, commit):
+        """Intercept commit() events."""
+        
+        return commit()
+        
+    def savepoint(self, conn, savepoint, name=None):
+        """Intercept savepoint() events."""
+        
+        return savepoint(name=name)
+        
+    def rollback_savepoint(self, conn, rollback_savepoint, name, context):
+        """Intercept rollback_savepoint() events."""
+        
+        return rollback_savepoint(name, context)
+        
+    def release_savepoint(self, conn, release_savepoint, name, context):
+        """Intercept release_savepoint() events."""
+        
+        return release_savepoint(name, context)
+        
+    def begin_twophase(self, conn, begin_twophase, xid):
+        """Intercept begin_twophase() events."""
+        
+        return begin_twophase(xid)
+        
+    def prepare_twophase(self, conn, prepare_twophase, xid):
+        """Intercept prepare_twophase() events."""
+        
+        return prepare_twophase(xid)
+        
+    def rollback_twophase(self, conn, rollback_twophase, xid, is_prepared):
+        """Intercept rollback_twophase() events."""
+        
+        return rollback_twophase(xid, is_prepared)
+        
+    def commit_twophase(self, conn, commit_twophase, xid, is_prepared):
+        """Intercept commit_twophase() events."""
+        
+        return commit_twophase(xid, is_prepared)