- A new implementation for :class:`.KeyedTuple` used by the

:class:`.Query` object offers dramatic speed improvements when
fetching large numbers of column-oriented rows.
fixes #3176

1 files changed, 39 insertions, 25 deletions

diff --git a/test/base/test_utils.py b/test/base/test_utils.py
index 4a53aa54f..a378b0160 100644
--- a/test/base/test_utils.py
+++ b/test/base/test_utils.py
@@ -7,26 +7,26 @@ from sqlalchemy.testing.util import picklers, gc_collect
 from sqlalchemy.util import classproperty, WeakSequence, get_callable_argspec
 from sqlalchemy.sql import column
 
-class KeyedTupleTest():
+
+class _KeyedTupleTest(object):
+
+    def _fixture(self, values, labels):
+        raise NotImplementedError()
 
     def test_empty(self):
-        keyed_tuple = util.KeyedTuple([])
-        eq_(type(keyed_tuple), util.KeyedTuple)
+        keyed_tuple = self._fixture([], [])
         eq_(str(keyed_tuple), '()')
         eq_(len(keyed_tuple), 0)
 
-        eq_(keyed_tuple.__dict__, {'_labels': []})
         eq_(list(keyed_tuple.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
     def test_values_but_no_labels(self):
-        keyed_tuple = util.KeyedTuple([1, 2])
-        eq_(type(keyed_tuple), util.KeyedTuple)
+        keyed_tuple = self._fixture([1, 2], [])
         eq_(str(keyed_tuple), '(1, 2)')
         eq_(len(keyed_tuple), 2)
 
-        eq_(keyed_tuple.__dict__, {'_labels': []})
         eq_(list(keyed_tuple.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
@@ -35,14 +35,14 @@ class KeyedTupleTest():
         eq_(keyed_tuple[1], 2)
 
     def test_basic_creation(self):
-        keyed_tuple = util.KeyedTuple([1, 2], ['a', 'b'])
+        keyed_tuple = self._fixture([1, 2], ['a', 'b'])
         eq_(str(keyed_tuple), '(1, 2)')
         eq_(list(keyed_tuple.keys()), ['a', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 2})
 
     def test_basic_index_access(self):
-        keyed_tuple = util.KeyedTuple([1, 2], ['a', 'b'])
+        keyed_tuple = self._fixture([1, 2], ['a', 'b'])
         eq_(keyed_tuple[0], 1)
         eq_(keyed_tuple[1], 2)
 
@@ -51,7 +51,7 @@ class KeyedTupleTest():
         assert_raises(IndexError, should_raise)
 
     def test_basic_attribute_access(self):
-        keyed_tuple = util.KeyedTuple([1, 2], ['a', 'b'])
+        keyed_tuple = self._fixture([1, 2], ['a', 'b'])
         eq_(keyed_tuple.a, 1)
         eq_(keyed_tuple.b, 2)
 
@@ -60,12 +60,9 @@ class KeyedTupleTest():
         assert_raises(AttributeError, should_raise)
 
     def test_none_label(self):
-        keyed_tuple = util.KeyedTuple([1, 2, 3], ['a', None, 'b'])
+        keyed_tuple = self._fixture([1, 2, 3], ['a', None, 'b'])
         eq_(str(keyed_tuple), '(1, 2, 3)')
 
-        # TODO: consider not allowing None labels
-        expected = {'a': 1, None: 2, 'b': 3, '_labels': ['a', None, 'b']}
-        eq_(keyed_tuple.__dict__, expected)
         eq_(list(keyed_tuple.keys()), ['a', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 3})
@@ -80,12 +77,9 @@ class KeyedTupleTest():
         eq_(keyed_tuple[2], 3)
 
     def test_duplicate_labels(self):
-        keyed_tuple = util.KeyedTuple([1, 2, 3], ['a', 'b', 'b'])
+        keyed_tuple = self._fixture([1, 2, 3], ['a', 'b', 'b'])
         eq_(str(keyed_tuple), '(1, 2, 3)')
 
-        # TODO: consider not allowing duplicate labels
-        expected = {'a': 1, 'b': 3, '_labels': ['a', 'b', 'b']}
-        eq_(keyed_tuple.__dict__, expected)
         eq_(list(keyed_tuple.keys()), ['a', 'b', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 3})
@@ -100,21 +94,41 @@ class KeyedTupleTest():
         eq_(keyed_tuple[2], 3)
 
     def test_immutable(self):
-        keyed_tuple = util.KeyedTuple([1, 2], ['a', 'b'])
+        keyed_tuple = self._fixture([1, 2], ['a', 'b'])
         eq_(str(keyed_tuple), '(1, 2)')
 
-        # attribute access: mutable
         eq_(keyed_tuple.a, 1)
-        keyed_tuple.a = 100
-        eq_(keyed_tuple.a, 100)
-        keyed_tuple.c = 300
-        eq_(keyed_tuple.c, 300)
 
-        # index access: immutable
+        assert_raises(AttributeError, setattr, keyed_tuple, "a", 5)
+
         def should_raise():
             keyed_tuple[0] = 100
         assert_raises(TypeError, should_raise)
 
+    def test_serialize(self):
+
+        keyed_tuple = self._fixture([1, 2, 3], ['a', None, 'b'])
+
+        for loads, dumps in picklers():
+            kt = loads(dumps(keyed_tuple))
+
+            eq_(str(kt), '(1, 2, 3)')
+
+            eq_(list(kt.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)
+
+
 class WeakSequenceTest(fixtures.TestBase):
     @testing.requires.predictable_gc
     def test_cleanout_elements(self):