perf: optimize was_applied fast path for known LWT statements

CHANGELOG.rst

@@ -1,3 +1,25 @@
+3.29.9
+======
+March 18, 2026
+
+Features
+--------
+* Add Private Link support via client routes handler
+* Add optional query_params parameter to QueryMessage
+
+Bug Fixes
+---------
+* Fix segmentation fault in libev prepare_callback during shutdown
+* Add null checks to io_callback and timer_callback in libev wrapper
+* Fix RecursionError in execute_concurrent on synchronous errbacks
+* Fix floating-point precision loss for timestamps far from epoch
+
+Others
+------
+* Cache parsed tablet routing type in ResponseFuture
+* Remove deprecated setup_requires in favor of PEP 517 build-system.requires
+* Update dependency hatchling to v1.29.0
+
 3.29.8
 ======
 February 09, 2026

benchmarks/bench_was_applied.py

@@ -0,0 +1,72 @@
+# Copyright DataStax, 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: was_applied fast path for known LWT statements.
+
+Measures the speedup from skipping regex batch detection when the
+query already knows it's an LWT statement (is_lwt() returns True).
+
+Run:
+    python benchmarks/bench_was_applied.py
+"""
+import re
+import timeit
+from unittest.mock import Mock
+
+from cassandra.query import named_tuple_factory, SimpleStatement, BatchStatement
+
+
+def bench_was_applied():
+    """Benchmark was_applied fast path vs slow path."""
+    batch_regex = re.compile(r'\s*BEGIN', re.IGNORECASE)
+
+    # Fast path: known LWT statement (BoundStatement-like, is_lwt=True)
+    lwt_query = Mock()
+    lwt_query.is_lwt.return_value = True
+
+    def fast_path():
+        query = lwt_query
+        if query.is_lwt() and not isinstance(query, BatchStatement):
+            # Fast path - known single LWT, skip batch detection
+            pass
+
+    # Slow path: non-LWT SimpleStatement (must check regex)
+    non_lwt_query = Mock(spec=SimpleStatement)
+    non_lwt_query.is_lwt.return_value = False
+    non_lwt_query.query_string = "INSERT INTO t (k, v) VALUES (1, 2) IF NOT EXISTS"
+
+    def slow_path():
+        query = non_lwt_query
+        if query.is_lwt() and not isinstance(query, BatchStatement):
+            pass
+        else:
+            isinstance(query, BatchStatement) or \
+                (isinstance(query, SimpleStatement) and batch_regex.match(query.query_string))
+
+    n = 500_000
+    t_fast = timeit.timeit(fast_path, number=n)
+    t_slow = timeit.timeit(slow_path, number=n)
+
+    print(f"Fast path (known LWT, {n} iters): {t_fast:.3f}s  ({t_fast / n * 1e6:.2f} us/call)")
+    print(f"Slow path (regex check, {n} iters): {t_slow:.3f}s  ({t_slow / n * 1e6:.2f} us/call)")
+    print(f"Speedup: {t_slow / t_fast:.1f}x")
+
+
+def main():
+    bench_was_applied()
+
+
+if __name__ == '__main__':
+    main()

cassandra/__init__.py

@@ -23,7 +23,7 @@ def emit(self, record):
 
 logging.getLogger('cassandra').addHandler(NullHandler())
 
-__version_info__ = (3, 29, 8)
+__version_info__ = (3, 29, 9)
 __version__ = '.'.join(map(str, __version_info__))