foo

2 files changed, 31 insertions, 20 deletions

diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py
index 62469d720..bdd9d2715 100644
--- a/lib/sqlalchemy/engine/default.py
+++ b/lib/sqlalchemy/engine/default.py
@@ -463,7 +463,7 @@ class DefaultExecutionContext(interfaces.ExecutionContext):
     executemany = False
     compiled = None
     statement = None
-    _result_columns = None
+    result_column_struct = None
     _is_implicit_returning = False
     _is_explicit_returning = False
 
@@ -522,10 +522,8 @@ class DefaultExecutionContext(interfaces.ExecutionContext):
         self.execution_options = compiled.statement._execution_options.union(
             connection._execution_options)
 
-        # compiled clauseelement.  process bind params, process table defaults,
-        # track collections used by ResultProxy to target and process results
-
-        self._result_columns = compiled._result_columns
+        self.result_column_struct = (
+            compiled._result_columns, compiled._ordered_columns)
 
         self.unicode_statement = util.text_type(compiled)
         if not dialect.supports_unicode_statements:
@@ -664,13 +662,6 @@ class DefaultExecutionContext(interfaces.ExecutionContext):
         return self
 
     @util.memoized_property
-    def result_map(self):
-        if self._result_columns:
-            return self.compiled.result_map
-        else:
-            return None
-
-    @util.memoized_property
     def engine(self):
         return self.root_connection.engine
 
diff --git a/lib/sqlalchemy/engine/result.py b/lib/sqlalchemy/engine/result.py
index 6eca54a34..893cd2a30 100644
--- a/lib/sqlalchemy/engine/result.py
+++ b/lib/sqlalchemy/engine/result.py
@@ -193,13 +193,14 @@ class ResultMetaData(object):
         translate_colname = context._translate_colname
         self.case_sensitive = case_sensitive = dialect.case_sensitive
 
-        if context._result_columns:
-            num_ctx_cols = len(context._result_columns)
+        if context.result_column_struct:
+            result_columns, cols_are_ordered = context.result_column_struct
+            num_ctx_cols = len(result_columns)
         else:
             num_ctx_cols = None
 
         if num_ctx_cols and \
-                context.compiled._ordered_columns and \
+                cols_are_ordered and \
                 num_ctx_cols == len(metadata):
             # case 1 - SQL expression statement, number of columns
             # in result matches number of cols in compiled.  This is the
@@ -217,10 +218,10 @@ class ResultMetaData(object):
                     obj,
                     None
                 ) for idx, (key, name, obj, type_)
-                in enumerate(context._result_columns)
+                in enumerate(result_columns)
             ]
             self.keys = [
-                elem[1] for elem in context._result_columns
+                elem[1] for elem in result_columns
             ]
         else:
             # case 2 - raw string, or number of columns in result does
@@ -234,6 +235,9 @@ class ResultMetaData(object):
             # In all these cases we fall back to the "named" approach
             # that SQLAlchemy has used up through 0.9.
 
+            if num_ctx_cols:
+                result_map = self._create_result_map(result_columns)
+
             raw = []
             self.keys = []
             untranslated = None
@@ -256,7 +260,7 @@ class ResultMetaData(object):
 
                 if num_ctx_cols:
                     try:
-                        ctx_rec = context.result_map[colname]
+                        ctx_rec = result_map[colname]
                     except KeyError:
                         mapped_type = typemap.get(coltype, sqltypes.NULLTYPE)
                         obj = None
@@ -296,8 +300,8 @@ class ResultMetaData(object):
             # ambiguous column exception when accessed.
             if len(by_key) != num_ctx_cols:
                 seen = set()
-                for idx in range(num_ctx_cols):
-                    key = raw[idx][1]
+                for rec in raw:
+                    key = rec[1]
                     if key in seen:
                         by_key[key] = (None, by_key[key][1], None)
                     seen.add(key)
@@ -324,6 +328,22 @@ class ResultMetaData(object):
                     for elem in raw if elem[5]
                 ])
 
+    @classmethod
+    def _create_result_map(cls, result_columns):
+        d = {}
+        for elem in result_columns:
+            key, rec = elem[0], elem[1:]
+            if key in d:
+                # conflicting keyname, just double up the list
+                # of objects.  this will cause an "ambiguous name"
+                # error if an attempt is made by the result set to
+                # access.
+                e_name, e_obj, e_type = d[key]
+                d[key] = e_name, e_obj + rec[1], e_type
+            else:
+                d[key] = rec
+        return d
+
     @util.pending_deprecation("0.8", "sqlite dialect uses "
                               "_translate_colname() now")
     def _set_keymap_synonym(self, name, origname):