You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by mi...@apache.org on 2026/10/19 20:03:28 UTC

(superset) branch master updated: fix(semantic-layer): refuse a chart's own filter on a column the semantic view lacks (#45294)

This is an automated email from the ASF dual-hosted git repository.

aminghadersohi pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/superset.git


The following commit(s) were added to refs/heads/master by this push:
     new 53f14e7b7b1 fix(semantic-layer): refuse a chart's own filter on a column the semantic view lacks (#45294)
53f14e7b7b1 is described below

commit 53f14e7b7b1da605f0732d474c4ad0c3b1cea8cc
Author: Mike Bridge <mi...@preset.io>
AuthorDate: Mon Oct 19 14:03:21 2026 -0600

    fix(semantic-layer): refuse a chart's own filter on a column the semantic view lacks (#45294)
    
    Co-authored-by: Claude Opus 5.5 <no...@anthropic.com>
    Co-authored-by: Mike Bridge <mi...@ext.preset.io>
---
 UPDATING.md                                        |  17 ++-
 .../creating-your-first-dashboard.mdx              |   9 +-
 superset/charts/data/dashboard_filter_context.py   |  22 ++++
 superset/common/query_context_factory.py           |  20 ++-
 superset/mcp_service/chart/chart_helpers.py        |   7 ++
 superset/semantic_layers/mapper.py                 |  43 +++++--
 superset/translations/messages.pot                 |  10 +-
 superset/utils/date_parser.py                      |   7 +-
 .../common/test_query_context_factory.py           |  35 ++++++
 .../mcp_service/chart/test_chart_helpers.py        |  25 ++++
 .../semantic_layers/metric_filter_test.py          | 136 ++++++++++++++++++---
 11 files changed, 297 insertions(+), 34 deletions(-)

diff --git a/UPDATING.md b/UPDATING.md
index 430fdcee64d..3b8b6b13ecd 100644
--- a/UPDATING.md
+++ b/UPDATING.md
@@ -118,8 +118,21 @@ assists people when migrating to a new version.
   the metric; select a dimension or remove the unsupported predicate. Dashboard
   filters on incompatible columns (including metrics) are skipped and reported
   as rejected, so the chart renders with an **Incompatible** filter indicator.
-  Unknown chart-defined columns are also reported as rejected, matching SQL
-  datasets. Valid dimension filters are reported as applied.
+  A chart-defined filter on a column the semantic view no longer has also
+  returns a client error naming the column, instead of being skipped (which
+  widened the result); edit the chart's filters and select a dimension. This
+  differs from SQL datasets, which skip and report such filters. Scheduled
+  reports, alerts and thumbnails for such charts fail until the chart is edited.
+  A "No filter" time range on a missing column is not refused. Dashboard time
+  overrides mark only previously unbounded temporal predicates as dashboard
+  filters; bounded chart-defined filters on missing columns or metrics remain
+  refused. This change affects only opt-in, pre-GA deployments with
+  `SEMANTIC_LAYERS` enabled. On upgrade, dashboard tabs already open across the
+  deploy send filters without `isExtra`; their semantic charts return HTTP 400
+  for incompatible dashboard filters until the user reloads the page. This
+  accepted pre-GA compatibility window will be revisited before GA. A dashboard
+  filter carried into a new chart (such as drill-by "Edit chart") becomes a chart
+  filter. Valid dimension filters are reported as applied.
 
 - Dashboard-applied filters now carry `isExtra` in chart-data requests, including
   MCP chart tools that accept `extra_form_data` (chart data, SQL and previews, for
diff --git a/docs/docs/using-superset/creating-your-first-dashboard.mdx b/docs/docs/using-superset/creating-your-first-dashboard.mdx
index fb4136d8b9e..8165989bfac 100644
--- a/docs/docs/using-superset/creating-your-first-dashboard.mdx
+++ b/docs/docs/using-superset/creating-your-first-dashboard.mdx
@@ -226,10 +226,11 @@ remove that predicate. It is not automatically translated into a HAVING filter.
 
 Dashboard cross-filters and native filters may target charts from other datasets.
 If their column is not a dimension of the semantic view (including metric names),
-the chart still renders and reports the filter as **Incompatible**. Unknown
-chart-defined columns are likewise skipped and reported as rejected, matching SQL
-datasets. Compatible dimension filters still apply, and the response reports both
-applied and rejected columns so skipped predicates are visible.
+the chart still renders and reports the filter as **Incompatible**. A filter
+defined by the chart on a column the view no longer has returns a client error
+naming the column; edit the chart's filters and select a dimension. Compatible
+dimension filters still apply, and the response reports both applied and rejected
+columns so skipped predicates are visible.
 
 The **Incompatible filters** badge and detail section apply only to semantic-view
 charts. SQL-dataset charts retain their applied-filter badge behavior.
diff --git a/superset/charts/data/dashboard_filter_context.py b/superset/charts/data/dashboard_filter_context.py
index 03ed6a3f6ca..8bc28737d6d 100644
--- a/superset/charts/data/dashboard_filter_context.py
+++ b/superset/charts/data/dashboard_filter_context.py
@@ -32,6 +32,8 @@ from superset.constants import (
 )
 from superset.models.dashboard import Dashboard
 from superset.utils import json
+from superset.utils.core import QueryObjectFilterClause
+from superset.utils.date_parser import is_no_time_range
 
 logger = logging.getLogger(__name__)
 
@@ -342,6 +344,24 @@ def get_dashboard_filter_context(
     return context
 
 
+def mark_dashboard_time_range_filters(
+    filters: list[QueryObjectFilterClause],
+) -> None:
+    """Give a dashboard time range provenance over saved unbounded predicates.
+
+    The query factory rewrites temporal predicates with the dashboard range; a
+    saved range with bounds stays the chart's own.
+    """
+    for filter_ in filters:
+        if not isinstance(filter_, dict):
+            continue  # Malformed saved filters are left to schema validation.
+        saved: object = filter_.get("val")
+        if filter_.get("op") == "TEMPORAL_RANGE" and (
+            saved is None or (isinstance(saved, str) and is_no_time_range(saved))
+        ):
+            filter_["isExtra"] = True
+
+
 def apply_dashboard_filter_context(  # noqa: C901
     query_context: dict[str, Any],
     extra_form_data: dict[str, Any],
@@ -382,5 +402,7 @@ def apply_dashboard_filter_context(  # noqa: C901
         for src_key, target_key in EXTRA_FORM_DATA_OVERRIDE_REGULAR_MAPPINGS.items():
             if src_key in extra_form_data:
                 query[target_key] = extra_form_data[src_key]
+                if src_key == "time_range" and extra_form_data[src_key]:
+                    mark_dashboard_time_range_filters(query.get("filters") or [])
 
         query["extra_form_data"] = extra_form_data
diff --git a/superset/common/query_context_factory.py b/superset/common/query_context_factory.py
index 96a1eacde82..ebd5d1c19e6 100644
--- a/superset/common/query_context_factory.py
+++ b/superset/common/query_context_factory.py
@@ -32,6 +32,7 @@ from superset.models.slice import Slice
 from superset.security.manager import STOCK_RAISE_FOR_ACCESS
 from superset.superset_typing import Column
 from superset.utils.core import DatasourceDict, DatasourceType, is_adhoc_column
+from superset.utils.date_parser import is_no_time_range
 
 if TYPE_CHECKING:
     from superset.connectors.sqla.models import BaseDatasource
@@ -172,7 +173,7 @@ class QueryContextFactory:  # pylint: disable=too-few-public-methods
         query_object: QueryObject,
     ) -> QueryObject:
         self._apply_granularity(query_object, form_data, datasource)
-        self._apply_filters(query_object)
+        self._apply_filters(query_object, form_data)
         self._add_tooltip_columns(query_object, form_data)
         self._add_currency_column(query_object, form_data, datasource)
         return query_object
@@ -434,8 +435,23 @@ class QueryContextFactory:  # pylint: disable=too-few-public-methods
                     if filter["col"] != filter_to_remove
                 ]
 
-    def _apply_filters(self, query_object: QueryObject) -> None:
+    def _apply_filters(
+        self, query_object: QueryObject, form_data: dict[str, Any] | None = None
+    ) -> None:
+        """Apply the time range, retaining the source of dashboard overrides."""
+        extra_form_data: object = (form_data or {}).get("extra_form_data")
+        dashboard_time_override: bool = (
+            isinstance(extra_form_data, dict)
+            and "time_range" in extra_form_data
+            and extra_form_data["time_range"] == query_object.time_range
+        )
         if query_object.time_range:
             for filter_object in query_object.filter:
                 if filter_object["op"] == "TEMPORAL_RANGE":
+                    saved: object = filter_object.get("val")
+                    was_unbounded: bool = saved is None or (
+                        isinstance(saved, str) and is_no_time_range(saved)
+                    )
                     filter_object["val"] = query_object.time_range
+                    if dashboard_time_override and was_unbounded:
+                        filter_object["isExtra"] = True
diff --git a/superset/mcp_service/chart/chart_helpers.py b/superset/mcp_service/chart/chart_helpers.py
index a56d081199b..92306bb97ed 100644
--- a/superset/mcp_service/chart/chart_helpers.py
+++ b/superset/mcp_service/chart/chart_helpers.py
@@ -432,6 +432,13 @@ def merge_extra_form_data_filters_into_query(
         extra_form_data,
     )
     merge_form_data_filters_into_query(query, extra_query_form_data)
+    if extra_form_data.get("time_range"):
+        from superset.charts.data.dashboard_filter_context import (
+            mark_dashboard_time_range_filters,
+        )
+
+        # Like a dashboard range, it is extra only over unbounded saved ranges.
+        mark_dashboard_time_range_filters(query.get("filters") or [])
 
 
 def _deck_gl_spatial_cols(spatial: dict[str, Any] | None) -> list[str]:
diff --git a/superset/semantic_layers/mapper.py b/superset/semantic_layers/mapper.py
index 0ef05f08833..4c73b13354e 100644
--- a/superset/semantic_layers/mapper.py
+++ b/superset/semantic_layers/mapper.py
@@ -94,7 +94,7 @@ from superset.utils.core import (
     QueryObjectFilterClause,
     TIME_COMPARISON,
 )
-from superset.utils.date_parser import get_past_or_future
+from superset.utils.date_parser import get_past_or_future, is_no_time_range
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -449,7 +449,8 @@ def map_semantic_result_to_query_result(
         # Template filters - not applicable to semantic layers
         # (semantic layers don't use Jinja templates)
         applied_template_filters=None,
-        # Match SQL datasets: unknown columns are rejected, not silently applied.
+        # Dashboard (isExtra) filters on columns the view lacks are reported
+        # as rejected; chart-defined ones were refused during validation.
         applied_filter_columns=[
             column
             for column in filter_columns
@@ -1436,22 +1437,48 @@ def validate_filter_columns(
     dimension_names: Collection[str],
     metric_names: Collection[str],
 ) -> None:
-    """Refuse chart-defined metric predicates; report incompatible extras later."""
+    """Refuse chart-defined predicates on metrics or on columns the view lacks.
+
+    Dashboard (``isExtra``) filters are not refused: incompatible ones are
+    skipped and reported, so a dashboard filter cannot break the chart. A
+    "No filter" time range constrains nothing, so missing columns are allowed;
+    chart-defined metric filters remain unsupported.
+    """
     for filter_ in filters:
         column: Column = filter_["col"]
         if (
-            isinstance(column, str)
-            and column not in dimension_names
-            and column in metric_names
-            and not filter_.get("isExtra")
+            not isinstance(column, str)
+            or column in dimension_names
+            or filter_.get("isExtra")
         ):
+            continue
+        if column in metric_names:
             raise QueryObjectValidationError(
                 _(
                     "Filter column '%(column)s' is a metric; semantic views only "
-                    "filter on dimensions",
+                    "filter on dimensions. Select a dimension or remove the filter.",
                     column=column,
                 )
             )
+        if _is_no_op_time_range(filter_):
+            continue
+        raise QueryObjectValidationError(
+            _(
+                "Filter column '%(column)s' is not in this semantic view. Select a "
+                "dimension or remove the filter.",
+                column=column,
+            )
+        )
+
+
+def _is_no_op_time_range(
+    filter_: QueryObjectFilterClause | ValidatedQueryObjectFilterClause,
+) -> bool:
+    """Whether a filter is a time range that applies no bounds."""
+    value: object = filter_.get("val")
+    return filter_.get("op") == FilterOperator.TEMPORAL_RANGE.value and (
+        value is None or (isinstance(value, str) and is_no_time_range(value))
+    )
 
 
 def _validate_filters(
diff --git a/superset/translations/messages.pot b/superset/translations/messages.pot
index 5d7efef10fe..0162b7db4a7 100644
--- a/superset/translations/messages.pot
+++ b/superset/translations/messages.pot
@@ -6822,7 +6822,15 @@ msgid "Filter charts"
 msgstr ""
 
 #, python-format
-msgid "Filter column '%(column)s' is a metric; semantic views only filter on dimensions"
+msgid ""
+"Filter column '%(column)s' is a metric; semantic views only filter on "
+"dimensions. Select a dimension or remove the filter."
+msgstr ""
+
+#, python-format
+msgid ""
+"Filter column '%(column)s' is not in this semantic view. Select a "
+"dimension or remove the filter."
 msgstr ""
 
 msgid "Filter has default value"
diff --git a/superset/utils/date_parser.py b/superset/utils/date_parser.py
index c30677d640f..bb232d01a72 100644
--- a/superset/utils/date_parser.py
+++ b/superset/utils/date_parser.py
@@ -490,6 +490,11 @@ def get_default_bound_for_shorthand(time_range: str) -> str:
     return get_relative_base(match.group(1)) if match else "today"
 
 
+def is_no_time_range(time_range: str | None) -> bool:
+    """Recognize the canonical or request-localized unbounded time range."""
+    return time_range == NO_TIME_RANGE or time_range == _(NO_TIME_RANGE)
+
+
 def get_since_until(  # pylint: disable=too-many-arguments,too-many-locals,too-many-branches,too-many-statements  # noqa: C901
     time_range: str | None = None,
     since: str | None = None,
@@ -526,7 +531,7 @@ def get_since_until(  # pylint: disable=too-many-arguments,too-many-locals,too-m
     separator = " : "
     _relative_end = relative_end if relative_end else "today"
 
-    if time_range == NO_TIME_RANGE or time_range == _(NO_TIME_RANGE):
+    if is_no_time_range(time_range):
         return None, None
 
     if time_range and time_range.startswith("Last") and separator not in time_range:
diff --git a/tests/unit_tests/common/test_query_context_factory.py b/tests/unit_tests/common/test_query_context_factory.py
index bdbcae3dd58..f9402ea8a1f 100644
--- a/tests/unit_tests/common/test_query_context_factory.py
+++ b/tests/unit_tests/common/test_query_context_factory.py
@@ -18,10 +18,12 @@ from datetime import datetime, timezone
 from unittest.mock import Mock, patch
 
 import pytest
+from pytest_mock import MockerFixture
 
 from superset.common.query_context_factory import QueryContextFactory
 from superset.common.query_object import QueryObject
 from superset.models.slice import Slice
+from superset.utils.core import QueryObjectFilterClause
 
 
 class TestQueryContextFactory:
@@ -977,3 +979,36 @@ class TestQueryContextFactory:
         self.factory._add_currency_column(query_object, form_data, datasource)
 
         assert query_object.columns == ["col1"]
+
+
+@pytest.mark.parametrize(
+    "saved", [None, "No filter", "Aucun filtre", "2024-01-01 : 2024-06-01"]
+)
+@pytest.mark.parametrize("dashboard", [False, True])
+@pytest.mark.parametrize("already_extra", [False, True])
+def test_time_override_stamps_only_unbounded_saved_predicates(
+    mocker: MockerFixture,
+    saved: str | None,
+    dashboard: bool,
+    already_extra: bool,
+) -> None:
+    """Rewriting a real chart range never grants it dashboard provenance."""
+    mocker.patch("superset.utils.date_parser._", return_value="Aucun filtre")
+    filter_: QueryObjectFilterClause = {
+        "col": "ds",
+        "op": "TEMPORAL_RANGE",
+        "val": saved,
+    }
+    if already_extra:
+        filter_["isExtra"] = True
+    query: QueryObject = QueryObject(
+        filters=[filter_], time_range="2025-01-01 : 2025-02-01"
+    )
+    form_data: dict[str, object] = (
+        {"extra_form_data": {"time_range": query.time_range}} if dashboard else {}
+    )
+    QueryContextFactory()._apply_filters(query, form_data)
+    assert filter_["val"] == query.time_range
+    assert bool(filter_.get("isExtra")) == (
+        already_extra or (dashboard and saved in (None, "No filter", "Aucun filtre"))
+    )
diff --git a/tests/unit_tests/mcp_service/chart/test_chart_helpers.py b/tests/unit_tests/mcp_service/chart/test_chart_helpers.py
index 92045de436c..64af1b546ed 100644
--- a/tests/unit_tests/mcp_service/chart/test_chart_helpers.py
+++ b/tests/unit_tests/mcp_service/chart/test_chart_helpers.py
@@ -435,6 +435,31 @@ def test_mcp_extra_filters_keep_dashboard_provenance(
         validate_filter_columns([chart_owned], {"category"}, {"total_amount"})
 
 
+def test_merge_extra_time_range_marks_only_unbounded_saved_ranges(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A request range is dashboard provenance over unbounded saved ranges only."""
+    monkeypatch.setattr(
+        "superset.mcp_service.chart.chart_helpers.resolve_datasource_engine",
+        lambda datasource_id, datasource_type: "base",
+    )
+    unbounded: dict[str, Any] = {"col": "ds", "op": "TEMPORAL_RANGE", "val": None}
+    bounded: dict[str, Any] = {
+        "col": "ds",
+        "op": "TEMPORAL_RANGE",
+        "val": "2024-01-01 : 2024-06-01",
+    }
+    query: dict[str, Any] = {"filters": [unbounded, bounded, None]}
+
+    merge_extra_form_data_filters_into_query(
+        query, {"time_range": "Last week"}, 1, "table"
+    )
+
+    assert query["time_range"] == "Last week"
+    assert unbounded["isExtra"] is True
+    assert "isExtra" not in bounded
+
+
 def test_merge_extra_form_data_time_grain_override_lands_in_extras(monkeypatch):
     """A time_grain_sqla override must reach the query object.
 
diff --git a/tests/unit_tests/semantic_layers/metric_filter_test.py b/tests/unit_tests/semantic_layers/metric_filter_test.py
index 4761db0fc38..67ab2c72568 100644
--- a/tests/unit_tests/semantic_layers/metric_filter_test.py
+++ b/tests/unit_tests/semantic_layers/metric_filter_test.py
@@ -37,9 +37,13 @@ from superset_core.semantic_layers.types import (
 )
 from werkzeug.test import TestResponse
 
+from superset.charts.data.dashboard_filter_context import apply_dashboard_filter_context
 from superset.common.query_context_processor import QueryCacheManager
 from superset.constants import CacheRegion
 from superset.exceptions import QueryObjectValidationError
+from superset.mcp_service.chart.chart_helpers import (
+    merge_extra_form_data_filters_into_query,
+)
 from superset.semantic_layers.mapper import (
     map_query_object,
     validate_query_object,
@@ -88,6 +92,14 @@ def metric_view(mocker: MockerFixture) -> tuple[SemanticView, MagicMock]:
     return view, provider
 
 
+METRIC_FILTER_ERROR: str = "is a metric; semantic views only filter on dimensions"
+MISSING_FILTER_ERROR: str = "is not in this semantic view"
+REFUSED_CHART_FILTERS: list[tuple[str, str]] = [
+    ("total_amount", METRIC_FILTER_ERROR),
+    ("missing_column", MISSING_FILTER_ERROR),
+]
+
+
 def _request(filters: list[QueryObjectFilterClause]) -> dict[str, Any]:
     """Build an ordinary synchronous JSON chart-data request."""
     return {
@@ -100,15 +112,17 @@ def _request(filters: list[QueryObjectFilterClause]) -> dict[str, Any]:
     }
 
 
+@pytest.mark.parametrize(("column", "error"), REFUSED_CHART_FILTERS)
 @pytest.mark.parametrize("mixed", [False, True])
 def test_chart_data_rejects_non_dimension_filters(
     client: FlaskClient,
     full_api_access: None,
     metric_view: tuple[SemanticView, MagicMock],
     mixed: bool,
+    column: str,
+    error: str,
 ) -> None:
-    """Chart-defined metric predicates refuse the whole data request with 400."""
-    column: str = "total_amount"
+    """Chart-defined metric or missing-column predicates refuse the request."""
     provider: MagicMock = metric_view[1]
     filters: list[QueryObjectFilterClause] = (
         [
@@ -123,16 +137,19 @@ def test_chart_data_rejects_non_dimension_filters(
 
     assert response.status_code == 400, response.json
     assert column in str(response.json)
-    assert "is a metric; semantic views only filter on dimensions" in str(response.json)
+    assert error in str(response.json)
     provider.get_table.assert_not_called()
     provider.get_row_count.assert_not_called()
 
 
+@pytest.mark.parametrize(("column", "error"), REFUSED_CHART_FILTERS)
 def test_invalid_filter_is_rejected_before_result_cache(
     client: FlaskClient,
     full_api_access: None,
     metric_view: tuple[SemanticView, MagicMock],
     mocker: MockerFixture,
+    column: str,
+    error: str,
 ) -> None:
     """A cached partially filtered result cannot bypass column validation."""
     metric_view[0].cache_timeout = 600
@@ -153,33 +170,36 @@ def test_invalid_filter_is_rejected_before_result_cache(
         json=_request(
             [
                 {"col": "category", "op": "==", "val": "Books"},
-                {"col": "total_amount", "op": ">=", "val": 999999},
+                {"col": column, "op": ">=", "val": 999999},
             ]
         ),
     )
     assert response.status_code == 400, response.json
-    assert "total_amount" in str(response.json)
+    assert error in str(response.json)
     cache_get.assert_not_called()
     backend.get.assert_not_called()
     metric_view[1].get_table.assert_not_called()
 
 
+@pytest.mark.parametrize(("column", "error"), REFUSED_CHART_FILTERS)
 @pytest.mark.parametrize("entry", ["validation", "mapping"])
-def test_direct_semantic_entry_rejects_metric_filter(
-    metric_view: tuple[SemanticView, MagicMock], entry: str
+def test_direct_semantic_entry_rejects_non_dimension_filter(
+    metric_view: tuple[SemanticView, MagicMock], entry: str, column: str, error: str
 ) -> None:
     """Direct mapper callers receive the same column-specific validation error."""
     query: ValidatedQueryObject = ValidatedQueryObject(
         datasource=metric_view[0],
         columns=["category"],
         metrics=["total_amount"],
-        filters=[{"col": "total_amount", "op": ">=", "val": 999999}],
+        filters=[{"col": column, "op": ">=", "val": 999999}],
     )
     entry_point: Callable[[ValidatedQueryObject], object] = (
         validate_query_object if entry == "validation" else map_query_object
     )
-    with pytest.raises(QueryObjectValidationError, match="total_amount"):
+    raised: pytest.ExceptionInfo[QueryObjectValidationError]
+    with pytest.raises(QueryObjectValidationError, match=error) as raised:
         entry_point(query)
+    assert column in str(raised.value)
 
 
 @pytest.mark.parametrize("same_named_metric", [False, True])
@@ -217,22 +237,18 @@ def test_dimension_filters_still_reach_provider(
     }
 
 
-@pytest.mark.parametrize(
-    ("column", "external"),
-    [("country", True), ("total_amount", True), ("missing_column", False)],
-)
+@pytest.mark.parametrize("column", ["country", "total_amount", "missing_column"])
 @pytest.mark.parametrize("mixed", [False, True])
 def test_incompatible_filter_is_reported_without_breaking_chart(
     client: FlaskClient,
     full_api_access: None,
     metric_view: tuple[SemanticView, MagicMock],
     column: str,
-    external: bool,
     mixed: bool,
 ) -> None:
-    """Foreign dashboard columns and unknown chart columns match SQL rejection."""
+    """Dashboard filters on columns the view lacks are skipped and reported."""
     filters: list[QueryObjectFilterClause] = [
-        {"col": column, "op": "IN", "val": ["US"], "isExtra": external},
+        {"col": column, "op": "IN", "val": ["US"], "isExtra": True},
     ]
     if mixed:
         filters.append({"col": "category", "op": "==", "val": "Books"})
@@ -286,3 +302,91 @@ def test_filter_reporting_survives_result_cache_hit(
         [{"column": column}] if column == "category" else []
     )
     metric_view[1].get_table.assert_not_called()
+
+
+@pytest.mark.parametrize("value", ["No filter", "Aucun filtre", None])
+def test_chart_no_op_time_range_on_missing_column_is_not_refused(
+    client: FlaskClient,
+    full_api_access: None,
+    metric_view: tuple[SemanticView, MagicMock],
+    value: str | None,
+    mocker: MockerFixture,
+) -> None:
+    """Saving from a dashboard can store a "No filter" range on a foreign column;
+    it constrains nothing, so it must not break the chart."""
+    mocker.patch("superset.utils.date_parser._", return_value="Aucun filtre")
+    filters: list[QueryObjectFilterClause] = [
+        {"col": "ds", "op": "TEMPORAL_RANGE", "val": value},
+    ]
+    response: TestResponse = client.post("/api/v1/chart/data", json=_request(filters))
+    assert response.status_code == 200, response.json
+    metric_view[1].get_table.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    "saved_range", [None, "No filter", "Aucun filtre", "2024-01-01 : 2024-06-01"]
+)
+@pytest.mark.parametrize("column", ["ds", "total_amount"])
+@pytest.mark.parametrize("source", ["chart", "browser", "server", "mcp", "mismatched"])
+def test_dashboard_time_override_preserves_foreign_filter_provenance(
+    client: FlaskClient,
+    full_api_access: None,
+    metric_view: tuple[SemanticView, MagicMock],
+    source: str,
+    saved_range: str | None,
+    column: str,
+    mocker: MockerFixture,
+) -> None:
+    """Only saved unbounded predicates acquire dashboard time provenance."""
+    mocker.patch("superset.utils.date_parser._", return_value="Aucun filtre")
+    payload: dict[str, Any] = _request(
+        [{"col": column, "op": "TEMPORAL_RANGE", "val": saved_range}]
+    )
+    time_range: str = "2025-01-01 : 2025-02-01"
+    if source == "server":
+        apply_dashboard_filter_context(payload, {"time_range": time_range})
+    elif source == "mcp":
+        # MCP get_chart_data merges the override into the saved query only.
+        merge_extra_form_data_filters_into_query(
+            payload["queries"][0], {"time_range": time_range}, 73, "semantic_view"
+        )
+    else:
+        payload["queries"][0]["time_range"] = time_range
+        if source in {"browser", "mismatched"}:
+            payload["form_data"] = {
+                "extra_form_data": {
+                    "time_range": time_range if source == "browser" else "Last week"
+                }
+            }
+    response: TestResponse = client.post("/api/v1/chart/data", json=payload)
+    refused: bool = (
+        source in {"chart", "mismatched"} or saved_range == "2024-01-01 : 2024-06-01"
+    )
+    assert response.status_code == (400 if refused else 200), response.json
+    if refused:
+        metric_view[1].get_table.assert_not_called()
+    else:
+        assert response.json is not None
+        assert response.json["result"][0]["rejected_filter_columns"] == [column]
+        metric_view[1].get_table.assert_called_once()
+        query: SemanticQuery = metric_view[1].get_table.call_args.args[0]
+        assert not query.filters
+
+
+@pytest.mark.parametrize("value", ["No filter", "Aucun filtre", None])
+def test_metric_no_op_time_range_is_still_refused(
+    client: FlaskClient,
+    full_api_access: None,
+    metric_view: tuple[SemanticView, MagicMock],
+    mocker: MockerFixture,
+    value: str | None,
+) -> None:
+    """The no-op exception for missing columns does not relax metric refusal."""
+    mocker.patch("superset.utils.date_parser._", return_value="Aucun filtre")
+    response: TestResponse = client.post(
+        "/api/v1/chart/data",
+        json=_request([{"col": "total_amount", "op": "TEMPORAL_RANGE", "val": value}]),
+    )
+    assert response.status_code == 400, response.json
+    assert METRIC_FILTER_ERROR in str(response.json)
+    metric_view[1].get_table.assert_not_called()