perf(eap): Add arrayExists filter for attribute name queries (#7832)

Add arrayExists conditions to the WHERE clause when filtering trace item
attributes by substring match. This allows ClickHouse to filter rows in
the PREWHERE stage before loading large attribute arrays, significantly
reducing memory usage and preventing OOM issues.

## Background

The `endpoint_trace_item_attribute_names` endpoint currently filters
attributes using `arrayFilter` in the SELECT clause. This approach
causes ClickHouse to load and process all rows (including large
attribute arrays) before filtering, which leads to OOM issues when many
rows don't contain matching attributes.

## Changes

This PR adds a helper function `_add_substring_match_optimization()`
that adds `arrayExists` conditions to the WHERE clause based on the
attribute type:
- **TYPE_STRING** → `arrayExists(x -> like(x, pattern),
attributes_string)`
- **TYPE_FLOAT/DOUBLE/INT** → `arrayExists(x -> like(x, pattern),
attributes_float)`
- **TYPE_BOOLEAN** → `arrayExists(x -> like(x, pattern),
attributes_bool)`
- **TYPE_UNSPECIFIED** → OR condition checking all three arrays

The optimization is applied after the existing `hasAll` bloom filter
optimization and before the `item_type` check, allowing both filters to
work together.

## How It Works

**Before:**
```sql
SELECT DISTINCT(arrayJoin(arrayFilter(attr -> ... AND like(attr.2, '%span.%'), ...)))
FROM table WHERE project_id = 1 AND date >= ...
-- ❌ Loads ALL rows and their full attribute arrays, then filters in SELECT
```

**After:**
```sql
SELECT DISTINCT(arrayJoin(arrayFilter(attr -> ... AND like(attr.2, '%span.%'), ...)))
FROM table 
WHERE project_id = 1 AND date >= ...
  AND arrayExists(x -> like(x, '%span.%'), attributes_string)  -- ✅ NEW!
-- ✅ ClickHouse filters in PREWHERE before loading arrays
```

## Performance Impact

- Reduces memory usage by filtering rows before loading large attribute
arrays
- Leverages ClickHouse's automatic PREWHERE optimization
- Only processes rows that actually contain matching attributes
- Follows the same pattern as the existing `hasAll` optimization (lines
177-184)
- No impact when `value_substring_match` is empty (guard clause prevents
optimization)

## Testing

All existing tests in
`tests/web/rpc/v1/test_endpoint_trace_item_attribute_names.py` pass
without modification, validating backward compatibility for:
- String, float, double, and boolean attribute types
- Substring matching across all types
- Empty results handling
- Co-occurring attributes with intersection filters

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: volokluev

snuba/web/rpc/v1/endpoint_trace_item_attribute_names.py

@@ -21,8 +21,8 @@
 from snuba.query import OrderBy, OrderByDirection, SelectedExpression
 from snuba.query.data_source.simple import Storage
 from snuba.query.dsl import Functions as f
-from snuba.query.dsl import and_cond, column, in_cond, not_cond
-from snuba.query.expressions import Expression, Lambda
+from snuba.query.dsl import and_cond, column, in_cond, not_cond, or_cond
+from snuba.query.expressions import Argument, Expression, FunctionCall, Lambda
 from snuba.query.logical import Query
 from snuba.query.query_settings import HTTPQuerySettings
 from snuba.reader import Row
@@ -105,6 +105,43 @@ def get_co_occurring_attributes_date_condition(
     )
 
 
+def _add_substring_match_optimization(
+    request: TraceItemAttributeNamesRequest,
+    condition: Expression,
+) -> FunctionCall | Expression:
+    """Add arrayExists to WHERE clause to filter rows before loading arrays.
+
+    This reduces memory usage by only processing rows with matching attributes.
+    Similar to the hasAll optimization, this allows ClickHouse to use PREWHERE
+    and filter rows before loading large attribute arrays.
+    """
+    if not request.value_substring_match:
+        return condition
+
+    pattern = f"%{request.value_substring_match}%"
+    like_lambda = Lambda(None, ("x",), f.like(Argument(None, "x"), pattern))
+
+    if request.type == AttributeKey.Type.TYPE_STRING:
+        return and_cond(condition, f.arrayExists(like_lambda, column("attributes_string")))
+    elif request.type in (
+        AttributeKey.Type.TYPE_FLOAT,
+        AttributeKey.Type.TYPE_DOUBLE,
+        AttributeKey.Type.TYPE_INT,
+    ):
+        return and_cond(condition, f.arrayExists(like_lambda, column("attributes_float")))
+    elif request.type == AttributeKey.Type.TYPE_BOOLEAN:
+        return and_cond(condition, f.arrayExists(like_lambda, column("attributes_bool")))
+    else:  # TYPE_UNSPECIFIED - check all arrays with OR
+        return and_cond(
+            condition,
+            or_cond(
+                f.arrayExists(like_lambda, column("attributes_string")),
+                f.arrayExists(like_lambda, column("attributes_float")),
+                f.arrayExists(like_lambda, column("attributes_bool")),
+            ),
+        )
+
+
 def get_co_occurring_attributes(
     request: TraceItemAttributeNamesRequest,
 ) -> SnubaRequest:
@@ -169,7 +206,7 @@ def get_co_occurring_attributes(
         sample=None,
     )
 
-    condition = and_cond(
+    condition: Expression = and_cond(
         project_id_and_org_conditions(request.meta),
         get_co_occurring_attributes_date_condition(request),
     )
@@ -183,6 +220,9 @@ def get_co_occurring_attributes(
             ),
         )
 
+    # Optimization: Add arrayExists to WHERE clause to filter rows before loading arrays
+    condition = _add_substring_match_optimization(request, condition)
+
     if request.meta.trace_item_type != TraceItemType.TRACE_ITEM_TYPE_UNSPECIFIED:
         condition = and_cond(f.equals(column("item_type"), request.meta.trace_item_type), condition)