- took out method calls for oid_column

- reduced complexity of parameter handling during execution; __distill_params does all
parameter munging, executioncontext.parameters always holds a list of parameter structures
(lists, tuples, or dicts).

2 files changed, 63 insertions, 82 deletions

diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index 32bf7b780..cc2ea6d5d 100644
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -790,42 +790,43 @@ class Connection(Connectable):
         return context.result()
 
     def __distill_params(self, multiparams, params):
-        if multiparams is None or len(multiparams) == 0:
-            parameters = params or None
-        elif len(multiparams) == 1 and isinstance(multiparams[0], (list, tuple, dict)):
-            parameters = multiparams[0]
-        else:
-            parameters = list(multiparams)
-        return parameters
-
-    def __distill_params_and_keys(self, multiparams, params):
+        """given arguments from the calling form *multiparams, **params, return a list
+        of bind parameter structures, usually a list of dictionaries.  
+        
+        in the case of 'raw' execution which accepts positional parameters, 
+        it may be a list of tuples or lists."""
+        
         if multiparams is None or len(multiparams) == 0:
             if params:
-                parameters = params
-                keys = params.keys()
+                return [params]
             else:
-                parameters = None
-                keys = []
-            executemany = False
-        elif len(multiparams) == 1 and isinstance(multiparams[0], (list, tuple, dict)):
-            parameters = multiparams[0]
-            if isinstance(parameters, dict):
-                keys = parameters.keys()
+                return [{}]
+        elif len(multiparams) == 1:
+            if isinstance(multiparams[0], (list, tuple)):
+                if isinstance(multiparams[0][0], (list, tuple, dict)):
+                    return multiparams[0]
+                else:
+                    return [multiparams[0]]
+            elif isinstance(multiparams[0], dict):
+                return [multiparams[0]]
             else:
-                keys = parameters[0].keys()
-            executemany = False
+                return [[multiparams[0]]]
         else:
-            parameters = list(multiparams)
-            keys = parameters[0].keys()
-            executemany = True
-        return (parameters, keys, executemany)
+            if isinstance(multiparams[0], (list, tuple, dict)):
+                return multiparams
+            else:
+                return [multiparams]
 
     def _execute_function(self, func, multiparams, params):
         return self._execute_clauseelement(func.select(), multiparams, params)
 
     def _execute_clauseelement(self, elem, multiparams=None, params=None):
-        (params, keys, executemany) = self.__distill_params_and_keys(multiparams, params)
-        return self._execute_compiled(elem.compile(dialect=self.dialect, column_keys=keys, inline=executemany), distilled_params=params)
+        params = self.__distill_params(multiparams, params)
+        if params:
+            keys = params[0].keys()
+        else:
+            keys = None
+        return self._execute_compiled(elem.compile(dialect=self.dialect, column_keys=keys, inline=len(params) > 1), distilled_params=params)
 
     def _execute_compiled(self, compiled, multiparams=None, params=None, distilled_params=None):
         """Execute a sql.Compiled object."""
@@ -845,17 +846,10 @@ class Connection(Connectable):
         return self.__engine.dialect.create_execution_context(connection=self, **kwargs)
 
     def __execute_raw(self, context):
-        if context.parameters is not None and isinstance(context.parameters, list) and len(context.parameters) > 0 and isinstance(context.parameters[0], (list, tuple, dict)):
+        if context.executemany:
             self._cursor_executemany(context.cursor, context.statement, context.parameters, context=context)
         else:
-            if context.parameters is None:
-                if context.dialect.positional:
-                    parameters = ()
-                else:
-                    parameters = {}
-            else:
-                parameters = context.parameters
-            self._cursor_execute(context.cursor, context.statement, parameters, context=context)
+            self._cursor_execute(context.cursor, context.statement, context.parameters[0], context=context)
         self._autocommit(context)
 
     def _cursor_execute(self, cursor, statement, parameters, context=None):
@@ -1123,6 +1117,10 @@ 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):
+        connection = self.contextual_connect(close_with_result=True)
+        return connection._execute_clauseelement(elem, multiparams, params)
+
     def _execute_compiled(self, compiled, multiparams, params):
         connection = self.contextual_connect(close_with_result=True)
         return connection._execute_compiled(compiled, multiparams, params)
diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py
index 578b19d16..07f07d0be 100644
--- a/lib/sqlalchemy/engine/default.py
+++ b/lib/sqlalchemy/engine/default.py
@@ -141,28 +141,22 @@ class DefaultExecutionContext(base.ExecutionContext):
             self.statement = unicode(compiled)
             self.isinsert = compiled.isinsert
             self.isupdate = compiled.isupdate
-            if parameters is None:
-                self.compiled_parameters = compiled.construct_params()
-                self.executemany = False
-            elif not isinstance(parameters, (list, tuple)):
-                self.compiled_parameters = compiled.construct_params(parameters)
+            if not parameters:
+                self.compiled_parameters = [compiled.construct_params()]
                 self.executemany = False
             else:
                 self.compiled_parameters = [compiled.construct_params(m) for m in parameters]
-                if len(self.compiled_parameters) == 1:
-                    self.compiled_parameters = self.compiled_parameters[0]
-                    self.executemany = False
-                else:
-                    self.executemany = True
+                self.executemany = len(parameters) > 1
 
         elif statement is not None:
             self.typemap = self.column_labels = None
             self.parameters = self.__encode_param_keys(parameters)
+            self.executemany = len(parameters) > 1
             self.statement = statement
             self.isinsert = self.isupdate = False
         else:
             self.statement = None
-            self.isinsert = self.isupdate = False
+            self.isinsert = self.isupdate = self.executemany = False
             
         if self.statement is not None and not dialect.supports_unicode_statements:
             self.statement = self.statement.encode(self.dialect.encoding)
@@ -174,9 +168,17 @@ class DefaultExecutionContext(base.ExecutionContext):
     root_connection = property(lambda s:s._connection)
     
     def __encode_param_keys(self, params):
-        """apply string encoding to the keys of dictionary-based bind parameters"""
+        """apply string encoding to the keys of dictionary-based bind parameters.
+        
+        This is only used executing textual, non-compiled SQL expressions."""
+        
         if self.dialect.positional or self.dialect.supports_unicode_statements:
-            return params
+            if params:
+                return params
+            elif self.dialect.positional:
+                return [()]
+            else:
+                return [{}]
         else:
             def proc(d):
                 # sigh, sometimes we get positional arguments with a dialect
@@ -184,32 +186,15 @@ class DefaultExecutionContext(base.ExecutionContext):
                 if not isinstance(d, dict):
                     return d
                 return dict([(k.encode(self.dialect.encoding), d[k]) for k in d])
-            if isinstance(params, list):
-                return [proc(d) for d in params]
-            else:
-                return proc(params)
+            return [proc(d) for d in params] or [{}]
 
     def __convert_compiled_params(self, parameters):
-        encode = not self.dialect.supports_unicode_statements
-        # the bind params are a CompiledParams object.  but all the
-        # DB-API's hate that object (or similar).  so convert it to a
-        # clean dictionary/list/tuple of dictionary/tuple of list
-        if parameters is not None:
-            if self.executemany:
-                processors = parameters[0].get_processors()
-            else:
-                processors = parameters.get_processors()
-
-            if self.dialect.positional:
-                if self.executemany:
-                    parameters = [p.get_raw_list(processors) for p in parameters]
-                else:
-                    parameters = parameters.get_raw_list(processors)
-            else:
-                if self.executemany:
-                    parameters = [p.get_raw_dict(processors, encode_keys=encode) for p in parameters]
-                else:
-                    parameters = parameters.get_raw_dict(processors, encode_keys=encode)
+        processors = parameters[0].get_processors()
+        if self.dialect.positional:
+            parameters = [p.get_raw_list(processors) for p in parameters]
+        else:
+            encode = not self.dialect.supports_unicode_statements
+            parameters = [p.get_raw_dict(processors, encode_keys=encode) for p in parameters]
         return parameters
                 
     def is_select(self):
@@ -275,10 +260,7 @@ class DefaultExecutionContext(base.ExecutionContext):
         from the bind parameter's ``TypeEngine`` objects.
         """
 
-        if isinstance(self.compiled_parameters, list):
-            plist = self.compiled_parameters
-        else:
-            plist = [self.compiled_parameters]
+        plist = self.compiled_parameters
         if self.dialect.positional:
             inputsizes = []
             for params in plist[0:1]:
@@ -319,6 +301,7 @@ class DefaultExecutionContext(base.ExecutionContext):
                     self.compiled_parameters = params
                     
             else:
+                compiled_parameters = self.compiled_parameters[0]
                 drunner = self.dialect.defaultrunner(self)
                 if self.isinsert:
                     self._last_inserted_ids = []
@@ -328,18 +311,18 @@ class DefaultExecutionContext(base.ExecutionContext):
                     else:
                         val = drunner.get_column_onupdate(c)
                     if val is not None:
-                        self.compiled_parameters.set_value(c.key, val)
+                        compiled_parameters.set_value(c.key, val)
 
                 if self.isinsert:
-                    processors = self.compiled_parameters.get_processors()
+                    processors = compiled_parameters.get_processors()
                     for c in self.compiled.statement.table.primary_key:
-                        if c.key in self.compiled_parameters:
-                            self._last_inserted_ids.append(self.compiled_parameters.get_processed(c.key, processors))
+                        if c.key in compiled_parameters:
+                            self._last_inserted_ids.append(compiled_parameters.get_processed(c.key, processors))
                         else:
                             self._last_inserted_ids.append(None)
                             
                 self._postfetch_cols = self.compiled.postfetch
                 if self.isinsert:
-                    self._last_inserted_params = self.compiled_parameters
+                    self._last_inserted_params = compiled_parameters
                 else:
-                    self._last_updated_params = self.compiled_parameters
+                    self._last_updated_params = compiled_parameters