CNDB-15432: CNDB-15155: Segregate SAI's query metrics per query type (#1969)

Add SAI query metrics per kind of query.

There are metrics for:
 * Filtering only queries.
 * Top-k only queries, such as ANN, BM25 and generic ordering.
 * Hybrid queries, combining both top-k and filtering.
 * Single-partition queries.
 * Multi-partition queries.

Each of these groups has the same records as the general query metrics.

These new metrics can be enabled/disabled with the system properties:
* cassandra.sai.metrics.query_kind.per_table.enabled
* cassandra.sai.metrics.query_kind.per_query.enabled

Rebase notes:
 * required to re-implement CASSANDRA-18940
 * will be replaced (made redundant) by CASSANDRA-20923

Author: adelapena

src/java/org/apache/cassandra/config/CassandraRelevantProperties.java

@@ -728,6 +728,20 @@ public enum CassandraRelevantProperties
     SAI_NUMERIC_VALUES_MONOTONIC_BLOCK_SIZE("dse.sai.numeric_values.monotonic_block_size", "16384"),
     /** Controls the number of rows read in a single batch when fetching rows for a partition key */
     SAI_PARTITION_ROW_BATCH_SIZE("cassandra.sai.partition_row_batch_size", "100"),
+
+    /**
+     * Whether to enable SAI per-query metrics for different kinds of query, such as filter-only queries, top-k-only
+     * queries, hybrid queries, single-partition queries, and multipartition queries. These metrics are histograms and
+     * timers.
+     */
+    SAI_QUERY_KIND_PER_QUERY_METRICS_ENABLED("cassandra.sai.metrics.query_kind.per_query.enabled", "false"),
+
+    /**
+     * Whether to enable SAI per-table metrics for different kinds of query, such as filter-only queries, top-k-only
+     * queries, hybrid queries, single-partition queries, and multipartition queries. These metrics are always counters.
+     */
+    SAI_QUERY_KIND_PER_TABLE_METRICS_ENABLED("cassandra.sai.metrics.query_kind.per_table.enabled", "true"),
+
     SAI_QUERY_OPT_LEVEL("cassandra.sai.query.optimization.level", "1"),
     SAI_REDUCE_TOPK_ACROSS_SSTABLES("cassandra.sai.reduce_topk_across_sstables", "true"),
     SAI_TEST_DISABLE_TIMEOUT("cassandra.sai.test.timeout_disabled", "false"),

src/java/org/apache/cassandra/db/MultiRangeReadCommand.java

@@ -150,6 +150,12 @@ public ReadResponse createEmptyResponse()
                : MultiRangeReadResponse.createDataResponse(iterator, this);
     }
 
+    @Override
+    public boolean isSinglePartition()
+    {
+        return dataRanges.size() == 1 && dataRanges.get(0).isSinglePartition();
+    }
+
     /**
      * @return all token ranges to be queried
      */

src/java/org/apache/cassandra/db/PartitionRangeReadCommand.java

@@ -188,6 +188,12 @@ public static PartitionRangeReadCommand allDataRead(TableMetadata metadata, long
                       false);
     }
 
+    @Override
+    public boolean isSinglePartition()
+    {
+        return dataRange.isSinglePartition();
+    }
+
     public ClusteringIndexFilter clusteringIndexFilter(DecoratedKey key)
     {
         return dataRange.clusteringIndexFilter(key);

src/java/org/apache/cassandra/db/ReadCommand.java

@@ -295,12 +295,25 @@ public Index.QueryPlan indexQueryPlan()
         return indexQueryPlan;
     }
 
+    /**
+     * @return {@code true} if this command uses index-based filtering, {@code false} otherwise
+     */
+    public boolean usesIndexFiltering()
+    {
+        return indexQueryPlan != null && indexQueryPlan.usesIndexFiltering();
+    }
+
     @Override
     public boolean isTopK()
     {
         return indexQueryPlan != null && indexQueryPlan.isTopK();
     }
 
+    /**
+     * @return {@code true} if this command only queries a single partition, {@code false} otherwise.
+     */
+    public abstract boolean isSinglePartition();
+
     @VisibleForTesting
     public Index.Searcher indexSearcher()
     {

src/java/org/apache/cassandra/db/SinglePartitionReadCommand.java

@@ -473,6 +473,12 @@ public SinglePartitionReadCommand forPaging(Clustering<?> lastReturned, DataLimi
         return cmd;
     }
 
+    @Override
+    public boolean isSinglePartition()
+    {
+        return true;
+    }
+
     @Override
     public PartitionIterator execute(ConsistencyLevel consistency, ClientState state, Dispatcher.RequestTime requestTime) throws RequestExecutionException
     {

src/java/org/apache/cassandra/index/Index.java

@@ -1186,6 +1186,14 @@ default boolean supportsMultiRangeReadCommand()
         {
             return false;
         }
+
+        /**
+         * @return {@code true} if this plan uses index-based filtering, {@code false} otherwise
+         */
+        default boolean usesIndexFiltering()
+        {
+            return true;
+        }
     }
 
     /*

src/java/org/apache/cassandra/index/sai/QueryContext.java

@@ -66,6 +66,7 @@ public class QueryContext
     private float annRerankFloor = 0.0f; // only called from single-threaded setup code
 
     private final LongAdder shadowedPrimaryKeyCount = new LongAdder();
+    private final LongAdder postFilteringReadLatency = new LongAdder();
 
     // Determines the order of using indexes for filtering and sorting.
     // Null means the query execution order hasn't been decided yet.
@@ -146,6 +147,11 @@ public void addAnnGraphSearchLatency(long val)
         annGraphSearchLatency.add(val);
     }
 
+    public void addPostFilteringReadLatency(long val)
+    {
+        postFilteringReadLatency.add(val);
+    }
+
     public void setFilterSortOrder(FilterSortOrder filterSortOrder)
     {
         this.filterSortOrder = filterSortOrder;
@@ -247,6 +253,11 @@ public void updateAnnRerankFloor(float observedFloor)
             annRerankFloor = max(annRerankFloor, observedFloor);
     }
 
+    public long getPostFilteringReadLatency()
+    {
+        return postFilteringReadLatency.longValue();
+    }
+
     /**
      * Determines the order of filtering and sorting operations.
      * Currently used only by vector search.