Require row_types length to match rows length at encode time

RowsResponse.encode_body previously accepted a ``row_types`` list
shorter than ``rows`` and silently fell through to per-row inference
for the trailing entries. That contradicts the documented invariant
that ``row_types`` is either empty (infer all) or exactly one-to-one
with ``rows``. Raise ``EncodeError`` instead so a partial list
surfaces loudly at encode time.

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

Author: antoineleclair

src/dqlitewire/messages/responses.py

@@ -300,6 +300,16 @@ def encode_body(self) -> bytes:
                 f"column_types length ({len(self.column_types)}) != "
                 f"column_names length ({col_count})"
             )
+        # ``row_types`` must either be empty (infer per-row from values /
+        # column_types) or exactly match ``rows`` one-to-one. A shorter
+        # list previously fell through to inference silently for the
+        # trailing rows, contradicting the documented invariant.
+        if self.row_types and len(self.row_types) != len(self.rows):
+            raise EncodeError(
+                f"row_types length ({len(self.row_types)}) != "
+                f"rows length ({len(self.rows)}); pass an empty row_types "
+                f"to infer per-row types from the values"
+            )
         # Zero-column rows produce zero bytes per row, so the encoded
         # output is indistinguishable from a zero-row result set — the
         # decoder's zero-column fast path returns no rows. Reject at

tests/test_messages_responses.py

@@ -676,6 +676,33 @@ def test_mismatched_row_types_length(self) -> None:
         with pytest.raises(EncodeError, match="row_types\\[0\\] has 1 types, expected 2"):
             resp.encode_body()
 
+    def test_partial_row_types_rejected(self) -> None:
+        """row_types must be empty or exactly match rows one-to-one."""
+        resp = RowsResponse(
+            column_names=["a"],
+            column_types=[ValueType.INTEGER],
+            row_types=[[ValueType.INTEGER]],  # only one entry, 3 rows
+            rows=[[1], [2], [3]],
+        )
+        with pytest.raises(EncodeError, match="row_types length .* != rows length"):
+            resp.encode_body()
+
+    def test_empty_row_types_with_rows_infers_ok(self) -> None:
+        """Empty row_types is valid — types are inferred per-row."""
+        resp = RowsResponse(
+            column_names=["a"],
+            rows=[[1], [2], [3]],
+        )
+        resp.encode_body()
+
+    def test_full_row_types_matches_rows_ok(self) -> None:
+        resp = RowsResponse(
+            column_names=["a"],
+            row_types=[[ValueType.INTEGER], [ValueType.INTEGER], [ValueType.INTEGER]],
+            rows=[[1], [2], [3]],
+        )
+        resp.encode_body()
+
     def test_empty_column_types_with_rows_ok(self) -> None:
         """Empty column_types is valid — types are inferred from values."""
         resp = RowsResponse(