chore: remove dead decode_rows_continuation and stale references

Issue 066 changed decode_continuation() to call decode_body()
instead of decode_rows_continuation(), making the latter dead code.
The method implemented a wire format that does not match the C
dqlite server (which always includes column headers in every ROWS
frame). Keeping it available would invite future callers to use the
wrong format.

Delete decode_rows_continuation (~100 lines) and its 7 dedicated
test methods. Update 4 stale comments/docstrings that still
referenced the old method or the incorrect "no column header"
continuation format.

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

Author: antoineleclair

src/dqlitewire/messages/responses.py

@@ -226,25 +226,18 @@ class RowsResponse(Message):
     has_more: bool = False
 
     def __post_init__(self) -> None:
-        # Defensive copies (issue 042). Three sources of aliasing
+        # Defensive copies (issue 042). Two sources of aliasing
         # motivate this:
         #
-        # 1. ``decode_body`` / ``decode_rows_continuation`` store
-        #    ``column_types = types`` where ``types`` is also stored
-        #    as ``all_row_types[0]``, so without a copy
-        #    ``self.column_types is self.row_types[0]`` and mutating
-        #    one silently rewrites the other.
+        # 1. ``decode_body`` stores ``column_types = types`` where
+        #    ``types`` is also stored as ``all_row_types[0]``, so
+        #    without a copy ``self.column_types is self.row_types[0]``
+        #    and mutating one silently rewrites the other.
         #
-        # 2. ``MessageDecoder.decode_continuation`` and
-        #    ``decode_rows_continuation`` pass the caller's
-        #    ``column_names`` list by reference into every
-        #    continuation response; any mutation on one response
-        #    propagates to every sibling.
-        #
-        # 3. User code constructing ``RowsResponse`` directly with a
+        # 2. User code constructing ``RowsResponse`` directly with a
         #    list they intend to keep mutating elsewhere.
         #
-        # Copying here catches all three sites uniformly and survives
+        # Copying here catches both sites uniformly and survives
         # future construction sites. The cost is two list allocations
         # per response — negligible compared to the row payload.
         self.column_names = list(self.column_names)
@@ -396,105 +389,6 @@ def decode_body(
             f"(decoded {len(rows)} rows, consumed {offset} of {len(data)} bytes)"
         )
 
-    @classmethod
-    def decode_rows_continuation(
-        cls,
-        data: bytes,
-        column_names: list[str],
-        column_count: int,
-        max_rows: int = DEFAULT_MAX_ROWS,
-    ) -> "RowsResponse":
-        """Decode a continuation message (rows without column header prefix).
-
-        After receiving a RowsResponse with has_more=True (PART marker), the
-        server sends additional ROWS messages that contain only row data and a
-        trailing marker — no column_count or column_names prefix. Use this
-        method to decode those continuation messages, passing the column_names
-        and column_count from the initial response.
-        """
-        if column_count > _MAX_COLUMN_COUNT:
-            raise DecodeError(f"Column count {column_count} exceeds maximum {_MAX_COLUMN_COUNT}")
-        if len(column_names) != column_count:
-            raise DecodeError(
-                f"column_names length ({len(column_names)}) does not match "
-                f"column_count ({column_count})"
-            )
-        offset = 0
-        rows: list[list[Any]] = []
-        all_row_types: list[list[ValueType]] = []
-        column_types: list[ValueType] = []
-
-        if column_count == 0:
-            from dqlitewire.constants import ROW_DONE_BYTE, ROW_PART_BYTE, WORD_SIZE
-
-            if offset + WORD_SIZE > len(data):
-                raise DecodeError(
-                    "RowsResponse continuation exhausted without end marker (zero-column result)"
-                )
-            marker_byte = data[offset]
-            if marker_byte == ROW_DONE_BYTE:
-                has_more = False
-            elif marker_byte == ROW_PART_BYTE:
-                has_more = True
-            else:
-                raise DecodeError(
-                    f"Expected DONE or PART marker for zero-column result, got 0x{marker_byte:02x}"
-                )
-            return cls(
-                column_names=column_names,
-                column_types=[],
-                row_types=[],
-                rows=[],
-                has_more=has_more,
-            )
-
-        while offset < len(data):
-            prev_offset = offset
-
-            result, consumed = decode_row_header(data[offset:], column_count)
-            offset += consumed
-
-            if result is RowMarker.DONE:
-                return cls(
-                    column_names,
-                    column_types=column_types,
-                    row_types=all_row_types,
-                    rows=rows,
-                    has_more=False,
-                )
-            if result is RowMarker.PART:
-                return cls(
-                    column_names,
-                    column_types=column_types,
-                    row_types=all_row_types,
-                    rows=rows,
-                    has_more=True,
-                )
-
-            types = result
-            if not isinstance(types, list):
-                raise DecodeError(f"Expected column types list, got {type(types).__name__}")
-            all_row_types.append(types)
-            if not column_types:
-                column_types = types
-
-            values, consumed = decode_row_values(data[offset:], types)
-            rows.append(values)
-            offset += consumed
-
-            if len(rows) >= max_rows:
-                raise DecodeError(f"Row count {len(rows)} exceeds maximum {max_rows}")
-
-            if offset == prev_offset:
-                raise DecodeError(
-                    "No progress in row decoding (possible zero-column result with malformed data)"
-                )
-
-        raise DecodeError(
-            f"RowsResponse continuation exhausted without end marker "
-            f"(decoded {len(rows)} rows, consumed {offset} of {len(data)} bytes)"
-        )
-
 
 @dataclass
 class EmptyResponse(Message):

tests/test_codec_signal_safety.py

@@ -2,7 +2,7 @@
 
 ``MessageDecoder.decode()`` and ``decode_continuation()`` both consume
 bytes from the buffer via ``read_message()`` and then parse them via
-``decode_bytes`` / ``RowsResponse.decode_rows_continuation``. The
+``decode_bytes`` / ``RowsResponse.decode_body``. The
 parse step is wrapped in ``try/except Exception`` so that a
 ``DecodeError``/``ValueError``/``struct.error`` from the parser
 poisons the buffer before propagating.

tests/test_messages_responses.py

@@ -154,19 +154,12 @@ class TestRowsResponseAliasing:
     """Regression tests for issue 042.
 
     ``RowsResponse`` used to store caller-supplied ``column_names`` and
-    ``column_types`` lists by reference, creating two kinds of silent
-    aliasing:
-
-    1. ``column_types`` was stored as ``all_row_types[0]`` inside
-       ``decode_body`` / ``decode_rows_continuation`` via
-       ``if not column_types: column_types = types``. The returned
-       object then had ``r.column_types is r.row_types[0]``, so
-       mutating one list silently rewrote the other.
-    2. ``column_names`` was passed through ``decode_rows_continuation``
-       unchanged and attached directly to every continuation
-       ``RowsResponse``. Callers who mutated ``msg.column_names`` on
-       one continuation silently mutated every sibling continuation
-       AND the original response.
+    ``column_types`` lists by reference, creating silent aliasing:
+
+    ``column_types`` was stored as ``all_row_types[0]`` inside
+    ``decode_body`` via ``if not column_types: column_types = types``.
+    The returned object then had ``r.column_types is r.row_types[0]``,
+    so mutating one list silently rewrote the other.
 
     The fix copies both lists on construction via ``__post_init__``.
     """
@@ -461,60 +454,6 @@ def test_zero_columns_missing_marker_raises(self) -> None:
         with pytest.raises(DecodeError, match="end marker"):
             RowsResponse.decode_body(data)
 
-    def test_zero_columns_continuation_missing_marker_raises(self) -> None:
-        """Zero-column continuation with no end marker should raise DecodeError."""
-        import pytest
-
-        from dqlitewire.exceptions import DecodeError
-
-        # Empty data for a zero-column continuation
-        with pytest.raises(DecodeError, match="end marker"):
-            RowsResponse.decode_rows_continuation(
-                data=b"",
-                column_names=[],
-                column_count=0,
-            )
-
-    def test_decode_rows_continuation(self) -> None:
-        """Continuation messages (after PART marker) have rows but no column header."""
-        from dqlitewire.tuples import encode_row_header, encode_row_values
-        from dqlitewire.types import encode_uint64
-
-        column_names = ["id", "name"]
-        types = [ValueType.INTEGER, ValueType.TEXT]
-        # Build a continuation body: rows + DONE marker (no column_count/names prefix)
-        body = b""
-        body += encode_row_header(types)
-        body += encode_row_values([3, "Charlie"], types)
-        body += encode_row_header(types)
-        body += encode_row_values([4, "Diana"], types)
-        body += encode_uint64(0xFFFFFFFFFFFFFFFF)  # DONE marker
-
-        decoded = RowsResponse.decode_rows_continuation(body, column_names, len(column_names))
-        assert decoded.column_names == ["id", "name"]
-        assert len(decoded.rows) == 2
-        assert decoded.rows[0] == [3, "Charlie"]
-        assert decoded.rows[1] == [4, "Diana"]
-        assert decoded.has_more is False
-
-    def test_decode_rows_continuation_truncated_raises(self) -> None:
-        """Truncated continuation (no marker) must raise DecodeError, not silently return."""
-        import pytest
-
-        from dqlitewire.exceptions import DecodeError
-        from dqlitewire.tuples import encode_row_header, encode_row_values
-
-        column_names = ["id", "name"]
-        types = [ValueType.INTEGER, ValueType.TEXT]
-        # Build continuation body with row data but NO end marker
-        body = b""
-        body += encode_row_header(types)
-        body += encode_row_values([3, "Charlie"], types)
-        # No DONE or PART marker at end!
-
-        with pytest.raises(DecodeError, match="end marker"):
-            RowsResponse.decode_rows_continuation(body, column_names, len(column_names))
-
     def test_decode_body_rejects_non_list_row_header(self) -> None:
         """decode_body must raise DecodeError if decode_row_header returns unexpected type."""
         from unittest.mock import patch
@@ -539,27 +478,6 @@ def test_decode_body_rejects_non_list_row_header(self) -> None:
         ):
             RowsResponse.decode_body(body)
 
-    def test_decode_rows_continuation_rejects_non_list_row_header(self) -> None:
-        """Same guard as decode_body but for the continuation path."""
-        from unittest.mock import patch
-
-        import pytest
-
-        from dqlitewire.exceptions import DecodeError
-        from dqlitewire.tuples import encode_row_header, encode_row_values
-        from dqlitewire.types import encode_uint64
-
-        # Build valid continuation body (rows only, no column header)
-        body = encode_row_header([ValueType.INTEGER])
-        body += encode_row_values([42], [ValueType.INTEGER])
-        body += encode_uint64(0xFFFFFFFFFFFFFFFF)  # DONE
-
-        with (
-            patch("dqlitewire.messages.responses.decode_row_header", return_value=("bad", 8)),
-            pytest.raises(DecodeError, match="Expected column types list"),
-        ):
-            RowsResponse.decode_rows_continuation(body, column_names=["id"], column_count=1)
-
     def test_truncated_body_without_marker_raises(self) -> None:
         """Body exhausted without DONE/PART marker must raise DecodeError."""
         import pytest
@@ -626,29 +544,6 @@ def test_max_rows_limit_decode_body(self) -> None:
         with pytest.raises(DecodeError, match="Row count.*exceeds maximum"):
             RowsResponse.decode_body(body, max_rows=3)
 
-    def test_max_rows_limit_decode_rows_continuation(self) -> None:
-        """decode_rows_continuation should reject messages exceeding the max_rows limit."""
-        import pytest
-
-        from dqlitewire.exceptions import DecodeError
-        from dqlitewire.tuples import encode_row_header, encode_row_values
-        from dqlitewire.types import encode_uint64
-
-        types = [ValueType.INTEGER]
-        body = b""
-        for i in range(5):
-            body += encode_row_header(types)
-            body += encode_row_values([i], types)
-        body += encode_uint64(0xFFFFFFFFFFFFFFFF)  # DONE
-
-        # Should succeed with default limit
-        decoded = RowsResponse.decode_rows_continuation(body, ["x"], 1)
-        assert len(decoded.rows) == 5
-
-        # Should fail with max_rows=2
-        with pytest.raises(DecodeError, match="Row count.*exceeds maximum"):
-            RowsResponse.decode_rows_continuation(body, ["x"], 1, max_rows=2)
-
     def test_max_rows_exact_boundary_rejects_at_limit(self) -> None:
         """max_rows=3 with exactly 3 rows should raise DecodeError.
 
@@ -680,42 +575,6 @@ def build_body(n_rows: int) -> bytes:
         decoded = RowsResponse.decode_body(build_body(2), max_rows=3)
         assert len(decoded.rows) == 2
 
-    def test_continuation_column_count_mismatch_raises(self) -> None:
-        """decode_rows_continuation should reject mismatched column_names/column_count."""
-        import pytest
-
-        from dqlitewire.exceptions import DecodeError
-        from dqlitewire.tuples import encode_row_header, encode_row_values
-        from dqlitewire.types import encode_uint64
-
-        types = [ValueType.INTEGER, ValueType.TEXT]
-        body = encode_row_header(types)
-        body += encode_row_values([1, "hello"], types)
-        body += encode_uint64(0xFFFFFFFFFFFFFFFF)  # DONE
-
-        # column_names has 3 elements but column_count is 2 — mismatch
-        with pytest.raises(DecodeError, match="column_names.*does not match.*column_count"):
-            RowsResponse.decode_rows_continuation(
-                body,
-                column_names=["a", "b", "c"],
-                column_count=2,
-            )
-
-    def test_decode_rows_continuation_rejects_excessive_column_count(self) -> None:
-        """decode_rows_continuation should reject column_count exceeding _MAX_COLUMN_COUNT."""
-        import pytest
-
-        from dqlitewire.exceptions import DecodeError
-
-        body = b"\xff" * 8  # DONE marker
-        excessive = 20_000
-        with pytest.raises(DecodeError, match="exceeds maximum"):
-            RowsResponse.decode_rows_continuation(
-                body,
-                column_names=["c"] * excessive,
-                column_count=excessive,
-            )
-
 
 class TestRowsResponseValueTypes:
     """Full RowsResponse round-trips with BOOLEAN, UNIXTIME, ISO8601, and BLOB."""