Align explain preagg routing with runtime (#95)

Author: nicosuave

sidemantic/core/semantic_layer.py

@@ -558,6 +558,8 @@ def explain(
 
         metrics = metrics or []
         dimensions = dimensions or []
+        filters = list(filters) if filters else []
+        segments = segments or []
 
         # Compile the actual SQL (respects use_preaggregations setting)
         sql = self.compile(
@@ -576,21 +578,15 @@ def explain(
 
         use_preaggs = use_preaggregations if use_preaggregations is not None else self.use_preaggregations
 
-        # Extract model names from metric/dimension/filter references
-        model_names = set()
-        for ref in list(metrics) + list(dimensions):
-            if "." in ref:
-                model_name = ref.split(".", 1)[0]
-                if model_name:
-                    model_names.add(model_name)
-
-        # Also extract model names from filters (e.g., "customers.status = 'vip'")
-        import re
-
-        for f in filters or []:
-            # Match "model.column" patterns before operators
-            for match in re.finditer(r"(\w+)\.(\w+)\s*[=<>!]", f):
-                model_names.add(match.group(1))
+        generator = SQLGenerator(
+            self.graph,
+            dialect=dialect or self.dialect,
+            preagg_database=self.preagg_database,
+            preagg_schema=self.preagg_schema,
+        )
+        segment_filters = generator._resolve_segments(segments)
+        all_filters = filters + segment_filters
+        model_names = generator._find_required_models(metrics, dimensions, all_filters)
 
         # Strip model prefixes from metrics and dimensions for matcher
         bare_metrics = []
@@ -610,18 +606,17 @@ def explain(
                 bare_dims.append(dim_name)
 
         bare_filters = []
-        if filters:
-            for f in filters:
-                # Strip any model prefix from filters
-                for mn in model_names:
-                    f = f.replace(f"{mn}.", "")
-                bare_filters.append(f)
+        for f in all_filters:
+            for mn in model_names:
+                f = f.replace(f"{mn}.", "")
+                f = f.replace(f"{mn}_cte.", "")
+            bare_filters.append(f)
 
         # Check preconditions for preagg routing
         if not use_preaggs:
             return QueryPlan(
                 sql=sql,
-                model=next(iter(model_names), None),
+                model=model_names[0] if model_names else None,
                 metrics=bare_metrics,
                 dimensions=bare_dims,
                 used_preaggregation=False,
@@ -641,14 +636,14 @@ def explain(
         if ungrouped:
             return QueryPlan(
                 sql=sql,
-                model=next(iter(model_names)),
+                model=model_names[0],
                 metrics=bare_metrics,
                 dimensions=bare_dims,
                 used_preaggregation=False,
                 routing_reason="ungrouped query, preaggs require aggregation",
             )
 
-        model_name = next(iter(model_names))
+        model_name = model_names[0]
         try:
             model = self.get_model(model_name)
         except KeyError:

tests/test_preagg_explain.py

@@ -258,3 +258,70 @@ def test_explain_cross_model_filter_detected(self):
 
         assert plan.used_preaggregation is False
         assert "multi-model" in plan.routing_reason
+
+    def test_explain_cross_model_filter_with_in_detected(self):
+        """IN filters referencing another model should trigger multi-model detection."""
+        layer = make_layer_with_preaggs()
+
+        from sidemantic import Relationship
+
+        customers = Model(
+            name="customers",
+            table="customers",
+            primary_key="customer_id",
+            dimensions=[
+                Dimension(name="status", type="categorical", sql="status"),
+            ],
+            metrics=[Metric(name="customer_count", agg="count")],
+        )
+        layer.add_model(customers)
+
+        events = layer.get_model("events")
+        events.relationships = [
+            Relationship(name="customers", type="many_to_one", foreign_key="customer_id"),
+        ]
+
+        plan = layer.explain(
+            metrics=["events.event_count"],
+            dimensions=["events.event_type"],
+            filters=["customers.status IN ('vip')"],
+        )
+
+        assert plan.used_preaggregation is False
+        assert "multi-model" in plan.routing_reason
+
+    def test_explain_includes_segment_filters_for_preagg_matching(self):
+        """Segment predicates should be considered when evaluating pre-agg eligibility."""
+        from sidemantic import Segment
+
+        layer = SemanticLayer(use_preaggregations=True)
+        layer.add_model(
+            Model(
+                name="events",
+                table="events",
+                primary_key="event_id",
+                dimensions=[
+                    Dimension(name="event_type", type="categorical", sql="event_type"),
+                    Dimension(name="status", type="categorical", sql="status"),
+                ],
+                metrics=[Metric(name="event_count", agg="count")],
+                segments=[Segment(name="active_only", sql="{model}.status = 'active'")],
+                pre_aggregations=[
+                    PreAggregation(
+                        name="by_type",
+                        measures=["event_count"],
+                        dimensions=["event_type"],
+                    )
+                ],
+            )
+        )
+
+        plan = layer.explain(
+            metrics=["events.event_count"],
+            dimensions=["events.event_type"],
+            segments=["events.active_only"],
+        )
+
+        assert plan.used_preaggregation is False
+        assert plan.selected_preagg is None
+        assert "no pre-aggregation matched" in plan.routing_reason