- _execute_clauseelement() goes back to being

a private method.  Subclassing Connection
is not needed now that ConnectionProxy
is available.
- tightened the interface for the various _execute_XXX()
methods to reduce ambiguity
- __distill_params() no longer creates artificial [{}] entry,
blank dict is no longer passed through to do_execute()
in any case unless explicitly sent from the outside
as in connection.execute("somestring"), {})
- fixed a few old sql.query tests which were doing that
- removed needless do_execute() from mysql dialect
- fixed charset param not properly being sent to
_compat_fetchone() in mysql

diff --git a/CHANGES b/CHANGES
index 4eabb400934fb40fc52bdd37d8ec8a2d2145106a..03c7debccf465844ef85966cf0b1829249d18bb6 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -155,7 +155,12 @@ CHANGES
       select() with order_by() (presumably to support
       LIMIT/OFFSET), you should also call self_group() 
       on it to apply parenthesis.
-      
+    
+    - _execute_clauseelement() goes back to being 
+      a private method.  Subclassing Connection
+      is not needed now that ConnectionProxy 
+      is available.
+
 - documentation
     - Tickets [ticket:1200] [ticket:1149].
       

diff --git a/lib/sqlalchemy/databases/mysql.py b/lib/sqlalchemy/databases/mysql.py
index 6a01b789b83ff4dc41c96fc2d2bc399d4f6a5120..0fc7c8fbd3ca5ed7d2756e980a1ab7a9ce98f78a 100644 (file)
--- a/lib/sqlalchemy/databases/mysql.py
+++ b/lib/sqlalchemy/databases/mysql.py
@@ -1510,9 +1510,6 @@ class MySQLDialect(default.DefaultDialect):
     def supports_unicode_statements(self):
         return True
 
-    def do_execute(self, cursor, statement, parameters, context=None):
-        cursor.execute(statement, parameters)
-
     def do_commit(self, connection):
         """Execute a COMMIT."""
 
@@ -1811,8 +1808,8 @@ class MySQLDialect(default.DefaultDialect):
             return
 
         row = _compat_fetchone(
-            connection.execute("SHOW VARIABLES LIKE 'sql_mode'",
-                               charset=charset))
+            connection.execute("SHOW VARIABLES LIKE 'sql_mode'"),
+                               charset=charset)
         if not row:
             mode = ''
         else:

diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index fc7fd90567a70ef35c3b15d8e8916963de83b086..c7101d10ec32ff81bae0bfe9e80efb68cfe6e818 100644 (file)
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -497,7 +497,7 @@ class Connectable(object):
     def execute(self, object, *multiparams, **params):
         raise NotImplementedError()
 
-    def execute_clauseelement(self, elem, multiparams=None, params=None):
+    def _execute_clauseelement(self, elem, multiparams=None, params=None):
         raise NotImplementedError()
 
 class Connection(Connectable):
@@ -833,7 +833,7 @@ class Connection(Connectable):
             if params:
                 return [params]
             else:
-                return [{}]
+                return []
         elif len(multiparams) == 1:
             zero = multiparams[0]
             if isinstance(zero, (list, tuple)):
@@ -852,17 +852,17 @@ class Connection(Connectable):
                 return [multiparams]
 
     def _execute_function(self, func, multiparams, params):
-        return self.execute_clauseelement(func.select(), multiparams, params)
+        return self._execute_clauseelement(func.select(), multiparams, params)
 
-    def _execute_default(self, default, multiparams=None, params=None):
+    def _execute_default(self, default, multiparams, params):
         return self.engine.dialect.defaultrunner(self.__create_execution_context()).traverse_single(default)
 
-    def execute_clauseelement(self, elem, multiparams=None, params=None):
+    def _execute_clauseelement(self, elem, multiparams, params):
         params = self.__distill_params(multiparams, params)
         if params:
             keys = params[0].keys()
         else:
-            keys = None
+            keys = []
 
         context = self.__create_execution_context(
                         compiled=elem.compile(dialect=self.dialect, column_keys=keys, inline=len(params) > 1), 
@@ -870,7 +870,7 @@ class Connection(Connectable):
                     )
         return self.__execute_context(context)
 
-    def _execute_compiled(self, compiled, multiparams=None, params=None):
+    def _execute_compiled(self, compiled, multiparams, params):
         """Execute a sql.Compiled object."""
 
         context = self.__create_execution_context(
@@ -955,7 +955,7 @@ class Connection(Connectable):
     # poor man's multimethod/generic function thingy
     executors = {
         expression._Function: _execute_function,
-        expression.ClauseElement: execute_clauseelement,
+        expression.ClauseElement: _execute_clauseelement,
         Compiled: _execute_compiled,
         schema.SchemaItem: _execute_default,
         schema.DDL: _execute_ddl,
@@ -1128,7 +1128,7 @@ class Engine(Connectable):
     def _execute_default(self, default):
         connection = self.contextual_connect()
         try:
-            return connection._execute_default(default)
+            return connection._execute_default(default, (), {})
         finally:
             connection.close()
 
@@ -1196,9 +1196,9 @@ class Engine(Connectable):
     def scalar(self, statement, *multiparams, **params):
         return self.execute(statement, *multiparams, **params).scalar()
 
-    def execute_clauseelement(self, elem, multiparams=None, params=None):
+    def _execute_clauseelement(self, elem, multiparams=None, params=None):
         connection = self.contextual_connect(close_with_result=True)
-        return connection.execute_clauseelement(elem, multiparams, params)
+        return connection._execute_clauseelement(elem, multiparams, params)
 
     def _execute_compiled(self, compiled, multiparams, params):
         connection = self.contextual_connect(close_with_result=True)
@@ -1273,7 +1273,7 @@ def _proxy_connection_cls(cls, proxy):
         def execute(self, object, *multiparams, **params):
             return proxy.execute(self, super(ProxyConnection, self).execute, object, *multiparams, **params)
  
-        def execute_clauseelement(self, elem, multiparams=None, params=None):
+        def _execute_clauseelement(self, elem, multiparams=None, params=None):
             return proxy.execute(self, super(ProxyConnection, self).execute, elem, *(multiparams or []), **(params or {}))
             
         def _cursor_execute(self, cursor, statement, parameters, context=None):
@@ -1834,7 +1834,7 @@ class DefaultRunner(schema.SchemaVisitor):
     def exec_default_sql(self, default):
         conn = self.context.connection
         c = expression.select([default.arg]).compile(bind=conn)
-        return conn._execute_compiled(c).scalar()
+        return conn._execute_compiled(c, (), {}).scalar()
 
     def execute_string(self, stmt, params=None):
         """execute a string statement, using the raw cursor, and return a scalar result."""

diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index 6bda4c82c3978f7534f944a42f19b98a5563e114..aa0b7228c4e94ba64c3f2ecb30e5cf3e772e10e7 100644 (file)
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -1124,7 +1124,7 @@ class ClauseElement(Visitable):
                    'or the Metadata of its underlying tables to enable '
                    'implicit execution via this method.' % label)
             raise exc.UnboundExecutionError(msg)
-        return e.execute_clauseelement(self, multiparams, params)
+        return e._execute_clauseelement(self, multiparams, params)
 
     def scalar(self, *multiparams, **params):
         """Compile and execute this ``ClauseElement``, returning the result's scalar representation."""

diff --git a/test/engine/execute.py b/test/engine/execute.py
index 5b3478c56cc51adeebca9847d34dcb8b46297918..515c99d309bd9d44d55ec44459fb0dcac7cd8d1d 100644 (file)
--- a/test/engine/execute.py
+++ b/test/engine/execute.py
@@ -151,11 +151,11 @@ class ProxyConnectionTest(TestBase):
                 ]
             else:
                 cursor = [
-                    ("CREATE TABLE t1", {}, None),
+                    ("CREATE TABLE t1", {}, ()),
                     ("INSERT INTO t1 (c1, c2)", {'c2': 'some data', 'c1': 5}, [5, 'some data']),
                     ("INSERT INTO t1 (c1, c2)", {'c1': 6, "lower_2":"Foo"}, [6, "Foo"]),  # bind param name 'lower_2' might be incorrect
-                    ("select * from t1", {}, None),
-                    ("DROP TABLE t1", {}, None)
+                    ("select * from t1", {}, ()),
+                    ("DROP TABLE t1", {}, ())
                 ]
                 
             assert_stmts(compiled, stmts)

diff --git a/test/sql/query.py b/test/sql/query.py
index 86ad02aa4ac506717285d0ba11c7a4868d2cabee..9b3d4cec5eab6c2618b272a1f76e9abde3ac9d34 100644 (file)
--- a/test/sql/query.py
+++ b/test/sql/query.py
@@ -486,10 +486,10 @@ class QueryTest(TestBase):
         r = users.select().execute().fetchone()
         self.assertEqual(len(r), 2)
         r.close()
-        r = testing.db.execute('select user_name, user_id from query_users', {}).fetchone()
+        r = testing.db.execute('select user_name, user_id from query_users').fetchone()
         self.assertEqual(len(r), 2)
         r.close()
-        r = testing.db.execute('select user_name from query_users', {}).fetchone()
+        r = testing.db.execute('select user_name from query_users').fetchone()
         self.assertEqual(len(r), 1)
         r.close()
 
@@ -513,7 +513,7 @@ class QueryTest(TestBase):
     def test_column_order_with_text_query(self):
         # should return values in query order
         users.insert().execute(user_id=1, user_name='foo')
-        r = testing.db.execute('select user_name, user_id from query_users', {}).fetchone()
+        r = testing.db.execute('select user_name, user_id from query_users').fetchone()
         self.assertEqual(r[0], 'foo')
         self.assertEqual(r[1], 1)
         self.assertEqual([x.lower() for x in r.keys()], ['user_name', 'user_id'])