Result initial introduction

This builds on cc718cccc0bf8a01abdf4068c7ea4f3 which moved
RowProxy to Row, allowing Row to be more like a named tuple.

- KeyedTuple in ORM is replaced with Row

- ResultSetMetaData broken out into "simple" and "cursor" versions
  for ORM and Core, as well as LegacyCursor version.

- Row now has _mapping attribute that supplies full mapping behavior.
Row and SimpleRow both have named tuple behavior otherwise.
LegacyRow has some mapping features on the tuple which emit
deprecation warnings (e.g. keys(), values(), etc).   the biggest
change for mapping->tuple is the behavior of __contains__ which
moves from testing of "key in row" to "value in row".

- ResultProxy breaks into ResultProxy and FutureResult (interim),
the latter has the newer APIs.   Made available to dialects
using execution options.

- internal reflection methods and most tests move off of implicit
Row mapping behavior and move to row._mapping, result.mappings()
method using future result

- a new strategy system for cursor handling replaces the various
subclasses of RowProxy

- some execution context adjustments. We will leave EC in but
refined things like get_result_proxy() and out parameter handling.
Dialects for 1.4 will need to adjust from get_result_proxy()
to get_result_cursor_strategy(), if they are using this method

- out parameter handling now accommodated by get_out_parameter_values()
EC method.   Oracle changes for this.  external dialect for
DB2 for example will also need to adjust for this.

- deprecate case_insensitive flag for engine / result, this
feature is not used

mapping-methods on Row are deprecated, and replaced with
Row._mapping.<meth>, including:

   row.keys()  -> use row._mapping.keys()
   row.items()  -> use row._mapping.items()
   row.values() -> use row._mapping.values()
   key in row  -> use key in row._mapping
   int in row  -> use int < len(row)

Fixes: #4710
Fixes: #4878
Change-Id: Ieb9085e9bcff564359095b754da9ae0af55679f0

24 files changed, 1190 insertions, 708 deletions

diff --git a/test/aaa_profiling/test_resultset.py b/test/aaa_profiling/test_resultset.py
index 51fcbde65..87908f016 100644
--- a/test/aaa_profiling/test_resultset.py
+++ b/test/aaa_profiling/test_resultset.py
@@ -8,6 +8,7 @@ from sqlalchemy import String
 from sqlalchemy import Table
 from sqlalchemy import testing
 from sqlalchemy import Unicode
+from sqlalchemy.engine.result import LegacyRow
 from sqlalchemy.engine.result import Row
 from sqlalchemy.testing import AssertsExecutionResults
 from sqlalchemy.testing import eq_
@@ -158,6 +159,9 @@ class RowTest(fixtures.TestBase):
             def __init__(self):
                 pass
 
+            def _warn_for_nonint(self, arg):
+                pass
+
         metadata = MockMeta()
 
         keymap = {}
@@ -167,7 +171,7 @@ class RowTest(fixtures.TestBase):
             keymap[index] = (index, key)
         return row_cls(metadata, processors, keymap, row)
 
-    def _test_getitem_value_refcounts(self, seq_factory):
+    def _test_getitem_value_refcounts_legacy(self, seq_factory):
         col1, col2 = object(), object()
 
         def proc1(value):
@@ -178,7 +182,7 @@ class RowTest(fixtures.TestBase):
             [(col1, "a"), (col2, "b")],
             [proc1, None],
             seq_factory([value1, value2]),
-            Row,
+            LegacyRow,
         )
 
         v1_refcount = sys.getrefcount(value1)
@@ -194,8 +198,36 @@ class RowTest(fixtures.TestBase):
         eq_(sys.getrefcount(value1), v1_refcount)
         eq_(sys.getrefcount(value2), v2_refcount)
 
+    def _test_getitem_value_refcounts_new(self, seq_factory):
+        col1, col2 = object(), object()
+
+        def proc1(value):
+            return value
+
+        value1, value2 = "x", "y"
+        row = self._rowproxy_fixture(
+            [(col1, "a"), (col2, "b")],
+            [proc1, None],
+            seq_factory([value1, value2]),
+            Row,
+        )
+
+        v1_refcount = sys.getrefcount(value1)
+        v2_refcount = sys.getrefcount(value2)
+        for i in range(10):
+            row._mapping[col1]
+            row._mapping["a"]
+            row._mapping[col2]
+            row._mapping["b"]
+            row[0]
+            row[1]
+            row[0:2]
+        eq_(sys.getrefcount(value1), v1_refcount)
+        eq_(sys.getrefcount(value2), v2_refcount)
+
     def test_value_refcounts_pure_tuple(self):
-        self._test_getitem_value_refcounts(tuple)
+        self._test_getitem_value_refcounts_legacy(tuple)
+        self._test_getitem_value_refcounts_new(tuple)
 
     def test_value_refcounts_custom_seq(self):
         class CustomSeq(object):
@@ -208,4 +240,5 @@ class RowTest(fixtures.TestBase):
             def __iter__(self):
                 return iter(self.data)
 
-        self._test_getitem_value_refcounts(CustomSeq)
+        self._test_getitem_value_refcounts_legacy(CustomSeq)
+        self._test_getitem_value_refcounts_new(CustomSeq)
diff --git a/test/aaa_profiling/test_zoomark.py b/test/aaa_profiling/test_zoomark.py
index abe994392..9f9cf7a94 100644
--- a/test/aaa_profiling/test_zoomark.py
+++ b/test/aaa_profiling/test_zoomark.py
@@ -440,9 +440,12 @@ class ZooMarkTest(replay_fixture.ReplayFixtureTest):
 
             # Edit
 
-            SDZ = engine.execute(
-                Zoo.select(Zoo.c.Name == "San Diego Zoo")
-            ).first()
+            SDZ = (
+                engine.execute(Zoo.select(Zoo.c.Name == "San Diego Zoo"))
+                .first()
+                ._mapping
+            )
+
             engine.execute(
                 Zoo.update(Zoo.c.ID == SDZ["ID"]),
                 Name="The San Diego Zoo",
@@ -453,9 +456,12 @@ class ZooMarkTest(replay_fixture.ReplayFixtureTest):
 
             # Test edits
 
-            SDZ = engine.execute(
-                Zoo.select(Zoo.c.Name == "The San Diego Zoo")
-            ).first()
+            SDZ = (
+                engine.execute(Zoo.select(Zoo.c.Name == "The San Diego Zoo"))
+                .first()
+                ._mapping
+            )
+
             assert SDZ["Founded"] == datetime.date(1900, 1, 1), SDZ["Founded"]
 
             # Change it back
@@ -470,9 +476,12 @@ class ZooMarkTest(replay_fixture.ReplayFixtureTest):
 
             # Test re-edits
 
-            SDZ = engine.execute(
-                Zoo.select(Zoo.c.Name == "San Diego Zoo")
-            ).first()
+            SDZ = (
+                engine.execute(Zoo.select(Zoo.c.Name == "San Diego Zoo"))
+                .first()
+                ._mapping
+            )
+
             assert SDZ["Founded"] == datetime.date(1935, 9, 13)
 
     def _baseline_7_multiview(self):
diff --git a/test/base/test_utils.py b/test/base/test_utils.py
index 1f7c0cf62..48e464a01 100644
--- a/test/base/test_utils.py
+++ b/test/base/test_utils.py
@@ -9,6 +9,7 @@ from sqlalchemy import exc
 from sqlalchemy import sql
 from sqlalchemy import testing
 from sqlalchemy import util
+from sqlalchemy.engine import result
 from sqlalchemy.sql import column
 from sqlalchemy.sql.base import DedupeColumnCollection
 from sqlalchemy.testing import assert_raises
@@ -41,30 +42,30 @@ class _KeyedTupleTest(object):
         eq_(str(keyed_tuple), "()")
         eq_(len(keyed_tuple), 0)
 
-        eq_(list(keyed_tuple.keys()), [])
+        eq_(list(keyed_tuple._mapping.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
-    def test_values_but_no_labels(self):
-        keyed_tuple = self._fixture([1, 2], [])
+    def test_values_none_labels(self):
+        keyed_tuple = self._fixture([1, 2], [None, None])
         eq_(str(keyed_tuple), "(1, 2)")
         eq_(len(keyed_tuple), 2)
 
-        eq_(list(keyed_tuple.keys()), [])
+        eq_(list(keyed_tuple._mapping.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
         eq_(keyed_tuple[0], 1)
         eq_(keyed_tuple[1], 2)
 
-    def test_basic_creation(self):
+    def test_creation(self):
         keyed_tuple = self._fixture([1, 2], ["a", "b"])
         eq_(str(keyed_tuple), "(1, 2)")
-        eq_(list(keyed_tuple.keys()), ["a", "b"])
+        eq_(list(keyed_tuple._mapping.keys()), ["a", "b"])
         eq_(keyed_tuple._fields, ("a", "b"))
         eq_(keyed_tuple._asdict(), {"a": 1, "b": 2})
 
-    def test_basic_index_access(self):
+    def test_index_access(self):
         keyed_tuple = self._fixture([1, 2], ["a", "b"])
         eq_(keyed_tuple[0], 1)
         eq_(keyed_tuple[1], 2)
@@ -74,7 +75,11 @@ class _KeyedTupleTest(object):
 
         assert_raises(IndexError, should_raise)
 
-    def test_basic_attribute_access(self):
+    def test_slice_access(self):
+        keyed_tuple = self._fixture([1, 2], ["a", "b"])
+        eq_(keyed_tuple[0:2], (1, 2))
+
+    def test_attribute_access(self):
         keyed_tuple = self._fixture([1, 2], ["a", "b"])
         eq_(keyed_tuple.a, 1)
         eq_(keyed_tuple.b, 2)
@@ -84,11 +89,26 @@ class _KeyedTupleTest(object):
 
         assert_raises(AttributeError, should_raise)
 
+    def test_contains(self):
+        keyed_tuple = self._fixture(["x", "y"], ["a", "b"])
+
+        is_true("x" in keyed_tuple)
+        is_false("z" in keyed_tuple)
+
+        is_true("z" not in keyed_tuple)
+        is_false("x" not in keyed_tuple)
+
+        # we don't do keys
+        is_false("a" in keyed_tuple)
+        is_false("z" in keyed_tuple)
+        is_true("a" not in keyed_tuple)
+        is_true("z" not in keyed_tuple)
+
     def test_none_label(self):
         keyed_tuple = self._fixture([1, 2, 3], ["a", None, "b"])
         eq_(str(keyed_tuple), "(1, 2, 3)")
 
-        eq_(list(keyed_tuple.keys()), ["a", "b"])
+        eq_(list(keyed_tuple._mapping.keys()), ["a", "b"])
         eq_(keyed_tuple._fields, ("a", "b"))
         eq_(keyed_tuple._asdict(), {"a": 1, "b": 3})
 
@@ -105,7 +125,7 @@ class _KeyedTupleTest(object):
         keyed_tuple = self._fixture([1, 2, 3], ["a", "b", "b"])
         eq_(str(keyed_tuple), "(1, 2, 3)")
 
-        eq_(list(keyed_tuple.keys()), ["a", "b", "b"])
+        eq_(list(keyed_tuple._mapping.keys()), ["a", "b", "b"])
         eq_(keyed_tuple._fields, ("a", "b", "b"))
         eq_(keyed_tuple._asdict(), {"a": 1, "b": 3})
 
@@ -124,7 +144,8 @@ class _KeyedTupleTest(object):
 
         eq_(keyed_tuple.a, 1)
 
-        assert_raises(AttributeError, setattr, keyed_tuple, "a", 5)
+        # eh
+        # assert_raises(AttributeError, setattr, keyed_tuple, "a", 5)
 
         def should_raise():
             keyed_tuple[0] = 100
@@ -140,19 +161,14 @@ class _KeyedTupleTest(object):
 
             eq_(str(kt), "(1, 2, 3)")
 
-            eq_(list(kt.keys()), ["a", "b"])
+            eq_(list(kt._mapping.keys()), ["a", "b"])
             eq_(kt._fields, ("a", "b"))
             eq_(kt._asdict(), {"a": 1, "b": 3})
 
 
-class KeyedTupleTest(_KeyedTupleTest, fixtures.TestBase):
-    def _fixture(self, values, labels):
-        return util.KeyedTuple(values, labels)
-
-
 class LWKeyedTupleTest(_KeyedTupleTest, fixtures.TestBase):
     def _fixture(self, values, labels):
-        return util.lightweight_named_tuple("n", labels)(values)
+        return result.result_tuple(labels)(values)
 
 
 class WeakSequenceTest(fixtures.TestBase):
diff --git a/test/dialect/postgresql/test_types.py b/test/dialect/postgresql/test_types.py
index be05dec7b..26e7bb8d6 100644
--- a/test/dialect/postgresql/test_types.py
+++ b/test/dialect/postgresql/test_types.py
@@ -1357,8 +1357,8 @@ class ArrayRoundTripTest(object):
         )
         results = arrtable.select().execute().fetchall()
         eq_(len(results), 1)
-        eq_(results[0]["intarr"], [1, 2, 3])
-        eq_(results[0]["strarr"], [util.u("abc"), util.u("def")])
+        eq_(results[0].intarr, [1, 2, 3])
+        eq_(results[0].strarr, [util.u("abc"), util.u("def")])
 
     def test_insert_array_w_null(self):
         arrtable = self.tables.arrtable
@@ -1367,8 +1367,8 @@ class ArrayRoundTripTest(object):
         )
         results = arrtable.select().execute().fetchall()
         eq_(len(results), 1)
-        eq_(results[0]["intarr"], [1, None, 3])
-        eq_(results[0]["strarr"], [util.u("abc"), None])
+        eq_(results[0].intarr, [1, None, 3])
+        eq_(results[0].strarr, [util.u("abc"), None])
 
     def test_array_where(self):
         arrtable = self.tables.arrtable
@@ -1383,7 +1383,7 @@ class ArrayRoundTripTest(object):
             .fetchall()
         )
         eq_(len(results), 1)
-        eq_(results[0]["intarr"], [1, 2, 3])
+        eq_(results[0].intarr, [1, 2, 3])
 
     def test_array_concat(self):
         arrtable = self.tables.arrtable
@@ -1422,9 +1422,9 @@ class ArrayRoundTripTest(object):
             arrtable.select(order_by=[arrtable.c.intarr]).execute().fetchall()
         )
         eq_(len(results), 2)
-        eq_(results[0]["strarr"], [util.ue("m\xe4\xe4"), util.ue("m\xf6\xf6")])
+        eq_(results[0].strarr, [util.ue("m\xe4\xe4"), util.ue("m\xf6\xf6")])
         eq_(
-            results[1]["strarr"],
+            results[1].strarr,
             [[util.ue("m\xe4\xe4")], [util.ue("m\xf6\xf6")]],
         )
 
diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py
index 7675b8aa6..01ef5f084 100644
--- a/test/dialect/test_sqlite.py
+++ b/test/dialect/test_sqlite.py
@@ -924,16 +924,16 @@ class AttachedDBTest(fixtures.TestBase):
 
         self.conn.execute(ct.insert(), {"id": 1, "name": "foo"})
         row = self.conn.execute(ct.select()).first()
-        eq_(row["id"], 1)
-        eq_(row["name"], "foo")
+        eq_(row._mapping["id"], 1)
+        eq_(row._mapping["name"], "foo")
 
     def test_col_targeting_union(self):
         ct = self._fixture()
 
         self.conn.execute(ct.insert(), {"id": 1, "name": "foo"})
         row = self.conn.execute(ct.select().union(ct.select())).first()
-        eq_(row["id"], 1)
-        eq_(row["name"], "foo")
+        eq_(row._mapping["id"], 1)
+        eq_(row._mapping["name"], "foo")
 
 
 class SQLTest(fixtures.TestBase, AssertsCompiledSQL):
diff --git a/test/orm/test_assorted_eager.py b/test/orm/test_assorted_eager.py
index 21534d6bc..5c62165f9 100644
--- a/test/orm/test_assorted_eager.py
+++ b/test/orm/test_assorted_eager.py
@@ -539,10 +539,10 @@ class EagerTest3(fixtures.MappedTest):
         arb_result = arb_data.execute().fetchall()
 
         # order the result list descending based on 'max'
-        arb_result.sort(key=lambda a: a["max"], reverse=True)
+        arb_result.sort(key=lambda a: a._mapping["max"], reverse=True)
 
         # extract just the "data_id" from it
-        arb_result = [row["data_id"] for row in arb_result]
+        arb_result = [row._mapping["data_id"] for row in arb_result]
 
         arb_data = arb_data.alias("arb")
 
diff --git a/test/orm/test_deprecations.py b/test/orm/test_deprecations.py
index cb41b384c..bf0452234 100644
--- a/test/orm/test_deprecations.py
+++ b/test/orm/test_deprecations.py
@@ -445,6 +445,30 @@ class DeprecatedQueryTest(_fixtures.FixtureTest, AssertsCompiledSQL):
                 [User(id=7), User(id=8), User(id=9), User(id=10)],
             )
 
+    def test_text_as_column(self):
+        User = self.classes.User
+
+        s = create_session()
+
+        # TODO: this works as of "use rowproxy for ORM keyed tuple"
+        # Ieb9085e9bcff564359095b754da9ae0af55679f0
+        # but im not sure how this relates to things here
+        q = s.query(User.id, text("users.name"))
+        self.assert_compile(
+            q, "SELECT users.id AS users_id, users.name FROM users"
+        )
+        eq_(q.all(), [(7, "jack"), (8, "ed"), (9, "fred"), (10, "chuck")])
+
+        # same here, this was "passing string names to Query.columns"
+        # deprecation message, that's gone here?
+        assert_raises_message(
+            exc.ArgumentError,
+            "Textual column expression 'name' should be explicitly",
+            s.query,
+            User.id,
+            "name",
+        )
+
     def test_query_as_scalar(self):
         User = self.classes.User
 
diff --git a/test/orm/test_loading.py b/test/orm/test_loading.py
index 5e993a27f..1c1a2c4df 100644
--- a/test/orm/test_loading.py
+++ b/test/orm/test_loading.py
@@ -1,6 +1,7 @@
 from sqlalchemy import exc
 from sqlalchemy import select
 from sqlalchemy import testing
+from sqlalchemy.engine import result_tuple
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm import loading
 from sqlalchemy.orm import mapper
@@ -10,7 +11,6 @@ from sqlalchemy.testing import mock
 from sqlalchemy.testing.assertions import assert_raises
 from sqlalchemy.testing.assertions import assert_raises_message
 from sqlalchemy.testing.assertions import eq_
-from sqlalchemy.util import KeyedTuple
 from . import _fixtures
 
 # class GetFromIdentityTest(_fixtures.FixtureTest):
@@ -146,7 +146,7 @@ class MergeResultTest(_fixtures.FixtureTest):
         it = loading.merge_result(q, collection)
         it = list(it)
         eq_([(x.id, y) for x, y in it], [(1, 1), (2, 2), (7, 7), (8, 8)])
-        eq_(list(it[0].keys()), ["User", "id"])
+        eq_(list(it[0]._mapping.keys()), ["User", "id"])
 
     def test_entity_col_mix_keyed_tuple(self):
         s, (u1, u2, u3, u4) = self._fixture()
@@ -154,14 +154,16 @@ class MergeResultTest(_fixtures.FixtureTest):
 
         q = s.query(User, User.id)
 
+        row = result_tuple(["User", "id"])
+
         def kt(*x):
-            return KeyedTuple(x, ["User", "id"])
+            return row(x)
 
         collection = [kt(u1, 1), kt(u2, 2), kt(u3, 7), kt(u4, 8)]
         it = loading.merge_result(q, collection)
         it = list(it)
         eq_([(x.id, y) for x, y in it], [(1, 1), (2, 2), (7, 7), (8, 8)])
-        eq_(list(it[0].keys()), ["User", "id"])
+        eq_(list(it[0]._mapping.keys()), ["User", "id"])
 
     def test_none_entity(self):
         s, (u1, u2, u3, u4) = self._fixture()
@@ -170,8 +172,10 @@ class MergeResultTest(_fixtures.FixtureTest):
         ua = aliased(User)
         q = s.query(User, ua)
 
+        row = result_tuple(["User", "useralias"])
+
         def kt(*x):
-            return KeyedTuple(x, ["User", "useralias"])
+            return row(x)
 
         collection = [kt(u1, u2), kt(u1, None), kt(u2, u3)]
         it = loading.merge_result(q, collection)
diff --git a/test/orm/test_pickled.py b/test/orm/test_pickled.py
index 4da583a0c..5c4d1e22d 100644
--- a/test/orm/test_pickled.py
+++ b/test/orm/test_pickled.py
@@ -756,14 +756,14 @@ class TupleLabelTest(_fixtures.FixtureTest):
                 if pickled is not False:
                     row = pickle.loads(pickle.dumps(row, pickled))
 
-                eq_(list(row.keys()), ["User", "Address"])
+                eq_(list(row._fields), ["User", "Address"])
                 eq_(row.User, row[0])
                 eq_(row.Address, row[1])
 
             for row in sess.query(User.name, User.id.label("foobar")):
                 if pickled is not False:
                     row = pickle.loads(pickle.dumps(row, pickled))
-                eq_(list(row.keys()), ["name", "foobar"])
+                eq_(list(row._fields), ["name", "foobar"])
                 eq_(row.name, row[0])
                 eq_(row.foobar, row[1])
 
@@ -772,7 +772,7 @@ class TupleLabelTest(_fixtures.FixtureTest):
             ):
                 if pickled is not False:
                     row = pickle.loads(pickle.dumps(row, pickled))
-                eq_(list(row.keys()), ["name", "foobar"])
+                eq_(list(row._fields), ["name", "foobar"])
                 eq_(row.name, row[0])
                 eq_(row.foobar, row[1])
 
@@ -784,7 +784,7 @@ class TupleLabelTest(_fixtures.FixtureTest):
             ):
                 if pickled is not False:
                     row = pickle.loads(pickle.dumps(row, pickled))
-                eq_(list(row.keys()), ["User"])
+                eq_(list(row._fields), ["User"])
                 eq_(row.User, row[0])
 
             oalias = aliased(Order, name="orders")
@@ -793,12 +793,12 @@ class TupleLabelTest(_fixtures.FixtureTest):
             ):
                 if pickled is not False:
                     row = pickle.loads(pickle.dumps(row, pickled))
-                eq_(list(row.keys()), ["User", "orders"])
+                eq_(list(row._fields), ["User", "orders"])
                 eq_(row.User, row[0])
                 eq_(row.orders, row[1])
 
             for row in sess.query(User.name + "hoho", User.name):
-                eq_(list(row.keys()), ["name"])
+                eq_(list(row._fields), ["name"])
                 eq_(row[0], row.name + "hoho")
 
             if pickled is not False:
diff --git a/test/orm/test_query.py b/test/orm/test_query.py
index 882255cc8..aabee82ad 100644
--- a/test/orm/test_query.py
+++ b/test/orm/test_query.py
@@ -111,6 +111,7 @@ class OnlyReturnTuplesTest(QueryTest):
         is_false(query.is_single_entity)
         row = query.first()
         assert isinstance(row, collections_abc.Sequence)
+        assert isinstance(row._mapping, collections_abc.Mapping)
 
     def test_multiple_entity_false(self):
         User = self.classes.User
@@ -118,6 +119,7 @@ class OnlyReturnTuplesTest(QueryTest):
         is_false(query.is_single_entity)
         row = query.first()
         assert isinstance(row, collections_abc.Sequence)
+        assert isinstance(row._mapping, collections_abc.Mapping)
 
     def test_multiple_entity_true(self):
         User = self.classes.User
@@ -125,6 +127,7 @@ class OnlyReturnTuplesTest(QueryTest):
         is_false(query.is_single_entity)
         row = query.first()
         assert isinstance(row, collections_abc.Sequence)
+        assert isinstance(row._mapping, collections_abc.Mapping)
 
 
 class RowTupleTest(QueryTest):
@@ -141,8 +144,48 @@ class RowTupleTest(QueryTest):
             .filter(User.id == 7)
             .first()
         )
-        assert row.id == 7
-        assert row.uname == "jack"
+
+        eq_(row.id, 7)
+        eq_(row.uname, "jack")
+
+    def test_entity_mapping_access(self):
+        User, users = self.classes.User, self.tables.users
+        Address, addresses = self.classes.Address, self.tables.addresses
+
+        mapper(User, users, properties={"addresses": relationship(Address)})
+        mapper(Address, addresses)
+
+        s = Session()
+
+        row = s.query(User).only_return_tuples(True).first()
+        eq_(row._mapping[User], row[0])
+
+        row = s.query(User, Address).join(User.addresses).first()
+        eq_(row._mapping[User], row[0])
+        eq_(row._mapping[Address], row[1])
+        eq_(row._mapping["User"], row[0])
+        eq_(row._mapping["Address"], row[1])
+
+        u1 = aliased(User)
+        row = s.query(u1).only_return_tuples(True).first()
+        eq_(row._mapping[u1], row[0])
+        assert_raises(KeyError, lambda: row._mapping[User])
+
+        row = (
+            s.query(User.id, Address.email_address)
+            .join(User.addresses)
+            .first()
+        )
+
+        eq_(row._mapping[User.id], row[0])
+        eq_(row._mapping[User.id], row[0])
+        eq_(row._mapping["id"], row[0])
+        eq_(row._mapping[Address.email_address], row[1])
+        eq_(row._mapping["email_address"], row[1])
+        eq_(row._mapping[users.c.id], row[0])
+        eq_(row._mapping[addresses.c.email_address], row[1])
+        assert_raises(KeyError, lambda: row._mapping[User.name])
+        assert_raises(KeyError, lambda: row._mapping[users.c.name])
 
     def test_deep_entity(self):
         users, User = (self.tables.users, self.classes.User)
@@ -3908,7 +3951,7 @@ class DistinctTest(QueryTest, AssertsCompiledSQL):
             ],
         )
         for row in q:
-            eq_(row.keys(), ["id", "foo", "id"])
+            eq_(row._mapping.keys(), ["id", "foo", "id"])
 
     def test_columns_augmented_sql_one(self):
         User, Address = self.classes.User, self.classes.Address
diff --git a/test/orm/test_unitofwork.py b/test/orm/test_unitofwork.py
index f5cc4836f..58eb62339 100644
--- a/test/orm/test_unitofwork.py
+++ b/test/orm/test_unitofwork.py
@@ -1504,7 +1504,7 @@ class OneToManyTest(_fixtures.FixtureTest):
         session.flush()
 
         user_rows = users.select(users.c.id.in_([u.id])).execute().fetchall()
-        eq_(list(user_rows[0].values()), [u.id, "one2manytester"])
+        eq_(list(user_rows[0]), [u.id, "one2manytester"])
 
         address_rows = (
             addresses.select(
@@ -1514,8 +1514,8 @@ class OneToManyTest(_fixtures.FixtureTest):
             .execute()
             .fetchall()
         )
-        eq_(list(address_rows[0].values()), [a2.id, u.id, "lala@test.org"])
-        eq_(list(address_rows[1].values()), [a.id, u.id, "one2many@test.org"])
+        eq_(list(address_rows[0]), [a2.id, u.id, "lala@test.org"])
+        eq_(list(address_rows[1]), [a.id, u.id, "one2many@test.org"])
 
         userid = u.id
         addressid = a2.id
@@ -1527,10 +1527,7 @@ class OneToManyTest(_fixtures.FixtureTest):
         address_rows = (
             addresses.select(addresses.c.id == addressid).execute().fetchall()
         )
-        eq_(
-            list(address_rows[0].values()),
-            [addressid, userid, "somethingnew@foo.com"],
-        )
+        eq_(list(address_rows[0]), [addressid, userid, "somethingnew@foo.com"])
         self.assert_(u.id == userid and a2.id == addressid)
 
     def test_one_to_many_2(self):
@@ -2065,11 +2062,11 @@ class SaveTest(_fixtures.FixtureTest):
         user_rows = (
             users.select(users.c.id.in_([u.foo_id])).execute().fetchall()
         )
-        eq_(list(user_rows[0].values()), [u.foo_id, "multitester"])
+        eq_(list(user_rows[0]), [u.foo_id, "multitester"])
         address_rows = (
             addresses.select(addresses.c.id.in_([u.id])).execute().fetchall()
         )
-        eq_(list(address_rows[0].values()), [u.id, u.foo_id, "multi@test.org"])
+        eq_(list(address_rows[0]), [u.id, u.foo_id, "multi@test.org"])
 
         u.email = "lala@hey.com"
         u.name = "imnew"
@@ -2078,11 +2075,11 @@ class SaveTest(_fixtures.FixtureTest):
         user_rows = (
             users.select(users.c.id.in_([u.foo_id])).execute().fetchall()
         )
-        eq_(list(user_rows[0].values()), [u.foo_id, "imnew"])
+        eq_(list(user_rows[0]), [u.foo_id, "imnew"])
         address_rows = (
             addresses.select(addresses.c.id.in_([u.id])).execute().fetchall()
         )
-        eq_(list(address_rows[0].values()), [u.id, u.foo_id, "lala@hey.com"])
+        eq_(list(address_rows[0]), [u.id, u.foo_id, "lala@hey.com"])
 
         session.expunge_all()
         u = session.query(User).get(id_)
@@ -2252,7 +2249,7 @@ class ManyToOneTest(_fixtures.FixtureTest):
             sa.and_(users.c.id == addresses.c.user_id, addresses.c.id == a.id),
         ).execute()
         eq_(
-            list(result.first().values()),
+            list(result.first()),
             [a.user.id, "asdf8d", a.id, a.user_id, "theater@foo.com"],
         )
 
diff --git a/test/profiles.txt b/test/profiles.txt
index 501ea699e..4244e1266 100644
--- a/test/profiles.txt
+++ b/test/profiles.txt
@@ -13,128 +13,138 @@
 
 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_insert
 
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mssql_pyodbc_dbapiunicode_cextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mssql_pyodbc_dbapiunicode_nocextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_pymysql_dbapiunicode_cextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_pymysql_dbapiunicode_nocextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_oracle_cx_oracle_dbapiunicode_cextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_cextensions 65
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_cextensions 65
-test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 65
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mssql_pyodbc_dbapiunicode_cextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mssql_pyodbc_dbapiunicode_nocextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_mysqldb_dbapiunicode_cextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_mysqldb_dbapiunicode_nocextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_pymysql_dbapiunicode_cextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_pymysql_dbapiunicode_nocextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_oracle_cx_oracle_dbapiunicode_cextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_postgresql_psycopg2_dbapiunicode_cextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 71
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_cextensions 70
-test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 70
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mssql_pyodbc_dbapiunicode_cextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mssql_pyodbc_dbapiunicode_nocextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_mysqldb_dbapiunicode_cextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_mysqldb_dbapiunicode_nocextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_pymysql_dbapiunicode_cextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_pymysql_dbapiunicode_nocextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_oracle_cx_oracle_dbapiunicode_cextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_cextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_cextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 67
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mssql_pyodbc_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mssql_pyodbc_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_mysqldb_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_mysqldb_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_pymysql_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_pymysql_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_oracle_cx_oracle_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_postgresql_psycopg2_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 72
 
 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_select
 
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mssql_pyodbc_dbapiunicode_cextensions 161,161
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mssql_pyodbc_dbapiunicode_nocextensions 161
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_pymysql_dbapiunicode_cextensions 163,163
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_pymysql_dbapiunicode_nocextensions 161
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_oracle_cx_oracle_dbapiunicode_cextensions 163,161
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 161
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_cextensions 163
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 161
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_cextensions 163
-test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 163
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mssql_pyodbc_dbapiunicode_cextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mssql_pyodbc_dbapiunicode_nocextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_mysqldb_dbapiunicode_cextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_mysqldb_dbapiunicode_nocextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_pymysql_dbapiunicode_cextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_pymysql_dbapiunicode_nocextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_oracle_cx_oracle_dbapiunicode_cextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_postgresql_psycopg2_dbapiunicode_cextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 174
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_cextensions 176
-test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 176
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mssql_pyodbc_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mssql_pyodbc_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_mysqldb_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_mysqldb_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_pymysql_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_pymysql_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_oracle_cx_oracle_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mssql_pyodbc_dbapiunicode_cextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mssql_pyodbc_dbapiunicode_nocextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_mysqldb_dbapiunicode_cextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_mysqldb_dbapiunicode_nocextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_pymysql_dbapiunicode_cextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_pymysql_dbapiunicode_nocextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_oracle_cx_oracle_dbapiunicode_cextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_postgresql_psycopg2_dbapiunicode_cextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_cextensions 177
+test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 177
 
 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_select_labels
 
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mssql_pyodbc_dbapiunicode_cextensions 194,194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mssql_pyodbc_dbapiunicode_nocextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mysql_pymysql_dbapiunicode_cextensions 196,196
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mysql_pymysql_dbapiunicode_nocextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_oracle_cx_oracle_dbapiunicode_cextensions 196,194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_postgresql_psycopg2_dbapiunicode_cextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_sqlite_pysqlite_dbapiunicode_cextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 194
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mssql_pyodbc_dbapiunicode_cextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mssql_pyodbc_dbapiunicode_nocextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_mysqldb_dbapiunicode_cextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_mysqldb_dbapiunicode_nocextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_pymysql_dbapiunicode_cextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_pymysql_dbapiunicode_nocextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_oracle_cx_oracle_dbapiunicode_cextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_postgresql_psycopg2_dbapiunicode_cextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_sqlite_pysqlite_dbapiunicode_cextensions 207
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 207
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mssql_pyodbc_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mssql_pyodbc_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mysql_mysqldb_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mysql_mysqldb_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mysql_pymysql_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_mysql_pymysql_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_oracle_cx_oracle_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_postgresql_psycopg2_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_sqlite_pysqlite_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mssql_pyodbc_dbapiunicode_cextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mssql_pyodbc_dbapiunicode_nocextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_mysqldb_dbapiunicode_cextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_mysqldb_dbapiunicode_nocextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_pymysql_dbapiunicode_cextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_mysql_pymysql_dbapiunicode_nocextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_oracle_cx_oracle_dbapiunicode_cextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_postgresql_psycopg2_dbapiunicode_cextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_sqlite_pysqlite_dbapiunicode_cextensions 208
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 208
 
 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_update
 
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mssql_pyodbc_dbapiunicode_cextensions 82,80
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mssql_pyodbc_dbapiunicode_nocextensions 78
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_pymysql_dbapiunicode_cextensions 80,80
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_pymysql_dbapiunicode_nocextensions 76
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_oracle_cx_oracle_dbapiunicode_cextensions 82,80
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 78
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_cextensions 77
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 78
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_cextensions 77
-test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 77
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mssql_pyodbc_dbapiunicode_cextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mssql_pyodbc_dbapiunicode_nocextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_mysqldb_dbapiunicode_cextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_mysqldb_dbapiunicode_nocextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_pymysql_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_pymysql_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_oracle_cx_oracle_dbapiunicode_cextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_postgresql_psycopg2_dbapiunicode_cextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 81
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_cextensions 80
-test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 80
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mssql_pyodbc_dbapiunicode_cextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mssql_pyodbc_dbapiunicode_nocextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_mysqldb_dbapiunicode_cextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_mysqldb_dbapiunicode_nocextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_pymysql_dbapiunicode_cextensions 77
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_pymysql_dbapiunicode_nocextensions 77
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_oracle_cx_oracle_dbapiunicode_cextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_cextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_cextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 79
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mssql_pyodbc_dbapiunicode_cextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mssql_pyodbc_dbapiunicode_nocextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_mysqldb_dbapiunicode_cextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_mysqldb_dbapiunicode_nocextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_pymysql_dbapiunicode_cextensions 80
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_pymysql_dbapiunicode_nocextensions 80
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_oracle_cx_oracle_dbapiunicode_cextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_postgresql_psycopg2_dbapiunicode_cextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_cextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 82
 
 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause
 
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mssql_pyodbc_dbapiunicode_cextensions 156,156
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mssql_pyodbc_dbapiunicode_nocextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mysql_pymysql_dbapiunicode_cextensions 158,158
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mysql_pymysql_dbapiunicode_nocextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_oracle_cx_oracle_dbapiunicode_cextensions 158,156
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_postgresql_psycopg2_dbapiunicode_cextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_sqlite_pysqlite_dbapiunicode_cextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 157
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mssql_pyodbc_dbapiunicode_cextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mssql_pyodbc_dbapiunicode_nocextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_mysqldb_dbapiunicode_cextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_mysqldb_dbapiunicode_nocextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_pymysql_dbapiunicode_cextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_pymysql_dbapiunicode_nocextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_oracle_cx_oracle_dbapiunicode_cextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_postgresql_psycopg2_dbapiunicode_cextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_sqlite_pysqlite_dbapiunicode_cextensions 162
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 162
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mssql_pyodbc_dbapiunicode_cextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mssql_pyodbc_dbapiunicode_nocextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mysql_mysqldb_dbapiunicode_cextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mysql_mysqldb_dbapiunicode_nocextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mysql_pymysql_dbapiunicode_cextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_mysql_pymysql_dbapiunicode_nocextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_oracle_cx_oracle_dbapiunicode_cextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_postgresql_psycopg2_dbapiunicode_cextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_sqlite_pysqlite_dbapiunicode_cextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 159
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mssql_pyodbc_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mssql_pyodbc_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_mysqldb_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_mysqldb_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_pymysql_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_mysql_pymysql_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_oracle_cx_oracle_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_postgresql_psycopg2_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_sqlite_pysqlite_dbapiunicode_cextensions 164
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 164
 
 # TEST: test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one
 
@@ -152,73 +162,73 @@ test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 49105
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 54205
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 51005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 56405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 49005
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 64705
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 50605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 64405
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 48605
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 53705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 50505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 55905
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 48505
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 64205
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 50105
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 63905
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46905
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 52005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48205
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 47405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 59805
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48505
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 59105
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46405
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 51505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53105
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46805
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 59205
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47905
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 58505
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_cextensions 39505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 44105
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_cextensions 41705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 46605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_cextensions 40205
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 46305
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_cextensions 42405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 48805
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46905
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 52005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48205
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 47405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 59805
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48505
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 59105
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46405
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 51505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53105
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46805
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 59205
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47905
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 58505
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 28505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28605
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30805
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26905
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30705
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28805
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 32705
 
 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations
 
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 28005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28105
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30305
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26305
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30105
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28205
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 32105
 
 # TEST: test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set
 
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_cextensions 3807
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 3807
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_cextensions 3928
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 3928
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_cextensions 3812
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 3812
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_cextensions 3933
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 3933
 
 # TEST: test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove
 
@@ -257,17 +267,17 @@ test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching
 
 # TEST: test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline
 
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_cextensions 17102
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30108
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_cextensions 17129
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30138
+test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_cextensions 17182
+test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 38188
+test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_cextensions 17209
+test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 38218
 
 # TEST: test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols
 
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 23249
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30255
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 23289
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30298
+test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 23250
+test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 32256
+test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 23290
+test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 32299
 
 # TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased
 
@@ -299,17 +309,17 @@ test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 3.7_sqlite_pys
 
 # TEST: test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query
 
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_cextensions 466578
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 466573
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_cextensions 497244
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 497244
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_cextensions 458478
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 458483
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_cextensions 489144
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 489144
 
 # TEST: test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results
 
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 457181
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 475681
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 461991
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 480791
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 458245
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 488845
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 463655
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 493955
 
 # TEST: test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity
 
@@ -320,24 +330,24 @@ test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_
 
 # TEST: test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity
 
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_cextensions 88227
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 91279
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_cextensions 90052
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 93306
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_cextensions 90023
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 93725
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_cextensions 91798
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 95802
 
 # TEST: test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks
 
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_cextensions 18356
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 18706
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_cextensions 18981
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 19417
+test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_cextensions 18540
+test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 19006
+test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_cextensions 19167
+test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 19719
 
 # TEST: test.aaa_profiling.test_orm.MergeTest.test_merge_load
 
-test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1009
-test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1036
-test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1044
-test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1075
+test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1027
+test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1061
+test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1062
+test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1100
 
 # TEST: test.aaa_profiling.test_orm.MergeTest.test_merge_no_load
 
@@ -348,24 +358,24 @@ test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_sqlite_pysqlite_dba
 
 # TEST: test.aaa_profiling.test_orm.QueryTest.test_query_cols
 
-test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 5764
-test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6414
-test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 5962
-test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6632
+test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 5816
+test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 7096
+test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 5994
+test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 7284
 
 # TEST: test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results
 
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 166153
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 172857
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 171502
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 178710
+test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 173671
+test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 195075
+test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 177890
+test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 197698
 
 # TEST: test.aaa_profiling.test_orm.SessionTest.test_expire_lots
 
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1153
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1130
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1271
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1264
+test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1158
+test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1124
+test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1265
+test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1243
 
 # TEST: test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect
 
@@ -383,58 +393,64 @@ test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_sqlite_pysqli
 
 # TEST: test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute
 
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mssql_pyodbc_dbapiunicode_cextensions 47
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mssql_pyodbc_dbapiunicode_nocextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_pymysql_dbapiunicode_cextensions 47
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_pymysql_dbapiunicode_nocextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_oracle_cx_oracle_dbapiunicode_cextensions 47
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 48
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 48
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mssql_pyodbc_dbapiunicode_cextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mssql_pyodbc_dbapiunicode_nocextensions 56
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_mysqldb_dbapiunicode_cextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_mysqldb_dbapiunicode_nocextensions 56
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_pymysql_dbapiunicode_cextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_pymysql_dbapiunicode_nocextensions 56
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_oracle_cx_oracle_dbapiunicode_cextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 56
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_postgresql_psycopg2_dbapiunicode_cextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 56
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_sqlite_pysqlite_dbapiunicode_cextensions 52
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 56
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mssql_pyodbc_dbapiunicode_cextensions 53
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mssql_pyodbc_dbapiunicode_nocextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_mysqldb_dbapiunicode_cextensions 53
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_mysqldb_dbapiunicode_nocextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_pymysql_dbapiunicode_cextensions 53
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_pymysql_dbapiunicode_nocextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_oracle_cx_oracle_dbapiunicode_cextensions 53
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 53
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 53
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mssql_pyodbc_dbapiunicode_cextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mssql_pyodbc_dbapiunicode_nocextensions 61
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_mysqldb_dbapiunicode_cextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_mysqldb_dbapiunicode_nocextensions 61
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_pymysql_dbapiunicode_cextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mysql_pymysql_dbapiunicode_nocextensions 61
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_oracle_cx_oracle_dbapiunicode_cextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 61
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_postgresql_psycopg2_dbapiunicode_cextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 61
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_sqlite_pysqlite_dbapiunicode_cextensions 57
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 61
 
 # TEST: test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute
 
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mssql_pyodbc_dbapiunicode_cextensions 86
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mssql_pyodbc_dbapiunicode_nocextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_pymysql_dbapiunicode_cextensions 86
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_pymysql_dbapiunicode_nocextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_oracle_cx_oracle_dbapiunicode_cextensions 86
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 86
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 86
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 90
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mssql_pyodbc_dbapiunicode_cextensions 90
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mssql_pyodbc_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_mysqldb_dbapiunicode_cextensions 90
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_mysqldb_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_pymysql_dbapiunicode_cextensions 90
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_pymysql_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_oracle_cx_oracle_dbapiunicode_cextensions 90
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_postgresql_psycopg2_dbapiunicode_cextensions 90
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_cextensions 88
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 92
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mssql_pyodbc_dbapiunicode_cextensions 91
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mssql_pyodbc_dbapiunicode_nocextensions 95
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_mysqldb_dbapiunicode_cextensions 91
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_mysqldb_dbapiunicode_nocextensions 95
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_pymysql_dbapiunicode_cextensions 91
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_pymysql_dbapiunicode_nocextensions 95
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_oracle_cx_oracle_dbapiunicode_cextensions 91
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 95
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 91
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 95
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 91
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 95
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mssql_pyodbc_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mssql_pyodbc_dbapiunicode_nocextensions 97
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_mysqldb_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_mysqldb_dbapiunicode_nocextensions 97
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_pymysql_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_pymysql_dbapiunicode_nocextensions 97
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_oracle_cx_oracle_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 97
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_postgresql_psycopg2_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 97
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 97
 
 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile
 
 test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_mssql_pyodbc_dbapiunicode_cextensions 15
 test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_mssql_pyodbc_dbapiunicode_nocextensions 15
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_mysql_mysqldb_dbapiunicode_cextensions 15
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_mysql_mysqldb_dbapiunicode_nocextensions 15
 test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_mysql_pymysql_dbapiunicode_cextensions 15
 test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_mysql_pymysql_dbapiunicode_nocextensions 15
 test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7_oracle_cx_oracle_dbapiunicode_cextensions 15
@@ -458,112 +474,122 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 3.7
 
 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string
 
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mssql_pyodbc_dbapiunicode_cextensions 256
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6260
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_pymysql_dbapiunicode_cextensions 122257
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_pymysql_dbapiunicode_nocextensions 128259
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_oracle_cx_oracle_dbapiunicode_cextensions 375
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36419
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 277
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6293
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 246
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6268
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mssql_pyodbc_dbapiunicode_cextensions 245
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6249
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_mysqldb_dbapiunicode_cextensions 281
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6285
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_pymysql_dbapiunicode_cextensions 88034
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_pymysql_dbapiunicode_nocextensions 94038
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_oracle_cx_oracle_dbapiunicode_cextensions 334
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6338
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_postgresql_psycopg2_dbapiunicode_cextensions 269
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6273
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 240
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6244
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mssql_pyodbc_dbapiunicode_cextensions 272
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6274
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_mysqldb_dbapiunicode_cextensions 314
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_mysqldb_dbapiunicode_nocextensions 6336
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_pymysql_dbapiunicode_cextensions 122270
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_pymysql_dbapiunicode_nocextensions 128272
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_oracle_cx_oracle_dbapiunicode_cextensions 381
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36423
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 285
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6307
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 253
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6275
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mssql_pyodbc_dbapiunicode_cextensions 257
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6261
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_mysqldb_dbapiunicode_cextensions 290
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6294
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_pymysql_dbapiunicode_cextensions 88045
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_pymysql_dbapiunicode_nocextensions 94049
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_oracle_cx_oracle_dbapiunicode_cextensions 346
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6350
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_postgresql_psycopg2_dbapiunicode_cextensions 281
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6285
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 247
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6251
 
 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode
 
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mssql_pyodbc_dbapiunicode_cextensions 256
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6260
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_pymysql_dbapiunicode_cextensions 122257
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_pymysql_dbapiunicode_nocextensions 128259
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_oracle_cx_oracle_dbapiunicode_cextensions 375
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36419
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 277
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6293
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 246
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6268
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mssql_pyodbc_dbapiunicode_cextensions 245
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6249
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_mysqldb_dbapiunicode_cextensions 281
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6285
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_pymysql_dbapiunicode_cextensions 88034
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_pymysql_dbapiunicode_nocextensions 94038
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_oracle_cx_oracle_dbapiunicode_cextensions 334
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6338
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_postgresql_psycopg2_dbapiunicode_cextensions 269
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6273
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 240
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6244
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mssql_pyodbc_dbapiunicode_cextensions 272
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6274
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_mysqldb_dbapiunicode_cextensions 314
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_mysqldb_dbapiunicode_nocextensions 6336
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_pymysql_dbapiunicode_cextensions 122270
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_pymysql_dbapiunicode_nocextensions 128272
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_oracle_cx_oracle_dbapiunicode_cextensions 381
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36423
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 285
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6307
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 253
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6275
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mssql_pyodbc_dbapiunicode_cextensions 257
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6261
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_mysqldb_dbapiunicode_cextensions 290
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6294
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_pymysql_dbapiunicode_cextensions 88045
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_pymysql_dbapiunicode_nocextensions 94049
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_oracle_cx_oracle_dbapiunicode_cextensions 346
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6350
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_postgresql_psycopg2_dbapiunicode_cextensions 281
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6285
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 247
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6251
 
 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_string
 
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mssql_pyodbc_dbapiunicode_cextensions 526
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6520
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_pymysql_dbapiunicode_cextensions 122496
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_pymysql_dbapiunicode_nocextensions 128488
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_oracle_cx_oracle_dbapiunicode_cextensions 555
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36569
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 500
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6491
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 455
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6457
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mssql_pyodbc_dbapiunicode_cextensions 519
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6523
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_mysqldb_dbapiunicode_cextensions 523
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6527
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_pymysql_dbapiunicode_cextensions 88277
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_pymysql_dbapiunicode_nocextensions 94281
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_oracle_cx_oracle_dbapiunicode_cextensions 538
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6542
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_postgresql_psycopg2_dbapiunicode_cextensions 511
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6515
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 472
-test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6476
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mssql_pyodbc_dbapiunicode_cextensions 534
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6536
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_mysqldb_dbapiunicode_cextensions 539
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_mysqldb_dbapiunicode_nocextensions 6541
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_pymysql_dbapiunicode_cextensions 122505
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_pymysql_dbapiunicode_nocextensions 128507
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_oracle_cx_oracle_dbapiunicode_cextensions 565
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36587
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 509
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6511
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 463
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6465
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mssql_pyodbc_dbapiunicode_cextensions 533
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6537
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_mysqldb_dbapiunicode_cextensions 538
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6542
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_pymysql_dbapiunicode_cextensions 88294
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_pymysql_dbapiunicode_nocextensions 94298
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_oracle_cx_oracle_dbapiunicode_cextensions 564
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6568
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_postgresql_psycopg2_dbapiunicode_cextensions 529
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6533
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 480
+test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6484
 
 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_unicode
 
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mssql_pyodbc_dbapiunicode_cextensions 526
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6520
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_pymysql_dbapiunicode_cextensions 122496
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_pymysql_dbapiunicode_nocextensions 128488
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_oracle_cx_oracle_dbapiunicode_cextensions 555
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36569
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 500
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6491
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 455
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6457
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mssql_pyodbc_dbapiunicode_cextensions 519
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6523
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_mysqldb_dbapiunicode_cextensions 523
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6527
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_pymysql_dbapiunicode_cextensions 88277
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_pymysql_dbapiunicode_nocextensions 94281
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_oracle_cx_oracle_dbapiunicode_cextensions 538
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6542
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_postgresql_psycopg2_dbapiunicode_cextensions 511
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6515
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 472
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6476
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mssql_pyodbc_dbapiunicode_cextensions 534
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6536
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_mysqldb_dbapiunicode_cextensions 539
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_mysqldb_dbapiunicode_nocextensions 6541
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_pymysql_dbapiunicode_cextensions 122505
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_pymysql_dbapiunicode_nocextensions 128507
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_oracle_cx_oracle_dbapiunicode_cextensions 565
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36587
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 509
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6511
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 463
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6465
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mssql_pyodbc_dbapiunicode_cextensions 533
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6537
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_mysqldb_dbapiunicode_cextensions 538
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6542
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_pymysql_dbapiunicode_cextensions 88294
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_pymysql_dbapiunicode_nocextensions 94298
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_oracle_cx_oracle_dbapiunicode_cextensions 564
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6568
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_postgresql_psycopg2_dbapiunicode_cextensions 529
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6533
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 480
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6484
 
 # TEST: test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation
 
-test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 6465,325,4295,12719,1286,2222,2793
-test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 6177,306,4162,12597,1233,2133,2852
-test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6260,306,4242,13203,1344,2151,3046
+test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 6685,336,4367,12924,1322,2274,2821
+test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6740,336,4431,13486,1445,2290,3005
+test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 6474,318,4335,12868,1309,2223,2872
+test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6551,318,4415,13476,1440,2245,3066
 
 # TEST: test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation
 
-test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 6959,432,7231,18822,1299,2861
-test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 7090,411,7281,19190,1247,2897
-test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 7186,416,7465,20675,1350,2957
+test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 7162,444,7247,18830,1335,2890
+test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 7338,454,7479,21133,1448,2949
+test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 7199,435,7459,19425,1323,2974
+test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 7347,443,7715,21791,1444,3042
diff --git a/test/requirements.py b/test/requirements.py
index 53c1f72e4..2b61bc6a1 100644
--- a/test/requirements.py
+++ b/test/requirements.py
@@ -792,7 +792,7 @@ class DefaultRequirements(SuiteRequirements):
         return skip_if(
             "mssql+pymssql", "crashes on pymssql"
         ) + fails_on_everything_except(
-            "mysql", "sqlite+pysqlite", "sqlite+pysqlcipher"
+            "mysql", "sqlite+pysqlite", "sqlite+pysqlcipher", "mssql"
         )
 
     @property
diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py
index a7e9916cd..6f16f0514 100644
--- a/test/sql/test_compiler.py
+++ b/test/sql/test_compiler.py
@@ -4841,7 +4841,7 @@ class ResultMapTest(fixtures.TestBase):
         )
 
     def test_nested_api(self):
-        from sqlalchemy.engine.result import ResultMetaData
+        from sqlalchemy.engine.result import CursorResultMetaData
 
         stmt2 = select([table2]).subquery()
 
@@ -4870,7 +4870,7 @@ class ResultMapTest(fixtures.TestBase):
 
         comp = MyCompiler(default.DefaultDialect(), stmt1)
         eq_(
-            ResultMetaData._create_description_match_map(
+            CursorResultMetaData._create_description_match_map(
                 contexts[stmt2.element][0]
             ),
             {
diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py
index 2fded335b..ad27828a4 100644
--- a/test/sql/test_defaults.py
+++ b/test/sql/test_defaults.py
@@ -684,7 +684,7 @@ class DefaultTest(fixtures.TestBase):
     def test_insert_values(self):
         t.insert(values={"col3": 50}).execute()
         result = t.select().execute()
-        eq_(50, result.first()["col3"])
+        eq_(50, result.first()._mapping["col3"])
 
     @testing.fails_on("firebird", "Data type unknown")
     def test_updatemany(self):
@@ -793,7 +793,7 @@ class DefaultTest(fixtures.TestBase):
         t.update(t.c.col1 == pk, values={"col3": 55}).execute()
         result = t.select(t.c.col1 == pk).execute()
         result = result.first()
-        eq_(55, result["col3"])
+        eq_(55, result._mapping["col3"])
 
 
 class CTEDefaultTest(fixtures.TablesTest):
diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py
index b058cbe1b..ba6048f07 100644
--- a/test/sql/test_deprecations.py
+++ b/test/sql/test_deprecations.py
@@ -34,6 +34,7 @@ from sqlalchemy.sql.selectable import SelectStatementGrouping
 from sqlalchemy.testing import assert_raises
 from sqlalchemy.testing import assert_raises_message
 from sqlalchemy.testing import AssertsCompiledSQL
+from sqlalchemy.testing import engines
 from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import in_
@@ -1282,15 +1283,24 @@ class ResultProxyTest(fixtures.TablesTest):
 
         with testing.expect_deprecated(
             "Retreiving row values using Column objects "
-            "with only matching names"
+            "with only matching names",
+            "Using non-integer/slice indices on Row is "
+            "deprecated and will be removed in version 2.0",
         ):
             eq_(r[users.c.user_id], 2)
 
+        r._keymap.pop(users.c.user_id)  # reset lookup
         with testing.expect_deprecated(
             "Retreiving row values using Column objects "
             "with only matching names"
         ):
-            eq_(r[users.c.user_name], "jack")
+            eq_(r._mapping[users.c.user_id], 2)
+
+        with testing.expect_deprecated(
+            "Retreiving row values using Column objects "
+            "with only matching names"
+        ):
+            eq_(r._mapping[users.c.user_name], "jack")
 
     def test_column_accessor_basic_text(self):
         users = self.tables.users
@@ -1300,17 +1310,35 @@ class ResultProxyTest(fixtures.TablesTest):
         ).first()
 
         with testing.expect_deprecated(
+            "Using non-integer/slice indices on Row is deprecated "
+            "and will be removed in version 2.0",
             "Retreiving row values using Column objects "
-            "with only matching names"
+            "with only matching names",
         ):
             eq_(r[users.c.user_id], 2)
 
+        r._keymap.pop(users.c.user_id)
         with testing.expect_deprecated(
             "Retreiving row values using Column objects "
             "with only matching names"
         ):
+            eq_(r._mapping[users.c.user_id], 2)
+
+        with testing.expect_deprecated(
+            "Using non-integer/slice indices on Row is deprecated "
+            "and will be removed in version 2.0",
+            "Retreiving row values using Column objects "
+            "with only matching names",
+        ):
             eq_(r[users.c.user_name], "jack")
 
+        r._keymap.pop(users.c.user_name)
+        with testing.expect_deprecated(
+            "Retreiving row values using Column objects "
+            "with only matching names"
+        ):
+            eq_(r._mapping[users.c.user_name], "jack")
+
     @testing.provide_metadata
     def test_column_label_overlap_fallback(self):
         content = Table("content", self.metadata, Column("type", String(30)))
@@ -1319,7 +1347,7 @@ class ResultProxyTest(fixtures.TablesTest):
         testing.db.execute(content.insert().values(type="t1"))
 
         row = testing.db.execute(content.select(use_labels=True)).first()
-        in_(content.c.type, row)
+        in_(content.c.type, row._mapping)
         not_in_(bar.c.content_type, row)
         with testing.expect_deprecated(
             "Retreiving row values using Column objects "
@@ -1387,18 +1415,38 @@ class ResultProxyTest(fixtures.TablesTest):
                         "Retreiving row values using Column objects "
                         "from a row that was unpickled"
                     ):
-                        eq_(result[0][users.c.user_id], 7)
+                        eq_(result[0]._mapping[users.c.user_id], 7)
+
+                    result[0]._keymap.pop(users.c.user_id)
+                    with testing.expect_deprecated(
+                        "Retreiving row values using Column objects "
+                        "from a row that was unpickled"
+                    ):
+                        eq_(result[0]._mapping[users.c.user_id], 7)
+
                     with testing.expect_deprecated(
                         "Retreiving row values using Column objects "
                         "from a row that was unpickled"
                     ):
-                        eq_(result[0][users.c.user_name], "jack")
+                        eq_(result[0]._mapping[users.c.user_name], "jack")
+
+                    result[0]._keymap.pop(users.c.user_name)
+                    with testing.expect_deprecated(
+                        "Retreiving row values using Column objects "
+                        "from a row that was unpickled"
+                    ):
+                        eq_(result[0]._mapping[users.c.user_name], "jack")
 
                 if not pickle or use_labels:
                     assert_raises(
                         exc.NoSuchColumnError,
                         lambda: result[0][addresses.c.user_id],
                     )
+
+                    assert_raises(
+                        exc.NoSuchColumnError,
+                        lambda: result[0]._mapping[addresses.c.user_id],
+                    )
                 else:
                     # test with a different table.  name resolution is
                     # causing 'user_id' to match when use_labels wasn't used.
@@ -1406,13 +1454,161 @@ class ResultProxyTest(fixtures.TablesTest):
                         "Retreiving row values using Column objects "
                         "from a row that was unpickled"
                     ):
-                        eq_(result[0][addresses.c.user_id], 7)
+                        eq_(result[0]._mapping[addresses.c.user_id], 7)
+
+                    result[0]._keymap.pop(addresses.c.user_id)
+                    with testing.expect_deprecated(
+                        "Retreiving row values using Column objects "
+                        "from a row that was unpickled"
+                    ):
+                        eq_(result[0]._mapping[addresses.c.user_id], 7)
 
                 assert_raises(
                     exc.NoSuchColumnError,
                     lambda: result[0][addresses.c.address_id],
                 )
 
+                assert_raises(
+                    exc.NoSuchColumnError,
+                    lambda: result[0]._mapping[addresses.c.address_id],
+                )
+
+    @testing.requires.duplicate_names_in_cursor_description
+    def test_ambiguous_column_case_sensitive(self):
+        with testing.expect_deprecated(
+            "The create_engine.case_sensitive parameter is deprecated"
+        ):
+            eng = engines.testing_engine(options=dict(case_sensitive=False))
+
+        row = eng.execute(
+            select(
+                [
+                    literal_column("1").label("SOMECOL"),
+                    literal_column("1").label("SOMECOL"),
+                ]
+            )
+        ).first()
+
+        assert_raises_message(
+            exc.InvalidRequestError,
+            "Ambiguous column name",
+            lambda: row._mapping["somecol"],
+        )
+
+    def test_row_getitem_string(self):
+        with testing.db.connect() as conn:
+            col = literal_column("1").label("foo")
+            row = conn.execute(select([col])).first()
+
+            with testing.expect_deprecated(
+                "Using non-integer/slice indices on Row is deprecated "
+                "and will be removed in version 2.0;"
+            ):
+                eq_(row["foo"], 1)
+
+            eq_(row._mapping["foo"], 1)
+
+    def test_row_getitem_column(self):
+        with testing.db.connect() as conn:
+            col = literal_column("1").label("foo")
+            row = conn.execute(select([col])).first()
+
+            with testing.expect_deprecated(
+                "Using non-integer/slice indices on Row is deprecated "
+                "and will be removed in version 2.0;"
+            ):
+                eq_(row[col], 1)
+
+            eq_(row._mapping[col], 1)
+
+    def test_row_case_insensitive(self):
+        with testing.expect_deprecated(
+            "The create_engine.case_sensitive parameter is deprecated"
+        ):
+            ins_db = engines.testing_engine(options={"case_sensitive": False})
+        row = ins_db.execute(
+            select(
+                [
+                    literal_column("1").label("case_insensitive"),
+                    literal_column("2").label("CaseSensitive"),
+                ]
+            )
+        ).first()
+
+        eq_(list(row._mapping.keys()), ["case_insensitive", "CaseSensitive"])
+
+        in_("case_insensitive", row._keymap)
+        in_("CaseSensitive", row._keymap)
+        in_("casesensitive", row._keymap)
+
+        eq_(row._mapping["case_insensitive"], 1)
+        eq_(row._mapping["CaseSensitive"], 2)
+        eq_(row._mapping["Case_insensitive"], 1)
+        eq_(row._mapping["casesensitive"], 2)
+
+    def test_row_case_insensitive_unoptimized(self):
+        with testing.expect_deprecated(
+            "The create_engine.case_sensitive parameter is deprecated"
+        ):
+            ins_db = engines.testing_engine(options={"case_sensitive": False})
+        row = ins_db.execute(
+            select(
+                [
+                    literal_column("1").label("case_insensitive"),
+                    literal_column("2").label("CaseSensitive"),
+                    text("3 AS screw_up_the_cols"),
+                ]
+            )
+        ).first()
+
+        eq_(
+            list(row._mapping.keys()),
+            ["case_insensitive", "CaseSensitive", "screw_up_the_cols"],
+        )
+
+        in_("case_insensitive", row._keymap)
+        in_("CaseSensitive", row._keymap)
+        in_("casesensitive", row._keymap)
+
+        eq_(row._mapping["case_insensitive"], 1)
+        eq_(row._mapping["CaseSensitive"], 2)
+        eq_(row._mapping["screw_up_the_cols"], 3)
+        eq_(row._mapping["Case_insensitive"], 1)
+        eq_(row._mapping["casesensitive"], 2)
+        eq_(row._mapping["screw_UP_the_cols"], 3)
+
+    def test_row_keys_deprecated(self):
+        r = testing.db.execute(
+            text("select * from users where user_id=2")
+        ).first()
+
+        with testing.expect_deprecated(
+            r"The Row.keys\(\) method is deprecated and will be "
+            "removed in a future release."
+        ):
+            eq_(r.keys(), ["user_id", "user_name"])
+
+    def test_row_contains_key_deprecated(self):
+        r = testing.db.execute(
+            text("select * from users where user_id=2")
+        ).first()
+
+        with testing.expect_deprecated(
+            "Using the 'in' operator to test for string or column keys, or "
+            "integer indexes, .* is deprecated"
+        ):
+            in_("user_name", r)
+
+        # no warning if the key is not there
+        not_in_("foobar", r)
+
+        # this seems to happen only with Python BaseRow
+        # with testing.expect_deprecated(
+        #    "Using the 'in' operator to test for string or column keys, or "
+        #   "integer indexes, .* is deprecated"
+        # ):
+        #    in_(1, r)
+
 
 class PositionalTextTest(fixtures.TablesTest):
     run_inserts = "once"
@@ -1452,7 +1648,7 @@ class PositionalTextTest(fixtures.TablesTest):
             "Retreiving row values using Column objects "
             "with only matching names"
         ):
-            eq_(row[text1.c.a], "a1")
+            eq_(row._mapping[text1.c.a], "a1")
 
     def test_anon_aliased_unique(self):
         text1 = self.tables.text1
@@ -1466,10 +1662,10 @@ class PositionalTextTest(fixtures.TablesTest):
         result = testing.db.execute(stmt)
         row = result.first()
 
-        eq_(row[c1], "a1")
-        eq_(row[c2], "b1")
-        eq_(row[c3], "c1")
-        eq_(row[c4], "d1")
+        eq_(row._mapping[c1], "a1")
+        eq_(row._mapping[c2], "b1")
+        eq_(row._mapping[c3], "c1")
+        eq_(row._mapping[c4], "d1")
 
         # key fallback rules still match this to a column
         # unambiguously based on its name
@@ -1477,7 +1673,7 @@ class PositionalTextTest(fixtures.TablesTest):
             "Retreiving row values using Column objects "
             "with only matching names"
         ):
-            eq_(row[text1.c.a], "a1")
+            eq_(row._mapping[text1.c.a], "a1")
 
         # key fallback rules still match this to a column
         # unambiguously based on its name
@@ -1485,7 +1681,7 @@ class PositionalTextTest(fixtures.TablesTest):
             "Retreiving row values using Column objects "
             "with only matching names"
         ):
-            eq_(row[text1.c.d], "d1")
+            eq_(row._mapping[text1.c.d], "d1")
 
         # text1.c.b goes nowhere....because we hit key fallback
         # but the text1.c.b doesn't derive from text1.c.c
@@ -1495,6 +1691,12 @@ class PositionalTextTest(fixtures.TablesTest):
             lambda: row[text1.c.b],
         )
 
+        assert_raises_message(
+            exc.NoSuchColumnError,
+            "Could not locate column in row for column 'text1.b'",
+            lambda: row._mapping[text1.c.b],
+        )
+
 
 class DefaultTest(fixtures.TestBase):
     __backend__ = True
diff --git a/test/sql/test_functions.py b/test/sql/test_functions.py
index 6ee8a67b7..fd3f55780 100644
--- a/test/sql/test_functions.py
+++ b/test/sql/test_functions.py
@@ -1015,15 +1015,15 @@ class ExecuteTest(fixtures.TestBase):
         )
         meta.create_all()
         t.insert(values=dict(value=func.length("one"))).execute()
-        assert t.select().execute().first()["value"] == 3
+        assert t.select().execute().first().value == 3
         t.update(values=dict(value=func.length("asfda"))).execute()
-        assert t.select().execute().first()["value"] == 5
+        assert t.select().execute().first().value == 5
 
         r = t.insert(values=dict(value=func.length("sfsaafsda"))).execute()
         id_ = r.inserted_primary_key[0]
-        assert t.select(t.c.id == id_).execute().first()["value"] == 9
+        assert t.select(t.c.id == id_).execute().first().value == 9
         t.update(values={t.c.value: func.length("asdf")}).execute()
-        assert t.select().execute().first()["value"] == 4
+        assert t.select().execute().first().value == 4
         t2.insert().execute()
         t2.insert(values=dict(value=func.length("one"))).execute()
         t2.insert(values=dict(value=func.length("asfda") + -19)).execute(
@@ -1045,7 +1045,7 @@ class ExecuteTest(fixtures.TestBase):
         t2.delete().execute()
 
         t2.insert(values=dict(value=func.length("one") + 8)).execute()
-        assert t2.select().execute().first()["value"] == 11
+        assert t2.select().execute().first().value == 11
 
         t2.update(values=dict(value=func.length("asfda"))).execute()
         eq_(
diff --git a/test/sql/test_insert_exec.py b/test/sql/test_insert_exec.py
index 85cdeca4b..2021c030c 100644
--- a/test/sql/test_insert_exec.py
+++ b/test/sql/test_insert_exec.py
@@ -112,7 +112,7 @@ class InsertExecTest(fixtures.TablesTest):
                 )
                 row = engine.execute(table_.select(criterion)).first()
                 for c in table_.c:
-                    ret[c.key] = row[c]
+                    ret[c.key] = row._mapping[c]
             return ret
 
         if testing.against("firebird", "postgresql", "oracle", "mssql"):
diff --git a/test/sql/test_query.py b/test/sql/test_query.py
index aa5e913d5..83c5da342 100644
--- a/test/sql/test_query.py
+++ b/test/sql/test_query.py
@@ -265,13 +265,13 @@ class QueryTest(fixtures.TestBase):
         users.insert().execute(user_id=7, user_name="jack")
         s = select([users], users.c.user_id == bindparam("id")).compile()
         c = testing.db.connect()
-        assert c.execute(s, id=7).fetchall()[0]["user_id"] == 7
+        eq_(c.execute(s, id=7).first()._mapping["user_id"], 7)
 
     def test_compiled_insert_execute(self):
         users.insert().compile().execute(user_id=7, user_name="jack")
         s = select([users], users.c.user_id == bindparam("id")).compile()
         c = testing.db.connect()
-        assert c.execute(s, id=7).fetchall()[0]["user_id"] == 7
+        eq_(c.execute(s, id=7).first()._mapping["user_id"], 7)
 
     def test_repeated_bindparams(self):
         """Tests that a BindParam can be used more than once.
diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py
index 8aa524d78..2a6851a99 100644
--- a/test/sql/test_resultset.py
+++ b/test/sql/test_resultset.py
@@ -1,3 +1,4 @@
+import collections
 from contextlib import contextmanager
 import csv
 import operator
@@ -134,8 +135,8 @@ class ResultProxyTest(fixtures.TablesTest):
             .scalar_subquery()
         )
         for row in select([sel + 1, sel + 3], bind=users.bind).execute():
-            eq_(row["anon_1"], 8)
-            eq_(row["anon_2"], 10)
+            eq_(row._mapping["anon_1"], 8)
+            eq_(row._mapping["anon_2"], 10)
 
     def test_row_comparison(self):
         users = self.tables.users
@@ -196,15 +197,18 @@ class ResultProxyTest(fixtures.TablesTest):
         testing.db.execute(content.insert().values(type="t1"))
 
         row = testing.db.execute(content.select(use_labels=True)).first()
-        in_(content.c.type, row)
-        not_in_(bar.c.content_type, row)
+        in_(content.c.type, row._mapping)
+        not_in_(bar.c.content_type, row._mapping)
+
+        not_in_(bar.c.content_type, row._mapping)
 
         row = testing.db.execute(
             select([func.now().label("content_type")])
         ).first()
 
-        not_in_(content.c.type, row)
-        not_in_(bar.c.content_type, row)
+        not_in_(content.c.type, row._mapping)
+
+        not_in_(bar.c.content_type, row._mapping)
 
     def test_pickled_rows(self):
         users = self.tables.users
@@ -229,14 +233,14 @@ class ResultProxyTest(fixtures.TablesTest):
 
                 eq_(result, [(7, "jack"), (8, "ed"), (9, "fred")])
                 if use_labels:
-                    eq_(result[0]["users_user_id"], 7)
+                    eq_(result[0]._mapping["users_user_id"], 7)
                     eq_(
-                        list(result[0].keys()),
+                        list(result[0]._fields),
                         ["users_user_id", "users_user_name"],
                     )
                 else:
-                    eq_(result[0]["user_id"], 7)
-                    eq_(list(result[0].keys()), ["user_id", "user_name"])
+                    eq_(result[0]._mapping["user_id"], 7)
+                    eq_(list(result[0]._fields), ["user_id", "user_name"])
 
                 eq_(result[0][0], 7)
 
@@ -244,6 +248,11 @@ class ResultProxyTest(fixtures.TablesTest):
                     exc.NoSuchColumnError, lambda: result[0]["fake key"]
                 )
 
+                assert_raises(
+                    exc.NoSuchColumnError,
+                    lambda: result[0]._mapping["fake key"],
+                )
+
     def test_column_error_printing(self):
         result = testing.db.execute(select([1]))
         row = result.first()
@@ -267,7 +276,9 @@ class ResultProxyTest(fixtures.TablesTest):
             is_(result._getter(accessor, False), None)
 
             assert_raises_message(
-                exc.NoSuchColumnError, msg % repl, lambda: row[accessor]
+                exc.NoSuchColumnError,
+                msg % repl,
+                lambda: row._mapping[accessor],
             )
 
     def test_fetchmany(self):
@@ -297,7 +308,24 @@ class ResultProxyTest(fixtures.TablesTest):
         eq_(r[1:], (2, "foo@bar.com"))
         eq_(r[:-1], (1, 2))
 
-    def test_column_accessor_basic_compiled(self):
+    def test_column_accessor_basic_compiled_mapping(self):
+        users = self.tables.users
+
+        users.insert().execute(
+            dict(user_id=1, user_name="john"),
+            dict(user_id=2, user_name="jack"),
+        )
+
+        r = users.select(users.c.user_id == 2).execute().first()
+        eq_(r.user_id, 2)
+        eq_(r._mapping["user_id"], 2)
+        eq_(r._mapping[users.c.user_id], 2)
+
+        eq_(r.user_name, "jack")
+        eq_(r._mapping["user_name"], "jack")
+        eq_(r._mapping[users.c.user_name], "jack")
+
+    def test_column_accessor_basic_compiled_traditional(self):
         users = self.tables.users
 
         users.insert().execute(
@@ -306,13 +334,28 @@ class ResultProxyTest(fixtures.TablesTest):
         )
 
         r = users.select(users.c.user_id == 2).execute().first()
+
         eq_(r.user_id, 2)
-        eq_(r["user_id"], 2)
-        eq_(r[users.c.user_id], 2)
+        eq_(r._mapping["user_id"], 2)
+        eq_(r._mapping[users.c.user_id], 2)
 
         eq_(r.user_name, "jack")
-        eq_(r["user_name"], "jack")
-        eq_(r[users.c.user_name], "jack")
+        eq_(r._mapping["user_name"], "jack")
+        eq_(r._mapping[users.c.user_name], "jack")
+
+    def test_row_getitem_string(self):
+        users = self.tables.users
+
+        users.insert().execute(
+            dict(user_id=1, user_name="john"),
+            dict(user_id=2, user_name="jack"),
+        )
+
+        r = testing.db.execute(
+            text("select * from users where user_id=2")
+        ).first()
+
+        eq_(r._mapping["user_name"], "jack")
 
     def test_column_accessor_basic_text(self):
         users = self.tables.users
@@ -326,10 +369,34 @@ class ResultProxyTest(fixtures.TablesTest):
         ).first()
 
         eq_(r.user_id, 2)
-        eq_(r["user_id"], 2)
 
         eq_(r.user_name, "jack")
-        eq_(r["user_name"], "jack")
+
+        eq_(r._mapping["user_id"], 2)
+
+        eq_(r.user_name, "jack")
+        eq_(r._mapping["user_name"], "jack")
+
+    def test_column_accessor_text_colexplicit(self):
+        users = self.tables.users
+
+        users.insert().execute(
+            dict(user_id=1, user_name="john"),
+            dict(user_id=2, user_name="jack"),
+        )
+        r = testing.db.execute(
+            text("select * from users where user_id=2").columns(
+                users.c.user_id, users.c.user_name
+            )
+        ).first()
+
+        eq_(r.user_id, 2)
+        eq_(r._mapping["user_id"], 2)
+        eq_(r._mapping[users.c.user_id], 2)
+
+        eq_(r.user_name, "jack")
+        eq_(r._mapping["user_name"], "jack")
+        eq_(r._mapping[users.c.user_name], "jack")
 
     def test_column_accessor_textual_select(self):
         users = self.tables.users
@@ -346,11 +413,12 @@ class ResultProxyTest(fixtures.TablesTest):
             .where(text("user_id=2"))
         ).first()
 
+        # keyed access works in many ways
         eq_(r.user_id, 2)
-        eq_(r["user_id"], 2)
-
         eq_(r.user_name, "jack")
-        eq_(r["user_name"], "jack")
+        eq_(r._mapping["user_id"], 2)
+        eq_(r.user_name, "jack")
+        eq_(r._mapping["user_name"], "jack")
 
     def test_column_accessor_dotted_union(self):
         users = self.tables.users
@@ -367,9 +435,9 @@ class ResultProxyTest(fixtures.TablesTest):
                 "users.user_name from users"
             )
         ).first()
-        eq_(r["user_id"], 1)
-        eq_(r["user_name"], "john")
-        eq_(list(r.keys()), ["user_id", "user_name"])
+        eq_(r._mapping["user_id"], 1)
+        eq_(r._mapping["user_name"], "john")
+        eq_(list(r._fields), ["user_id", "user_name"])
 
     def test_column_accessor_sqlite_raw(self):
         users = self.tables.users
@@ -395,14 +463,14 @@ class ResultProxyTest(fixtures.TablesTest):
             eq_(r["users.user_id"], 1)
             eq_(r["users.user_name"], "john")
 
-            eq_(list(r.keys()), ["users.user_id", "users.user_name"])
+            eq_(list(r._fields), ["users.user_id", "users.user_name"])
         else:
-            not_in_("users.user_id", r)
-            not_in_("users.user_name", r)
-            eq_(r["user_id"], 1)
-            eq_(r["user_name"], "john")
+            not_in_("users.user_id", r._mapping)
+            not_in_("users.user_name", r._mapping)
+            eq_(r._mapping["user_id"], 1)
+            eq_(r._mapping["user_name"], "john")
 
-            eq_(list(r.keys()), ["user_id", "user_name"])
+            eq_(list(r._fields), ["user_id", "user_name"])
 
     def test_column_accessor_sqlite_translated(self):
         users = self.tables.users
@@ -420,17 +488,17 @@ class ResultProxyTest(fixtures.TablesTest):
             .execute()
             .first()
         )
-        eq_(r["user_id"], 1)
-        eq_(r["user_name"], "john")
+        eq_(r._mapping["user_id"], 1)
+        eq_(r._mapping["user_name"], "john")
 
         if testing.against("sqlite < 3.10.0"):
-            eq_(r["users.user_id"], 1)
-            eq_(r["users.user_name"], "john")
+            eq_(r._mapping["users.user_id"], 1)
+            eq_(r._mapping["users.user_name"], "john")
         else:
-            not_in_("users.user_id", r)
-            not_in_("users.user_name", r)
+            not_in_("users.user_id", r._mapping)
+            not_in_("users.user_name", r._mapping)
 
-        eq_(list(r.keys()), ["user_id", "user_name"])
+        eq_(list(r._fields), ["user_id", "user_name"])
 
     def test_column_accessor_labels_w_dots(self):
         users = self.tables.users
@@ -448,10 +516,10 @@ class ResultProxyTest(fixtures.TablesTest):
             .execute()
             .first()
         )
-        eq_(r["users.user_id"], 1)
-        eq_(r["users.user_name"], "john")
-        not_in_("user_name", r)
-        eq_(list(r.keys()), ["users.user_id", "users.user_name"])
+        eq_(r._mapping["users.user_id"], 1)
+        eq_(r._mapping["users.user_name"], "john")
+        not_in_("user_name", r._mapping)
+        eq_(list(r._fields), ["users.user_id", "users.user_name"])
 
     def test_column_accessor_unary(self):
         users = self.tables.users
@@ -465,7 +533,7 @@ class ResultProxyTest(fixtures.TablesTest):
             .execute()
             .first()
         )
-        eq_(r[users.c.user_name], "john")
+        eq_(r._mapping[users.c.user_name], "john")
         eq_(r.user_name, "john")
 
     def test_column_accessor_err(self):
@@ -480,7 +548,7 @@ class ResultProxyTest(fixtures.TablesTest):
         assert_raises_message(
             KeyError,
             "Could not locate column in row for column 'foo'",
-            lambda: r["foo"],
+            lambda: r._mapping["foo"],
         )
 
     def test_graceful_fetch_on_non_rows(self):
@@ -586,20 +654,20 @@ class ResultProxyTest(fixtures.TablesTest):
             )
         ).first()
 
-        eq_(list(row.keys()), ["case_insensitive", "CaseSensitive"])
+        eq_(list(row._fields), ["case_insensitive", "CaseSensitive"])
 
         in_("case_insensitive", row._keymap)
         in_("CaseSensitive", row._keymap)
         not_in_("casesensitive", row._keymap)
 
-        eq_(row["case_insensitive"], 1)
-        eq_(row["CaseSensitive"], 2)
+        eq_(row._mapping["case_insensitive"], 1)
+        eq_(row._mapping["CaseSensitive"], 2)
 
-        assert_raises(KeyError, lambda: row["Case_insensitive"])
-        assert_raises(KeyError, lambda: row["casesensitive"])
+        assert_raises(KeyError, lambda: row._mapping["Case_insensitive"])
+        assert_raises(KeyError, lambda: row._mapping["casesensitive"])
 
     def test_row_case_sensitive_unoptimized(self):
-        ins_db = engines.testing_engine(options={"case_sensitive": True})
+        ins_db = engines.testing_engine()
         row = ins_db.execute(
             select(
                 [
@@ -611,7 +679,7 @@ class ResultProxyTest(fixtures.TablesTest):
         ).first()
 
         eq_(
-            list(row.keys()),
+            list(row._fields),
             ["case_insensitive", "CaseSensitive", "screw_up_the_cols"],
         )
 
@@ -619,63 +687,13 @@ class ResultProxyTest(fixtures.TablesTest):
         in_("CaseSensitive", row._keymap)
         not_in_("casesensitive", row._keymap)
 
-        eq_(row["case_insensitive"], 1)
-        eq_(row["CaseSensitive"], 2)
-        eq_(row["screw_up_the_cols"], 3)
-
-        assert_raises(KeyError, lambda: row["Case_insensitive"])
-        assert_raises(KeyError, lambda: row["casesensitive"])
-        assert_raises(KeyError, lambda: row["screw_UP_the_cols"])
-
-    def test_row_case_insensitive(self):
-        ins_db = engines.testing_engine(options={"case_sensitive": False})
-        row = ins_db.execute(
-            select(
-                [
-                    literal_column("1").label("case_insensitive"),
-                    literal_column("2").label("CaseSensitive"),
-                ]
-            )
-        ).first()
-
-        eq_(list(row.keys()), ["case_insensitive", "CaseSensitive"])
-
-        in_("case_insensitive", row._keymap)
-        in_("CaseSensitive", row._keymap)
-        in_("casesensitive", row._keymap)
-
-        eq_(row["case_insensitive"], 1)
-        eq_(row["CaseSensitive"], 2)
-        eq_(row["Case_insensitive"], 1)
-        eq_(row["casesensitive"], 2)
-
-    def test_row_case_insensitive_unoptimized(self):
-        ins_db = engines.testing_engine(options={"case_sensitive": False})
-        row = ins_db.execute(
-            select(
-                [
-                    literal_column("1").label("case_insensitive"),
-                    literal_column("2").label("CaseSensitive"),
-                    text("3 AS screw_up_the_cols"),
-                ]
-            )
-        ).first()
-
-        eq_(
-            list(row.keys()),
-            ["case_insensitive", "CaseSensitive", "screw_up_the_cols"],
-        )
-
-        in_("case_insensitive", row._keymap)
-        in_("CaseSensitive", row._keymap)
-        in_("casesensitive", row._keymap)
+        eq_(row._mapping["case_insensitive"], 1)
+        eq_(row._mapping["CaseSensitive"], 2)
+        eq_(row._mapping["screw_up_the_cols"], 3)
 
-        eq_(row["case_insensitive"], 1)
-        eq_(row["CaseSensitive"], 2)
-        eq_(row["screw_up_the_cols"], 3)
-        eq_(row["Case_insensitive"], 1)
-        eq_(row["casesensitive"], 2)
-        eq_(row["screw_UP_the_cols"], 3)
+        assert_raises(KeyError, lambda: row._mapping["Case_insensitive"])
+        assert_raises(KeyError, lambda: row._mapping["casesensitive"])
+        assert_raises(KeyError, lambda: row._mapping["screw_UP_the_cols"])
 
     def test_row_as_args(self):
         users = self.tables.users
@@ -683,7 +701,7 @@ class ResultProxyTest(fixtures.TablesTest):
         users.insert().execute(user_id=1, user_name="john")
         r = users.select(users.c.user_id == 1).execute().first()
         users.delete().execute()
-        users.insert().execute(r)
+        users.insert().execute(r._mapping)
         eq_(users.select().execute().fetchall(), [(1, "john")])
 
     def test_result_as_args(self):
@@ -697,7 +715,7 @@ class ResultProxyTest(fixtures.TablesTest):
             ]
         )
         r = users.select().execute()
-        users2.insert().execute(list(r))
+        users2.insert().execute([row._mapping for row in r])
         eq_(
             users2.select().order_by(users2.c.user_id).execute().fetchall(),
             [(1, "john"), (2, "ed")],
@@ -705,7 +723,7 @@ class ResultProxyTest(fixtures.TablesTest):
 
         users2.delete().execute()
         r = users.select().execute()
-        users2.insert().execute(*list(r))
+        users2.insert().execute(*[row._mapping for row in r])
         eq_(
             users2.select().order_by(users2.c.user_id).execute().fetchall(),
             [(1, "john"), (2, "ed")],
@@ -723,7 +741,7 @@ class ResultProxyTest(fixtures.TablesTest):
         assert_raises_message(
             exc.InvalidRequestError,
             "Ambiguous column name",
-            lambda: r["user_id"],
+            lambda: r._mapping["user_id"],
         )
 
         assert_raises_message(
@@ -736,8 +754,8 @@ class ResultProxyTest(fixtures.TablesTest):
         # pure positional targeting; users.c.user_id
         # and addresses.c.user_id are known!
         # works as of 1.1 issue #3501
-        eq_(r[users.c.user_id], 1)
-        eq_(r[addresses.c.user_id], None)
+        eq_(r._mapping[users.c.user_id], 1)
+        eq_(r._mapping[addresses.c.user_id], None)
 
         # try to trick it - fake_table isn't in the result!
         # we get the correct error
@@ -745,14 +763,14 @@ class ResultProxyTest(fixtures.TablesTest):
         assert_raises_message(
             exc.InvalidRequestError,
             "Could not locate column in row for column 'fake.user_id'",
-            lambda: r[fake_table.c.user_id],
+            lambda: r._mapping[fake_table.c.user_id],
         )
 
         r = util.pickle.loads(util.pickle.dumps(r))
         assert_raises_message(
             exc.InvalidRequestError,
             "Ambiguous column name",
-            lambda: r["user_id"],
+            lambda: r._mapping["user_id"],
         )
 
         result = users.outerjoin(addresses).select().execute()
@@ -762,7 +780,7 @@ class ResultProxyTest(fixtures.TablesTest):
         assert_raises_message(
             exc.InvalidRequestError,
             "Ambiguous column name",
-            lambda: r["user_id"],
+            lambda: r._mapping["user_id"],
         )
 
     @testing.requires.duplicate_names_in_cursor_description
@@ -781,35 +799,16 @@ class ResultProxyTest(fixtures.TablesTest):
 
         # as of 1.1 issue #3501, we use pure positional
         # targeting for the column objects here
-        eq_(row[users.c.user_id], 1)
+        eq_(row._mapping[users.c.user_id], 1)
 
-        eq_(row[ua.c.user_id], 1)
+        eq_(row._mapping[ua.c.user_id], 1)
 
         # this now works as of 1.1 issue #3501;
         # previously this was stuck on "ambiguous column name"
         assert_raises_message(
             exc.InvalidRequestError,
             "Could not locate column in row",
-            lambda: row[u2.c.user_id],
-        )
-
-    @testing.requires.duplicate_names_in_cursor_description
-    def test_ambiguous_column_case_sensitive(self):
-        eng = engines.testing_engine(options=dict(case_sensitive=False))
-
-        row = eng.execute(
-            select(
-                [
-                    literal_column("1").label("SOMECOL"),
-                    literal_column("1").label("SOMECOL"),
-                ]
-            )
-        ).first()
-
-        assert_raises_message(
-            exc.InvalidRequestError,
-            "Ambiguous column name",
-            lambda: row["somecol"],
+            lambda: row._mapping[u2.c.user_id],
         )
 
     @testing.requires.duplicate_names_in_cursor_description
@@ -829,7 +828,12 @@ class ResultProxyTest(fixtures.TablesTest):
         row = result.first()
 
         eq_(
-            set([users.c.user_id in row, addresses.c.user_id in row]),
+            set(
+                [
+                    users.c.user_id in row._mapping,
+                    addresses.c.user_id in row._mapping,
+                ]
+            ),
             set([True]),
         )
 
@@ -864,8 +868,8 @@ class ResultProxyTest(fixtures.TablesTest):
                 )
             )
             row = result.first()
-            eq_(row[users.c.user_id], 1)
-            eq_(row[users.c.user_name], "john")
+            eq_(row._mapping[users.c.user_id], 1)
+            eq_(row._mapping[users.c.user_name], "john")
 
     def test_loose_matching_two(self):
         users = self.tables.users
@@ -898,14 +902,14 @@ class ResultProxyTest(fixtures.TablesTest):
             assert_raises_message(
                 exc.InvalidRequestError,
                 "Ambiguous column name",
-                lambda: row[users.c.user_id],
+                lambda: row._mapping[users.c.user_id],
             )
             assert_raises_message(
                 exc.InvalidRequestError,
                 "Ambiguous column name",
-                lambda: row[addresses.c.user_id],
+                lambda: row._mapping[addresses.c.user_id],
             )
-            eq_(row[users.c.user_name], "john")
+            eq_(row._mapping[users.c.user_name], "john")
 
     def test_ambiguous_column_by_col_plus_label(self):
         users = self.tables.users
@@ -918,7 +922,7 @@ class ResultProxyTest(fixtures.TablesTest):
             ]
         ).execute()
         row = result.first()
-        eq_(row[users.c.user_id], 1)
+        eq_(row._mapping[users.c.user_id], 1)
         eq_(row[1], 1)
 
     def test_fetch_partial_result_map(self):
@@ -969,8 +973,52 @@ class ResultProxyTest(fixtures.TablesTest):
             users.select().alias(users.name),
         ):
             row = s.select(use_labels=True).execute().first()
-            eq_(row[s.c.user_id], 7)
-            eq_(row[s.c.user_name], "ed")
+            eq_(row._mapping[s.c.user_id], 7)
+            eq_(row._mapping[s.c.user_name], "ed")
+
+    @testing.requires.python3
+    def test_ro_mapping_py3k(self):
+        users = self.tables.users
+
+        users.insert().execute(user_id=1, user_name="foo")
+        result = users.select().execute()
+
+        row = result.first()
+        dict_row = row._asdict()
+
+        # dictionaries aren't ordered in Python 3 until 3.7
+        odict_row = collections.OrderedDict(
+            [("user_id", 1), ("user_name", "foo")]
+        )
+        eq_(dict_row, odict_row)
+
+        mapping_row = row._mapping
+
+        eq_(list(mapping_row), list(mapping_row.keys()))
+        eq_(odict_row.keys(), mapping_row.keys())
+        eq_(odict_row.values(), mapping_row.values())
+        eq_(odict_row.items(), mapping_row.items())
+
+    @testing.requires.python2
+    def test_ro_mapping_py2k(self):
+        users = self.tables.users
+
+        users.insert().execute(user_id=1, user_name="foo")
+        result = users.select().execute()
+
+        row = result.first()
+        dict_row = row._asdict()
+
+        odict_row = collections.OrderedDict(
+            [("user_id", 1), ("user_name", "foo")]
+        )
+        eq_(dict_row, odict_row)
+        mapping_row = row._mapping
+
+        eq_(list(mapping_row), list(mapping_row.keys()))
+        eq_(odict_row.keys(), list(mapping_row.keys()))
+        eq_(odict_row.values(), list(mapping_row.values()))
+        eq_(odict_row.items(), list(mapping_row.items()))
 
     def test_keys(self):
         users = self.tables.users
@@ -979,7 +1027,8 @@ class ResultProxyTest(fixtures.TablesTest):
         result = users.select().execute()
         eq_(result.keys(), ["user_id", "user_name"])
         row = result.first()
-        eq_(row.keys(), ["user_id", "user_name"])
+        eq_(list(row._mapping.keys()), ["user_id", "user_name"])
+        eq_(row._fields, ("user_id", "user_name"))
 
     def test_keys_anon_labels(self):
         """test [ticket:3483]"""
@@ -999,7 +1048,8 @@ class ResultProxyTest(fixtures.TablesTest):
 
         eq_(result.keys(), ["user_id", "user_name_1", "count_1"])
         row = result.first()
-        eq_(row.keys(), ["user_id", "user_name_1", "count_1"])
+        eq_(row._fields, ("user_id", "user_name_1", "count_1"))
+        eq_(list(row._mapping.keys()), ["user_id", "user_name_1", "count_1"])
 
     def test_items(self):
         users = self.tables.users
@@ -1007,7 +1057,7 @@ class ResultProxyTest(fixtures.TablesTest):
         users.insert().execute(user_id=1, user_name="foo")
         r = users.select().execute().first()
         eq_(
-            [(x[0].lower(), x[1]) for x in list(r.items())],
+            [(x[0].lower(), x[1]) for x in list(r._mapping.items())],
             [("user_id", 1), ("user_name", "foo")],
         )
 
@@ -1046,8 +1096,8 @@ class ResultProxyTest(fixtures.TablesTest):
         r = users.select(users.c.user_id == 1).execute().first()
         eq_(r[0], 1)
         eq_(r[1], "foo")
-        eq_([x.lower() for x in list(r.keys())], ["user_id", "user_name"])
-        eq_(list(r.values()), [1, "foo"])
+        eq_([x.lower() for x in r._fields], ["user_id", "user_name"])
+        eq_(list(r._mapping.values()), [1, "foo"])
 
     def test_column_order_with_text_query(self):
         # should return values in query order
@@ -1057,8 +1107,8 @@ class ResultProxyTest(fixtures.TablesTest):
         r = testing.db.execute("select user_name, user_id from users").first()
         eq_(r[0], "foo")
         eq_(r[1], 1)
-        eq_([x.lower() for x in list(r.keys())], ["user_name", "user_id"])
-        eq_(list(r.values()), ["foo", 1])
+        eq_([x.lower() for x in r._fields], ["user_name", "user_id"])
+        eq_(list(r._mapping.values()), ["foo", 1])
 
     @testing.crashes("oracle", "FIXME: unknown, varify not fails_on()")
     @testing.crashes("firebird", "An identifier must begin with a letter")
@@ -1086,23 +1136,23 @@ class ResultProxyTest(fixtures.TablesTest):
         r = shadowed.select(shadowed.c.shadow_id == 1).execute().first()
 
         eq_(r.shadow_id, 1)
-        eq_(r["shadow_id"], 1)
-        eq_(r[shadowed.c.shadow_id], 1)
+        eq_(r._mapping["shadow_id"], 1)
+        eq_(r._mapping[shadowed.c.shadow_id], 1)
 
         eq_(r.shadow_name, "The Shadow")
-        eq_(r["shadow_name"], "The Shadow")
-        eq_(r[shadowed.c.shadow_name], "The Shadow")
+        eq_(r._mapping["shadow_name"], "The Shadow")
+        eq_(r._mapping[shadowed.c.shadow_name], "The Shadow")
 
         eq_(r.parent, "The Light")
-        eq_(r["parent"], "The Light")
-        eq_(r[shadowed.c.parent], "The Light")
+        eq_(r._mapping["parent"], "The Light")
+        eq_(r._mapping[shadowed.c.parent], "The Light")
 
         eq_(r.row, "Without light there is no shadow")
-        eq_(r["row"], "Without light there is no shadow")
-        eq_(r[shadowed.c.row], "Without light there is no shadow")
+        eq_(r._mapping["row"], "Without light there is no shadow")
+        eq_(r._mapping[shadowed.c.row], "Without light there is no shadow")
 
-        eq_(r["_parent"], "Hidden parent")
-        eq_(r["_row"], "Hidden row")
+        eq_(r._mapping["_parent"], "Hidden parent")
+        eq_(r._mapping["_row"], "Hidden row")
 
     def test_nontuple_row(self):
         """ensure the C version of BaseRow handles
@@ -1131,7 +1181,7 @@ class ResultProxyTest(fixtures.TablesTest):
         )
         eq_(list(proxy), ["value"])
         eq_(proxy[0], "value")
-        eq_(proxy["key"], "value")
+        eq_(proxy._mapping["key"], "value")
 
     @testing.provide_metadata
     def test_no_rowcount_on_selects_inserts(self):
@@ -1202,8 +1252,8 @@ class ResultProxyTest(fixtures.TablesTest):
 
         testing.db.execute(values.insert(), dict(key="One", value="Uno"))
         row = testing.db.execute(values.select()).first()
-        eq_(row["key"], "One")
-        eq_(row["value"], "Uno")
+        eq_(row._mapping["key"], "One")
+        eq_(row._mapping["value"], "Uno")
         eq_(row[0], "One")
         eq_(row[1], "Uno")
         eq_(row[-2], "One")
@@ -1213,8 +1263,8 @@ class ResultProxyTest(fixtures.TablesTest):
     @testing.only_on("sqlite")
     def test_row_getitem_indexes_raw(self):
         row = testing.db.execute("select 'One' as key, 'Uno' as value").first()
-        eq_(row["key"], "One")
-        eq_(row["value"], "Uno")
+        eq_(row._mapping["key"], "One")
+        eq_(row._mapping["value"], "Uno")
         eq_(row[0], "One")
         eq_(row[1], "Uno")
         eq_(row[-2], "One")
@@ -1366,12 +1416,12 @@ class KeyTargetingTest(fixtures.TablesTest):
         )
         row = testing.db.execute(stmt).first()
 
-        eq_(row[expression], "a1")
-        eq_(row[lt], 2)
+        eq_(row._mapping[expression], "a1")
+        eq_(row._mapping[lt], 2)
 
         # Postgresql for example has the key as "?column?", which dupes
         # easily.  we get around that because we know that "2" is unique
-        eq_(row["2"], 2)
+        eq_(row._mapping["2"], 2)
 
     def test_keyed_targeting_no_label_at_all_one(self):
         class not_named_max(expression.ColumnElement):
@@ -1411,8 +1461,8 @@ class KeyTargetingTest(fixtures.TablesTest):
         stmt = select([t1, t2]).select_from(self.tables.keyed1)
         row = testing.db.execute(stmt).first()
 
-        eq_(row[t1], "a1")
-        eq_(row[t2], "a1")
+        eq_(row._mapping[t1], "a1")
+        eq_(row._mapping[t2], "a1")
 
     @testing.requires.duplicate_names_in_cursor_description
     def test_keyed_accessor_composite_conflict_2(self):
@@ -1424,7 +1474,7 @@ class KeyTargetingTest(fixtures.TablesTest):
         ).first()
 
         # column access is unambiguous
-        eq_(row[self.tables.keyed2.c.b], "b2")
+        eq_(row._mapping[self.tables.keyed2.c.b], "b2")
 
         # row.a is ambiguous
         assert_raises_message(
@@ -1459,10 +1509,10 @@ class KeyTargetingTest(fixtures.TablesTest):
         ).first()
 
         # column access is unambiguous
-        eq_(row[self.tables.keyed2.c.b], "b2")
+        eq_(row._mapping[self.tables.keyed2.c.b], "b2")
 
-        eq_(row["keyed2_b"], "b2")
-        eq_(row["keyed1_a"], "a1")
+        eq_(row._mapping["keyed2_b"], "b2")
+        eq_(row._mapping["keyed1_a"], "a1")
 
     def test_keyed_accessor_composite_names_precedent(self):
         keyed1 = self.tables.keyed1
@@ -1516,8 +1566,11 @@ class KeyTargetingTest(fixtures.TablesTest):
         eq_(row.keyed1_c, "c1")
         eq_(row.keyed2_a, "a2")
         eq_(row.keyed2_b, "b2")
+
         assert_raises(KeyError, lambda: row["keyed2_c"])
         assert_raises(KeyError, lambda: row["keyed2_q"])
+        assert_raises(KeyError, lambda: row._mapping["keyed2_c"])
+        assert_raises(KeyError, lambda: row._mapping["keyed2_q"])
 
     def test_keyed_accessor_column_is_repeated_multiple_times(self):
         # test new logic added as a result of the combination of #4892 and
@@ -1568,10 +1621,10 @@ class KeyTargetingTest(fixtures.TablesTest):
         row = result.first()
 
         # keyed access will ignore the dupe cols
-        eq_(row[keyed2.c.a], "a2")
-        eq_(row[keyed3.c.a], "a3")
+        eq_(row._mapping[keyed2.c.a], "a2")
+        eq_(row._mapping[keyed3.c.a], "a3")
         eq_(result._getter(keyed3.c.a)(row), "a3")
-        eq_(row[keyed3.c.d], "d3")
+        eq_(row._mapping[keyed3.c.d], "d3")
 
         # however we can get everything positionally
         eq_(row, ("a2", "a3", "a2", "a2", "a3", "a3", "d3", "d3"))
@@ -1591,8 +1644,8 @@ class KeyTargetingTest(fixtures.TablesTest):
         stmt = select([a, b]).select_from(table("keyed2"))
         row = testing.db.execute(stmt).first()
 
-        in_(a, row)
-        in_(b, row)
+        in_(a, row._mapping)
+        in_(b, row._mapping)
 
     def test_columnclause_schema_column_two(self):
         keyed2 = self.tables.keyed2
@@ -1600,17 +1653,16 @@ class KeyTargetingTest(fixtures.TablesTest):
         stmt = select([keyed2.c.a, keyed2.c.b])
         row = testing.db.execute(stmt).first()
 
-        in_(keyed2.c.a, row)
-        in_(keyed2.c.b, row)
+        in_(keyed2.c.a, row._mapping)
+        in_(keyed2.c.b, row._mapping)
 
     def test_columnclause_schema_column_three(self):
         # this is also addressed by [ticket:2932]
-
         stmt = text("select a, b from keyed2").columns(a=CHAR, b=CHAR)
         row = testing.db.execute(stmt).first()
 
-        in_(stmt.selected_columns.a, row)
-        in_(stmt.selected_columns.b, row)
+        in_(stmt.selected_columns.a, row._mapping)
+        in_(stmt.selected_columns.b, row._mapping)
 
     def test_columnclause_schema_column_four(self):
         # originally addressed by [ticket:2932], however liberalized
@@ -1622,10 +1674,11 @@ class KeyTargetingTest(fixtures.TablesTest):
         )
         row = testing.db.execute(stmt).first()
 
-        in_(a, row)
-        in_(b, row)
-        in_(stmt.selected_columns.keyed2_a, row)
-        in_(stmt.selected_columns.keyed2_b, row)
+        in_(a, row._mapping)
+        in_(b, row._mapping)
+
+        in_(stmt.selected_columns.keyed2_a, row._mapping)
+        in_(stmt.selected_columns.keyed2_b, row._mapping)
 
     def test_columnclause_schema_column_five(self):
         # this is also addressed by [ticket:2932]
@@ -1635,8 +1688,8 @@ class KeyTargetingTest(fixtures.TablesTest):
         )
         row = testing.db.execute(stmt).first()
 
-        in_(stmt.selected_columns.keyed2_a, row)
-        in_(stmt.selected_columns.keyed2_b, row)
+        in_(stmt.selected_columns.keyed2_a, row._mapping)
+        in_(stmt.selected_columns.keyed2_b, row._mapping)
 
 
 class PositionalTextTest(fixtures.TablesTest):
@@ -1668,13 +1721,14 @@ class PositionalTextTest(fixtures.TablesTest):
         result = testing.db.execute(stmt)
         row = result.first()
 
-        eq_(row[c2], "b1")
-        eq_(row[c4], "d1")
+        eq_(row._mapping[c2], "b1")
+        eq_(row._mapping[c4], "d1")
         eq_(row[1], "b1")
-        eq_(row["b"], "b1")
-        eq_(row.keys(), ["a", "b", "c", "d"])
-        eq_(row["r"], "c1")
-        eq_(row["d"], "d1")
+        eq_(row._mapping["b"], "b1")
+        eq_(list(row._mapping.keys()), ["a", "b", "c", "d"])
+        eq_(row._fields, ("a", "b", "c", "d"))
+        eq_(row._mapping["r"], "c1")
+        eq_(row._mapping["d"], "d1")
 
     def test_fewer_cols_than_sql_positional(self):
         c1, c2 = column("q"), column("p")
@@ -1684,8 +1738,8 @@ class PositionalTextTest(fixtures.TablesTest):
         result = testing.db.execute(stmt)
         row = result.first()
 
-        eq_(row[c1], "a1")
-        eq_(row["c"], "c1")
+        eq_(row._mapping[c1], "a1")
+        eq_(row._mapping["c"], "c1")
 
     def test_fewer_cols_than_sql_non_positional(self):
         c1, c2 = column("a"), column("p")
@@ -1696,15 +1750,17 @@ class PositionalTextTest(fixtures.TablesTest):
         row = result.first()
 
         # c1 name matches, locates
-        eq_(row[c1], "a1")
-        eq_(row["c"], "c1")
+        eq_(row._mapping[c1], "a1")
+        eq_(row._mapping["c"], "c1")
 
         # c2 name does not match, doesn't locate
         assert_raises_message(
-            exc.NoSuchColumnError, "in row for column 'p'", lambda: row[c2]
+            exc.NoSuchColumnError,
+            "in row for column 'p'",
+            lambda: row._mapping[c2],
         )
 
-    def test_more_cols_than_sql(self):
+    def test_more_cols_than_sql_positional(self):
         c1, c2, c3, c4 = column("q"), column("p"), column("r"), column("d")
         stmt = text("select a, b from text1").columns(c1, c2, c3, c4)
 
@@ -1715,10 +1771,56 @@ class PositionalTextTest(fixtures.TablesTest):
             result = testing.db.execute(stmt)
 
         row = result.first()
-        eq_(row[c2], "b1")
+        eq_(row._mapping[c2], "b1")
+
+        assert_raises_message(
+            exc.NoSuchColumnError,
+            "in row for column 'r'",
+            lambda: row._mapping[c3],
+        )
+
+    def test_more_cols_than_sql_nonpositional(self):
+        c1, c2, c3, c4 = column("b"), column("a"), column("r"), column("d")
+        stmt = TextualSelect(
+            text("select a, b from text1"), [c1, c2, c3, c4], positional=False
+        )
+
+        # no warning for non-positional
+        result = testing.db.execute(stmt)
+
+        row = result.first()
+        eq_(row._mapping[c1], "b1")
+        eq_(row._mapping[c2], "a1")
+
+        assert_raises_message(
+            exc.NoSuchColumnError,
+            "in row for column 'r'",
+            lambda: row._mapping[c3],
+        )
+
+    def test_more_cols_than_sql_nonpositional_labeled_cols(self):
+        text1 = self.tables.text1
+        c1, c2, c3, c4 = text1.c.b, text1.c.a, column("r"), column("d")
+
+        # the compiler will enable loose matching for this statement
+        # so that column._label is taken into account
+        stmt = TextualSelect(
+            text("select a, b AS text1_b from text1"),
+            [c1, c2, c3, c4],
+            positional=False,
+        )
+
+        # no warning for non-positional
+        result = testing.db.execute(stmt)
+
+        row = result.first()
+        eq_(row._mapping[c1], "b1")
+        eq_(row._mapping[c2], "a1")
 
         assert_raises_message(
-            exc.NoSuchColumnError, "in row for column 'r'", lambda: row[c3]
+            exc.NoSuchColumnError,
+            "in row for column 'r'",
+            lambda: row._mapping[c3],
         )
 
     def test_dupe_col_obj(self):
@@ -1745,17 +1847,17 @@ class PositionalTextTest(fixtures.TablesTest):
         result = testing.db.execute(stmt)
         row = result.first()
 
-        eq_(row[c1], "a1")
-        eq_(row[c2], "b1")
-        eq_(row[c3], "c1")
-        eq_(row[c4], "d1")
+        eq_(row._mapping[c1], "a1")
+        eq_(row._mapping[c2], "b1")
+        eq_(row._mapping[c3], "c1")
+        eq_(row._mapping[c4], "d1")
 
         # text1.c.b goes nowhere....because we hit key fallback
         # but the text1.c.b doesn't derive from text1.c.c
         assert_raises_message(
             exc.NoSuchColumnError,
             "Could not locate column in row for column 'text1.b'",
-            lambda: row[text1.c.b],
+            lambda: row._mapping[text1.c.b],
         )
 
     def test_anon_aliased_overlapping(self):
@@ -1770,10 +1872,10 @@ class PositionalTextTest(fixtures.TablesTest):
         result = testing.db.execute(stmt)
         row = result.first()
 
-        eq_(row[c1], "a1")
-        eq_(row[c2], "b1")
-        eq_(row[c3], "c1")
-        eq_(row[c4], "d1")
+        eq_(row._mapping[c1], "a1")
+        eq_(row._mapping[c2], "b1")
+        eq_(row._mapping[c3], "c1")
+        eq_(row._mapping[c4], "d1")
 
     def test_anon_aliased_name_conflict(self):
         text1 = self.tables.text1
@@ -1791,17 +1893,17 @@ class PositionalTextTest(fixtures.TablesTest):
         result = testing.db.execute(stmt)
         row = result.first()
 
-        eq_(row[c1], "a1")
-        eq_(row[c2], "b1")
-        eq_(row[c3], "c1")
-        eq_(row[c4], "d1")
+        eq_(row._mapping[c1], "a1")
+        eq_(row._mapping[c2], "b1")
+        eq_(row._mapping[c3], "c1")
+        eq_(row._mapping[c4], "d1")
 
         # fails, because we hit key fallback and find conflicts
         # in columns that are presnet
         assert_raises_message(
             exc.NoSuchColumnError,
             "Could not locate column in row for column 'text1.a'",
-            lambda: row[text1.c.a],
+            lambda: row._mapping[text1.c.a],
         )
 
 
@@ -1834,8 +1936,11 @@ class AlternateResultProxyTest(fixtures.TablesTest):
         self.table = self.tables.test
 
         class ExcCtx(default.DefaultExecutionContext):
+            def get_result_cursor_strategy(self, result):
+                return cls.create(result)
+
             def get_result_proxy(self):
-                return cls(self)
+                raise NotImplementedError()
 
         self.patcher = patch.object(
             self.engine.dialect, "execution_ctx_cls", ExcCtx
@@ -1847,7 +1952,7 @@ class AlternateResultProxyTest(fixtures.TablesTest):
         with self._proxy_fixture(cls):
             rows = []
             r = self.engine.execute(select([self.table]))
-            assert isinstance(r, cls)
+            assert isinstance(r.cursor_strategy, cls)
             for i in range(5):
                 rows.append(r.fetchone())
             eq_(rows, [(i, "t_%d" % i) for i in range(1, 6)])
@@ -1908,40 +2013,42 @@ class AlternateResultProxyTest(fixtures.TablesTest):
         )
 
     def test_basic_plain(self):
-        self._test_proxy(_result.ResultProxy)
+        self._test_proxy(_result.DefaultCursorFetchStrategy)
 
     def test_basic_buffered_row_result_proxy(self):
-        self._test_proxy(_result.BufferedRowResultProxy)
+        self._test_proxy(_result.BufferedRowCursorFetchStrategy)
 
     def test_basic_fully_buffered_result_proxy(self):
-        self._test_proxy(_result.FullyBufferedResultProxy)
+        self._test_proxy(_result.FullyBufferedCursorFetchStrategy)
 
     def test_basic_buffered_column_result_proxy(self):
-        self._test_proxy(_result.BufferedColumnResultProxy)
+        self._test_proxy(_result.DefaultCursorFetchStrategy)
 
     def test_resultprocessor_plain(self):
-        self._test_result_processor(_result.ResultProxy, False)
+        self._test_result_processor(_result.DefaultCursorFetchStrategy, False)
 
     def test_resultprocessor_plain_cached(self):
-        self._test_result_processor(_result.ResultProxy, True)
-
-    def test_resultprocessor_buffered_column(self):
-        self._test_result_processor(_result.BufferedColumnResultProxy, False)
-
-    def test_resultprocessor_buffered_column_cached(self):
-        self._test_result_processor(_result.BufferedColumnResultProxy, True)
+        self._test_result_processor(_result.DefaultCursorFetchStrategy, True)
 
     def test_resultprocessor_buffered_row(self):
-        self._test_result_processor(_result.BufferedRowResultProxy, False)
+        self._test_result_processor(
+            _result.BufferedRowCursorFetchStrategy, False
+        )
 
     def test_resultprocessor_buffered_row_cached(self):
-        self._test_result_processor(_result.BufferedRowResultProxy, True)
+        self._test_result_processor(
+            _result.BufferedRowCursorFetchStrategy, True
+        )
 
     def test_resultprocessor_fully_buffered(self):
-        self._test_result_processor(_result.FullyBufferedResultProxy, False)
+        self._test_result_processor(
+            _result.FullyBufferedCursorFetchStrategy, False
+        )
 
     def test_resultprocessor_fully_buffered_cached(self):
-        self._test_result_processor(_result.FullyBufferedResultProxy, True)
+        self._test_result_processor(
+            _result.FullyBufferedCursorFetchStrategy, True
+        )
 
     def _test_result_processor(self, cls, use_cache):
         class MyType(TypeDecorator):
@@ -1963,7 +2070,7 @@ class AlternateResultProxyTest(fixtures.TablesTest):
 
     @testing.fixture
     def row_growth_fixture(self):
-        with self._proxy_fixture(_result.BufferedRowResultProxy):
+        with self._proxy_fixture(_result.BufferedRowCursorFetchStrategy):
             with self.engine.connect() as conn:
                 conn.execute(
                     self.table.insert(),
@@ -2001,7 +2108,7 @@ class AlternateResultProxyTest(fixtures.TablesTest):
         max_size = max(checks.values())
         for idx, row in enumerate(result, 0):
             if idx in checks:
-                assertion[idx] = result._bufsize
-            le_(len(result._BufferedRowResultProxy__rowbuffer), max_size)
+                assertion[idx] = result.cursor_strategy._bufsize
+            le_(len(result.cursor_strategy._rowbuffer), max_size)
 
         eq_(checks, assertion)
diff --git a/test/sql/test_returning.py b/test/sql/test_returning.py
index b8a3cce7c..4cfb3f0d6 100644
--- a/test/sql/test_returning.py
+++ b/test/sql/test_returning.py
@@ -65,7 +65,7 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults):
             .execute({"persons": 1, "full": False})
         )
 
-        row = result.first()
+        row = result.first()._mapping
         assert row[table.c.id] == row["id"] == 1
         assert row[table.c.full] == row["full"]
         assert row["full"] is False
@@ -76,7 +76,7 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults):
             .returning(table.c.persons, table.c.full, table.c.goofy)
             .execute()
         )
-        row = result.first()
+        row = result.first()._mapping
         assert row[table.c.persons] == row["persons"] == 5
         assert row[table.c.full] == row["full"]
 
@@ -91,7 +91,7 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults):
             .returning(table.c.persons.label("lala"))
             .execute()
         )
-        row = result.first()
+        row = result.first()._mapping
         assert row["lala"] == 6
 
     @testing.fails_on(
@@ -181,7 +181,7 @@ class ReturningTest(fixtures.TestBase, AssertsExecutionResults):
             'insert into tables (id, persons, "full") '
             "values (5, 10, %s) returning persons" % literal_true
         )
-        eq_([dict(row) for row in result4], [{"persons": 10}])
+        eq_([dict(row._mapping) for row in result4], [{"persons": 10}])
 
     def test_delete_returning(self):
         table.insert().execute(
@@ -288,10 +288,10 @@ class KeyReturningTest(fixtures.TestBase, AssertsExecutionResults):
         result = (
             table.insert().returning(table.c.foo_id).execute(data="somedata")
         )
-        row = result.first()
+        row = result.first()._mapping
         assert row[table.c.foo_id] == row["id"] == 1
 
-        result = table.select().execute().first()
+        result = table.select().execute().first()._mapping
         assert row[table.c.foo_id] == row["id"] == 1
 
 
@@ -331,7 +331,10 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             t1.insert().values(upddef=1).return_defaults(t1.c.insdef)
         )
         eq_(
-            [result.returned_defaults[k] for k in (t1.c.id, t1.c.insdef)],
+            [
+                result.returned_defaults._mapping[k]
+                for k in (t1.c.id, t1.c.insdef)
+            ],
             [1, 0],
         )
 
@@ -341,7 +344,10 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             t1.insert(return_defaults=[t1.c.insdef]).values(upddef=1)
         )
         eq_(
-            [result.returned_defaults[k] for k in (t1.c.id, t1.c.insdef)],
+            [
+                result.returned_defaults._mapping[k]
+                for k in (t1.c.id, t1.c.insdef)
+            ],
             [1, 0],
         )
 
@@ -351,7 +357,9 @@ class ReturnDefaultsTest(fixtures.TablesTest):
         result = testing.db.execute(
             t1.update().values(data="d1").return_defaults(t1.c.upddef)
         )
-        eq_([result.returned_defaults[k] for k in (t1.c.upddef,)], [1])
+        eq_(
+            [result.returned_defaults._mapping[k] for k in (t1.c.upddef,)], [1]
+        )
 
     def test_arg_update_pk(self):
         t1 = self.tables.t1
@@ -359,7 +367,9 @@ class ReturnDefaultsTest(fixtures.TablesTest):
         result = testing.db.execute(
             t1.update(return_defaults=[t1.c.upddef]).values(data="d1")
         )
-        eq_([result.returned_defaults[k] for k in (t1.c.upddef,)], [1])
+        eq_(
+            [result.returned_defaults._mapping[k] for k in (t1.c.upddef,)], [1]
+        )
 
     def test_insert_non_default(self):
         """test that a column not marked at all as a
@@ -370,7 +380,10 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             t1.insert().values(upddef=1).return_defaults(t1.c.data)
         )
         eq_(
-            [result.returned_defaults[k] for k in (t1.c.id, t1.c.data)],
+            [
+                result.returned_defaults._mapping[k]
+                for k in (t1.c.id, t1.c.data)
+            ],
             [1, None],
         )
 
@@ -383,7 +396,10 @@ class ReturnDefaultsTest(fixtures.TablesTest):
         result = testing.db.execute(
             t1.update().values(upddef=2).return_defaults(t1.c.data)
         )
-        eq_([result.returned_defaults[k] for k in (t1.c.data,)], [None])
+        eq_(
+            [result.returned_defaults._mapping[k] for k in (t1.c.data,)],
+            [None],
+        )
 
     def test_insert_non_default_plus_default(self):
         t1 = self.tables.t1
@@ -393,7 +409,7 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             .return_defaults(t1.c.data, t1.c.insdef)
         )
         eq_(
-            dict(result.returned_defaults),
+            dict(result.returned_defaults._mapping),
             {"id": 1, "data": None, "insdef": 0},
         )
 
@@ -405,7 +421,10 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             .values(insdef=2)
             .return_defaults(t1.c.data, t1.c.upddef)
         )
-        eq_(dict(result.returned_defaults), {"data": None, "upddef": 1})
+        eq_(
+            dict(result.returned_defaults._mapping),
+            {"data": None, "upddef": 1},
+        )
 
     def test_insert_all(self):
         t1 = self.tables.t1
@@ -413,7 +432,7 @@ class ReturnDefaultsTest(fixtures.TablesTest):
             t1.insert().values(upddef=1).return_defaults()
         )
         eq_(
-            dict(result.returned_defaults),
+            dict(result.returned_defaults._mapping),
             {"id": 1, "data": None, "insdef": 0},
         )
 
@@ -423,7 +442,7 @@ class ReturnDefaultsTest(fixtures.TablesTest):
         result = testing.db.execute(
             t1.update().values(insdef=2).return_defaults()
         )
-        eq_(dict(result.returned_defaults), {"upddef": 1})
+        eq_(dict(result.returned_defaults._mapping), {"upddef": 1})
 
 
 class ImplicitReturningFlag(fixtures.TestBase):
diff --git a/test/sql/test_type_expressions.py b/test/sql/test_type_expressions.py
index 2d45231cd..8c3e8c5d4 100644
--- a/test/sql/test_type_expressions.py
+++ b/test/sql/test_type_expressions.py
@@ -364,14 +364,14 @@ class RoundTripTestBase(object):
             self.tables.test_table.insert(), {"x": "X1", "y": "Y1"}
         )
         row = testing.db.execute(select([self.tables.test_table])).first()
-        eq_(row[self.tables.test_table.c.y], "Y1")
+        eq_(row._mapping[self.tables.test_table.c.y], "Y1")
 
     def test_targeting_by_string(self):
         testing.db.execute(
             self.tables.test_table.insert(), {"x": "X1", "y": "Y1"}
         )
         row = testing.db.execute(select([self.tables.test_table])).first()
-        eq_(row["y"], "Y1")
+        eq_(row._mapping["y"], "Y1")
 
     def test_targeting_apply_labels(self):
         testing.db.execute(
@@ -380,7 +380,7 @@ class RoundTripTestBase(object):
         row = testing.db.execute(
             select([self.tables.test_table]).apply_labels()
         ).first()
-        eq_(row[self.tables.test_table.c.y], "Y1")
+        eq_(row._mapping[self.tables.test_table.c.y], "Y1")
 
     def test_targeting_individual_labels(self):
         testing.db.execute(
@@ -394,7 +394,7 @@ class RoundTripTestBase(object):
                 ]
             )
         ).first()
-        eq_(row[self.tables.test_table.c.y], "Y1")
+        eq_(row._mapping[self.tables.test_table.c.y], "Y1")
 
 
 class StringRoundTripTest(fixtures.TablesTest, RoundTripTestBase):
diff --git a/test/sql/test_types.py b/test/sql/test_types.py
index d40d0902f..356470dd3 100644
--- a/test/sql/test_types.py
+++ b/test/sql/test_types.py
@@ -1970,13 +1970,15 @@ class BinaryTest(fixtures.TestBase, AssertsExecutionResults):
             ),
         ):
             result = stmt.execute().fetchall()
-            eq_(stream1, result[0]["data"])
-            eq_(stream1[0:100], result[0]["data_slice"])
-            eq_(stream2, result[1]["data"])
-            eq_(testobj1, result[0]["pickled"])
-            eq_(testobj2, result[1]["pickled"])
-            eq_(testobj3.moredata, result[0]["mypickle"].moredata)
-            eq_(result[0]["mypickle"].stuff, "this is the right stuff")
+            eq_(stream1, result[0]._mapping["data"])
+            eq_(stream1[0:100], result[0]._mapping["data_slice"])
+            eq_(stream2, result[1]._mapping["data"])
+            eq_(testobj1, result[0]._mapping["pickled"])
+            eq_(testobj2, result[1]._mapping["pickled"])
+            eq_(testobj3.moredata, result[0]._mapping["mypickle"].moredata)
+            eq_(
+                result[0]._mapping["mypickle"].stuff, "this is the right stuff"
+            )
 
     @testing.requires.binary_comparisons
     def test_comparison(self):
@@ -2875,9 +2877,9 @@ class IntervalTest(fixtures.TestBase, AssertsExecutionResults):
                 non_native_interval=delta,
             )
             row = conn.execute(interval_table.select()).first()
-        eq_(row["native_interval"], small_delta)
-        eq_(row["native_interval_args"], delta)
-        eq_(row["non_native_interval"], delta)
+        eq_(row.native_interval, small_delta)
+        eq_(row.native_interval_args, delta)
+        eq_(row.non_native_interval, delta)
 
     def test_null(self):
         with testing.db.begin() as conn:
@@ -2888,9 +2890,9 @@ class IntervalTest(fixtures.TestBase, AssertsExecutionResults):
                 non_native_interval=None,
             )
             row = conn.execute(interval_table.select()).first()
-        eq_(row["native_interval"], None)
-        eq_(row["native_interval_args"], None)
-        eq_(row["non_native_interval"], None)
+        eq_(row.native_interval, None)
+        eq_(row.native_interval_args, None)
+        eq_(row.non_native_interval, None)
 
 
 class IntegerTest(fixtures.TestBase):
diff --git a/test/sql/test_unicode.py b/test/sql/test_unicode.py
index dd7cad6b2..195a699bb 100644
--- a/test/sql/test_unicode.py
+++ b/test/sql/test_unicode.py
@@ -128,18 +128,18 @@ class UnicodeSchemaTest(fixtures.TestBase):
         )
 
         row = t1.select().execute().first()
-        eq_(row[t1.c[u("méil")]], 1)
-        eq_(row[t1.c[ue("\u6e2c\u8a66")]], 5)
+        eq_(row._mapping[t1.c[u("méil")]], 1)
+        eq_(row._mapping[t1.c[ue("\u6e2c\u8a66")]], 5)
 
         row = t2.select().execute().first()
-        eq_(row[t2.c[u("a")]], 1)
-        eq_(row[t2.c[u("b")]], 1)
+        eq_(row._mapping[t2.c[u("a")]], 1)
+        eq_(row._mapping[t2.c[u("b")]], 1)
 
         row = t3.select().execute().first()
-        eq_(row[t3.c[ue("\u6e2c\u8a66_id")]], 1)
-        eq_(row[t3.c[ue("unitable1_\u6e2c\u8a66")]], 5)
-        eq_(row[t3.c[u("Unitéble2_b")]], 1)
-        eq_(row[t3.c[ue("\u6e2c\u8a66_self")]], 1)
+        eq_(row._mapping[t3.c[ue("\u6e2c\u8a66_id")]], 1)
+        eq_(row._mapping[t3.c[ue("unitable1_\u6e2c\u8a66")]], 5)
+        eq_(row._mapping[t3.c[u("Unitéble2_b")]], 1)
+        eq_(row._mapping[t3.c[ue("\u6e2c\u8a66_self")]], 1)
 
     def test_reflect(self):
         t1.insert().execute({u("méil"): 2, ue("\u6e2c\u8a66"): 7})