Allow empty Record objects.

Author: 1st1

asyncpg/protocol/prepared_stmt.pyx

@@ -141,7 +141,11 @@ cdef class PreparedStatementState:
             Codec codec
             list codecs
 
-        if self.cols_num == 0 or self.cols_desc is not None:
+        if self.cols_desc is not None:
+            return
+
+        if self.cols_num == 0:
+            self.cols_desc = record.ApgRecordDesc_New({}, ())
             return
 
         cols_mapping = collections.OrderedDict()
@@ -219,7 +223,9 @@ cdef class PreparedStatementState:
                     fnum, self.cols_num))
 
         if rows_codecs is None or len(rows_codecs) < fnum:
-            raise RuntimeError('invalid rows_codecs')
+            if fnum > 0:
+                # It's OK to have no rows_codecs for empty records
+                raise RuntimeError('invalid rows_codecs')
 
         dec_row = record.ApgRecord_New(self.cols_desc, fnum)
         for i in range(fnum):

asyncpg/protocol/protocol.pyx

@@ -479,7 +479,12 @@ def _create_record(object mapping, tuple elems):
         object rec
         int32_t i
 
-    desc = record.ApgRecordDesc_New(mapping, tuple(mapping) if mapping else ())
+    if mapping is None:
+        desc = record.ApgRecordDesc_New({}, ())
+    else:
+        desc = record.ApgRecordDesc_New(
+            mapping, tuple(mapping) if mapping else ())
+
     rec = record.ApgRecord_New(desc, len(elems))
     for i in range(len(elems)):
         elem = elems[i]

asyncpg/protocol/record/recordobj.c

@@ -22,7 +22,7 @@ ApgRecord_New(PyObject *desc, Py_ssize_t size)
     ApgRecordObject *o;
     Py_ssize_t i;
 
-    if (size < 1 || desc == NULL || !ApgRecordDesc_CheckExact(desc)) {
+    if (size < 0 || desc == NULL || !ApgRecordDesc_CheckExact(desc)) {
         PyErr_BadInternalCall();
         return NULL;
     }
@@ -346,7 +346,9 @@ record_repr(ApgRecordObject *v)
     _PyUnicodeWriter writer;
 
     n = Py_SIZE(v);
-    assert(n > 0);
+    if (n == 0) {
+        return PyUnicode_FromString("<Record>");
+    }
 
     keys_iter = PyObject_GetIter(v->desc->keys);
     if (keys_iter == NULL) {

tests/test_prepare.py

@@ -395,3 +395,8 @@ async def test_prepare_21_errors(self):
             await stmt.fetchval(0)
 
         self.assertEqual(await stmt.fetchval(5), 2)
+
+    async def test_prepare_22_empty(self):
+        result = await self.con.fetchrow('SELECT')
+        self.assertEqual(result, ())
+        self.assertEqual(repr(result), '<Record>')

tests/test_record.py

@@ -10,7 +10,6 @@
 import gc
 import pickle
 import sys
-import unittest
 
 from asyncpg import _testbase as tb
 from asyncpg.protocol.protocol import _create_record as Record
@@ -37,10 +36,6 @@ def checkref(self, *objs):
                 self.fail('refcounts differ for {!r}: {:+}'.format(
                     objs[i], after - before))
 
-    def test_record_zero_length(self):
-        with self.assertRaises(SystemError):
-            Record({}, ())
-
     def test_record_gc(self):
         elem = object()
         mapping = {}
@@ -153,10 +148,7 @@ def test_record_keys(self):
         r = Record(R_AB, (42, 43))
         vv = r.keys()
         self.assertEqual(tuple(vv), ('a', 'b'))
-
-        # test invalid record
-        with self.assertRaisesRegex(TypeError, 'not iterable'):
-            Record(None, (42, 43)).keys()
+        self.assertEqual(list(Record(None, (42, 43)).keys()), [])
 
     def test_record_items(self):
         r = Record(R_AB, (42, 43))
@@ -188,9 +180,12 @@ def test_record_items(self):
         self.assertEqual(list(r.items()), [('a', 42)])
         r = Record(R_AB, (42,))
         self.assertEqual(list(r.items()), [('a', 42)])
-        r = Record(None, (42, 43))
-        with self.assertRaises(TypeError):
-            list(r.items())
+
+        # Try to iterate over exhausted items() iterator
+        r = Record(R_A, (42, 43))
+        it = r.items()
+        list(it)
+        list(it)
 
     def test_record_hash(self):
         AB = collections.namedtuple('AB', ('a', 'b'))
@@ -220,8 +215,7 @@ def test_record_contains(self):
         self.assertNotIn('z', r)
 
         r = Record(None, (42, 43))
-        with self.assertRaises(TypeError):
-            self.assertIn('a', r)
+        self.assertNotIn('a', r)
 
         with self.assertRaises(TypeError):
             type(r).__contains__(None, 'a')
@@ -281,6 +275,21 @@ def test_record_not_pickleable(self):
         with self.assertRaises(Exception):
             pickle.dumps(r)
 
+    def test_record_empty(self):
+        r = Record(None, ())
+        self.assertEqual(r, ())
+        self.assertLess(r, (1,))
+        self.assertEqual(len(r), 0)
+        self.assertFalse(r)
+        self.assertNotIn('a', r)
+        self.assertEqual(repr(r), '<Record>')
+        self.assertEqual(str(r), '<Record>')
+        with self.assertRaisesRegex(KeyError, 'aaa'):
+            r['aaa']
+        self.assertEqual(dict(r.items()), {})
+        self.assertEqual(list(r.keys()), [])
+        self.assertEqual(list(r.values()), [])
+
     async def test_record_duplicate_colnames(self):
         """Test that Record handles duplicate column names."""
         r = await self.con.fetchrow('SELECT 1 as a, 2 as a')