perf: reorder RESULT_KIND dispatch and replace getattr with direct access

Two micro-optimizations in _set_result() hot path:

1. Reorder the RESULT_KIND if/elif chain to check ROWS first (was third),
   since it is by far the most common result type.  VOID is second.
   SET_KEYSPACE and SCHEMA_CHANGE (rare) are now last.

2. Add continuous_paging_options = None class attribute to _QueryMessage,
   allowing direct attribute access instead of
   getattr(self.message, 'continuous_paging_options', None).

Benchmark (2M iters, Python 3.14):
  RESULT_KIND reorder: 35.5 -> 24.3 ns (1.46x, -11.2 ns/dispatch)
  getattr -> direct:   32.0 -> 18.3 ns (1.75x, -13.7 ns/access)
  Combined: ~25 ns saved per query

Author: mykaul

benchmarks/bench_result_kind_dispatch.py

@@ -0,0 +1,115 @@
+# 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: RESULT_KIND dispatch ordering and getattr vs direct access.
+
+Measures the cost difference between:
+1. Checking RESULT_KIND_ROWS first vs third in the if/elif chain
+2. getattr(msg, 'continuous_paging_options', None) vs msg.continuous_paging_options
+
+Run:
+    python benchmarks/bench_result_kind_dispatch.py
+"""
+
+import sys
+import timeit
+
+
+def bench():
+    n = 2_000_000
+
+    # Simulate the result kind values
+    RESULT_KIND_SET_KEYSPACE = 0x0003
+    RESULT_KIND_SCHEMA_CHANGE = 0x0005
+    RESULT_KIND_ROWS = 0x0002
+    RESULT_KIND_VOID = 0x0001
+
+    kind = RESULT_KIND_ROWS  # the common case
+
+    # Old order: SET_KEYSPACE, SCHEMA_CHANGE, ROWS, VOID
+    def old_dispatch():
+        if kind == RESULT_KIND_SET_KEYSPACE:
+            return 'set_keyspace'
+        elif kind == RESULT_KIND_SCHEMA_CHANGE:
+            return 'schema_change'
+        elif kind == RESULT_KIND_ROWS:
+            return 'rows'
+        elif kind == RESULT_KIND_VOID:
+            return 'void'
+
+    # New order: ROWS, VOID, SET_KEYSPACE, SCHEMA_CHANGE
+    def new_dispatch():
+        if kind == RESULT_KIND_ROWS:
+            return 'rows'
+        elif kind == RESULT_KIND_VOID:
+            return 'void'
+        elif kind == RESULT_KIND_SET_KEYSPACE:
+            return 'set_keyspace'
+        elif kind == RESULT_KIND_SCHEMA_CHANGE:
+            return 'schema_change'
+
+    print(f"=== RESULT_KIND dispatch order ({n:,} iters) ===\n")
+
+    # Warmup
+    for _ in range(10000):
+        old_dispatch()
+        new_dispatch()
+
+    t_old = timeit.timeit(old_dispatch, number=n)
+    t_new = timeit.timeit(new_dispatch, number=n)
+    ns_old = t_old / n * 1e9
+    ns_new = t_new / n * 1e9
+    saving = ns_old - ns_new
+    speedup = ns_old / ns_new if ns_new > 0 else float('inf')
+    print(f"  Old (ROWS=3rd):  {ns_old:.1f} ns")
+    print(f"  New (ROWS=1st):  {ns_new:.1f} ns")
+    print(f"  Saving: {saving:.1f} ns ({speedup:.2f}x)")
+
+    # getattr vs direct attribute access
+    print(f"\n=== getattr vs direct attribute access ({n:,} iters) ===\n")
+
+    class OldMsg:
+        pass
+
+    class NewMsg:
+        continuous_paging_options = None
+
+    old_msg = OldMsg()
+    new_msg = NewMsg()
+
+    def old_getattr():
+        return getattr(old_msg, 'continuous_paging_options', None)
+
+    def new_direct():
+        return new_msg.continuous_paging_options
+
+    for _ in range(10000):
+        old_getattr()
+        new_direct()
+
+    t_old = timeit.timeit(old_getattr, number=n)
+    t_new = timeit.timeit(new_direct, number=n)
+    ns_old = t_old / n * 1e9
+    ns_new = t_new / n * 1e9
+    saving = ns_old - ns_new
+    speedup = ns_old / ns_new if ns_new > 0 else float('inf')
+    print(f"  getattr(msg, 'continuous_paging_options', None): {ns_old:.1f} ns")
+    print(f"  msg.continuous_paging_options:                    {ns_new:.1f} ns")
+    print(f"  Saving: {saving:.1f} ns ({speedup:.2f}x)")
+
+
+if __name__ == "__main__":
+    print(f"Python {sys.version}\n")
+    bench()

cassandra/cluster.py

@@ -4751,7 +4751,26 @@ def _set_result(self, host, connection, pool, response):
                         if tablet is not None:
                             self.session.cluster.metadata._tablets.add_tablet(self.query.keyspace, self.query.table, tablet)
 
-                if response.kind == RESULT_KIND_SET_KEYSPACE:
+                if response.kind == RESULT_KIND_ROWS:
+                    self._paging_state = response.paging_state
+                    # Use pre-cached column names/types from PreparedStatement
+                    # when available to avoid rebuilding lists from metadata.
+                    ps = self.prepared_statement
+                    if ps is not None and ps._result_col_names is not None:
+                        col_names = ps._result_col_names
+                        col_types = ps._result_col_types
+                    else:
+                        col_names = response.column_names
+                        col_types = response.column_types
+                    self._col_names = col_names
+                    self._col_types = col_types
+                    if self.message.continuous_paging_options:
+                        self._handle_continuous_paging_first_response(connection, response)
+                    else:
+                        self._set_final_result(self.row_factory(col_names, response.parsed_rows))
+                elif response.kind == RESULT_KIND_VOID:
+                    self._set_final_result(None)
+                elif response.kind == RESULT_KIND_SET_KEYSPACE:
                     session = getattr(self, 'session', None)
                     # since we're running on the event loop thread, we need to
                     # use a non-blocking method for setting the keyspace on
@@ -4771,25 +4790,6 @@ def _set_result(self, host, connection, pool, response):
                         refresh_schema_and_set_result,
                         self.session.cluster.control_connection,
                         self, connection, **response.schema_change_event)
-                elif response.kind == RESULT_KIND_ROWS:
-                    self._paging_state = response.paging_state
-                    # Use pre-cached column names/types from PreparedStatement
-                    # when available to avoid rebuilding lists from metadata.
-                    ps = self.prepared_statement
-                    if ps is not None and ps._result_col_names is not None:
-                        col_names = ps._result_col_names
-                        col_types = ps._result_col_types
-                    else:
-                        col_names = response.column_names
-                        col_types = response.column_types
-                    self._col_names = col_names
-                    self._col_types = col_types
-                    if getattr(self.message, 'continuous_paging_options', None):
-                        self._handle_continuous_paging_first_response(connection, response)
-                    else:
-                        self._set_final_result(self.row_factory(col_names, response.parsed_rows))
-                elif response.kind == RESULT_KIND_VOID:
-                    self._set_final_result(None)
                 else:
                     self._set_final_result(response)
             elif isinstance(response, ErrorMessage):

cassandra/protocol.py

@@ -544,6 +544,11 @@ def recv_body(cls, f, *args):
 
 class _QueryMessage(_MessageType):
 
+    # DSE continuous paging: stored when the feature is active, otherwise None.
+    # Declared as a class attribute so that callers can use direct attribute
+    # access instead of getattr(msg, 'continuous_paging_options', None).
+    continuous_paging_options = None
+
     def __init__(self, query_params, consistency_level,
                  serial_consistency_level=None, fetch_size=None,
                  paging_state=None, timestamp=None, skip_meta=False,