fix: validate column count consistency in RowsResponse.encode_body

RowsResponse.encode_body() now validates that column_types, row_types,
and row values all have lengths matching column_names before encoding.
Previously, mismatched lengths produced malformed wire data with
confusing errors deep in tuples.py or silent misparse on decode.

Closes #096

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

Author: antoineleclair

src/dqlitewire/messages/responses.py

@@ -12,7 +12,7 @@
     ResponseType,
     ValueType,
 )
-from dqlitewire.exceptions import DecodeError
+from dqlitewire.exceptions import DecodeError, EncodeError
 from dqlitewire.messages.base import Message
 from dqlitewire.tuples import (
     RowMarker,
@@ -264,7 +264,21 @@ def _get_row_types(self, row_idx: int, row: list[Any]) -> list[ValueType]:
         return [encode_value(v)[1] for v in row]
 
     def encode_body(self) -> bytes:
-        result = encode_uint64(len(self.column_names))
+        col_count = len(self.column_names)
+        if self.column_types and len(self.column_types) != col_count:
+            raise EncodeError(
+                f"column_types length ({len(self.column_types)}) != "
+                f"column_names length ({col_count})"
+            )
+        for i, row in enumerate(self.rows):
+            if len(row) != col_count:
+                raise EncodeError(f"Row {i} has {len(row)} values, expected {col_count}")
+            if self.row_types and i < len(self.row_types) and len(self.row_types[i]) != col_count:
+                raise EncodeError(
+                    f"row_types[{i}] has {len(self.row_types[i])} types, expected {col_count}"
+                )
+
+        result = encode_uint64(col_count)
 
         # Column names
         for name in self.column_names:

tests/test_messages_responses.py

@@ -1,6 +1,9 @@
 """Tests for response message encoding/decoding."""
 
+import pytest
+
 from dqlitewire.constants import HEADER_SIZE, ResponseType, ValueType
+from dqlitewire.exceptions import EncodeError
 from dqlitewire.messages.base import Header
 from dqlitewire.messages.responses import (
     DbResponse,
@@ -576,6 +579,48 @@ def build_body(n_rows: int) -> bytes:
         assert len(decoded.rows) == 2
 
 
+class TestRowsResponseEncodeValidation:
+    """Encode-time validation of column count consistency."""
+
+    def test_mismatched_column_types_length(self) -> None:
+        resp = RowsResponse(
+            column_names=["a", "b", "c"],
+            column_types=[ValueType.INTEGER],
+            rows=[],
+        )
+        with pytest.raises(EncodeError, match="column_types length"):
+            resp.encode_body()
+
+    def test_mismatched_row_values_length(self) -> None:
+        resp = RowsResponse(
+            column_names=["a", "b"],
+            column_types=[ValueType.INTEGER, ValueType.TEXT],
+            row_types=[[ValueType.INTEGER, ValueType.TEXT]],
+            rows=[[1]],  # only 1 value, expected 2
+        )
+        with pytest.raises(EncodeError, match="Row 0 has 1 values, expected 2"):
+            resp.encode_body()
+
+    def test_mismatched_row_types_length(self) -> None:
+        resp = RowsResponse(
+            column_names=["a", "b"],
+            row_types=[[ValueType.INTEGER]],  # only 1 type, expected 2
+            rows=[[1, 2]],
+        )
+        with pytest.raises(EncodeError, match="row_types\\[0\\] has 1 types, expected 2"):
+            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(
+            column_names=["a"],
+            rows=[[42]],
+        )
+        encoded = resp.encode_body()
+        decoded = RowsResponse.decode_body(encoded)
+        assert decoded.rows == [[42]]
+
+
 class TestRowsResponseValueTypes:
     """Full RowsResponse round-trips with BOOLEAN, UNIXTIME, ISO8601, and BLOB."""