(improvement) query, serializers: address PR review feedback

- Replace malloc/free with PyBytes_FromStringAndSize(NULL, ...) pattern in
  vector fast-paths, eliminating extra buffer copy and malloc(0) edge case
- Change _check_int32_range to raise OverflowError instead of struct.error,
  consistent with _check_float_range
- Remove unused imports (struct, malloc, free)
- Differentiate error messages in _raise_bind_serialize_error: 'invalid type'
  for TypeError vs 'value out of range' for OverflowError/struct.error
- Replace unused loop variable with while loop in UNSET_VALUE fill
- Expand __getitem__ docstrings explaining performance rationale
- Fix copyright header in test_parameter_binding.py

Author: mykaul

cassandra/query.py

@@ -547,7 +547,9 @@ def _serializers(self):
 
         The column_encryption_policy check is performed on every access (not
         cached) so that serializers are correctly bypassed if a policy is set
-        after construction.
+        after construction.  This means the cache never goes stale: once a CE
+        policy is present, we always return None and fall through to the
+        encryption-aware bind path.
         """
         if self.column_encryption_policy:
             return None
@@ -667,15 +669,25 @@ def _raise_bind_serialize_error(col_spec, value, exc):
 
     Called from all three bind loop paths (CE, Cython, plain Python) to
     provide a uniform error message that includes the column name and
-    expected type.  struct.error arises from int32 out-of-range values;
-    OverflowError from float out-of-range values.  Other exception types
-    (e.g. ValueError from VectorType dimension mismatch) propagate
-    without wrapping.
+    expected type.  The message distinguishes between wrong-type and
+    out-of-range scenarios:
+
+    - TypeError           -> "invalid type"
+    - OverflowError       -> "value out of range"
+    - struct.error        -> "value out of range"
+
+    Other exception types (e.g. ValueError from VectorType dimension
+    mismatch) propagate without wrapping.
     """
     actual_type = type(value)
+    if isinstance(exc, (OverflowError, struct.error)):
+        reason = "value out of range"
+    else:
+        reason = "invalid type"
     message = (
-        'Received an argument of invalid type for column "%s". '
-        "Expected: %s, Got: %s; (%s)" % (col_spec.name, col_spec.type, actual_type, exc)
+        'Received an argument with %s for column "%s". '
+        "Expected: %s, Got: %s; (%s)"
+        % (reason, col_spec.name, col_spec.type, actual_type, exc)
     )
     raise TypeError(message) from exc
 
@@ -888,7 +900,7 @@ def bind(self, values):
             # Fill remaining unbound columns with UNSET_VALUE (v4+ feature).
             # The pre-allocated list already has slots for these, so index
             # assignment works directly without trimming first.
-            for i in range(idx, col_meta_len):
+            while idx < col_meta_len:
                 idx = self._append_unset_value(idx)
         elif idx < col_meta_len:
             # Pre-v4: trim trailing unused slots (no UNSET_VALUE support)

cassandra/serializers.pyx

@@ -28,14 +28,12 @@ cqltype.serialize() classmethod.
 
 from libc.stdint cimport int32_t
 from libc.string cimport memcpy
-from libc.stdlib cimport malloc, free
 from libc.float cimport FLT_MAX
 from libc.math cimport isinf, isnan
-from cpython.bytes cimport PyBytes_FromStringAndSize
+from cpython.bytes cimport PyBytes_FromStringAndSize, PyBytes_AS_STRING
 
 from cassandra import cqltypes
 import io
-import struct
 from cassandra.marshal import uvint_pack
 
 cdef bint is_little_endian
@@ -79,15 +77,15 @@ cdef inline void _check_float_range(double value) except *:
 # ---------------------------------------------------------------------------
 
 cdef inline void _check_int32_range(object value) except *:
-    """Raise struct.error for values outside the signed int32 range.
+    """Raise OverflowError for values outside the signed int32 range.
 
-    Matches the behaviour of struct.pack('>i', value), which raises
-    struct.error for out-of-range values. The check must be done on the
-    Python int *before* the C-level <int32_t> cast, which would silently
-    truncate.
+    Mirrors ``_check_float_range``: we intentionally raise OverflowError
+    (not struct.error) so callers only need to catch one exception type
+    for out-of-range values.  The check must be done on the Python int
+    *before* the C-level <int32_t> cast, which would silently truncate.
     """
     if value > 2147483647 or value < -2147483648:
-        raise struct.error(
+        raise OverflowError(
             "'i' format requires -2147483648 <= number <= 2147483647"
         )
 
@@ -226,116 +224,116 @@ cdef class SerVectorType(Serializer):
     cdef inline bytes _serialize_float(self, object values):
         """Serialize a sequence of floats into a contiguous big-endian buffer.
 
-        Note: uses index-based access (values[i]) rather than iteration, so
-        the input must support __getitem__ (e.g. list or tuple).
+        Uses index-based access (values[i]) rather than iteration for
+        performance — the input must support ``__getitem__`` (list, tuple,
+        etc.).  This is intentional: index access lets Cython emit a single
+        ``PyObject_GetItem`` call per element instead of iterator protocol
+        overhead.
         """
         cdef Py_ssize_t i
         cdef Py_ssize_t buf_size = self.vector_size * 4
         if buf_size == 0:
             return b""
-        cdef char *buf = <char *>malloc(buf_size)
-        if buf == NULL:
-            raise MemoryError("Failed to allocate %d bytes for vector serialization" % buf_size)
+
+        cdef object result = PyBytes_FromStringAndSize(NULL, buf_size)
+        cdef char *buf = PyBytes_AS_STRING(result)
 
         cdef float val
         cdef char *src
         cdef char *dst
 
-        try:
-            for i in range(self.vector_size):
-                _check_float_range(<double>values[i])
-                val = <float>values[i]
-                src = <char *>&val
-                dst = buf + i * 4
-
-                if is_little_endian:
-                    dst[0] = src[3]
-                    dst[1] = src[2]
-                    dst[2] = src[1]
-                    dst[3] = src[0]
-                else:
-                    memcpy(dst, src, 4)
-
-            return PyBytes_FromStringAndSize(buf, buf_size)
-        finally:
-            free(buf)
+        for i in range(self.vector_size):
+            _check_float_range(<double>values[i])
+            val = <float>values[i]
+            src = <char *>&val
+            dst = buf + i * 4
+
+            if is_little_endian:
+                dst[0] = src[3]
+                dst[1] = src[2]
+                dst[2] = src[1]
+                dst[3] = src[0]
+            else:
+                memcpy(dst, src, 4)
+
+        return result
 
     cdef inline bytes _serialize_double(self, object values):
         """Serialize a sequence of doubles into a contiguous big-endian buffer.
 
-        Note: uses index-based access (values[i]) rather than iteration, so
-        the input must support __getitem__ (e.g. list or tuple).
+        Uses index-based access (values[i]) rather than iteration for
+        performance — the input must support ``__getitem__`` (list, tuple,
+        etc.).  This is intentional: index access lets Cython emit a single
+        ``PyObject_GetItem`` call per element instead of iterator protocol
+        overhead.
         """
         cdef Py_ssize_t i
         cdef Py_ssize_t buf_size = self.vector_size * 8
         if buf_size == 0:
             return b""
-        cdef char *buf = <char *>malloc(buf_size)
-        if buf == NULL:
-            raise MemoryError("Failed to allocate %d bytes for vector serialization" % buf_size)
+
+        cdef object result = PyBytes_FromStringAndSize(NULL, buf_size)
+        cdef char *buf = PyBytes_AS_STRING(result)
 
         cdef double val
         cdef char *src
         cdef char *dst
 
-        try:
-            for i in range(self.vector_size):
-                val = <double>values[i]
-                src = <char *>&val
-                dst = buf + i * 8
-
-                if is_little_endian:
-                    dst[0] = src[7]
-                    dst[1] = src[6]
-                    dst[2] = src[5]
-                    dst[3] = src[4]
-                    dst[4] = src[3]
-                    dst[5] = src[2]
-                    dst[6] = src[1]
-                    dst[7] = src[0]
-                else:
-                    memcpy(dst, src, 8)
-
-            return PyBytes_FromStringAndSize(buf, buf_size)
-        finally:
-            free(buf)
+        for i in range(self.vector_size):
+            val = <double>values[i]
+            src = <char *>&val
+            dst = buf + i * 8
+
+            if is_little_endian:
+                dst[0] = src[7]
+                dst[1] = src[6]
+                dst[2] = src[5]
+                dst[3] = src[4]
+                dst[4] = src[3]
+                dst[5] = src[2]
+                dst[6] = src[1]
+                dst[7] = src[0]
+            else:
+                memcpy(dst, src, 8)
+
+        return result
 
     cdef inline bytes _serialize_int32(self, object values):
         """Serialize a sequence of int32 values into a contiguous big-endian buffer.
 
-        Note: uses index-based access (values[i]) rather than iteration, so
-        the input must support __getitem__ (e.g. list or tuple).
+        Uses index-based access (values[i]) rather than iteration for
+        performance — the input must support ``__getitem__`` (list, tuple,
+        etc.).  This is intentional: index access lets Cython emit a single
+        ``PyObject_GetItem`` call per element instead of iterator protocol
+        overhead.
         """
         cdef Py_ssize_t i
         cdef Py_ssize_t buf_size = self.vector_size * 4
         if buf_size == 0:
             return b""
-        cdef char *buf = <char *>malloc(buf_size)
-        if buf == NULL:
-            raise MemoryError("Failed to allocate %d bytes for vector serialization" % buf_size)
+
+        cdef object result = PyBytes_FromStringAndSize(NULL, buf_size)
+        cdef char *buf = PyBytes_AS_STRING(result)
 
         cdef int32_t val
         cdef char *src
         cdef char *dst
 
-        try:
-            for i in range(self.vector_size):
-                _check_int32_range(values[i])
-                val = <int32_t>values[i]
-                src = <char *>&val
-                dst = buf + i * 4
-
-                if is_little_endian:
-                    dst[0] = src[3]
-                    dst[1] = src[2]
-                    dst[2] = src[1]
-                    dst[3] = src[0]
-                else:
-                    memcpy(dst, src, 4)
-
-            return PyBytes_FromStringAndSize(buf, buf_size)
-        finally:
-            free(buf)
+        for i in range(self.vector_size):
+            _check_int32_range(values[i])
+            val = <int32_t>values[i]
+            src = <char *>&val
+            dst = buf + i * 4
+
+            if is_little_endian:
+                dst[0] = src[3]
+                dst[1] = src[2]
+                dst[2] = src[1]
+                dst[3] = src[0]
+            else:
+                memcpy(dst, src, 4)
+
+        return result
 
     cdef inline bytes _serialize_generic(self, object values, int protocol_version):
         """Fallback: element-by-element Python serialization for non-optimized types."""

tests/unit/test_parameter_binding.py

@@ -1,4 +1,4 @@
-# Copyright DataStax, Inc.
+# Copyright ScyllaDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -349,8 +349,9 @@ def test_cython_path_type_error_wrapped(self):
         assert "Int32Type" in msg
 
     def test_plain_path_overflow_error_wrapped(self):
-        """Out-of-range int in the plain Python path raises struct.error (caught
-        alongside OverflowError) and is wrapped with column context."""
+        """Out-of-range int in the plain Python path raises OverflowError (from
+        the Cython serializer) or struct.error (from the pure-Python fallback)
+        and is wrapped with column context."""
         column_metadata = [ColumnMetadata("keyspace", "cf", "v0", Int32Type)]
         # Force the plain Python path (no Cython serializers)
         prepared = self._make_prepared(column_metadata, serializers=None)