Add server-side table chart search (dimension + metric columns)

ddpui/api/public_api.py

@@ -32,7 +32,12 @@
     FilterPreviewResponse,
     FilterOptionResponse as AuthFilterOptionResponse,
 )
-from ddpui.schemas.chart_schemas import ChartConfig, ChartDataResponse, ChartDataPayload
+from ddpui.schemas.chart_schemas import (
+    ChartConfig,
+    ChartDataResponse,
+    ChartDataPayload,
+    ChartSort,
+)
 from ddpui.core.charts import charts_service
 from ddpui.core.charts.charts_service import get_warehouse_client, execute_query
 from ddpui.core.datainsights.query_builder import AggQueryBuilder
@@ -1287,12 +1292,34 @@ def get_public_report_chart_data(request, token: str, chart_id: int):
         return 404, PublicErrorResponse(error="Chart data unavailable", is_valid=False)
 
 
+def _apply_live_sort_search_override(
+    chart_payload: ChartDataPayload, sort: Optional[str], search: Optional[str]
+) -> None:
+    """Apply live sort/search on top of the frozen payload — everything else stays frozen."""
+    if not sort and not search:
+        return
+    if chart_payload.extra_config is None:
+        chart_payload.extra_config = {}
+    if sort:
+        chart_payload.extra_config["sort"] = [
+            ChartSort(**item).model_dump() for item in json.loads(sort)
+        ]
+    if search:
+        chart_payload.extra_config["search"] = search
+
+
 @public_router.get(
     "/reports/{token}/charts/{chart_id}/data-preview/",
     response={200: dict, 404: PublicErrorResponse},
 )
 def get_public_report_table_data(
-    request, token: str, chart_id: int, page: int = 0, limit: int = 100
+    request,
+    token: str,
+    chart_id: int,
+    page: int = 0,
+    limit: int = 100,
+    sort: Optional[str] = None,
+    search: Optional[str] = None,
 ):
     """Get table chart data for a public report"""
     try:
@@ -1308,6 +1335,7 @@ def get_public_report_table_data(
             extra_config=chart_config.get("extra_config"),
         )
         chart_payload = charts_service.build_chart_data_payload(config)
+        _apply_live_sort_search_override(chart_payload, sort, search)
 
         preview_data = charts_service.get_chart_data_table_preview(
             org_warehouse, chart_payload, page, limit
@@ -1336,8 +1364,13 @@ def get_public_report_table_data(
     "/reports/{token}/charts/{chart_id}/total-rows/",
     response={200: dict, 404: PublicErrorResponse},
 )
-def get_public_report_table_total_rows(request, token: str, chart_id: int):
-    """Get total row count for table chart in a public report"""
+def get_public_report_table_total_rows(
+    request, token: str, chart_id: int, search: Optional[str] = None
+):
+    """Get total row count for table chart in a public report.
+
+    Sort isn't accepted here — it can't change a row count, only search can.
+    """
     try:
         snapshot, chart_config, org_warehouse = _get_frozen_chart_for_public_report(
             token, chart_id, request
@@ -1351,6 +1384,7 @@ def get_public_report_table_total_rows(request, token: str, chart_id: int):
             extra_config=chart_config.get("extra_config"),
         )
         chart_payload = charts_service.build_chart_data_payload(config)
+        _apply_live_sort_search_override(chart_payload, sort=None, search=search)
 
         total_rows = charts_service.get_chart_data_total_rows(org_warehouse, chart_payload)
 

ddpui/core/charts/charts_service.py

@@ -5,12 +5,12 @@
 from decimal import Decimal
 from collections import defaultdict
 
-from sqlalchemy import column, func, and_, or_, text, literal_column
+from sqlalchemy import column, func, and_, or_, text, literal_column, cast, String
 
 from ddpui.models.org import OrgWarehouse
 from ddpui.models.metric import Metric
 from ddpui.models.visualization import Chart
-from ddpui.core.datainsights.query_builder import AggQueryBuilder
+from ddpui.core.datainsights.query_builder import AggQueryBuilder, build_aggregate_expression
 from ddpui.utils.warehouse.client.warehouse_factory import WarehouseFactory
 from ddpui.utils.warehouse.client.warehouse_interface import Warehouse
 from ddpui.utils.custom_logger import CustomLogger
@@ -571,11 +571,36 @@ def build_chart_query(
                 # Aggregated query: use multi-metric query builder
                 query_builder = build_multi_metric_query(payload, query_builder, org_warehouse)
 
-            # Apply filters and sorting before returning
+            # Apply filters, search and sorting before returning
             if payload.dashboard_filters:
                 query_builder = apply_dashboard_filters(query_builder, payload.dashboard_filters)
             if payload.extra_config and payload.extra_config.get("filters"):
                 query_builder = apply_chart_filters(query_builder, payload.extra_config["filters"])
+            if payload.extra_config and payload.extra_config.get("search"):
+                # HAVING can only reference GROUP BY keys. With metrics + time_grain +
+                # a warehouse, the primary dimension is grouped by DATE_TRUNC(...), not
+                # its raw column, so search must use that same expression. Otherwise
+                # (any one missing) it's grouped by the raw column, which stays searchable.
+                time_grain = payload.extra_config.get("time_grain")
+                warehouse_type = org_warehouse.wtype.lower() if org_warehouse else None
+                primary_dim_is_time_grained = bool(
+                    payload.metrics and time_grain and warehouse_type and payload.dimension_col
+                )
+                extra_search_expressions = None
+                if primary_dim_is_time_grained:
+                    search_dimensions = [d for d in dimensions if d != payload.dimension_col]
+                    extra_search_expressions = [
+                        apply_time_grain(column(payload.dimension_col), time_grain, warehouse_type)
+                    ]
+                else:
+                    search_dimensions = dimensions
+                query_builder = apply_table_search(
+                    query_builder,
+                    payload.extra_config["search"],
+                    search_dimensions,
+                    payload.metrics,
+                    extra_expressions=extra_search_expressions,
+                )
             if payload.extra_config and payload.extra_config.get("sort"):
                 query_builder = apply_chart_sorting(
                     query_builder, payload.extra_config["sort"], payload
@@ -926,6 +951,69 @@ def apply_chart_filters(
     return query_builder
 
 
+def apply_table_search(
+    query_builder: AggQueryBuilder,
+    search_term: str,
+    columns: List[str],
+    metrics: Optional[List[Any]] = None,
+    extra_expressions: Optional[List[Any]] = None,
+) -> AggQueryBuilder:
+    """Filter table-chart rows to those where any column, metric, or extra expression
+    contains the search term.
+
+    Case-insensitive substring match, OR'd across columns (matches if ANY column
+    contains the term) — unlike apply_chart_filters, which ANDs distinct filter
+    conditions together and can't express "match in any of these columns".
+
+    Everything is cast to text first: dimensions/metrics aren't always strings
+    (e.g. a boolean column or a COUNT), and lower()/like() only accept text —
+    Postgres errors with "function lower(boolean) does not exist" otherwise.
+
+    Without metrics or extra_expressions, this is a plain WHERE (filters raw rows,
+    cheaper). With either, dimensions are grouped (GROUP BY), so a metric's value
+    only exists post-aggregation — WHERE can't see it. The whole condition (columns +
+    metrics + extra_expressions) moves to HAVING instead, referencing the grouped
+    dimension columns directly (valid — they're GROUP BY keys, not output aliases)
+    alongside the same aggregate/derived expressions used to build the SELECT list.
+
+    Args:
+        query_builder: The AggQueryBuilder instance to modify
+        search_term: Raw search text from the table's search box
+        columns: Column names to search across (a table chart's dimensions)
+        metrics: The chart's metrics (ChartMetric-like objects), if any
+        extra_expressions: Pre-built SQLAlchemy expressions to search via HAVING —
+            e.g. a time-grain-transformed dimension, which must reuse the exact same
+            expression used in GROUP BY rather than its raw column name.
+
+    Returns:
+        Modified query builder with the search condition applied
+    """
+    if not search_term or (not columns and not metrics and not extra_expressions):
+        return query_builder
+
+    pattern = f"%{search_term.strip().lower()}%"
+    conditions = [func.lower(cast(column(col), String)).like(pattern) for col in columns]
+    for expr in extra_expressions or []:
+        conditions.append(func.lower(cast(expr, String)).like(pattern))
+
+    if not metrics and not extra_expressions:
+        query_builder.where_clause(or_(*conditions))
+        return query_builder
+
+    for metric in metrics or []:
+        if metric.column_expression:
+            expr = literal_column(metric.column_expression)
+        else:
+            if not metric.aggregation:
+                continue
+            expr = build_aggregate_expression(metric.column, metric.aggregation)
+        conditions.append(func.lower(cast(expr, String)).like(pattern))
+
+    query_builder.having_clause(or_(*conditions))
+
+    return query_builder
+
+
 def apply_chart_sorting(
     query_builder: AggQueryBuilder, sort_config: List[Dict[str, Any]], payload=None
 ) -> AggQueryBuilder:

ddpui/core/datainsights/query_builder.py

@@ -12,6 +12,35 @@
 )
 
 
+def build_aggregate_expression(column_name: str, agg_func: str):
+    """Build the raw (unlabeled) SQLAlchemy aggregate expression for a column + function.
+
+    Extracted from add_aggregate_column so callers that need the expression itself
+    (e.g. a HAVING clause referencing the same aggregate) don't duplicate this mapping.
+    """
+    agg_func_lower = agg_func.lower()
+
+    # Handle count with None column - use COUNT(*) instead of COUNT(None)
+    if agg_func_lower == "count" and column_name is None:
+        return func.count()
+
+    col = column(column_name)
+
+    agg_functions = {
+        "sum": func.sum,
+        "avg": func.avg,
+        "count": func.count,
+        "min": func.min,
+        "max": func.max,
+        "count_distinct": lambda c: func.count(func.distinct(c)),
+    }
+
+    if agg_func_lower not in agg_functions:
+        raise ValueError(f"Unsupported aggregate function: {agg_func}")
+
+    return agg_functions[agg_func_lower](col)
+
+
 class AggQueryBuilder:
     """
     Aggregate query builder
@@ -36,31 +65,7 @@ def add_column(self, agg_col: Function | ColumnClause):
 
     def add_aggregate_column(self, column_name: str, agg_func: str, alias: str = None):
         """Add an aggregate column with specified function"""
-        agg_func_lower = agg_func.lower()
-
-        # Handle count with None column - use COUNT(*) instead of COUNT(None)
-        if agg_func_lower == "count" and column_name is None:
-            agg_column = func.count()
-        else:
-            # Quote column name to preserve case
-            col = column(column_name)
-
-            agg_functions = {
-                "sum": func.sum,
-                "avg": func.avg,
-                "count": func.count,
-                "min": func.min,
-                "max": func.max,
-                "count_distinct": lambda c: func.count(func.distinct(c)),
-            }
-
-            if agg_func_lower not in agg_functions:
-                raise ValueError(f"Unsupported aggregate function: {agg_func}")
-
-            if agg_func_lower == "count_distinct":
-                agg_column = agg_functions[agg_func_lower](col)
-            else:
-                agg_column = agg_functions[agg_func_lower](col)
+        agg_column = build_aggregate_expression(column_name, agg_func)
 
         if alias:
             agg_column = agg_column.label(alias)