perf: skip ColDesc creation in bind() when column encryption is disabled

Split BoundStatement.bind() into two code paths: when
column_encryption_policy is None (the overwhelmingly common case),
skip ColDesc namedtuple creation, ce_policy.contains_column() check,
and ce_policy.column_type() lookup per column.  Call
col_spec.type.serialize() directly instead.

When column encryption IS enabled, behavior is unchanged.

Benchmark (inner loop only, 200k iters, Python 3.14):
  3-col: 1375 -> 523 ns  (2.63x, saving 852 ns/bind)
  5-col: 2226 -> 1013 ns (2.20x, saving 1213 ns/bind)
  8-col: 3495 -> 1317 ns (2.65x, saving 2178 ns/bind)

Author: mykaul

cassandra/query.py

@@ -636,28 +636,48 @@ def bind(self, values):
 
         self.raw_values = values
         self.values = []
-        for value, col_spec in zip(values, col_meta):
-            if value is None:
-                self.values.append(None)
-            elif value is UNSET_VALUE:
-                if proto_version >= 4:
-                    self._append_unset_value()
+        if ce_policy:
+            # Column encryption enabled — need ColDesc per column
+            for value, col_spec in zip(values, col_meta):
+                if value is None:
+                    self.values.append(None)
+                elif value is UNSET_VALUE:
+                    if proto_version >= 4:
+                        self._append_unset_value()
+                    else:
+                        raise ValueError("Attempt to bind UNSET_VALUE while using unsuitable protocol version (%d < 4)" % proto_version)
                 else:
-                    raise ValueError("Attempt to bind UNSET_VALUE while using unsuitable protocol version (%d < 4)" % proto_version)
-            else:
-                try:
-                    col_desc = ColDesc(col_spec.keyspace_name, col_spec.table_name, col_spec.name)
-                    uses_ce = ce_policy and ce_policy.contains_column(col_desc)
-                    col_type = ce_policy.column_type(col_desc) if uses_ce else col_spec.type
-                    col_bytes = col_type.serialize(value, proto_version)
-                    if uses_ce:
-                        col_bytes = ce_policy.encrypt(col_desc, col_bytes)
-                    self.values.append(col_bytes)
-                except (TypeError, struct.error) as exc:
-                    actual_type = type(value)
-                    message = ('Received an argument of invalid type for column "%s". '
-                               'Expected: %s, Got: %s; (%s)' % (col_spec.name, col_spec.type, actual_type, exc))
-                    raise TypeError(message)
+                    try:
+                        col_desc = ColDesc(col_spec.keyspace_name, col_spec.table_name, col_spec.name)
+                        uses_ce = ce_policy.contains_column(col_desc)
+                        col_type = ce_policy.column_type(col_desc) if uses_ce else col_spec.type
+                        col_bytes = col_type.serialize(value, proto_version)
+                        if uses_ce:
+                            col_bytes = ce_policy.encrypt(col_desc, col_bytes)
+                        self.values.append(col_bytes)
+                    except (TypeError, struct.error) as exc:
+                        actual_type = type(value)
+                        message = ('Received an argument of invalid type for column "%s". '
+                                   'Expected: %s, Got: %s; (%s)' % (col_spec.name, col_spec.type, actual_type, exc))
+                        raise TypeError(message)
+        else:
+            # Fast path — no column encryption (common case)
+            for value, col_spec in zip(values, col_meta):
+                if value is None:
+                    self.values.append(None)
+                elif value is UNSET_VALUE:
+                    if proto_version >= 4:
+                        self._append_unset_value()
+                    else:
+                        raise ValueError("Attempt to bind UNSET_VALUE while using unsuitable protocol version (%d < 4)" % proto_version)
+                else:
+                    try:
+                        self.values.append(col_spec.type.serialize(value, proto_version))
+                    except (TypeError, struct.error) as exc:
+                        actual_type = type(value)
+                        message = ('Received an argument of invalid type for column "%s". '
+                                   'Expected: %s, Got: %s; (%s)' % (col_spec.name, col_spec.type, actual_type, exc))
+                        raise TypeError(message)
 
         if proto_version >= 4:
             diff = col_meta_len - len(self.values)