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/09/18 22:35:55 UTC
(superset) branch master updated: fix(mcp): pre-validate metric/dimension compatibility in semantic-view get_table (#44265)
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 5ecb19cf92a fix(mcp): pre-validate metric/dimension compatibility in semantic-view get_table (#44265)
5ecb19cf92a is described below
commit 5ecb19cf92ae8dedbf5b33ec92324cc77c4ee10e
Author: Mike Bridge <mi...@preset.io>
AuthorDate: Fri Sep 18 16:35:47 2026 -0600
fix(mcp): pre-validate metric/dimension compatibility in semantic-view get_table (#44265)
Co-authored-by: Claude Opus 4.8 <no...@anthropic.com>
---
.../mcp_service/semantic_layer/tool/get_table.py | 33 +-
.../semantic_layer/tool/test_get_table.py | 384 +++++++++++++++++++++
2 files changed, 416 insertions(+), 1 deletion(-)
diff --git a/superset/mcp_service/semantic_layer/tool/get_table.py b/superset/mcp_service/semantic_layer/tool/get_table.py
index 550bc7bcc14..8fb6390154a 100644
--- a/superset/mcp_service/semantic_layer/tool/get_table.py
+++ b/superset/mcp_service/semantic_layer/tool/get_table.py
@@ -25,7 +25,7 @@ import logging
import time
from collections.abc import Iterable
from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, TYPE_CHECKING
from fastmcp import Context
from sqlalchemy.exc import SQLAlchemyError
@@ -55,6 +55,9 @@ from superset.mcp_service.utils.cache_utils import get_cache_status_from_result
from superset.mcp_service.utils.oauth2_utils import build_oauth2_redirect_message
from superset.mcp_service.utils.response_utils import format_data_columns
+if TYPE_CHECKING:
+ from superset.semantic_layers.models import SemanticView
+
logger = logging.getLogger(__name__)
@@ -67,6 +70,7 @@ class _ResolvedDatasource:
valid_columns: set[str]
valid_metrics: set[str]
warnings: list[str] = field(default_factory=list)
+ view: "SemanticView | None" = None
grain_column: str | None = None
valid_grains: dict[str, dict[str, str]] | None = None
temporal_columns: set[str] = field(default_factory=set)
@@ -244,6 +248,7 @@ def _resolve_external_view(
valid_columns,
valid_metrics,
warnings,
+ view=view,
grain_column=grain_column,
valid_grains=valid_grains,
temporal_columns=valid_dttm_columns,
@@ -438,6 +443,32 @@ async def _run_get_table_query(
error_type="ValidationError",
)
+ required_dimensions: set[str] = (
+ set(request.dimensions)
+ | {query_filter.col for query_filter in request.filters}
+ | (set(request.order_by) & resolved.valid_columns)
+ ) - resolved.temporal_columns
+ if (
+ not is_builtin
+ and resolved.view is not None
+ and request.metrics
+ and required_dimensions
+ ):
+ compatible: set[str] = set(
+ resolved.view.get_compatible_dimensions(request.metrics, [])
+ )
+ incompatible: list[str] = sorted(required_dimensions - compatible)
+ if incompatible:
+ return SemanticLayerError.create(
+ error=(
+ f"Dimension(s) {incompatible} are not compatible with the selected "
+ f"metric(s) {sorted(request.metrics)} "
+ f"for view '{resolved.display_name}'. "
+ "Call get_compatible_dimensions for the valid combinations."
+ ),
+ error_type="ValidationError",
+ )
+
await ctx.report_progress(3, 5, "Building query")
query_dict = _build_query_dict(request, resolved.time_col, resolved.grain_column)
diff --git a/tests/unit_tests/mcp_service/semantic_layer/tool/test_get_table.py b/tests/unit_tests/mcp_service/semantic_layer/tool/test_get_table.py
index e506041e532..d4f1be1c7e2 100644
--- a/tests/unit_tests/mcp_service/semantic_layer/tool/test_get_table.py
+++ b/tests/unit_tests/mcp_service/semantic_layer/tool/test_get_table.py
@@ -117,6 +117,7 @@ def _make_view(view_id: int = 5) -> MagicMock:
def temporal_view() -> Generator[MagicMock, None, None]:
"""Resolve a view with a temporal dimension and three queryable grains."""
view: MagicMock = _make_view()
+ view.get_compatible_dimensions.return_value = ["country_name"]
view.columns = [
_make_column("metric_time", True),
_make_column("country_name"),
@@ -215,6 +216,11 @@ async def test_get_table_temporal_result_requires_known_variant(
_make_column("other_date", True),
]
temporal_view.metrics = [_make_metric("date_count")]
+ temporal_view.get_compatible_dimensions.return_value = [
+ "date__label",
+ "date__",
+ "date__Year",
+ ]
temporal_view.implementation.get_dimensions.return_value = [
Dimension(
id="date_month", name="date", type=pa.timestamp("us"), grain=Grains.MONTH
@@ -465,6 +471,142 @@ def test_get_table_builtin_grain_rejected() -> None:
assert "semantic views only" in result.error
+@pytest.mark.asyncio
+async def test_get_table_incompatible_view_dimensions(mcp_server: FastMCP) -> None:
+ """Reject known-incompatible pairs before querying, with deterministic guidance."""
+ view: MagicMock = _make_view()
+ view.metrics = [_make_metric("orders"), _make_metric("bookings")]
+ view.columns = [_make_column("product__product_name"), _make_column("category")]
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(get_table_module, "execute_tabular_query") as execute,
+ patch.object(get_table_module, "_build_query_dict") as build,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "view_id": 5,
+ "metrics": ["orders", "bookings"],
+ "dimensions": ["product__product_name", "category"],
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is False
+ assert data["error_type"] == "ValidationError"
+ assert data["error"] == (
+ "Dimension(s) ['category', 'product__product_name'] are not compatible "
+ "with the selected metric(s) ['bookings', 'orders'] for view 'view_5'. "
+ "Call get_compatible_dimensions for the valid combinations."
+ )
+ view.get_compatible_dimensions.assert_called_once_with(["orders", "bookings"], [])
+ build.assert_not_called()
+ execute.assert_not_called()
+
+
+@pytest.mark.parametrize("backend_fails", [False, True])
+@pytest.mark.asyncio
+async def test_get_table_compatible_view_executes(
+ mcp_server: FastMCP,
+ backend_fails: bool,
+) -> None:
+ """Compatible selections execute; genuine backend failures remain InternalError."""
+ view: MagicMock = _make_view()
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ query_result: dict[str, Any] = {
+ "queries": [
+ {
+ "data": [{"country_name": "GB", "bookings": 3}],
+ "colnames": ["country_name", "bookings"],
+ "rowcount": 1,
+ }
+ ]
+ }
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(
+ get_table_module, "execute_tabular_query", return_value=query_result
+ ) as execute,
+ ):
+ if backend_fails:
+ execute.side_effect = RuntimeError("provider execution failed")
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "view_id": 5,
+ "metrics": ["bookings"],
+ "dimensions": ["country_name"],
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ view.get_compatible_dimensions.assert_called_once_with(["bookings"], [])
+ execute.assert_called_once()
+ assert execute.call_args.args[:2] == (5, "semantic_view")
+ if backend_fails:
+ assert data["success"] is False
+ assert data["error_type"] == "InternalError"
+ assert "provider execution failed" in data["error"]
+ else:
+ assert data["success"] is True
+ assert data["data"] == [{"country_name": "GB", "bookings": 3}]
+
+
+@pytest.mark.parametrize(
+ "builtin,metrics,dimensions",
+ [
+ (True, ["revenue"], ["region"]),
+ (False, [], ["country_name"]),
+ (False, ["bookings"], []),
+ ],
+)
+@pytest.mark.asyncio
+async def test_get_table_skips_compatibility_without_join_risk(
+ mcp_server: FastMCP,
+ builtin: bool,
+ metrics: list[str],
+ dimensions: list[str],
+) -> None:
+ """Builtin datasets and empty selections never consult view compatibility."""
+ dataset: MagicMock = _make_dataset()
+ view: MagicMock = _make_view()
+ query_result: dict[str, Any] = {"queries": [{"data": [], "colnames": []}]}
+ with (
+ patch("superset.daos.dataset.DatasetDAO.find_by_id", return_value=dataset),
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(
+ get_table_module, "execute_tabular_query", return_value=query_result
+ ) as execute,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "dataset_id" if builtin else "view_id": 42 if builtin else 5,
+ "metrics": metrics,
+ "dimensions": dimensions,
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is True
+ execute.assert_called_once()
+ dataset.get_compatible_dimensions.assert_not_called()
+ view.get_compatible_dimensions.assert_not_called()
+
+
@pytest.mark.asyncio
async def test_get_table_builtin_happy_path(mcp_server: FastMCP) -> None:
"""get_table returns tabular data for a built-in dataset."""
@@ -877,6 +1019,172 @@ async def test_get_table_builtin_time_range_without_configured_dttm_validation_e
assert "no temporal column is configured" in data["message"]
+@pytest.mark.parametrize("dimensions", [[], ["country_name"]])
+@pytest.mark.asyncio
+async def test_get_table_rejects_incompatible_ordering_dimension(
+ mcp_server: FastMCP, dimensions: list[str]
+) -> None:
+ """Ordering by an unselected dimension still requires a compatible join."""
+ view: MagicMock = _make_view()
+ view.columns.append(_make_column("product_name"))
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(get_table_module, "execute_tabular_query") as execute,
+ patch.object(get_table_module, "_build_query_dict") as build,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "view_id": 5,
+ "metrics": ["bookings"],
+ "dimensions": dimensions,
+ "order_by": ["product_name"],
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is False
+ assert data["error_type"] == "ValidationError"
+ assert "product_name" in data["error"]
+ view.get_compatible_dimensions.assert_called_once_with(["bookings"], [])
+ build.assert_not_called()
+ execute.assert_not_called()
+
+
+@pytest.mark.parametrize(
+ "order_by", [["country_name"], ["bookings"], ["country_name", "bookings"]]
+)
+@pytest.mark.asyncio
+async def test_get_table_preserves_compatible_and_metric_ordering(
+ mcp_server: FastMCP, order_by: list[str]
+) -> None:
+ """Metric ordering is not mistaken for a required join dimension."""
+ view: MagicMock = _make_view()
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(
+ get_table_module,
+ "execute_tabular_query",
+ return_value={"queries": [{"data": [], "colnames": []}]},
+ ) as execute,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "view_id": 5,
+ "metrics": ["bookings"],
+ "order_by": order_by,
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is True
+ execute.assert_called_once()
+ assert [name for name, _ in execute.call_args.args[2]["orderby"]] == order_by
+ if "country_name" in order_by:
+ view.get_compatible_dimensions.assert_called_once_with(["bookings"], [])
+ else:
+ view.get_compatible_dimensions.assert_not_called()
+
+
+@pytest.mark.parametrize("longhand", [False, True])
+@pytest.mark.asyncio
+async def test_temporal_filter_spellings_delegate_to_execution(
+ mcp_server: FastMCP, longhand: bool
+) -> None:
+ """Both temporal spellings execute even when discovery excludes the axis."""
+ view: MagicMock = _make_view()
+ view.columns.append(_make_column("order_ts", True))
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ request: dict[str, Any] = {"view_id": 5, "metrics": ["bookings"]}
+ temporal_filter: dict[str, str] = {
+ "col": "order_ts",
+ "op": "TEMPORAL_RANGE",
+ "val": "2024-01-01 : 2024-03-01",
+ }
+ if longhand:
+ request["filters"] = [temporal_filter]
+ else:
+ request.update(time_column="order_ts", time_range=temporal_filter["val"])
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(
+ get_table_module,
+ "execute_tabular_query",
+ return_value={"queries": [{"data": [], "colnames": []}]},
+ ) as execute,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool("get_table", {"request": request})
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is True
+ execute.assert_called_once()
+ assert execute.call_args.args[2]["filters"] == [temporal_filter]
+ view.get_compatible_dimensions.assert_not_called()
+
+
+@pytest.mark.parametrize(
+ "usage", ["ordinary_filter", "groupby", "ordering", "temporal_range"]
+)
+@pytest.mark.parametrize("temporal", [False, True])
+@pytest.mark.asyncio
+async def test_temporal_column_identity_controls_compatibility_exemption(
+ mcp_server: FastMCP, usage: str, temporal: bool
+) -> None:
+ """An undiscovered time axis remains usable; ordinary columns are rejected."""
+ view: MagicMock = _make_view()
+ view.columns.append(_make_column("order_ts", True))
+ view.get_compatible_dimensions.return_value = []
+ column: str = "order_ts" if temporal else "country_name"
+ request: dict[str, Any] = {
+ "view_id": 5,
+ "metrics": ["bookings"],
+ }
+ if usage == "ordinary_filter":
+ request["filters"] = [{"col": column, "op": "==", "val": "2024-02-01"}]
+ elif usage == "groupby":
+ request["dimensions"] = [column]
+ elif usage == "ordering":
+ request["order_by"] = [column]
+ else:
+ request["filters"] = [
+ {"col": column, "op": "TEMPORAL_RANGE", "val": "2024-01-01 : 2024-03-01"}
+ ]
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(
+ get_table_module,
+ "execute_tabular_query",
+ return_value={"queries": [{"data": [], "colnames": []}]},
+ ) as execute,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool("get_table", {"request": request})
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is temporal
+ if temporal:
+ execute.assert_called_once()
+ view.get_compatible_dimensions.assert_not_called()
+ else:
+ assert data["error_type"] == "ValidationError"
+ assert column in data["error"]
+ execute.assert_not_called()
+
+
class TestGetTableTimeRangeValidation:
"""GetTableRequest.time_range rejects values get_since_until() would
otherwise silently resolve to an unbounded, full-table range.
@@ -1049,6 +1357,82 @@ async def test_get_table_rejects_open_ended_range_before_execution(
execute.assert_not_called()
+@pytest.mark.parametrize("dimensions", [[], ["country_name"]])
+@pytest.mark.asyncio
+async def test_get_table_rejects_unselected_incompatible_filter(
+ mcp_server: FastMCP,
+ dimensions: list[str],
+) -> None:
+ """Filtering still requires a join when the dimension is absent from groupby."""
+ view: MagicMock = _make_view()
+ view.columns.append(_make_column("product_name"))
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(get_table_module, "execute_tabular_query") as execute,
+ patch.object(get_table_module, "_build_query_dict") as build,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "view_id": 5,
+ "metrics": ["bookings"],
+ "dimensions": dimensions,
+ "filters": [
+ {"col": "product_name", "op": "==", "val": "Widget"}
+ ],
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is False
+ assert data["error_type"] == "ValidationError"
+ assert "product_name" in data["error"]
+ view.get_compatible_dimensions.assert_called_once_with(["bookings"], [])
+ build.assert_not_called()
+ execute.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_get_table_compatible_filter_without_groupby(mcp_server: FastMCP) -> None:
+ """A filter-only compatible dimension is validated and retained in the query."""
+ view: MagicMock = _make_view()
+ view.get_compatible_dimensions.return_value = ["country_name"]
+ with (
+ patch(
+ "superset.daos.semantic_layer.SemanticViewDAO.find_by_id", return_value=view
+ ),
+ patch.object(
+ get_table_module,
+ "execute_tabular_query",
+ return_value={"queries": [{"data": [], "colnames": []}]},
+ ) as execute,
+ ):
+ async with Client(mcp_server) as client:
+ result: Any = await client.call_tool(
+ "get_table",
+ {
+ "request": {
+ "view_id": 5,
+ "metrics": ["bookings"],
+ "dimensions": [],
+ "filters": [{"col": "country_name", "op": "==", "val": "GB"}],
+ }
+ },
+ )
+ data: dict[str, Any] = json.loads(result.content[0].text)
+ assert data["success"] is True
+ view.get_compatible_dimensions.assert_called_once_with(["bookings"], [])
+ execute.assert_called_once()
+ assert execute.call_args.args[2]["filters"] == [
+ {"col": "country_name", "op": "==", "val": "GB"}
+ ]
+
+
@pytest.mark.parametrize("explicit_column", [False, True])
def test_grain_is_validated_for_selected_column(
temporal_view: MagicMock,