perf: memoize cql_parameterized_type() on all type classes

Cache the computed CQL type string in a _cql_type_str class attribute.
The string is computed lazily on first call and returned from cache on
subsequent calls.  Since type classes are immutable after
apply_parameters(), no invalidation logic is needed.

All 6 cql_parameterized_type() overrides are covered:
  _CassandraType (base), TupleType, UserType, CompositeType,
  DynamicCompositeType, VectorType.

Benchmark (500k iters, Python 3.14):
  Int32Type (simple):         6.9x  (157 -> 23 ns)
  MapType<text, int>:        22.9x  (464 -> 20 ns)
  SetType<float>:            18.2x  (371 -> 20 ns)
  ListType<double>:          17.3x  (357 -> 21 ns)
  TupleType<int,text,bool>:  25.0x  (509 -> 20 ns)
  Nested map/list/tuple:     11.4x  (636 -> 56 ns)

Author: mykaul

benchmarks/bench_cql_parameterized_type.py

@@ -0,0 +1,86 @@
+# 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Micro-benchmark: cql_parameterized_type memoization.
+
+Measures the cost of building the CQL type string representation
+with and without memoization for various type complexities.
+
+Run:
+    python benchmarks/bench_cql_parameterized_type.py
+"""
+
+import sys
+import timeit
+
+from cassandra.cqltypes import (
+    MapType, SetType, ListType, TupleType,
+    Int32Type, UTF8Type, FloatType, DoubleType, BooleanType,
+    _CassandraType,
+)
+
+
+def bench():
+    # Create parameterized types
+    map_type = MapType.apply_parameters([UTF8Type, Int32Type])
+    set_type = SetType.apply_parameters([FloatType])
+    list_type = ListType.apply_parameters([DoubleType])
+    tuple_type = TupleType.apply_parameters([Int32Type, UTF8Type, BooleanType])
+    nested_type = MapType.apply_parameters([
+        UTF8Type,
+        ListType.apply_parameters([
+            TupleType.apply_parameters([Int32Type, FloatType, DoubleType])
+        ])
+    ])
+
+    test_types = [
+        ("Int32Type (simple)", Int32Type),
+        ("MapType<text, int>", map_type),
+        ("SetType<float>", set_type),
+        ("ListType<double>", list_type),
+        ("TupleType<int, text, bool>", tuple_type),
+        ("MapType<text, list<tuple<int, float, double>>>", nested_type),
+    ]
+
+    n = 500_000
+    print(f"=== cql_parameterized_type ({n:,} iters) ===\n")
+
+    for label, typ in test_types:
+        # Clear cache to measure uncached
+        typ._cql_type_str = None
+        # One call to populate cache
+        result = typ.cql_parameterized_type()
+
+        # Measure cached (warm)
+        t_cached = timeit.timeit(typ.cql_parameterized_type, number=n)
+
+        # Measure uncached (cold)
+        def uncached():
+            typ._cql_type_str = None
+            return typ.cql_parameterized_type()
+        t_uncached = timeit.timeit(uncached, number=n)
+
+        saving_ns = (t_uncached - t_cached) / n * 1e9
+        speedup = t_uncached / t_cached if t_cached > 0 else float('inf')
+        print(f"  {label}:")
+        print(f"    result: {result}")
+        print(f"    uncached: {t_uncached / n * 1e9:.1f} ns, "
+              f"cached: {t_cached / n * 1e9:.1f} ns, "
+              f"saving: {saving_ns:.1f} ns ({speedup:.1f}x)")
+
+
+if __name__ == "__main__":
+    print(f"Python {sys.version}\n")
+    bench()

cassandra/cqltypes.py

@@ -314,6 +314,11 @@ class _CassandraType(object, metaclass=CassandraTypeType):
     num_subtypes = 0
     empty_binary_ok = False
 
+    # Cached result of cql_parameterized_type(). Computed lazily on first
+    # access and stored as a class attribute. Safe because type classes are
+    # immutable after creation via apply_parameters().
+    _cql_type_str = None
+
     support_empty_values = False
     """
     Back in the Thrift days, empty strings were used for "null" values of
@@ -428,12 +433,18 @@ def cql_parameterized_type(cls):
         Return a CQL type specifier for this type. If this type has parameters,
         they are included in standard CQL <> notation.
         """
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         if not cls.subtypes:
-            return cls.typename
-        return "%s<%s>" % (
-            cls.typename,
-            ", ".join(styp.cql_parameterized_type() for styp in cls.subtypes),
-        )
+            result = cls.typename
+        else:
+            result = "%s<%s>" % (
+                cls.typename,
+                ", ".join(styp.cql_parameterized_type() for styp in cls.subtypes),
+            )
+        cls._cql_type_str = result
+        return result
 
     @classmethod
     def cass_parameterized_type(cls, full=False):
@@ -1042,10 +1053,15 @@ def serialize_safe(cls, val, protocol_version):
 
     @classmethod
     def cql_parameterized_type(cls):
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         subtypes_string = ", ".join(
             sub.cql_parameterized_type() for sub in cls.subtypes
         )
-        return "frozen<tuple<%s>>" % (subtypes_string,)
+        result = "frozen<tuple<%s>>" % (subtypes_string,)
+        cls._cql_type_str = result
+        return result
 
 
 class UserType(TupleType):
@@ -1102,7 +1118,12 @@ def apply_parameters(cls, subtypes, names):
 
     @classmethod
     def cql_parameterized_type(cls):
-        return "frozen<%s>" % (cls.typename,)
+        result = cls._cql_type_str
+        if result is not None:
+            return result
+        result = "frozen<%s>" % (cls.typename,)
+        cls._cql_type_str = result
+        return result
 
     @classmethod
     def deserialize_safe(cls, byts, protocol_version):
@@ -1182,8 +1203,13 @@ def cql_parameterized_type(cls):
         """
         There is no CQL notation for Composites, so we override this.
         """
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         typestring = cls.cass_parameterized_type(full=True)
-        return "'%s'" % (typestring,)
+        result = "'%s'" % (typestring,)
+        cls._cql_type_str = result
+        return result
 
     @classmethod
     def deserialize_safe(cls, byts, protocol_version):
@@ -1208,11 +1234,16 @@ class DynamicCompositeType(_ParameterizedType):
 
     @classmethod
     def cql_parameterized_type(cls):
+        result = cls._cql_type_str
+        if result is not None:
+            return result
         sublist = ", ".join(
             "%s=>%s" % (alias, typ.cass_parameterized_type(full=True))
             for alias, typ in zip(cls.fieldnames, cls.subtypes)
         )
-        return "'%s(%s)'" % (cls.typename, sublist)
+        result = "'%s(%s)'" % (cls.typename, sublist)
+        cls._cql_type_str = result
+        return result
 
 
 class ColumnToCollectionType(_ParameterizedType):
@@ -1655,8 +1686,13 @@ def serialize(cls, v, protocol_version):
 
     @classmethod
     def cql_parameterized_type(cls):
-        return "%s<%s, %s>" % (
+        result = cls._cql_type_str
+        if result is not None:
+            return result
+        result = "%s<%s, %s>" % (
             cls.typename,
             cls.subtype.cql_parameterized_type(),
             cls.vector_size,
         )
+        cls._cql_type_str = result
+        return result