Simplify optimization - only define decode_row differently

Per review feedback, removed code duplication:
- Only define decode_row() function differently based on encryption policy
- Removed separate decode_val helper functions
- Keep single try/except block instead of duplicating it
- Reduced from 75 lines to 57 lines (-18 lines)

Still maintains the same optimization: contains_column() called once per column instead of per value.

Co-authored-by: mykaul <[email protected]>

Author: Copilot

cassandra/protocol.py

@@ -720,7 +720,7 @@ def recv_results_rows(self, f, protocol_version, user_type_map, result_metadata,
         self.column_types = [c[3] for c in column_metadata]
         col_descs = [ColDesc(md[0], md[1], md[2]) for md in column_metadata]
 
-        # Optimize by checking column_encryption_policy once and creating appropriate decode path.
+        # Optimize by checking column_encryption_policy once and defining appropriate decode_row function.
         # This avoids checking the policy for every single value decoded (rows × columns times).
         if column_encryption_policy:
             # Pre-compute encryption info for each column to avoid repeated lookups.
@@ -730,51 +730,33 @@ def recv_results_rows(self, f, protocol_version, user_type_map, result_metadata,
                 for col_desc in col_descs
             ]
 
-            def decode_val_with_encryption(val, col_md, uses_ce, col_desc):
-                if uses_ce:
-                    col_type = column_encryption_policy.column_type(col_desc)
-                    raw_bytes = column_encryption_policy.decrypt(col_desc, val)
-                else:
-                    col_type = col_md[3]
-                    raw_bytes = val
-                return col_type.from_binary(raw_bytes, protocol_version)
-
             def decode_row(row):
                 return tuple(
-                    decode_val_with_encryption(val, col_md, uses_ce, col_desc)
+                    column_encryption_policy.column_type(col_desc).from_binary(
+                        column_encryption_policy.decrypt(col_desc, val), protocol_version
+                    ) if uses_ce else col_md[3].from_binary(val, protocol_version)
                     for val, col_md, (uses_ce, col_desc) in zip(row, column_metadata, column_encryption_info)
                 )
-
-            try:
-                self.parsed_rows = [decode_row(row) for row in rows]
-            except Exception:
-                for row in rows:
-                    for val, col_md, (uses_ce, col_desc) in zip(row, column_metadata, column_encryption_info):
-                        try:
-                            decode_val_with_encryption(val, col_md, uses_ce, col_desc)
-                        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)))
         else:
             # Simple path without encryption - just decode raw bytes directly
-            def decode_val_simple(val, col_type):
-                return col_type.from_binary(val, protocol_version)
-
             def decode_row(row):
-                return tuple(decode_val_simple(val, col_md[3]) for val, col_md in zip(row, column_metadata))
-
-            try:
-                self.parsed_rows = [decode_row(row) for row in rows]
-            except Exception:
-                for row in rows:
-                    for val, col_md in zip(row, column_metadata):
-                        try:
-                            decode_val_simple(val, col_md[3])
-                        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(col_md[3].from_binary(val, protocol_version) for val, col_md in zip(row, column_metadata))
+
+        try:
+            self.parsed_rows = [decode_row(row) for row in rows]
+        except Exception:
+            for row in rows:
+                for val, col_md, col_desc in zip(row, column_metadata, col_descs):
+                    try:
+                        # Fallback to original decode_val logic for error reporting
+                        uses_ce = column_encryption_policy and column_encryption_policy.contains_column(col_desc)
+                        col_type = column_encryption_policy.column_type(col_desc) if uses_ce else col_md[3]
+                        raw_bytes = column_encryption_policy.decrypt(col_desc, val) if uses_ce else val
+                        col_type.from_binary(raw_bytes, 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)))
 
     def recv_results_prepared(self, f, protocol_version, user_type_map):
         self.query_id = read_binary_string(f)