Make Row a sequence like sqlite3.Row instead of a mapping

dqlitedbapi.Row subclassed collections.abc.Mapping, so iterating it
(tuple(row), list(row), for v in row, a, b = row) yielded column NAMES.
stdlib sqlite3.Row — the documented 1:1 porting target — is a sequence
whose iteration yields VALUES, so ported code silently got names instead
of data with no error. (The mapping __contains__ was also buggy, leaking
IndexError/TypeError for out-of-range/bool keys.)

Drop the Mapping base and yield values from __iter__, matching stdlib;
add slice indexing (row[0:2]); keep keys(), int/str indexing, len, eq,
hash, repr. dict(row) and **row still work because CPython consumes
keys() + __getitem__, not __iter__. This restores the row factory's
originally specified sequence shape. Add a side-by-side parity test
against a real sqlite3.Row covering iteration, slicing, membership, and
name/dict access.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqlitedbapi/row.py

@@ -6,8 +6,7 @@
 at the first fetch with ``DataError("row_factory call failed:
 argument 1 must be sqlite3.Cursor, not Cursor")``. ``dqlitedbapi.Row``
 is the same surface (positional + column-name indexing, ``.keys()``,
-``dict(row)`` conversion, full ``Mapping`` protocol) without the
-cursor-type constraint.
+``dict(row)`` conversion) without the cursor-type constraint.
 
 Use the same idiom on dqlite as on stdlib::
 
@@ -16,23 +15,27 @@
     row = cur.fetchone()
     assert row["x"] == 1
     assert row[0] == 1
+    assert tuple(row) == (1, 2)
     assert list(row.keys()) == ["x", "y"]
     assert dict(row) == {"x": 1, "y": 2}
 """
 
 from __future__ import annotations
 
-from collections.abc import Iterator, Mapping
+from collections.abc import Iterator
 from typing import Any, final
 
 
 @final
-class Row(Mapping[str, Any]):
+class Row:
     """Stdlib ``sqlite3.Row``-equivalent row factory.
 
-    Wraps a result tuple with column-name and positional access.
-    Implements the full ``collections.abc.Mapping`` protocol so
-    ``dict(row)``, ``**row``-spread, and ``row.items()`` all work.
+    Wraps a result tuple with column-name and positional access. Like
+    stdlib ``sqlite3.Row`` it is a SEQUENCE, not a mapping: iteration
+    (``tuple(row)`` / ``list(row)`` / ``for v in row`` / ``a, b = row``)
+    yields VALUES, and ``row[i]`` / ``row[i:j]`` index positionally.
+    ``row["name"]`` and ``.keys()`` provide column-name access, and
+    ``dict(row)`` / ``**row`` work via ``keys()`` + ``__getitem__``.
 
     Unlike stdlib ``sqlite3.Row``, this class accepts any cursor
     object that exposes a ``description`` attribute (the canonical
@@ -58,6 +61,10 @@ def __init__(self, cursor: object, row: tuple[Any, ...]) -> None:
         self._values: tuple[Any, ...] = tuple(row)
 
     def __getitem__(self, key: object) -> Any:
+        # Slice indexing returns a tuple of values, matching stdlib
+        # ``sqlite3.Row`` (``row[0:2]`` -> ``(v0, v1)``).
+        if isinstance(key, slice):
+            return self._values[key]
         # ``bool`` is an ``int`` subclass: without the explicit
         # exclusion ``row[True]`` would silently return column 1 and
         # ``row[False]`` column 0. A ``bool`` index is almost always a
@@ -75,11 +82,12 @@ def __getitem__(self, key: object) -> Any:
             return self._values[idx]
         raise TypeError(f"Row indices must be int or str, not {type(key).__name__}")
 
-    def __iter__(self) -> Iterator[str]:
-        # ``Mapping.__iter__`` yields keys; ``dict(row)`` consumes
-        # this. Matches stdlib ``sqlite3.Row.keys()`` behaviour but
-        # via the canonical Mapping protocol.
-        return iter(self._columns)
+    def __iter__(self) -> Iterator[Any]:
+        # Sequence iteration yields VALUES, matching stdlib
+        # ``sqlite3.Row`` (``tuple(row)`` / ``list(row)`` / ``a, b =
+        # row``). ``dict(row)`` and ``**row`` do NOT use this — CPython
+        # consumes ``keys()`` + ``__getitem__`` when ``keys()`` exists.
+        return iter(self._values)
 
     def __len__(self) -> int:
         return len(self._values)
@@ -92,9 +100,10 @@ def __eq__(self, other: object) -> bool:
     def __hash__(self) -> int:
         return hash((self._columns, self._values))
 
-    def keys(self) -> tuple[str, ...]:  # type: ignore[override]
+    def keys(self) -> tuple[str, ...]:
         """Return the column names tuple — matches stdlib
-        ``sqlite3.Row.keys()`` shape (list-like).
+        ``sqlite3.Row.keys()`` shape (list-like). Used by ``dict(row)``
+        and ``**row`` for name-keyed access.
         """
         return self._columns
 

tests/test_row_factory_sqlite3_equivalent.py

@@ -1,8 +1,9 @@
 """Pin: ``dqlitedbapi.Row`` is the cross-driver-portable equivalent
-of stdlib ``sqlite3.Row`` — positional + column-name access,
-``Mapping`` protocol, ``dict(row)`` / ``**row`` spread, without
-the cursor-type constraint that makes stdlib's class unusable
-on this driver.
+of stdlib ``sqlite3.Row`` — a SEQUENCE (value iteration, positional +
+slice indexing) plus column-name access via ``row["name"]`` /
+``.keys()`` and ``dict(row)`` / ``**row`` spread, without the
+cursor-type constraint that makes stdlib's class unusable on this
+driver.
 
 Cross-driver porting: swap ``sqlite3.Row`` for ``dqlitedbapi.Row``
 1:1; every documented stdlib idiom holds.
@@ -71,8 +72,8 @@ def test_row_equality() -> None:
 
 
 def test_row_double_spread_into_kwargs() -> None:
-    """The ``**row`` spread requires the Mapping protocol to work
-    on string keys.
+    """The ``**row`` spread works on string keys via ``keys()`` +
+    ``__getitem__`` (CPython consumes those, not ``__iter__``).
     """
     cur = _cursor_with_description("a", "b")
     row = Row(cur, (10, 20))
@@ -135,3 +136,42 @@ def test_row_repr() -> None:
     row = Row(cur, (1, 2))
     assert "x=1" in repr(row)
     assert "y=2" in repr(row)
+
+
+def test_row_sqlite3_sequence_parity() -> None:
+    """``dqlitedbapi.Row`` matches stdlib ``sqlite3.Row``'s SEQUENCE
+    semantics exactly: iteration / tuple / list / unpacking yield
+    VALUES (not column names), positional + slice indexing work, and
+    ``in`` checks values — while name access, ``dict(row)``, ``**row``
+    and ``keys()`` still behave identically. Pins the regression where
+    Row subclassed ``Mapping`` and silently iterated column names.
+    """
+    import sqlite3
+
+    cur = _cursor_with_description("x", "y")
+    row = Row(cur, (1, 2))
+
+    con = sqlite3.connect(":memory:")
+    con.row_factory = sqlite3.Row
+    std = con.execute("SELECT 1 AS x, 2 AS y").fetchone()
+    con.close()
+
+    # Sequence iteration yields values (the corrupted idioms).
+    assert tuple(row) == tuple(std) == (1, 2)
+    assert list(row) == list(std) == [1, 2]
+    assert [v for v in row] == [1, 2]
+    a, b = row
+    assert (a, b) == (1, 2)
+    # Positional + slice indexing.
+    assert row[0] == std[0] == 1
+    assert row[1] == std[1] == 2
+    assert row[0:2] == std[0:2] == (1, 2)
+    # Membership checks values, matching stdlib (not column names).
+    assert (2 in row) is (2 in std) is True
+    assert ("x" in row) is ("x" in std) is False
+    # Name-keyed access and mapping conversions remain identical.
+    assert row["x"] == std["x"] == 1
+    assert tuple(row.keys()) == tuple(std.keys()) == ("x", "y")
+    assert dict(row) == dict(std) == {"x": 1, "y": 2}
+    assert {**row} == {"x": 1, "y": 2}
+    assert len(row) == len(std) == 2

tests/test_row_hash_eq_empty.py

@@ -1,6 +1,6 @@
-"""Pin: ``dqlitedbapi.Row`` Mapping-protocol surface that prior tests
-did not cover — hashability, ``__eq__`` vs a non-``Row``, and
-construction from a cursor with ``description=None``.
+"""Pin: ``dqlitedbapi.Row`` surface that prior tests did not cover —
+hashability, ``__eq__`` vs a non-``Row``, and construction from a
+cursor with ``description=None``.
 
 ``Row`` is a ``@final`` documented stdlib-``sqlite3.Row`` replacement.
 Existing tests cover positional/name indexing, ``dict(row)``,