Reject zero-column RowsResponse rows at encode time

encode_body() silently accepted a RowsResponse with empty
column_names and a non-empty rows list. Each row contributed zero
bytes to the encoded payload, so the resulting message was
indistinguishable from a zero-row result set — round-tripping lost
the rows. decode_body() already has a zero-column fast path that
returns no rows.

Raise EncodeError when col_count == 0 and rows is non-empty. Place
the check above the per-row length validation so the higher-level
diagnostic wins over the "row N has 0 values, expected 0" message
that would otherwise fire (and confuse).

Zero-column-zero-row remains valid (symmetric with the decoder).
SQLite cannot produce zero-column results from sqlite3_step, so the
C server never hits this case; the fix is purely symmetry hardening
for mock-server authors and fuzzers.

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

Author: antoineleclair

src/dqlitewire/messages/responses.py

@@ -300,6 +300,15 @@ def encode_body(self) -> bytes:
                 f"column_types length ({len(self.column_types)}) != "
                 f"column_names length ({col_count})"
             )
+        # 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
+        # encode time rather than silently lose row count.
+        if col_count == 0 and self.rows:
+            raise EncodeError(
+                f"RowsResponse with zero columns cannot carry rows "
+                f"(got {len(self.rows)} empty row(s))"
+            )
         for i, row in enumerate(self.rows):
             if len(row) != col_count:
                 raise EncodeError(f"Row {i} has {len(row)} values, expected {col_count}")

tests/test_messages_responses.py

@@ -686,6 +686,21 @@ def test_empty_column_types_with_rows_ok(self) -> None:
         decoded = RowsResponse.decode_body(encoded)
         assert decoded.rows == [[42]]
 
+    def test_zero_columns_with_rows_raises(self) -> None:
+        """Zero-column rows are nonsensical: each row emits 0 bytes, so
+        the encoded message is indistinguishable from a zero-row result
+        set. Reject at encode time so the encoder is symmetric with the
+        decoder's zero-column fast path (it returns no rows).
+        """
+        resp = RowsResponse(
+            column_names=[],
+            column_types=[],
+            row_types=[],
+            rows=[[]],
+        )
+        with pytest.raises(EncodeError, match=r"zero columns.*1 empty row"):
+            resp.encode_body()
+
 
 class TestRowsResponseNullInTypedColumn:
     """137: None values in rows with explicit column types must encode correctly."""