fix: preserve wrapped decode errors in inline row path

Author: mykaul

cassandra/protocol.py

@@ -722,17 +722,10 @@ def recv_results_rows(self, f, protocol_version, user_type_map, result_metadata,
 
         if not column_encryption_policy:
             # Fast path: no column encryption — decode inline, skip ColDesc creation
-            col_types = self.column_types
-            colcount = len(col_types)
-            try:
-                self.parsed_rows = [
-                    _decode_row_inline(f, colcount, col_types, protocol_version)
-                    for _ in range(rowcount)
-                ]
-            except Exception:
-                # Re-read is not possible since we consumed the buffer.
-                # This path should be extremely rare (type mismatch in server response).
-                raise
+            self.parsed_rows = [
+                _decode_row_inline(f, column_metadata, protocol_version)
+                for _ in range(rowcount)
+            ]
         else:
             # Slow path: column encryption enabled — need ColDesc and per-column CE check
             rows = [self.recv_row(f, len(column_metadata)) for _ in range(rowcount)]
@@ -1436,16 +1429,21 @@ def read_error_code_map(f):
 
 
 
-def _decode_row_inline(f, colcount, col_types, protocol_version):
+def _decode_row_inline(f, column_metadata, protocol_version):
     """Decode a single row directly from the buffer (no column encryption)."""
     row = []
-    for i in range(colcount):
+    for col_md in column_metadata:
         size = read_int(f)
         if size < 0:
             row.append(None)
         else:
             val = f.read(size)
-            row.append(col_types[i].from_binary(val, protocol_version))
+            try:
+                row.append(col_md[3].from_binary(val, protocol_version))
+            except Exception as e:
+                raise DriverException('Failed decoding result column "%s" of type %s: %s' % (col_md[2],
+                                                                                             col_md[3].cql_parameterized_type(),
+                                                                                             str(e)))
     return tuple(row)
 
 

tests/unit/test_protocol.py

@@ -12,16 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import io
 import unittest
 
 from unittest.mock import Mock
 
-from cassandra import ProtocolVersion, UnsupportedOperation
+from cassandra import DriverException, ProtocolVersion, UnsupportedOperation, type_codes
 from cassandra.protocol import (
-    PrepareMessage, QueryMessage, ExecuteMessage, UnsupportedOperation,
+    PrepareMessage, QueryMessage, ExecuteMessage, ResultMessage, UnsupportedOperation,
     _PAGING_OPTIONS_FLAG, _WITH_SERIAL_CONSISTENCY_FLAG,
     _PAGE_SIZE_FLAG, _WITH_PAGING_STATE_FLAG,
-    BatchMessage
+    BatchMessage, RESULT_KIND_ROWS, write_int, write_short, write_string
 )
 from cassandra.query import BatchType
 from cassandra.marshal import uint32_unpack
@@ -31,6 +32,22 @@
 
 class MessageTest(unittest.TestCase):
 
+    def test_result_message_wraps_inline_decode_errors(self):
+        body = io.BytesIO()
+        write_int(body, RESULT_KIND_ROWS)
+        write_int(body, 0)
+        write_int(body, 1)
+        write_string(body, "ks")
+        write_string(body, "tbl")
+        write_string(body, "v")
+        write_short(body, type_codes.DateType)
+        write_int(body, 1)
+        write_int(body, 1)
+        body.write(b"\x00")
+
+        with pytest.raises(DriverException, match='Failed decoding result column "v"'):
+            ResultMessage.recv_body(io.BytesIO(body.getvalue()), ProtocolVersion.V4, 0, {}, None, None)
+
     def test_prepare_message(self):
         """
         Test to check the appropriate calls are made