going back to the simple way, plus trying to make the engine thing simpler, and....doesn't work.

on_before_execute and on_after_execute really not appealing here.   might have to just go back to
what it was the other day.

1 files changed, 41 insertions, 43 deletions

diff --git a/lib/sqlalchemy/interfaces.py b/lib/sqlalchemy/interfaces.py
index d502afbd8..1cceff0b4 100644
--- a/lib/sqlalchemy/interfaces.py
+++ b/lib/sqlalchemy/interfaces.py
@@ -6,14 +6,13 @@
 
 """Interfaces and abstract types."""
 
-from sqlalchemy.util import as_interface
-from sqlalchemy import event
+from sqlalchemy import event, util
 
 class PoolListener(object):
     """Hooks into the lifecycle of connections in a :class:`Pool`.
 
     .. note:: :class:`PoolListener` is deprecated.   Please
-       refer to :func:`event.listen_raw` as well as 
+       refer to :func:`event.listen` as well as 
        :attr:`.Pool.events`.
     
     Usage::
@@ -72,16 +71,16 @@ class PoolListener(object):
         
         """
 
-        listener = as_interface(listener, methods=('connect',
+        listener = util.as_interface(listener, methods=('connect',
                                 'first_connect', 'checkout', 'checkin'))
         if hasattr(listener, 'connect'):
-            event.listen_raw(listener.connect, 'on_connect', self)
+            event.listen(listener.connect, 'on_connect', self)
         if hasattr(listener, 'first_connect'):
-            event.listen_raw(listener.first_connect, 'on_first_connect', self)
+            event.listen(listener.first_connect, 'on_first_connect', self)
         if hasattr(listener, 'checkout'):
-            event.listen_raw(listener.checkout, 'on_checkout', self)
+            event.listen(listener.checkout, 'on_checkout', self)
         if hasattr(listener, 'checkin'):
-            event.listen_raw(listener.checkin, 'on_checkin', self)
+            event.listen(listener.checkin, 'on_checkin', self)
             
         
     def connect(self, dbapi_con, con_record):
@@ -146,7 +145,7 @@ class ConnectionProxy(object):
     """Allows interception of statement execution by Connections.
 
     .. note:: :class:`ConnectionProxy` is deprecated.   Please
-       refer to :func:`event.listen_raw` as well as 
+       refer to :func:`event.listen` as well as 
        :attr:`.Engine.events`.
     
     Either or both of the ``execute()`` and ``cursor_execute()``
@@ -175,42 +174,41 @@ class ConnectionProxy(object):
     
     @classmethod
     def _adapt_listener(cls, self, listener):
-        # TODO: suppose if new style listeners used here.  then we say:
-        
-        # def _wrap_in_some_way(legacy_listener):
-        #   def go(clauseelement, *multiparams, **params):
-        #       # 'fake' execute function.  in reality just repopulates
-        #       # the event with the given args in case they were modified.
-        #       args.update({'clauseelement':clauseelement, 'multiparams':multiparams, 'params':params})
-        #       return args
-        #   def listen(evt, args):
-        #       return legacy_listener(args['conn'], go, args['clauseelement'], *args['multiparams'], **args['params'])
-        # 
-        # event.listen(_wrap_in_some_way(self.execute), 'on_execute', self)
-        # 
-        # that way all the complex crap is left in the legacy adapter, and the "re-execute" idea is
-        # scrapped, since it was fairly pointless.  The proxyconnection stuff in base.py can just 
-        # iterate through listeners.
-        #
-
-        event.listen_raw(listener.execute, 'on_execute', self)
-        def _adapt_cursor_execute(conn, execute, cursor, statement, 
+        
+        def adapt_execute(conn, clauseelement, *multiparams, **params):
+            def execute_wrapper(clauseelement, *multiparams, **params):
+                return clauseelement, multiparams, params
+            return listener.execute(conn, execute_wrapper, clauseelement, *multiparams, **params)
+            
+        event.listen(adapt_execute, 'on_execute', self)
+
+        def adapt_cursor_execute(conn, cursor, statement, 
                                     parameters, context, executemany):
-            def _re_execute(cursor, statement, parameters, context):
-                return execute(cursor, statement, parameters, context, executemany)
-            return listener.cursor_execute(_re_execute, cursor, statement, 
+            def execute_wrapper(cursor, statement, parameters, context):
+                return statement, parameters
+            return listener.cursor_execute(execute_wrapper, cursor, statement, 
                                         parameters, context, executemany)
-        event.listen_raw(_adapt_cursor_execute, 'on_cursor_execute', self)
-        event.listen_raw(listener.begin, 'on_begin', self)
-        event.listen_raw(listener.rollback, 'on_rollback', self)
-        event.listen_raw(listener.commit, 'on_commit', self)
-        event.listen_raw(listener.savepoint, 'on_savepoint', self)
-        event.listen_raw(listener.rollback_savepoint, 'on_rollback_savepoint', self)
-        event.listen_raw(listener.release_savepoint, 'on_release_savepoint', self)
-        event.listen_raw(listener.begin_twophase, 'on_begin_twophase', self)
-        event.listen_raw(listener.prepare_twophase, 'on_prepare_twophase', self)
-        event.listen_raw(listener.rollback_twophase, 'on_rollback_twophase', self)
-        event.listen_raw(listener.commit_twophase, 'on_commit_twophase', self)
+                                        
+        event.listen(adapt_cursor_execute, 'on_cursor_execute', self)
+
+        def do_nothing_callback(*arg, **kw):
+            pass
+        
+        def adapt_listener(fn):
+            def go(conn, *arg, **kw):
+                fn(conn, do_nothing_callback, *arg, **kw)
+            return util.update_wrapper(go, fn)
+            
+        event.listen(adapt_listener(listener.begin), 'on_begin', self)
+        event.listen(adapt_listener(listener.rollback), 'on_rollback', self)
+        event.listen(adapt_listener(listener.commit), 'on_commit', self)
+        event.listen(adapt_listener(listener.savepoint), 'on_savepoint', self)
+        event.listen(adapt_listener(listener.rollback_savepoint), 'on_rollback_savepoint', self)
+        event.listen(adapt_listener(listener.release_savepoint), 'on_release_savepoint', self)
+        event.listen(adapt_listener(listener.begin_twophase), 'on_begin_twophase', self)
+        event.listen(adapt_listener(listener.prepare_twophase), 'on_prepare_twophase', self)
+        event.listen(adapt_listener(listener.rollback_twophase), 'on_rollback_twophase', self)
+        event.listen(adapt_listener(listener.commit_twophase), 'on_commit_twophase', self)
         
         
     def execute(self, conn, execute, clauseelement, *multiparams, **params):