Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Metrics Math UX (#70733)

Denis Berezin4c217bdb3c58
diff --git a/.clj-kondo/config.edn b/.clj-kondo/config.edn
index 41b20e42d11..d1508c765af 100644
--- a/.clj-kondo/config.edn
+++ b/.clj-kondo/config.edn
@@ -186,6 +186,7 @@
;; Workspace isolation functions are safe in parallel tests because they operate on
;; isolated, test-specific workspaces and databases that don't affect other tests
metabase-enterprise.workspaces.isolation/destroy-workspace-isolation!
+ metabase.lib-metric.ast.plan/validate-arithmetic-ast!
metabase-enterprise.workspaces.isolation/ensure-database-isolation!
metabase-enterprise.workspaces.test-util/create-ready-ws!
;; Safe in tests, where we typically use a private, temporary index per thread.
diff --git a/e2e/support/helpers/e2e-metrics-viewer-helpers.ts b/e2e/support/helpers/e2e-metrics-viewer-helpers.ts
index 94b52f37c61..bbcbb147d9e 100644
--- a/e2e/support/helpers/e2e-metrics-viewer-helpers.ts
+++ b/e2e/support/helpers/e2e-metrics-viewer-helpers.ts
@@ -1,6 +1,11 @@
export const MetricsViewer = {
goToViewer: () => cy.visit("/explore"),
- searchInput: () => cy.findByTestId("metrics-viewer-search-input"),
+ searchInput: () => {
+ // Click the right edge of the container to focus the CodeMirror input
+ // without accidentally hitting a pill (which would trigger the swap-metric flow).
+ cy.findByTestId("metrics-formula-input").click("right");
+ return cy.findByTestId("metrics-viewer-search-input");
+ },
searchBarPills: () => cy.findAllByTestId("metrics-viewer-search-pill"),
searchResults: () => cy.findByTestId("metrics-search-results"),
breakoutLegend: () => cy.findByTestId("metrics-viewer-breakout-legend"),
@@ -29,6 +34,15 @@ export const MetricsViewer = {
"data-viz-ui-name",
displayType,
),
+ assertAllVizTypes: (displayType: string, expectedLength?: number) => {
+ const subject = MetricsViewer.getAllMetricVisualizations();
+ if (expectedLength !== undefined) {
+ subject.should("have.length", expectedLength);
+ }
+ subject.each(($el) => {
+ cy.wrap($el).should("have.attr", "data-viz-ui-name", displayType);
+ });
+ },
getMerticControls: () => cy.findByTestId("metrics-viewer-controls"),
changeVizType: (display: string) =>
MetricsViewer.getMerticControls()
@@ -44,4 +58,5 @@ export const MetricsViewer = {
MetricsViewer.searchBarPills().contains(metricName).rightclick();
cy.findByText(/Go to metric home page/).click();
},
+ runButton: () => cy.findByTestId("run-expression-button"),
};
diff --git a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts
index 93f8bcee6c2..92fa64fb7b2 100644
--- a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts
+++ b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts
@@ -1,6 +1,7 @@
import Color from "color";
const { H } = cy;
+
import { SAMPLE_DB_ID, WRITABLE_DB_ID } from "e2e/support/cypress_data";
import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";
import {
@@ -8,7 +9,6 @@ import {
ORDERS_MODEL_ID,
} from "e2e/support/cypress_sample_instance_data";
import type { StructuredQuestionDetails } from "e2e/support/helpers";
-
const { ORDERS_ID, ORDERS, PRODUCTS_ID, PRODUCTS, ACCOUNTS_ID, FEEDBACK_ID } =
SAMPLE_DATABASE;
@@ -113,6 +113,150 @@ const ALL_MODELS = [
const SNAPSHOT_NAME = "metrics-explorer-snapshot";
+// ============================================================================
+// Test Helpers
+// ============================================================================
+
+/**
+ * Add a metric or measure to the explorer via the search panel
+ */
+const addMetric = (name: string) => {
+ // for some reason `type` clicks in the middle of the input first
+ // so we use `{end}` to make sure we type at the end
+ H.MetricsViewer.searchInput().type(`{end}, ${name}`);
+ H.MetricsViewer.searchResults().findByText(name).click();
+
+ H.MetricsViewer.runButton().click();
+};
+const addMetricMath = (expression: ({ metricName: string } | string)[]) => {
+ H.MetricsViewer.searchInput().type("{end}, ");
+ for (const item of expression) {
+ if (typeof item === "string") {
+ H.MetricsViewer.searchInput().type(`{end}${item}`);
+ } else {
+ H.MetricsViewer.searchInput().type(`{end}${item.metricName}`);
+ H.MetricsViewer.searchResults().findByText(item.metricName).click();
+ }
+ }
+ H.MetricsViewer.runButton().click();
+};
+
+/**
+ * Select a breakout dimension
+ */
+const selectBreakout = (
+ cardname: string,
+ dimensionName: string,
+ index = 0,
+ binning?: string,
+) => {
+ H.MetricsViewer.searchBarPills().contains(cardname).rightclick();
+ H.popover().findByText("Break out").click();
+ const breakout = H.popover()
+ .findAllByText(dimensionName)
+ .should("have.length.at.least", index)
+ .eq(index)
+ .closest("[role=option]");
+
+ if (binning) {
+ breakout.findByTestId("dimension-list-item-binning").realHover().click();
+ H.popover().findByRole("menuitem", { name: binning }).click();
+ } else {
+ breakout.click();
+ }
+};
+
+/**
+ * Intercept and wait for dataset query
+ */
+const interceptDatasetQuery = () => {
+ cy.intercept("POST", "/api/metric/dataset").as("dataset");
+};
+
+/**
+ * Verify the grid displays the correct number of metric cards
+ */
+const verifyMetricCount = (count: number) => {
+ H.MetricsViewer.searchBarPills().should("have.length", count);
+};
+
+/**
+ * Switch to a specific tab
+ */
+const switchToTab = (tabName: string) => {
+ H.MetricsViewer.getTab(tabName).click();
+};
+
+/**
+ * Convert CSS rgb() color string to uppercase hex (#RRGGBB).
+ */
+const rgbToHex = (rgb: string): string => {
+ return Color(rgb).hex().toUpperCase();
+};
+
+/**
+ * Get hex color(s) from a search bar pill's color indicator.
+ * Returns an array of hex color strings.
+ */
+const getPillColors = (pillIndex: number): Cypress.Chainable<string[]> => {
+ // eslint-disable-next-line metabase/no-unsafe-element-filtering
+ return H.MetricsViewer.searchBarPills()
+ .should("have.length.greaterThan", pillIndex)
+ .eq(pillIndex)
+ .findByTestId("color-indicator-container")
+ .children()
+ .then(($children) => {
+ const colors: string[] = [];
+ $children.each((_i, el) => {
+ const $el = Cypress.$(el);
+ // Multi-dot: backgroundColor is set; single icon: color is set
+ const bg = $el.css("background-color");
+ const fg = $el.css("color");
+ const raw =
+ bg && bg !== "rgba(0, 0, 0, 0)" && bg !== "transparent" ? bg : fg;
+ colors.push(rgbToHex(raw));
+ });
+ return colors;
+ });
+};
+
+/**
+ * Assert that every color in a pill's indicator appears somewhere on the
+ * chart (as a `fill` or `stroke` attribute on an SVG `path`).
+ */
+const assertPillColorsInChart = (pillIndex: number) => {
+ getPillColors(pillIndex).then((colors) => {
+ for (const color of colors) {
+ H.echartsContainer()
+ .find(`path[fill="${color}"], path[stroke="${color}"]`)
+ .should("exist");
+ }
+ });
+};
+
+/**
+ * Assert that the breakout legend dot colors match the pill colors for the
+ * given pill index.
+ */
+const assertLegendColorsMatchPill = (pillIndex: number) => {
+ getPillColors(pillIndex).then((pillColors) => {
+ H.MetricsViewer.breakoutLegend()
+ .findAllByTestId("breakout-legend-dot")
+ .then(($dots) => {
+ const legendColors: string[] = [];
+ $dots.each((_i, el) => {
+ const bg = Cypress.$(el).css("background-color");
+ legendColors.push(rgbToHex(bg));
+ });
+
+ // Every pill color should appear in the legend
+ for (const color of pillColors) {
+ expect(legendColors).to.include(color);
+ }
+ });
+ });
+};
+
describe("scenarios > metrics > explorer", () => {
before(() => {
H.restore();
@@ -124,6 +268,10 @@ describe("scenarios > metrics > explorer", () => {
beforeEach(() => {
H.restore(SNAPSHOT_NAME as any);
cy.signInAsAdmin();
+
+ interceptDatasetQuery();
+ cy.intercept("GET", "/api/metric/*").as("getMetric");
+ cy.intercept("GET", "/api/measure/*").as("getMeasure");
H.resetSnowplow();
H.enableTracking();
});
@@ -132,64 +280,6 @@ describe("scenarios > metrics > explorer", () => {
H.expectNoBadSnowplowEvents();
});
- // ============================================================================
- // Test Helpers
- // ============================================================================
-
- /**
- * Add a metric or measure to the explorer via the search panel
- */
- const addMetric = (name: string) => {
- H.MetricsViewer.searchInput().clear().type(name);
- H.MetricsViewer.searchResults().findByText(name).click();
- };
-
- /**
- * Select a breakout dimension
- */
- const selectBreakout = (
- cardname: string,
- dimensionName: string,
- index = 0,
- binning?: string,
- ) => {
- H.MetricsViewer.searchBarPills().contains(cardname).rightclick();
- H.popover().findByText("Break out").click();
- const breakout = H.popover()
- .findAllByText(dimensionName)
- .should("have.length.at.least", index)
- .eq(index)
- .closest("[role=option]");
-
- if (binning) {
- breakout.findByTestId("dimension-list-item-binning").realHover().click();
- H.popover().findByRole("menuitem", { name: binning }).click();
- } else {
- breakout.click();
- }
- };
-
- /**
- * Intercept and wait for dataset query
- */
- const intercedptDatasetQuery = () => {
- cy.intercept("POST", "/api/metric/dataset").as("dataset");
- };
-
- /**
- * Verify the grid displays the correct number of metric cards
- */
- const verifyMetricCount = (count: number) => {
- H.MetricsViewer.searchBarPills().should("have.length", count);
- };
-
- /**
- * Switch to a specific tab
- */
- const switchToTab = (tabName: string) => {
- H.MetricsViewer.getTab(tabName).click();
- };
-
// ============================================================================
// Entry Points
// ============================================================================
@@ -245,10 +335,6 @@ describe("scenarios > metrics > explorer", () => {
// ============================================================================
describe("Adding metrics and measures", () => {
- beforeEach(() => {
- intercedptDatasetQuery();
- });
-
it("should add multiple metrics", () => {
H.MetricsViewer.goToViewer();
@@ -264,28 +350,22 @@ describe("scenarios > metrics > explorer", () => {
cy.wait("@dataset");
verifyMetricCount(2);
- cy.log("no results");
- H.MetricsViewer.searchInput().type("xyznonexistent");
- H.MetricsViewer.searchResults().should(
- "contain.text",
- "No results found",
- );
-
- cy.log("does not allow duplicates");
- H.MetricsViewer.searchInput().clear().type("Count of products");
- H.MetricsViewer.searchResults().should(
- "contain.text",
- "No results found",
- );
+ cy.log("allows duplicates");
+ addMetric("Count of products");
cy.log("Should allow me to add measures");
- H.MetricsViewer.searchInput().clear();
addMetric("Test Measure");
-
H.expectUnstructuredSnowplowEvent({
event: "metrics_viewer_metric_added",
event_detail: "measure",
});
+
+ cy.log("no results");
+ H.MetricsViewer.searchInput().type("{end}, xyznonexistent");
+ H.MetricsViewer.searchResults().should(
+ "contain.text",
+ "No results found",
+ );
});
it("Should not show me metrics that live in collections I do not have permissions to see", () => {
@@ -310,6 +390,8 @@ describe("scenarios > metrics > explorer", () => {
"No results found",
);
+ H.MetricsViewer.searchInput().clear();
+
addMetric("Count of orders");
cy.log(
"even though we can see the metric, we don't have permissions to run the query",
@@ -326,9 +408,11 @@ describe("scenarios > metrics > explorer", () => {
describe("Breakouts", () => {
beforeEach(() => {
- intercedptDatasetQuery();
+ interceptDatasetQuery();
+ cy.intercept("GET", "/api/metric/*").as("getMetric");
H.MetricsViewer.goToViewer();
addMetric("Count of orders");
+ cy.wait("@getMetric");
cy.wait("@dataset");
});
@@ -403,6 +487,384 @@ describe("scenarios > metrics > explorer", () => {
.children()
.should("have.length", 6);
});
+
+ it("should handle breakout independently for multiple instances of the same metric", () => {
+ cy.log(
+ "Expand formula editor and create expression with second metric instance",
+ );
+ cy.findByTestId("metrics-formula-input").click();
+ H.MetricsViewer.searchInput()
+ .clear()
+ .type("Count of orders, Count of orders + Count of products");
+ H.MetricsViewer.searchResults().findByText("Count of products").click();
+ cy.wait("@getMetric");
+
+ H.MetricsViewer.searchInput().type(", Count of orders");
+ cy.findByTestId("run-expression-button").click();
+
+ cy.wait("@dataset");
+
+ cy.log("Should have 2 metric pills (expression pill is separate)");
+ H.MetricsViewer.searchBarPills().should("have.length", 3);
+
+ cy.log(
+ "Two standalone instances of the same metric should have different pill colors",
+ );
+ getPillColors(0).then((pill0Colors) => {
+ getPillColors(2).then((pill2Colors) => {
+ expect(pill0Colors[0]).to.not.equal(pill2Colors[0]);
+ });
+ });
+
+ cy.log(
+ "Each standalone pill color should appear on the chart as fill or stroke",
+ );
+ assertPillColorsInChart(0);
+ assertPillColorsInChart(2);
+
+ cy.log("Apply breakout to first instance of Count of orders");
+ H.MetricsViewer.searchBarPills().eq(0).rightclick();
+ H.popover().findByText("Break out").click();
+ H.popover().findByText("Source").click();
+ cy.wait("@dataset");
+
+ cy.log("Breakout legend should be visible with Source values");
+ H.MetricsViewer.breakoutLegend().should("be.visible");
+ H.MetricsViewer.breakoutLegend().within(() => {
+ cy.findByRole("heading", { name: "User → Source" }).should(
+ "be.visible",
+ );
+ cy.findByText("Twitter").should("be.visible");
+ cy.findByText("Facebook").should("be.visible");
+ cy.findByText("Organic").should("be.visible");
+ cy.findByText("Google").should("be.visible");
+ cy.findByText("Affiliate").should("be.visible");
+ });
+
+ cy.log("First pill should show multiple color indicators (breakout)");
+ H.MetricsViewer.searchBarPills()
+ .eq(0)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+
+ cy.log("Second pill should have single color (no breakout yet)");
+ H.MetricsViewer.searchBarPills()
+ .eq(2)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length", 1);
+
+ cy.log("Breakout pill colors should appear on the chart");
+ assertPillColorsInChart(0);
+
+ cy.log("Non-breakout pill color should appear on the chart");
+ assertPillColorsInChart(2);
+
+ cy.log(
+ "Legend dot colors should match pill colors for breakout instance",
+ );
+ assertLegendColorsMatchPill(0);
+
+ cy.log("Apply breakout to second instance of Count of orders");
+ H.MetricsViewer.searchBarPills().eq(2).rightclick();
+ H.popover().findByText("Break out").click();
+ H.popover().findByText("Source").click();
+ cy.wait("@dataset");
+
+ cy.log("Both pills should now have multiple color indicators");
+ H.MetricsViewer.searchBarPills()
+ .eq(0)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+ H.MetricsViewer.searchBarPills()
+ .eq(2)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+
+ cy.log("Both breakout pills' colors should appear on the chart");
+ assertPillColorsInChart(0);
+ assertPillColorsInChart(2);
+
+ cy.log(
+ "The two breakout pills should have different color sets (different entities)",
+ );
+ getPillColors(0).then((pill0Colors) => {
+ getPillColors(2).then((pill2Colors) => {
+ expect(pill0Colors[0]).to.not.equal(pill2Colors[0]);
+ });
+ });
+
+ cy.log("Remove breakout from first instance");
+ H.MetricsViewer.searchBarPills().eq(0).rightclick();
+ H.popover().findByText("Remove breakout").click();
+
+ cy.log(
+ "Legend should still be visible because second instance has breakout",
+ );
+ H.MetricsViewer.breakoutLegend().should("be.visible");
+ H.MetricsViewer.breakoutLegend().within(() => {
+ cy.findByRole("heading", { name: "User → Source" }).should(
+ "be.visible",
+ );
+ });
+
+ cy.log("First pill should have single color (breakout removed)");
+ H.MetricsViewer.searchBarPills()
+ .eq(0)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length", 1);
+
+ cy.log("Second pill should still have multiple colors");
+ H.MetricsViewer.searchBarPills()
+ .eq(2)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+
+ cy.log("After removing breakout, pill colors should still match chart");
+ assertPillColorsInChart(0);
+ assertPillColorsInChart(2);
+ });
+
+ it("should preserve breakout state when editing formula and re-running", () => {
+ cy.log("Set up: two instances of Count of orders with an expression");
+ cy.findByTestId("metrics-formula-input").click();
+
+ H.MetricsViewer.searchInput().type(", Count of orders");
+ cy.findByTestId("run-expression-button").click();
+
+ H.MetricsViewer.searchBarPills().should("have.length", 2);
+
+ cy.log("Apply breakout to first instance of Count of orders");
+ H.MetricsViewer.searchBarPills().eq(0).rightclick();
+ H.popover().findByText("Break out").click();
+ H.popover().findByText("Source").click();
+ cy.wait("@dataset");
+
+ cy.log("Verify breakout is applied — first pill has multiple colors");
+ H.MetricsViewer.searchBarPills()
+ .eq(0)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+
+ H.MetricsViewer.breakoutLegend().should("be.visible");
+
+ cy.log("Enter formula edit mode and append a new metric");
+ cy.findByTestId("metrics-formula-input").click();
+ H.MetricsViewer.searchInput().type(", Count of products");
+ H.MetricsViewer.searchResults().findByText("Count of products").click();
+ cy.wait("@getMetric");
+
+ cy.findByTestId("run-expression-button").click();
+ cy.wait("@dataset");
+
+ cy.log("Should now have 3 metric pills");
+ H.MetricsViewer.searchBarPills().should("have.length", 3);
+
+ cy.log(
+ "First pill should still have breakout — multiple color indicators preserved",
+ );
+ H.MetricsViewer.searchBarPills()
+ .eq(0)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+
+ cy.log("Breakout legend should still be visible");
+ H.MetricsViewer.breakoutLegend().should("be.visible");
+ H.MetricsViewer.breakoutLegend().within(() => {
+ cy.findByRole("heading", { name: "User → Source" }).should(
+ "be.visible",
+ );
+ });
+
+ cy.log("Newly added third pill should have single color (no breakout)");
+ H.MetricsViewer.searchBarPills()
+ .eq(2)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length", 1);
+
+ cy.log("Second pill (standalone Count of orders) should still be single");
+ H.MetricsViewer.searchBarPills()
+ .eq(1)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length", 1);
+
+ cy.log("Remove second pill (standalone Count of orders)");
+ H.MetricsViewer.searchBarPills()
+ .eq(1)
+ .findByLabelText("Remove Count of orders")
+ .click();
+
+ cy.log(
+ "First pill should still have breakout — multiple color indicators preserved",
+ );
+ H.MetricsViewer.searchBarPills()
+ .eq(0)
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length.greaterThan", 1);
+ });
+
+ it("cannot breakout a metric math expression", () => {
+ addMetricMath([
+ { metricName: "Count of orders" },
+ "+",
+ { metricName: "Test Measure" },
+ ]);
+ cy.wait("@dataset");
+ H.MetricsViewer.searchBarPills().eq(1).rightclick();
+ H.popover({ skipVisibilityCheck: true }).should("not.exist");
+ });
+
+ it("should show an expression dimension pill with per-metric accordion", () => {
+ cy.log("Create expression: Count of orders + Count of products");
+ cy.findByTestId("metrics-formula-input").click();
+ H.MetricsViewer.searchInput().type(
+ ", Count of orders + Count of products",
+ );
+ H.MetricsViewer.searchResults().findByText("Count of products").click();
+ cy.wait("@getMetric");
+
+ cy.findByTestId("run-expression-button").click();
+ cy.wait("@dataset");
+
+ cy.log(
+ "Dimension pill bar should contain an expression dimension pill with a selected dimension",
+ );
+ H.MetricsViewer.getDimensionPillContainer().within(() => {
+ cy.findByTestId("expression-dimension-pill").should("exist");
+ cy.findByTestId("expression-dimension-pill").should(
+ "not.contain.text",
+ "Select dimensions",
+ );
+ });
+
+ cy.log("Click the expression dimension pill to open the popover");
+ H.MetricsViewer.getDimensionPillContainer()
+ .findByTestId("expression-dimension-pill")
+ .click();
+
+ cy.log(
+ "Popover should show accordion sections for each metric in the expression",
+ );
+ H.popover().within(() => {
+ cy.findAllByTestId("expression-metric-section").should(
+ "have.length",
+ 2,
+ );
+ cy.findAllByTestId("expression-metric-header")
+ .eq(0)
+ .should("contain.text", "Count of orders");
+ cy.findAllByTestId("expression-metric-header")
+ .eq(1)
+ .should("contain.text", "Count of products");
+ });
+
+ cy.log(
+ "Expand the second metric section and verify dimension options are shown",
+ );
+ H.popover().findAllByTestId("expression-metric-header").eq(1).click();
+
+ H.popover().within(() => {
+ cy.get("[data-element-id=list-item][aria-selected=false]")
+ .contains(/Created At/)
+ .click();
+ });
+
+ cy.wait("@dataset");
+
+ cy.log("Expression dimension pill should now show 'Multiple dimensions'");
+ H.MetricsViewer.getDimensionPillContainer()
+ .findByTestId("expression-dimension-pill")
+ .should("contain.text", "Multiple dimensions");
+ });
+
+ it("should preserve non-default expression dimensions after page reload", () => {
+ cy.log(
+ "Create expression with only expression entity: Count of orders + Count of products",
+ );
+ H.MetricsViewer.searchInput().clear();
+ H.MetricsViewer.searchInput().type("Count of orders + Count of products");
+ H.MetricsViewer.searchResults().findByText("Count of products").click();
+ cy.wait("@getMetric");
+
+ cy.findByTestId("run-expression-button").click();
+ cy.wait("@dataset");
+
+ cy.log(
+ "Open the expression dimension pill and pick a non-default dimension for the second metric",
+ );
+ H.MetricsViewer.getDimensionPillContainer()
+ .findByTestId("expression-dimension-pill")
+ .click();
+
+ // Expand the second metric accordion section
+ H.popover().findAllByTestId("expression-metric-header").eq(1).click();
+
+ // Pick a non-default dimension (e.g. "Created At" for Products)
+ H.popover().within(() => {
+ cy.get("[data-element-id=list-item][aria-selected=false]")
+ .contains(/Created At/)
+ .click();
+ });
+
+ cy.wait("@dataset");
+
+ cy.log("Verify the pill shows 'Multiple dimensions' (non-default state)");
+ H.MetricsViewer.getDimensionPillContainer()
+ .findByTestId("expression-dimension-pill")
+ .should("contain.text", "Multiple dimensions");
+
+ cy.log(
+ "Remember the selected dimension index for the first metric before reload",
+ );
+ H.MetricsViewer.getDimensionPillContainer()
+ .findByTestId("expression-dimension-pill")
+ .click();
+
+ H.popover()
+ .find("[data-element-id=list-item]")
+ .then(($items) => {
+ const selectedIndex = $items
+ .toArray()
+ .findIndex((el) => el.getAttribute("aria-selected") === "true");
+ expect(selectedIndex).to.be.gte(0);
+ cy.wrap(selectedIndex).as("firstMetricDimensionIndex");
+ });
+
+ // Close the popover
+ cy.realPress("Escape");
+
+ cy.log("Reload the page and verify the dimension choice persists");
+ cy.reload();
+ cy.wait("@getMetric");
+ cy.wait("@dataset");
+
+ H.MetricsViewer.getDimensionPillContainer()
+ .findByTestId("expression-dimension-pill")
+ .should("contain.text", "Multiple dimensions")
+ .click();
+
+ cy.log(
+ "Verify the first metric still has the same selected dimension after reload",
+ );
+
+ cy.get<number>("@firstMetricDimensionIndex").then((expectedIndex) => {
+ // eslint-disable-next-line metabase/no-unsafe-element-filtering
+ H.popover()
+ .find("[data-element-id=list-item]")
+ .eq(expectedIndex)
+ .should("have.attr", "aria-selected", "true");
+ });
+ });
});
// ============================================================================
@@ -411,18 +873,27 @@ describe("scenarios > metrics > explorer", () => {
describe("Tabs", () => {
beforeEach(() => {
- intercedptDatasetQuery();
+ interceptDatasetQuery();
H.MetricsViewer.goToViewer();
addMetric("Count of orders");
cy.wait("@dataset");
});
it("should switch between tabs", () => {
+ //should work with metric math as well
+ addMetricMath([
+ { metricName: "Count of orders" },
+ "+",
+ { metricName: "Test Measure" },
+ ]);
+ cy.wait("@dataset");
+
H.MetricsViewer.tabsShouldBe([
"Created At",
"State",
"Title",
"Category",
+ "Totals",
]);
H.MetricsViewer.assertVizType("Line");
@@ -430,7 +901,7 @@ describe("scenarios > metrics > explorer", () => {
H.expectUnstructuredSnowplowEvent({
event: "metrics_viewer_dimension_tab_switched",
});
- H.MetricsViewer.assertVizType("Map");
+ H.MetricsViewer.assertAllVizTypes("Map", 2);
switchToTab("Category");
H.MetricsViewer.assertVizType("Bar");
@@ -438,6 +909,9 @@ describe("scenarios > metrics > explorer", () => {
cy.log("should allow changing display types");
H.MetricsViewer.changeVizType("line");
H.MetricsViewer.assertVizType("Line");
+
+ switchToTab("Totals");
+ H.MetricsViewer.assertAllVizTypes("Number", 2);
});
it("should not show dimensions that are already in tabs in the dimension picker", () => {
@@ -461,6 +935,28 @@ describe("scenarios > metrics > explorer", () => {
});
});
+ it("should auto-assign dimensions for a newly added metric after running the formula", () => {
+ cy.log(
+ "After adding a second metric, all dimension pills should have a selected dimension",
+ );
+
+ cy.findByTestId("metrics-formula-input").click();
+ addMetric("Count of products");
+ cy.wait("@dataset");
+
+ H.MetricsViewer.getDimensionPillContainer().within(() => {
+ cy.findAllByText("Select a dimension").should("not.exist");
+ });
+
+ cy.log(
+ "Switch to another tab and verify dimensions are assigned there too",
+ );
+ switchToTab("Category");
+ H.MetricsViewer.getDimensionPillContainer().within(() => {
+ cy.findAllByText("Select a dimension").should("not.exist");
+ });
+ });
+
it("should map shared dimensions to all metrics when adding a tab from the picker", () => {
addMetric("Count of products");
cy.wait("@dataset");
@@ -481,6 +977,37 @@ describe("scenarios > metrics > explorer", () => {
});
});
+ it("should remove then re-add the totals tab", () => {
+ //should work with metric math as well
+ addMetricMath([
+ { metricName: "Count of orders" },
+ "+",
+ { metricName: "Test Measure" },
+ ]);
+ cy.wait("@dataset");
+
+ // Need to hover the tab so that the remove button is accessible
+ H.MetricsViewer.tablist()
+ .findByRole("tab", { name: "Totals" })
+ .realHover();
+ H.MetricsViewer.getRemoveTabButton("Totals").click();
+ H.MetricsViewer.tablist()
+ .findByRole("tab", { name: "Totals" })
+ .should("not.exist");
+
+ H.MetricsViewer.getAddDimensionButton().click();
+ H.popover().within(() => {
+ cy.findAllByText("Totals").click();
+ });
+ cy.wait("@dataset");
+
+ cy.log("totals tab should be selected and show correct viz type");
+ H.MetricsViewer.tablist()
+ .findByRole("tab", { name: "Totals" })
+ .should("have.attr", "aria-selected", "true");
+ H.MetricsViewer.assertAllVizTypes("Number", 2);
+ });
+
it("should add a dimension tab and remove it", () => {
addMetric("Count of feedback");
H.MetricsViewer.tabsShouldBe([
@@ -533,7 +1060,7 @@ describe("scenarios > metrics > explorer", () => {
});
H.MetricsViewer.getDimensionPillContainer().within(() => {
cy.findByText("User → Source").should("exist");
- cy.findByText("Select a dimension").click();
+ cy.findByText("Account → Source").click();
});
H.popover().findByText("Plan").click();
@@ -607,7 +1134,7 @@ describe("scenarios > metrics > explorer", () => {
describe("Automatic split view", () => {
beforeEach(() => {
- intercedptDatasetQuery();
+ interceptDatasetQuery();
H.MetricsViewer.goToViewer();
addMetric("Count of orders");
cy.wait("@dataset");
@@ -678,7 +1205,7 @@ describe("scenarios > metrics > explorer", () => {
describe("Filters", () => {
beforeEach(() => {
- intercedptDatasetQuery();
+ interceptDatasetQuery();
H.MetricsViewer.goToViewer();
addMetric("Count of orders");
cy.wait("@dataset");
@@ -1012,17 +1539,30 @@ describe("scenarios > metrics > explorer", () => {
describe("Drill through", () => {
beforeEach(() => {
- intercedptDatasetQuery();
+ interceptDatasetQuery();
H.MetricsViewer.goToViewer();
addMetric("Count of orders");
cy.wait("@dataset");
+ //should work with metric math as well
+ addMetricMath([
+ { metricName: "Count of orders" },
+ "+",
+ { metricName: "Test Measure" },
+ ]);
+ cy.wait("@dataset");
});
- it("should drill into more graual time dimensions on timeseries chart", () => {
+ it("should drill into more granular time dimensions on timeseries chart", () => {
H.MetricsViewer.getMerticControls()
.findByRole("button", { name: /by month/ })
.should("exist");
- H.MetricsViewer.getMetricVisualizationDataPoints().eq(4).click();
+ // this is messy, but adding the metric math expression causes the viz to unmount and dispose the ECharts instance
+ // if you click on the chart while it's being disposed, the click isn't handled properly
+ cy.wait(1000);
+ H.MetricsViewer.getMetricVisualization()
+ .get("path[stroke='#EF8C8C']")
+ .eq(4)
+ .click();
H.popover().findByText("See this month by week").click();
H.MetricsViewer.getMerticControls()
@@ -1030,7 +1570,7 @@ describe("scenarios > metrics > explorer", () => {
.should("exist");
H.MetricsViewer.getMetricVisualizationDataPoints().should(
"have.length",
- 5,
+ 12,
);
});
@@ -1043,10 +1583,98 @@ describe("scenarios > metrics > explorer", () => {
cy.findByText(/September/).should("be.visible");
cy.findByText(/October/).should("be.visible");
cy.findByText(/November/).should("be.visible");
- cy.findByText(/December/).should("be.visible");
});
});
});
+
+ describe("metric math", () => {
+ beforeEach(() => {
+ interceptDatasetQuery();
+ H.MetricsViewer.goToViewer();
+ addMetric("Count of orders");
+ cy.wait("@dataset");
+ });
+ it("should apply filters and dimensions to individual metric instances within expressions", () => {
+ selectBreakout("Count of orders", "Category");
+ cy.wait("@dataset");
+ addMetricMath([
+ { metricName: "Count of orders" },
+ "+",
+ { metricName: "Count of orders" },
+ ]);
+ cy.wait("@dataset");
+
+ H.MetricsViewer.getFilterButton().click();
+ H.popover().within(() => {
+ cy.findAllByText("Count of orders")
+ .should("have.length", 3)
+ .eq(1)
+ .click();
+ cy.findByText("Category").click();
+ cy.findByText("Doohickey").click();
+ cy.button("Add filter").click();
+ });
+ H.MetricsViewer.getFilterButton().click();
+ H.popover().within(() => {
+ cy.findAllByText("Count of orders").eq(2).click();
+ cy.findByText("Category").click();
+ cy.findByText("Gadget").click();
+ cy.button("Add filter").click();
+ });
+ H.MetricsViewer.getMerticControls()
+ .findByRole("button", { name: /All time/i })
+ .click();
+ H.popover().findByText("Previous 12 months").click();
+
+ function assertMetricMath() {
+ cy.log("breakout is applied");
+ H.MetricsViewer.searchBarPills()
+ .contains(
+ "[data-testid=metrics-viewer-search-pill]",
+ "Count of orders",
+ )
+ .findByTestId("color-indicator-container")
+ .children()
+ .should("have.length", 4);
+ cy.log(
+ "filter pills are in place and show the badge indicating the unique metric instance",
+ );
+ const filterPills = H.MetricsViewer.getAllFilterPills();
+ filterPills.should("have.length", 2);
+ H.MetricsViewer.getAllFilterPills()
+ .eq(0)
+ .findByText("2")
+ .should("not.exist");
+ H.MetricsViewer.getAllFilterPills()
+ .eq(1)
+ .findByText("2")
+ .should("exist");
+
+ cy.log("dimension filter is applied");
+ H.MetricsViewer.getMetricVisualizationDataPoints().should(
+ "have.length.of.at.most",
+ 60,
+ );
+ switchToTab("Totals");
+ cy.log("correct value is calculated from metric math expression");
+ H.MetricsViewer.getAllMetricVisualizations()
+ .should("have.length", 5)
+ .eq(4)
+ .contains("8,915");
+ switchToTab("Created At");
+ }
+ assertMetricMath();
+
+ cy.log("refresh and assert again");
+ cy.reload();
+ assertMetricMath();
+
+ cy.log("edit formula and assert again");
+ H.MetricsViewer.searchInput().type("{end} + 0", { delay: 100 });
+ H.MetricsViewer.runButton().click();
+ assertMetricMath();
+ });
+ });
});
describe("scenarios > metrics > explorer > BigInt filters", () => {
@@ -1073,8 +1701,7 @@ describe("scenarios > metrics > explorer > BigInt filters", () => {
};
H.createQuestion(BIGINT_METRIC);
H.MetricsViewer.goToViewer();
- H.MetricsViewer.searchInput().type(METRIC_NAME);
- H.MetricsViewer.searchResults().findByText(METRIC_NAME).click();
+ addMetric(METRIC_NAME);
H.MetricsViewer.getFilterButton().click();
H.popover().findByText("ID").click();
H.popover().within(() => {
diff --git a/frontend/src/metabase-lib/metric/core.ts b/frontend/src/metabase-lib/metric/core.ts
index 7bd46a2e736..11d7725758a 100644
--- a/frontend/src/metabase-lib/metric/core.ts
+++ b/frontend/src/metabase-lib/metric/core.ts
@@ -713,3 +713,10 @@ export function isSameSource(
): boolean {
return LibMetric.isSameSource(dimension1, dimension2) as boolean;
}
+
+export function isCompatibleType(
+ dimension1: DimensionMetadata,
+ dimension2: DimensionMetadata,
+): boolean {
+ return LibMetric.isCompatibleType(dimension1, dimension2) as boolean;
+}
diff --git a/frontend/src/metabase-types/api/metric.ts b/frontend/src/metabase-types/api/metric.ts
index 745fc47ba4c..9d702d708d1 100644
--- a/frontend/src/metabase-types/api/metric.ts
+++ b/frontend/src/metabase-types/api/metric.ts
@@ -23,10 +23,40 @@ export type Metric = {
result_column_name?: string;
};
-export type ExpressionRef =
+export const MATH_OPERATORS = ["+", "-", "*", "/"] as const;
+export type MathOperator = (typeof MATH_OPERATORS)[number];
+
+export function isMathOperator(key: string): key is MathOperator {
+ return (MATH_OPERATORS as readonly string[]).includes(key);
+}
+
+export const MATH_EXPRESSION_OPERATORS = [
+ ...MATH_OPERATORS,
+ "(",
+ ")",
+ ",",
+] as const;
+export type MathExpressionOperator = (typeof MATH_OPERATORS)[number];
+
+export function isMathExpressionOperator(
+ key: string,
+): key is MathExpressionOperator {
+ return (MATH_EXPRESSION_OPERATORS as readonly string[]).includes(key);
+}
+
+export type JsExpressionRef =
| ["metric", { "lib/uuid": string }, number]
| ["measure", { "lib/uuid": string }, number];
+export type ExpressionRef =
+ | JsExpressionRef
+ | [
+ MathOperator,
+ Record<string, never>,
+ ExpressionRef | number,
+ ExpressionRef | number,
+ ];
+
export type InstanceFilter = {
"lib/uuid": string;
filter: unknown;
@@ -40,7 +70,7 @@ export type TypedProjection = {
};
export type JsMetricDefinition = {
- expression: ExpressionRef | unknown[];
+ expression: JsExpressionRef | unknown[];
filters?: InstanceFilter[];
projections?: TypedProjection[];
};
diff --git a/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx b/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx
index bb44df05440..4d10584fbe8 100644
--- a/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx
+++ b/frontend/src/metabase/common/components/SourceColorIndicator/SourceColorIndicator.tsx
@@ -5,7 +5,7 @@ import S from "./SourceColorIndicator.module.css";
type SourceColorIndicatorProps = {
colors?: string[];
- fallbackIcon: IconName;
+ fallbackIcon?: IconName;
size?: number;
limit?: number;
};
@@ -34,8 +34,22 @@ export function SourceColorIndicator({
</Flex>
);
}
-
+ const color = colors?.[0] ?? "var(--mb-color-text-primary)";
+ if (fallbackIcon) {
+ return (
+ <Flex align="center" data-testid="color-indicator-container">
+ <Icon name={fallbackIcon} size={size} style={{ color }} />
+ </Flex>
+ );
+ }
return (
- <Icon name={fallbackIcon} size={size} style={{ color: colors?.[0] }} />
+ <Box
+ className={S.colorDot}
+ w={size}
+ h={size}
+ style={{
+ backgroundColor: color,
+ }}
+ />
);
}
diff --git a/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx b/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx
index 538b90f3756..6d2fd505cc5 100644
--- a/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/BreakoutLegend/BreakoutLegend.tsx
@@ -3,7 +3,9 @@ import { useMemo } from "react";
import { Box, Flex, Paper, Stack, Text, Title } from "metabase/ui";
import type {
+ MetricSourceId,
MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
SourceBreakoutColorMap,
} from "../../types/viewer-state";
import { buildLegendGroups } from "../../utils/legend";
@@ -11,17 +13,19 @@ import { buildLegendGroups } from "../../utils/legend";
import S from "./BreakoutLegend.module.css";
type BreakoutLegendProps = {
- definitions: MetricsViewerDefinitionEntry[];
+ formulaEntities: MetricsViewerFormulaEntity[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
activeBreakoutColors: SourceBreakoutColorMap;
};
export function BreakoutLegend({
+ formulaEntities,
definitions,
activeBreakoutColors,
}: BreakoutLegendProps) {
const groups = useMemo(
- () => buildLegendGroups(definitions, activeBreakoutColors),
- [definitions, activeBreakoutColors],
+ () => buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),
+ [formulaEntities, definitions, activeBreakoutColors],
);
if (groups.length === 0) {
@@ -41,7 +45,7 @@ export function BreakoutLegend({
<Paper withBorder radius="md" p="lg">
<Stack gap="lg">
{groups.map((group) => (
- <Stack key={group.header} gap="sm">
+ <Stack key={group.key} gap="sm">
<div>
<Title fw="bold" size="md" lh={1.3}>
{group.header}
diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx
index 2712f03000e..147e4473866 100644
--- a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/DimensionPillBar.tsx
@@ -6,21 +6,54 @@ import type { DimensionMetadata } from "metabase-lib/metric";
import type { MetricSourceId } from "../../types/viewer-state";
-export interface DimensionItem {
- id: MetricSourceId;
+import { ExpressionDimensionPill } from "./ExpressionDimensionPill";
+
+// ── Standalone metric pill item ──
+
+export interface MetricDimensionItem {
+ type: "metric";
+ id: number;
label?: string;
icon?: IconName;
colors?: string[];
availableOptions: DimensionOption[];
}
+// ── Expression pill item (one pill per expression entity) ──
+
+export interface ExpressionMetricSource {
+ /** Slot index in dimensionMapping — used as the callback key. */
+ slotIndex: number;
+ sourceId: MetricSourceId;
+ metricName: string;
+ metricCount?: number;
+ colors?: string[];
+ currentDimensionLabel?: string;
+ currentDimensionIcon?: IconName;
+ availableOptions: DimensionOption[];
+}
+
+export interface ExpressionDimensionItem {
+ type: "expression";
+ /** Expression entity index — used as the React key. */
+ id: number;
+ colors?: string[];
+ icon?: IconName;
+ /** Aggregate label derived from selected dimensions. */
+ label?: string;
+ metricSources: ExpressionMetricSource[];
+}
+
+export type DimensionPillBarItem =
+ | MetricDimensionItem
+ | ExpressionDimensionItem;
+
+// ── Component ──
+
export interface DimensionPillBarProps {
- items: DimensionItem[];
- onDimensionChange: (
- itemId: MetricSourceId,
- dimension: DimensionMetadata,
- ) => void;
- onDimensionRemove?: (itemId: MetricSourceId) => void;
+ items: DimensionPillBarItem[];
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ onDimensionRemove?: (slotIndex: number) => void;
disabled?: boolean;
}
@@ -46,20 +79,29 @@ export function DimensionPillBar({
wrap="wrap"
data-testid="metrics-viewer-dimension-pill-container"
>
- {items.map((item) => (
- <DimensionPill
- key={item.id}
- label={item.label}
- icon={item.icon}
- colors={item.colors}
- options={item.availableOptions}
- onSelect={(dimension) => onDimensionChange(item.id, dimension)}
- onRemove={
- onDimensionRemove ? () => onDimensionRemove(item.id) : undefined
- }
- disabled={disabled}
- />
- ))}
+ {items.map((item) =>
+ item.type === "expression" ? (
+ <ExpressionDimensionPill
+ key={`expr-${item.id}`}
+ item={item}
+ onDimensionChange={onDimensionChange}
+ disabled={disabled}
+ />
+ ) : (
+ <DimensionPill
+ key={item.id}
+ label={item.label}
+ icon={item.icon}
+ colors={item.colors}
+ options={item.availableOptions}
+ onSelect={(dimension) => onDimensionChange(item.id, dimension)}
+ onRemove={
+ onDimensionRemove ? () => onDimensionRemove(item.id) : undefined
+ }
+ disabled={disabled}
+ />
+ ),
+ )}
</Flex>
);
}
diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.module.css b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.module.css
new file mode 100644
index 00000000000..2441366f3df
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.module.css
@@ -0,0 +1,25 @@
+.dropdown {
+ display: flex;
+ flex-direction: column;
+ overflow-y: auto;
+}
+
+.dimensionList {
+ max-width: 100%;
+ color: var(--mb-color-brand);
+}
+
+.accordionItem {
+ &:not(:last-child) {
+ border-bottom: 1px solid var(--mb-color-border);
+ }
+}
+
+.accordionControl {
+ padding-block: 0.875rem;
+ cursor: pointer;
+}
+
+.accordionControlExpanded {
+ padding-bottom: 0.375rem;
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.tsx b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.tsx
new file mode 100644
index 00000000000..21a843dcd1c
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/ExpressionDimensionPill.tsx
@@ -0,0 +1,293 @@
+import cx from "classnames";
+import { useCallback, useMemo, useState } from "react";
+import { t } from "ttag";
+
+import {
+ AccordionList,
+ type Section,
+} from "metabase/common/components/AccordionList";
+import type { DimensionOption } from "metabase/common/components/DimensionPill";
+import DPS from "metabase/common/components/DimensionPill/DimensionPill.module.css";
+import { groupIntoSections } from "metabase/common/components/DimensionPill/utils";
+import { SourceColorIndicator } from "metabase/common/components/SourceColorIndicator";
+import {
+ Badge,
+ Box,
+ Flex,
+ Icon,
+ Popover,
+ Text,
+ UnstyledButton,
+} from "metabase/ui";
+import type { DimensionMetadata } from "metabase-lib/metric";
+
+import type {
+ ExpressionDimensionItem,
+ ExpressionMetricSource,
+} from "./DimensionPillBar";
+import S from "./ExpressionDimensionPill.module.css";
+
+const LIST_WIDTH = "20rem";
+
+interface ExpressionDimensionPillProps {
+ item: ExpressionDimensionItem;
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ disabled?: boolean;
+}
+
+function renderItemName(item: DimensionOption) {
+ return item.displayName;
+}
+
+function renderItemIcon(item: DimensionOption) {
+ return <Icon name={item.icon} />;
+}
+
+function itemIsSelected(item: DimensionOption) {
+ return item.selected ?? false;
+}
+
+/**
+ * A dimension pill for expression entities. Renders a single pill that, when
+ * clicked, opens a popover with per-metric accordion sections so the user can
+ * independently pick dimensions for each metric token in the expression.
+ *
+ * When the expression contains only one metric, the popover shows a flat
+ * dimension list (same as a regular DimensionPill).
+ */
+export function ExpressionDimensionPill({
+ item,
+ onDimensionChange,
+ disabled,
+}: ExpressionDimensionPillProps) {
+ const [isOpen, setIsOpen] = useState(false);
+ const [expandedSlots, setExpandedSlots] = useState<number[]>(() =>
+ item.metricSources.length > 0 ? [item.metricSources[0].slotIndex] : [],
+ );
+
+ const hasOptions = item.metricSources.some(
+ (s) => s.availableOptions.length > 0,
+ );
+ const isSingleMetric = item.metricSources.length === 1;
+ const isPlaceholder = !item.label;
+ const isEmpty = isPlaceholder && !hasOptions;
+ const canOpenPopover = hasOptions && !disabled;
+
+ const handleToggleExpanded = useCallback((slotIndex: number) => {
+ setExpandedSlots((prev) =>
+ prev.includes(slotIndex)
+ ? prev.filter((s) => s !== slotIndex)
+ : [...prev, slotIndex],
+ );
+ }, []);
+
+ let pillLabel: string;
+ if (isEmpty) {
+ pillLabel = t`No compatible dimensions`;
+ } else if (isPlaceholder) {
+ pillLabel = t`Select dimensions`;
+ } else {
+ pillLabel = item.label ?? "";
+ }
+
+ return (
+ <Popover
+ opened={isOpen}
+ onChange={setIsOpen}
+ position="top-start"
+ disabled={!canOpenPopover}
+ >
+ <Popover.Target>
+ <Flex
+ className={cx(DPS.pill, canOpenPopover && DPS.interactive)}
+ align="center"
+ gap="xs"
+ opacity={disabled || isEmpty ? 0.6 : undefined}
+ onClick={canOpenPopover ? () => setIsOpen(true) : undefined}
+ data-testid="expression-dimension-pill"
+ >
+ <SourceColorIndicator colors={item.colors} fallbackIcon={item.icon} />
+ <Text size="sm" lh={1} c={isEmpty ? "text-tertiary" : undefined}>
+ {pillLabel}
+ </Text>
+ </Flex>
+ </Popover.Target>
+ <Popover.Dropdown
+ px={0}
+ py="xs"
+ w={LIST_WIDTH}
+ mah={300}
+ className={S.dropdown}
+ >
+ {isSingleMetric ? (
+ <SingleMetricContent
+ source={item.metricSources[0]}
+ onDimensionChange={onDimensionChange}
+ onClose={() => setIsOpen(false)}
+ />
+ ) : (
+ <MultiMetricContent
+ sources={item.metricSources}
+ expandedSlots={expandedSlots}
+ onToggleExpanded={handleToggleExpanded}
+ onDimensionChange={onDimensionChange}
+ onClose={() => setIsOpen(false)}
+ />
+ )}
+ </Popover.Dropdown>
+ </Popover>
+ );
+}
+
+// ── Single metric: flat dimension list ──
+
+interface SingleMetricContentProps {
+ source: ExpressionMetricSource;
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ onClose: () => void;
+}
+
+function SingleMetricContent({
+ source,
+ onDimensionChange,
+ onClose,
+}: SingleMetricContentProps) {
+ const sections = useMemo(
+ () => groupIntoSections(source.availableOptions),
+ [source.availableOptions],
+ );
+
+ const handleSelect = useCallback(
+ (option: DimensionOption) => {
+ onDimensionChange(source.slotIndex, option.dimension);
+ onClose();
+ },
+ [onDimensionChange, source.slotIndex, onClose],
+ );
+
+ return (
+ <AccordionList
+ className={S.dimensionList}
+ sections={sections}
+ onChange={handleSelect}
+ renderItemName={renderItemName}
+ renderItemIcon={renderItemIcon}
+ itemIsSelected={itemIsSelected}
+ alwaysExpanded
+ maxHeight={Infinity}
+ width={240}
+ />
+ );
+}
+
+// ── Multiple metrics: accordion sections ──
+
+interface MultiMetricContentProps {
+ sources: ExpressionMetricSource[];
+ expandedSlots: number[];
+ onToggleExpanded: (slotIndex: number) => void;
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ onClose: () => void;
+}
+
+function MultiMetricContent({
+ sources,
+ expandedSlots,
+ onToggleExpanded,
+ onDimensionChange,
+ onClose,
+}: MultiMetricContentProps) {
+ return (
+ <Box>
+ {sources.map((source) => {
+ const isExpanded = expandedSlots.includes(source.slotIndex);
+ const hasDimensions = source.availableOptions.length > 0;
+ const showDimensions = isExpanded && hasDimensions;
+
+ return (
+ <MetricAccordionItem
+ key={source.slotIndex}
+ source={source}
+ isExpanded={isExpanded}
+ showDimensions={showDimensions}
+ onToggle={() => onToggleExpanded(source.slotIndex)}
+ onDimensionChange={onDimensionChange}
+ onClose={onClose}
+ />
+ );
+ })}
+ </Box>
+ );
+}
+
+interface MetricAccordionItemProps {
+ source: ExpressionMetricSource;
+ isExpanded: boolean;
+ showDimensions: boolean;
+ onToggle: () => void;
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ onClose: () => void;
+}
+
+function MetricAccordionItem({
+ source,
+ isExpanded,
+ showDimensions,
+ onToggle,
+ onDimensionChange,
+ onClose,
+}: MetricAccordionItemProps) {
+ const sections: Section<DimensionOption>[] = useMemo(
+ () => groupIntoSections(source.availableOptions),
+ [source.availableOptions],
+ );
+
+ const handleSelect = useCallback(
+ (option: DimensionOption) => {
+ onDimensionChange(source.slotIndex, option.dimension);
+ onClose();
+ },
+ [onDimensionChange, source.slotIndex, onClose],
+ );
+
+ return (
+ <Box className={S.accordionItem} data-testid="expression-metric-section">
+ <UnstyledButton
+ className={cx(S.accordionControl, {
+ [S.accordionControlExpanded]: showDimensions,
+ })}
+ onClick={onToggle}
+ w="100%"
+ data-testid="expression-metric-header"
+ >
+ <Flex align="center" gap="sm" px="md">
+ <SourceColorIndicator colors={source.colors} size={16} />
+ <Flex align="center" gap="xs" fw={700} style={{ flex: 1 }}>
+ <span>{source.metricName}</span>
+ {(source.metricCount ?? 0) > 1 && (
+ <Badge circle c="text-hover">
+ {source.metricCount}
+ </Badge>
+ )}
+ </Flex>
+ <Icon name={isExpanded ? "chevronup" : "chevrondown"} size={12} />
+ </Flex>
+ </UnstyledButton>
+ {showDimensions && (
+ <Box pb="sm">
+ <AccordionList
+ className={S.dimensionList}
+ sections={sections}
+ onChange={handleSelect}
+ renderItemName={renderItemName}
+ renderItemIcon={renderItemIcon}
+ itemIsSelected={itemIsSelected}
+ alwaysExpanded
+ maxHeight={Infinity}
+ width="100%"
+ />
+ </Box>
+ )}
+ </Box>
+ );
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts
index 24827e77ccf..df64899b439 100644
--- a/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts
+++ b/frontend/src/metabase/metrics-viewer/components/DimensionPillBar/index.ts
@@ -1,2 +1,8 @@
export { DimensionPillBar } from "./DimensionPillBar";
-export type { DimensionPillBarProps, DimensionItem } from "./DimensionPillBar";
+export type {
+ DimensionPillBarProps,
+ MetricDimensionItem,
+ DimensionPillBarItem,
+ ExpressionDimensionItem,
+ ExpressionMetricSource,
+} from "./DimensionPillBar";
diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx
index 1ca37517c3a..2f7ff08a309 100644
--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopover.tsx
@@ -1,53 +1,41 @@
import { useCallback, useState } from "react";
import { Box, Popover } from "metabase/ui";
-import type { FilterClause, MetricDefinition } from "metabase-lib/metric";
-import * as LibMetric from "metabase-lib/metric";
+import type { MetricDefinition } from "metabase-lib/metric";
import { trackMetricsViewerFilterAdded } from "../../analytics";
-import type { MetricSourceId, SourceColorMap } from "../../types/viewer-state";
+import type { SourceColorMap } from "../../types/viewer-state";
+import type { DefinitionSource } from "../../utils/definition-sources";
import S from "./FilterPopover.module.css";
-import type { DefinitionSource } from "./FilterPopoverContent";
import { FilterPopoverContent } from "./FilterPopoverContent";
const POPOVER_MAX_HEIGHT = "37.5rem";
interface FilterPopoverProps {
- definitions: DefinitionSource[];
+ definitionSources: DefinitionSource[];
metricColors: SourceColorMap;
- onUpdateDefinition: (
- id: MetricSourceId,
- definition: MetricDefinition,
+ onSourceDefinitionChange: (
+ source: DefinitionSource,
+ newDefinition: MetricDefinition,
) => void;
children: React.ReactNode;
}
export function FilterPopover({
- definitions,
+ definitionSources,
metricColors,
- onUpdateDefinition,
+ onSourceDefinitionChange,
children,
}: FilterPopoverProps) {
const [isOpen, setIsOpen] = useState(false);
const [contentKey, setContentKey] = useState(0);
- const handleFilterApplied = useCallback(
- (sourceId: MetricSourceId, filter: FilterClause) => {
- const source = definitions.find(
- (definition) => definition.id === sourceId,
- );
- if (!source) {
- return;
- }
- const newDefinition = LibMetric.filter(source.definition, filter);
- onUpdateDefinition(sourceId, newDefinition);
- trackMetricsViewerFilterAdded("metric_filter");
- setIsOpen(false);
- setContentKey((key) => key + 1);
- },
- [definitions, onUpdateDefinition],
- );
+ const handleFilterApplied = useCallback(() => {
+ setIsOpen(false);
+ setContentKey((key) => key + 1);
+ trackMetricsViewerFilterAdded("metric_filter");
+ }, []);
const handleToggle = useCallback(() => {
setIsOpen((prev) => !prev);
@@ -61,11 +49,12 @@ export function FilterPopover({
</Box>
</Popover.Target>
<Popover.Dropdown p={0} mah={POPOVER_MAX_HEIGHT} className={S.dropdown}>
- {definitions.length > 0 && (
+ {definitionSources.length > 0 && (
<FilterPopoverContent
key={contentKey}
- definitions={definitions}
+ definitionSources={definitionSources}
metricColors={metricColors}
+ onSourceDefinitionChange={onSourceDefinitionChange}
onFilterApplied={handleFilterApplied}
/>
)}
diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx
index a47389d8699..865df51f85f 100644
--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx
@@ -7,19 +7,29 @@ import { SourceColorIndicator } from "metabase/common/components/SourceColorIndi
import type {
DimensionListItem,
DimensionSection,
+ MetricGroup,
} from "metabase/metrics/components/FilterPicker/FilterDimensionPicker/types";
import { getMetricGroups } from "metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils";
import { FilterPickerBody } from "metabase/metrics/components/FilterPicker/FilterPickerBody";
import { getDimensionIcon } from "metabase/metrics/utils/dimensions";
-import type { IconName } from "metabase/ui";
-import { Box, Flex, Icon, Text, TextInput, UnstyledButton } from "metabase/ui";
+import {
+ Badge,
+ Box,
+ Flex,
+ Icon,
+ Text,
+ TextInput,
+ UnstyledButton,
+} from "metabase/ui";
import type {
DimensionMetadata,
FilterClause,
MetricDefinition,
} from "metabase-lib/metric";
+import * as LibMetric from "metabase-lib/metric";
-import type { MetricSourceId, SourceColorMap } from "../../types/viewer-state";
+import type { SourceColorMap } from "../../types/viewer-state";
+import type { DefinitionSource } from "../../utils/definition-sources";
import S from "./FilterPopover.module.css";
import { filterDisplayGroupsBySearch } from "./utils";
@@ -27,53 +37,33 @@ import { filterDisplayGroupsBySearch } from "./utils";
const LIST_WIDTH = "20rem";
const FILTER_WIDTH = "24rem";
-export type DefinitionSource = {
- id: MetricSourceId;
- definition: MetricDefinition;
-};
-
type NavigationState =
| { view: "list" }
| { view: "filter"; definitionIndex: number; dimension: DimensionMetadata };
-type DisplayMetricGroup = {
- id: MetricSourceId;
- metricName: string;
- icon: IconName;
- colors: string[] | undefined;
- sections: DimensionSection[];
-};
-
interface FilterPopoverContentProps {
- definitions: DefinitionSource[];
+ definitionSources: DefinitionSource[];
metricColors: SourceColorMap;
- onFilterApplied: (id: MetricSourceId, filter: FilterClause) => void;
+ onSourceDefinitionChange: (
+ source: DefinitionSource,
+ newDefinition: MetricDefinition,
+ ) => void;
+ onFilterApplied: () => void;
}
export function FilterPopoverContent({
- definitions,
+ definitionSources,
metricColors,
+ onSourceDefinitionChange,
onFilterApplied,
}: FilterPopoverContentProps) {
const [navState, setNavState] = useState<NavigationState>({ view: "list" });
- const [expandedItems, setExpandedItems] = useState<string[]>([]);
+ const [expandedItems, setExpandedItems] = useState<number[]>([]);
const [searchText, setSearchText] = useState("");
- const displayGroups = useMemo((): DisplayMetricGroup[] => {
- const rawGroups = getMetricGroups(
- definitions.map((definition) => definition.definition),
- );
- return rawGroups.map((group, index) => {
- const sourceId = definitions[index].id;
- return {
- id: sourceId,
- metricName: group.metricName,
- icon: group.icon,
- colors: metricColors[sourceId],
- sections: group.sections,
- };
- });
- }, [definitions, metricColors]);
+ const displayGroups = useMemo((): MetricGroup[] => {
+ return getMetricGroups(definitionSources, metricColors);
+ }, [definitionSources, metricColors]);
const filteredDisplayGroups = useMemo(
() => filterDisplayGroupsBySearch(displayGroups, searchText),
@@ -97,17 +87,16 @@ export function FilterPopoverContent({
if (navState.view !== "filter") {
return;
}
- const selected = definitions[navState.definitionIndex];
- if (!selected) {
- return;
- }
- onFilterApplied(selected.id, filter);
+ const selected = definitionSources[navState.definitionIndex];
+ const newDefinition = LibMetric.filter(selected.definition, filter);
+ onSourceDefinitionChange(selected, newDefinition);
+ onFilterApplied();
setNavState({ view: "list" });
},
- [navState, definitions, onFilterApplied],
+ [navState, definitionSources, onFilterApplied, onSourceDefinitionChange],
);
- const toggleExpanded = useCallback((id: string) => {
+ const toggleExpanded = useCallback((id: number) => {
setExpandedItems((prev) =>
prev.includes(id) ? prev.filter((item) => item !== id) : [...prev, id],
);
@@ -116,10 +105,10 @@ export function FilterPopoverContent({
const isSearching = filteredDisplayGroups !== null;
const visibleGroups = isSearching ? filteredDisplayGroups : displayGroups;
const hasNoResults = isSearching && visibleGroups.length === 0;
- const showMetricHeaders = definitions.length > 1;
+ const showMetricHeaders = definitionSources.length > 1;
if (navState.view === "filter") {
- const selected = definitions[navState.definitionIndex];
+ const selected = definitionSources[navState.definitionIndex];
if (!selected) {
return null;
}
@@ -209,10 +198,10 @@ function MetricGroupList({
onToggleExpanded,
onDimensionSelect,
}: {
- groups: DisplayMetricGroup[];
- expandedItems: string[];
+ groups: MetricGroup[];
+ expandedItems: number[];
collapsible: boolean;
- onToggleExpanded: (id: string) => void;
+ onToggleExpanded: (id: number) => void;
onDimensionSelect: (item: DimensionListItem) => void;
}) {
return (
@@ -240,7 +229,14 @@ function MetricGroupList({
fallbackIcon={group.icon}
size={16}
/>
- <Box fw={700}>{group.metricName}</Box>
+ <Flex align="center" gap="xs" fw={700}>
+ <span>{group.metricName}</span>
+ {(group.metricCount ?? 0) > 1 && (
+ <Badge circle c="text-hover">
+ {group.metricCount}
+ </Badge>
+ )}
+ </Flex>
<Icon
name={isExpanded ? "chevronup" : "chevrondown"}
size={12}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.module.css
new file mode 100644
index 00000000000..9ab785abec9
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.module.css
@@ -0,0 +1,15 @@
+.metricExpressionPill {
+ background-color: var(--mb-color-background-primary);
+ border: 1px solid var(--mb-color-border);
+ border-radius: var(--default-border-radius);
+ transition: background-color 150ms ease;
+ max-width: 100%;
+}
+
+.metricExpressionPill:hover {
+ background-color: var(--mb-color-background-secondary);
+}
+
+.expressionText {
+ white-space: pre-wrap;
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.tsx
new file mode 100644
index 00000000000..7840fc1c5a9
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/MetricExpressionPill.tsx
@@ -0,0 +1,73 @@
+import { t } from "ttag";
+
+import { SourceColorIndicator } from "metabase/common/components/SourceColorIndicator";
+import { Badge, Flex, Pill } from "metabase/ui";
+
+import type { ExpressionDefinitionEntry } from "../../../types/viewer-state";
+import { type MetricNameMap, buildExpressionForPill } from "../utils";
+
+import S from "./MetricExpressionPill.module.css";
+
+type MetricExpressionPillProps = {
+ expressionEntry: ExpressionDefinitionEntry;
+ metricNames: MetricNameMap;
+ colors?: string[];
+ onClick: (e: React.MouseEvent) => void;
+ onRemove: () => void;
+};
+
+export function MetricExpressionPill({
+ expressionEntry,
+ metricNames,
+ colors,
+ onClick,
+ onRemove,
+}: MetricExpressionPillProps) {
+ const expression = buildExpressionForPill(
+ expressionEntry.tokens,
+ metricNames,
+ );
+ return (
+ <Pill
+ className={S.metricExpressionPill}
+ c="text-primary"
+ h="2rem"
+ px="sm"
+ py="xs"
+ fw={600}
+ withRemoveButton
+ onRemove={onRemove}
+ removeButtonProps={{
+ mr: 0,
+ "aria-label": t`Remove expression`,
+ }}
+ onClick={onClick}
+ data-testid="metrics-viewer-search-pill"
+ >
+ <Flex align="center" gap="xs">
+ <SourceColorIndicator colors={colors} />
+ <Flex align="center" gap={0}>
+ {expression.map((e, i) => {
+ if (typeof e === "number") {
+ return (
+ <Badge
+ key={i}
+ circle
+ c="text-hover"
+ style={{ marginInlineStart: "0.2em" }}
+ >
+ {e}
+ </Badge>
+ );
+ }
+ return (
+ <span key={i} className={S.expressionText}>
+ {e}
+ </span>
+ );
+ })}
+ </Flex>
+ </Flex>
+ </Pill>
+ );
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/index.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/index.ts
new file mode 100644
index 00000000000..ee57573a2fa
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricExpressionPill/index.ts
@@ -0,0 +1 @@
+export { MetricExpressionPill } from "./MetricExpressionPill";
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css
index 1aa8fe63eb3..5a63e1aae35 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.module.css
@@ -1,13 +1,13 @@
.metricPill {
background-color: var(--mb-color-background-primary);
- border-radius: var(--mantine-radius-md);
+ border: 1px solid var(--mb-color-border);
+ border-radius: var(--default-border-radius);
cursor: pointer;
transition: background-color 150ms ease;
- box-shadow: var(--mantine-shadow-xs);
}
.metricPill:hover {
- background-color: var(--mb-color-background-brand);
+ background-color: var(--mb-color-background-secondary);
}
.menuTarget {
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx
index 9b6d2675517..f49b5727b31 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.tsx
@@ -25,8 +25,6 @@ type MetricPillProps = {
metric: SelectedMetric;
colors?: string[];
definitionEntry: MetricsViewerDefinitionEntry;
- selectedMetricIds: Set<number>;
- selectedMeasureIds: Set<number>;
onSwap: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;
onRemove: (metricId: number, sourceType: "metric" | "measure") => void;
onSetBreakout: (dimension: ProjectionClause | undefined) => void;
@@ -37,8 +35,6 @@ export function MetricPill({
metric,
colors,
definitionEntry,
- selectedMetricIds,
- selectedMeasureIds,
onSwap,
onRemove,
onSetBreakout,
@@ -46,6 +42,26 @@ export function MetricPill({
}: MetricPillProps) {
const [popoverState, setPopoverState] = useState<PillPopoverState>("closed");
+ const { selectedMetricIds, selectedMeasureIds } = useMemo(() => {
+ if (metric.sourceType === "metric") {
+ return {
+ selectedMetricIds: new Set<number>([metric.id]),
+ selectedMeasureIds: new Set<number>(),
+ };
+ }
+ if (metric.sourceType === "measure") {
+ return {
+ selectedMetricIds: new Set<number>(),
+ selectedMeasureIds: new Set<number>([metric.id]),
+ };
+ }
+
+ return {
+ selectedMetricIds: new Set<number>(),
+ selectedMeasureIds: new Set<number>(),
+ };
+ }, [metric.id, metric.sourceType]);
+
const dimensions = useMemo(
() =>
definitionEntry.definition
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx
index b174dfef11c..755aa2071f1 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricPill/MetricPill.unit.spec.tsx
@@ -25,8 +25,6 @@ function setup({
<MetricPill
metric={metric}
definitionEntry={definitionEntry ?? { id: "measure:1", definition: null }}
- selectedMetricIds={new Set()}
- selectedMeasureIds={new Set()}
onSwap={jest.fn()}
onRemove={jest.fn()}
onSetBreakout={jest.fn()}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx
index d78dbc070e7..0f0257a8c56 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchDropdown/MetricSearchDropdown.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
import { t } from "ttag";
import { useListKeyboardNavigation } from "metabase/common/hooks/use-list-keyboard-navigation";
@@ -15,13 +15,14 @@ import { type ExcludeMetric, filterSearchResults } from "../utils";
import S from "./MetricSearchDropdown.module.css";
type MetricSearchDropdownProps = {
- selectedMetricIds: Set<number>;
- selectedMeasureIds: Set<number>;
+ selectedMetricIds?: Set<number>;
+ selectedMeasureIds?: Set<number>;
onSelect: (metric: SelectedMetric) => void;
onClose?: () => void;
excludeMetric?: ExcludeMetric;
showSearchInput?: boolean;
externalSearchText?: string;
+ onHasSelectionChange?: (hasSelection: boolean) => void;
};
export function MetricSearchDropdown({
@@ -32,6 +33,7 @@ export function MetricSearchDropdown({
excludeMetric,
showSearchInput = false,
externalSearchText,
+ onHasSelectionChange,
}: MetricSearchDropdownProps) {
const [internalSearchText, setInternalSearchText] = useState("");
const searchText = showSearchInput
@@ -84,6 +86,10 @@ export function MetricSearchDropdown({
onEnter: handleEnter,
});
+ useEffect(() => {
+ onHasSelectionChange?.(cursorIndex != null);
+ }, [cursorIndex, onHasSelectionChange]);
+
const handleKeyDown = useCallback(
(e: React.KeyboardEvent) => {
if (e.key === "Escape") {
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css
index 1eb7e2b58d8..fac66b697ff 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.module.css
@@ -8,8 +8,76 @@
padding: 0;
height: auto;
min-height: unset;
+ font-family: Monaco, monospace;
}
.inputField::placeholder {
color: var(--mb-color-text-tertiary);
}
+
+.cmOperator {
+ color: var(--mb-color-syntax-parameters);
+}
+
+.cmMetricToken {
+ border: 1px solid var(--mb-color-border);
+ border-radius: 0.25rem;
+ padding: 0 0.25rem;
+}
+
+.cmErrorUnderline {
+ text-decoration: underline wavy;
+ text-decoration-color: var(--mb-color-error);
+ text-decoration-skip-ink: none;
+}
+
+.cmErrorTooltip {
+ padding: 4px 8px;
+ font-size: 0.75rem;
+ color: var(--mb-color-error);
+ background: var(--mb-color-background-primary);
+ border: 1px solid var(--mb-color-error);
+ border-radius: var(--mantine-radius-sm, 4px);
+ max-width: 20rem;
+ white-space: normal;
+ pointer-events: none;
+}
+
+.codeEditor {
+ flex: 1;
+ min-width: 7.5rem;
+
+ :global {
+ .cm-editor {
+ background: transparent;
+ }
+
+ .cm-focused {
+ outline: none;
+ }
+
+ .cm-content {
+ padding: 0;
+ font-family: var(--mb-default-monospace-font-family);
+ font-size: 0.875rem;
+ color: var(--mb-color-text-primary);
+ }
+
+ .cm-line {
+ padding: 0;
+ }
+
+ .cm-cursor {
+ border-left-width: 1.6px;
+ border-left-color: var(--mb-color-text-secondary);
+ }
+
+ .cm-placeholder {
+ color: var(--mb-color-text-tertiary);
+ }
+
+ .cm-scroller {
+ overflow: hidden;
+ }
+ }
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx
index 641873ea236..adc6988db02 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.tsx
@@ -1,172 +1,275 @@
-import { useCallback, useMemo, useRef, useState } from "react";
+import type { ReactCodeMirrorRef } from "@uiw/react-codemirror";
+import { useMemo, useRef } from "react";
import { t } from "ttag";
-import { Flex, Popover, TextInput } from "metabase/ui";
+import { CodeMirror } from "metabase/common/components/CodeMirror";
+import { Button, Flex, Icon, Popover } from "metabase/ui";
import type { ProjectionClause } from "metabase-lib/metric";
import type {
+ MetricDefinitionEntry,
MetricSourceId,
MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
SelectedMetric,
SourceColorMap,
} from "../../../types/viewer-state";
+import { isExpressionEntry, isMetricEntry } from "../../../types/viewer-state";
+import { getEffectiveDefinitionEntry } from "../../../utils/definition-entries";
import {
createMeasureSourceId,
createMetricSourceId,
} from "../../../utils/source-ids";
+import { MetricExpressionPill } from "../MetricExpressionPill";
import { MetricPill } from "../MetricPill";
import { MetricSearchDropdown } from "../MetricSearchDropdown";
-import { getSelectedMeasureIds, getSelectedMetricIds } from "../utils";
import S from "./MetricSearchInput.module.css";
+import { buildEditorExtensions } from "./editorExtensions";
+import { useFormulaEditor } from "./useFormulaEditor";
+import { useMetricNameTracking } from "./useMetricNameTracking";
type MetricSearchInputProps = {
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ formulaEntities: MetricsViewerFormulaEntity[];
+ onFormulaEntitiesChange: (
+ entities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) => void;
selectedMetrics: SelectedMetric[];
metricColors: SourceColorMap;
- definitions: MetricsViewerDefinitionEntry[];
onAddMetric: (metric: SelectedMetric) => void;
onRemoveMetric: (metricId: number, sourceType: "metric" | "measure") => void;
onSwapMetric: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;
onSetBreakout: (
- id: MetricSourceId,
+ entity: MetricDefinitionEntry,
dimension: ProjectionClause | undefined,
) => void;
};
export function MetricSearchInput({
+ definitions,
+ formulaEntities,
+ onFormulaEntitiesChange,
selectedMetrics,
metricColors,
- definitions,
onAddMetric,
onRemoveMetric,
onSwapMetric,
onSetBreakout,
}: MetricSearchInputProps) {
- const [searchText, setSearchText] = useState("");
- const [isOpen, setIsOpen] = useState(false);
- const inputRef = useRef<HTMLInputElement>(null);
-
- const selectedMetricIds = useMemo(
- () => getSelectedMetricIds(selectedMetrics),
- [selectedMetrics],
- );
-
- const selectedMeasureIds = useMemo(
- () => getSelectedMeasureIds(selectedMetrics),
- [selectedMetrics],
- );
+ const containerRef = useRef<HTMLDivElement>(null);
+ const editorRef = useRef<ReactCodeMirrorRef>(null);
- const definitionsBySourceId = useMemo(
- () => new Map(definitions.map((entry) => [entry.id, entry] as const)),
- [definitions],
- );
+ const { metricNames, metricNamesRef, ...metricHandlers } =
+ useMetricNameTracking({
+ definitions,
+ onAddMetric,
+ onRemoveMetric,
+ onSwapMetric,
+ });
- const handleSelect = useCallback(
- (metric: SelectedMetric) => {
- onAddMetric(metric);
- setSearchText("");
- setIsOpen(false);
- },
- [onAddMetric],
- );
+ const {
+ editText,
+ isFocused,
+ isOpen,
+ setIsOpen,
+ currentWord,
+ validationError,
+ anchorRect,
+ isExpressionDirty,
+ pendingFocusRef,
+ handleInputFocus,
+ handleInputBlur,
+ handleChange,
+ handleSelect,
+ handleRemoveItem,
+ handleContainerClick,
+ handleEditorClick,
+ handleEditorKeyDown,
+ handleDropdownHasSelectionChange,
+ handleRun,
+ handleRunRef,
+ isOpenRef,
+ dropdownHasSelectionRef,
+ } = useFormulaEditor({
+ formulaEntities,
+ onFormulaEntitiesChange,
+ selectedMetrics,
+ definitions,
+ metricNames,
+ metricNamesRef,
+ handleAddMetric: metricHandlers.handleAddMetric,
+ handleRemoveMetric: metricHandlers.handleRemoveMetric,
+ editorRef,
+ containerRef,
+ });
- const handleKeyDown = useCallback(
- (event: React.KeyboardEvent) => {
- if (
- event.key === "Backspace" &&
- searchText === "" &&
- selectedMetrics.length > 0
- ) {
- const last = selectedMetrics[selectedMetrics.length - 1];
- onRemoveMetric(last.id, last.sourceType);
- }
- },
- [searchText, selectedMetrics, onRemoveMetric],
+ const editorExtensions = useMemo(
+ () =>
+ buildEditorExtensions(formulaEntities.length, {
+ dropdownHasSelectionRef,
+ handleRunRef,
+ isOpenRef,
+ }),
+ [formulaEntities.length, dropdownHasSelectionRef, handleRunRef, isOpenRef],
);
- const handleContainerClick = useCallback(() => {
- inputRef.current?.focus();
- }, []);
-
- const handleInputClick = useCallback(() => {
- setIsOpen(true);
- }, []);
+ const isCollapsed = !isFocused && formulaEntities.length > 0;
return (
<Flex
+ ref={containerRef}
className={S.inputWrapper}
- bg="background-secondary"
+ bg="background-primary"
align="center"
gap="sm"
px="sm"
py="xs"
onClick={handleContainerClick}
+ data-has-error={validationError ? true : undefined}
+ data-testid="metrics-formula-input"
>
- <Flex align="center" gap="sm" flex={1} wrap="wrap" mih="2.25rem">
- {selectedMetrics.map((metric) => {
- const sid =
- metric.sourceType === "metric"
- ? createMetricSourceId(metric.id)
- : createMeasureSourceId(metric.id);
- const entry = definitionsBySourceId.get(sid);
- if (!entry) {
- return null;
- }
- return (
- <MetricPill
- key={`${metric.sourceType}-${metric.id}`}
- metric={metric}
- colors={metricColors[sid]}
- definitionEntry={entry}
- selectedMetricIds={selectedMetricIds}
- selectedMeasureIds={selectedMeasureIds}
- onSwap={onSwapMetric}
- onRemove={onRemoveMetric}
- onSetBreakout={(dimension) => onSetBreakout(sid, dimension)}
- onOpen={() => setIsOpen(false)}
- />
- );
- })}
- <Popover
- opened={isOpen}
- onChange={setIsOpen}
- position="bottom-start"
- shadow="md"
- withinPortal
- >
- <Popover.Target>
- <TextInput
- ref={inputRef}
- classNames={{ input: S.inputField }}
- flex={1}
- miw="7.5rem"
- ml="xs"
- variant="unstyled"
- placeholder={
- selectedMetrics.length === 0 ? t`Search for metrics...` : ""
+ <Flex align="center" gap="sm" flex={1} wrap="wrap" mih="2.375rem">
+ {isCollapsed ? (
+ // Unfocused: each formula entity rendered as MetricPill or MetricExpressionPill
+ <>
+ {formulaEntities.map((entry, entryIndex) => {
+ if (isMetricEntry(entry)) {
+ const metric = selectedMetrics.find((m) => {
+ const sid =
+ m.sourceType === "metric"
+ ? createMetricSourceId(m.id)
+ : createMeasureSourceId(m.id);
+ return sid === entry.id;
+ });
+ if (!metric) {
+ return null;
+ }
+ const definition = getEffectiveDefinitionEntry(
+ entry,
+ definitions,
+ );
+ return (
+ <span key={`${entry.id}-${entryIndex}`}>
+ <MetricPill
+ metric={metric}
+ colors={metricColors[entryIndex]}
+ definitionEntry={definition}
+ onSwap={metricHandlers.handleSwapMetric}
+ onRemove={(_id, _sourceType) =>
+ handleRemoveItem(entryIndex)
+ }
+ onSetBreakout={(dimension) =>
+ onSetBreakout(entry, dimension)
+ }
+ />
+ </span>
+ );
}
- value={searchText}
- onChange={(event) => {
- setSearchText(event.target.value);
- setIsOpen(true);
- }}
- onClick={handleInputClick}
- onKeyDown={handleKeyDown}
- data-testid="metrics-viewer-search-input"
- />
- </Popover.Target>
- <Popover.Dropdown p={0} miw="19rem" maw="25rem">
- {isOpen && (
- <MetricSearchDropdown
- selectedMetricIds={selectedMetricIds}
- selectedMeasureIds={selectedMeasureIds}
- onSelect={handleSelect}
- externalSearchText={searchText}
+
+ if (isExpressionEntry(entry)) {
+ const expressionColors = metricColors[entryIndex]
+ ? [metricColors[entryIndex][0]]
+ : undefined;
+
+ return (
+ <span key={`${entry.id}-${entryIndex}`}>
+ <MetricExpressionPill
+ expressionEntry={entry}
+ metricNames={metricNames}
+ colors={expressionColors}
+ onClick={(e: React.MouseEvent) => {
+ e.stopPropagation();
+ handleContainerClick(e);
+ }}
+ onRemove={() => handleRemoveItem(entryIndex)}
+ />
+ </span>
+ );
+ }
+
+ return null;
+ })}
+ </>
+ ) : (
+ // Focused: CodeMirror editor with syntax highlighting.
+ // The Popover is anchored to a zero-size fixed span that tracks the
+ // viewport position of the word under the cursor, so the dropdown
+ // appears directly below the current word rather than the full input.
+ <>
+ <div
+ className={S.codeEditor}
+ onFocus={handleInputFocus}
+ onBlur={handleInputBlur}
+ onClick={handleEditorClick}
+ onKeyDown={handleEditorKeyDown}
+ >
+ <CodeMirror
+ ref={editorRef}
+ basicSetup={false}
+ autoFocus
+ value={editText}
+ onChange={handleChange}
+ extensions={editorExtensions}
+ data-testid="metrics-viewer-search-input"
/>
- )}
- </Popover.Dropdown>
- </Popover>
+ </div>
+ <Popover
+ opened={isOpen}
+ onChange={setIsOpen}
+ position="bottom-start"
+ shadow="md"
+ withinPortal
+ >
+ <Popover.Target>
+ <span
+ aria-hidden
+ style={{
+ position: "fixed",
+ left: anchorRect.left,
+ top: anchorRect.top,
+ width: 0,
+ height: 0,
+ pointerEvents: "none",
+ }}
+ />
+ </Popover.Target>
+ <Popover.Dropdown
+ p={0}
+ miw="19rem"
+ maw="25rem"
+ onMouseDown={(e) => e.preventDefault()}
+ >
+ {isOpen && (
+ <MetricSearchDropdown
+ onSelect={handleSelect}
+ externalSearchText={currentWord}
+ onHasSelectionChange={handleDropdownHasSelectionChange}
+ onClose={() => setIsOpen(false)}
+ />
+ )}
+ </Popover.Dropdown>
+ </Popover>
+ </>
+ )}
</Flex>
+ {isFocused && !pendingFocusRef.current && isExpressionDirty && (
+ <Button
+ variant="light"
+ color="brand"
+ size="xs"
+ py="sm"
+ px="sm"
+ leftSection={<Icon size="0.75rem" name="enter_or_return" />}
+ disabled={!!validationError}
+ data-testid="run-expression-button"
+ onClick={(e: React.MouseEvent) => {
+ e.stopPropagation();
+ handleRun();
+ }}
+ >{t`Run`}</Button>
+ )}
</Flex>
);
}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.unit.spec.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.unit.spec.tsx
new file mode 100644
index 00000000000..ed64bf2828a
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/MetricSearchInput.unit.spec.tsx
@@ -0,0 +1,640 @@
+import { fireEvent, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { renderWithProviders, screen, waitFor } from "__support__/ui";
+
+import type {
+ ExpressionDefinitionEntry,
+ ExpressionSubToken,
+ MetricDefinitionEntry,
+ MetricExpressionId,
+ MetricSourceId,
+ MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
+ SelectedMetric,
+ SourceColorMap,
+} from "../../../types/viewer-state";
+import { isExpressionEntry, isMetricEntry } from "../../../types/viewer-state";
+import { createMetricSourceId } from "../../../utils/source-ids";
+
+import { MetricSearchInput } from "./MetricSearchInput";
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+jest.mock("../../../utils/definition-builder", () => ({
+ getDefinitionName: (def: any) => def?.["display-name"] ?? null,
+}));
+
+jest.mock("../MetricPill", () => ({
+ MetricPill: ({
+ metric,
+ onRemove,
+ }: {
+ metric: SelectedMetric;
+ onRemove: (id: number, sourceType: "metric" | "measure") => void;
+ }) => (
+ <div data-testid="metric-pill" data-metric-name={metric.name}>
+ <span>{metric.name}</span>
+ <button onClick={() => onRemove(metric.id, metric.sourceType)}>
+ remove
+ </button>
+ </div>
+ ),
+}));
+
+jest.mock("../MetricExpressionPill", () => ({
+ MetricExpressionPill: ({
+ expressionEntry,
+ onClick,
+ onRemove,
+ }: {
+ expressionEntry: { name: string };
+ metricEntries: unknown[];
+ colors?: string[];
+ onClick: (e: React.MouseEvent) => void;
+ onRemove: () => void;
+ }) => {
+ return (
+ <div
+ data-testid="metric-expression-pill"
+ data-expression-text={expressionEntry.name}
+ onClick={onClick}
+ >
+ <span>{expressionEntry.name}</span>
+ <button onClick={onRemove}>remove</button>
+ </div>
+ );
+ },
+}));
+
+jest.mock("../MetricSearchDropdown", () => ({
+ MetricSearchDropdown: ({
+ onSelect,
+ externalSearchText,
+ }: {
+ onSelect: (metric: SelectedMetric) => void;
+ externalSearchText: string;
+ }) => (
+ <div data-testid="search-dropdown" data-search-text={externalSearchText}>
+ <button
+ onClick={() =>
+ onSelect({ id: 99, name: "New Metric", sourceType: "metric" })
+ }
+ >
+ select-new-metric
+ </button>
+ </div>
+ ),
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMetric(
+ id: number,
+ name: string,
+ sourceType: "metric" | "measure" = "metric",
+): SelectedMetric {
+ return { id, name, sourceType };
+}
+
+function makeMetricEntry(metric: SelectedMetric): MetricDefinitionEntry {
+ const sid =
+ metric.sourceType === "metric"
+ ? createMetricSourceId(metric.id)
+ : (`measure:${metric.id}` as MetricSourceId);
+ // Create a fake definition with display-name for getDefinitionName
+ const fakeDefinition = {
+ "display-name": metric.name,
+ } as unknown as MetricDefinitionEntry["definition"];
+ return { id: sid, type: "metric" as const, definition: fakeDefinition };
+}
+
+function makeExpressionEntry(
+ name: string,
+ tokens: ExpressionSubToken[],
+): ExpressionDefinitionEntry {
+ return {
+ id: `expression:${name}` as MetricExpressionId,
+ type: "expression",
+ name,
+ tokens,
+ };
+}
+
+/** Build a definitions map from metric entries only */
+function buildDefinitionsMap(
+ entries: MetricDefinitionEntry[],
+): Record<MetricSourceId, MetricsViewerDefinitionEntry> {
+ const map: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {};
+ for (const entry of entries) {
+ map[entry.id] = { id: entry.id, definition: entry.definition };
+ }
+ return map;
+}
+
+/** Build formulaEntities from a mixed array of metric + expression entries */
+function buildFormulaEntities(
+ entries: (MetricDefinitionEntry | ExpressionDefinitionEntry)[],
+): MetricsViewerFormulaEntity[] {
+ return entries;
+}
+
+type SetupOptions = {
+ /** Mixed array of metric and expression entries (old-style convenience) */
+ entries?: (MetricDefinitionEntry | ExpressionDefinitionEntry)[];
+ selectedMetrics?: SelectedMetric[];
+ metricColors?: SourceColorMap;
+ onFormulaEntitiesChange?: jest.Mock;
+ onAddMetric?: jest.Mock;
+ onRemoveMetric?: jest.Mock;
+ onSwapMetric?: jest.Mock;
+ onSetBreakout?: jest.Mock;
+};
+
+function setup(options: SetupOptions = {}) {
+ const revenue = makeMetric(1, "Revenue");
+ const costs = makeMetric(2, "Costs");
+
+ const {
+ selectedMetrics = [revenue, costs],
+ metricColors = {},
+ entries = selectedMetrics.map(makeMetricEntry),
+ onFormulaEntitiesChange = jest.fn(),
+ onAddMetric = jest.fn(),
+ onRemoveMetric = jest.fn(),
+ onSwapMetric = jest.fn(),
+ onSetBreakout = jest.fn(),
+ } = options;
+
+ // Derive definitions map from metric entries only
+ const metricEntries = entries.filter(isMetricEntry);
+ const definitions = buildDefinitionsMap(metricEntries);
+ const formulaEntities = buildFormulaEntities(entries);
+
+ const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+
+ renderWithProviders(
+ <MetricSearchInput
+ definitions={definitions}
+ formulaEntities={formulaEntities}
+ onFormulaEntitiesChange={onFormulaEntitiesChange}
+ selectedMetrics={selectedMetrics}
+ metricColors={metricColors}
+ onAddMetric={onAddMetric}
+ onRemoveMetric={onRemoveMetric}
+ onSwapMetric={onSwapMetric}
+ onSetBreakout={onSetBreakout}
+ />,
+ );
+
+ return {
+ user,
+ onFormulaEntitiesChange,
+ onAddMetric,
+ onRemoveMetric,
+ onSwapMetric,
+ onSetBreakout,
+ };
+}
+
+// ---------------------------------------------------------------------------
+// Definition factories
+// ---------------------------------------------------------------------------
+
+const revenue = makeMetric(1, "Revenue");
+const costs = makeMetric(2, "Costs");
+const revenueEntry = makeMetricEntry(revenue);
+const costsEntry = makeMetricEntry(costs);
+
+const m = (sourceId: MetricSourceId): ExpressionSubToken => ({
+ type: "metric",
+ sourceId,
+ count: 1,
+});
+const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({
+ type: "operator",
+ op: o,
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+ jest.useFakeTimers();
+});
+
+afterEach(() => {
+ jest.runOnlyPendingTimers();
+ jest.useRealTimers();
+});
+
+// ── Collapsed view (pills) ──────────────────────────────────────────────────
+
+describe("collapsed view (definitions present, not focused)", () => {
+ it("renders a single metric definition as a MetricPill", () => {
+ setup({ entries: [revenueEntry] });
+
+ expect(screen.getByTestId("metric-pill")).toBeInTheDocument();
+ expect(screen.getByText("Revenue")).toBeInTheDocument();
+ expect(screen.queryByRole("textbox")).not.toBeInTheDocument();
+ });
+
+ it("renders an expression entry as MetricExpressionPill", () => {
+ const expr = makeExpressionEntry("Revenue + Costs", [
+ m("metric:1"),
+ op("+"),
+ m("metric:2"),
+ ]);
+ setup({
+ entries: [revenueEntry, costsEntry, expr],
+ });
+
+ const pill = screen.getByTestId("metric-expression-pill");
+ expect(pill).toBeInTheDocument();
+ expect(pill).toHaveAttribute("data-expression-text", "Revenue + Costs");
+ });
+
+ it("renders two separate metric entries as two pills", () => {
+ setup({ entries: [revenueEntry, costsEntry] });
+
+ const pills = screen.getAllByTestId("metric-pill");
+ expect(pills).toHaveLength(2);
+ expect(pills[0]).toHaveAttribute("data-metric-name", "Revenue");
+ expect(pills[1]).toHaveAttribute("data-metric-name", "Costs");
+ });
+
+ it("does not render a text input when collapsed", () => {
+ setup({ entries: [revenueEntry] });
+ expect(screen.queryByRole("textbox")).not.toBeInTheDocument();
+ });
+
+ it("shows the CodeMirror editor when there are no definitions", () => {
+ setup({ entries: [] });
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+});
+
+// ── Expanded view (focused text input) ─────────────────────────────────────
+
+describe("expanded view (focused text input)", () => {
+ it("transitions to text input when clicking the container", async () => {
+ const { user } = setup({ entries: [revenueEntry] });
+
+ await user.click(screen.getByTestId("metric-pill"));
+
+ await waitFor(() => {
+ expect(screen.getByRole("textbox")).toBeInTheDocument();
+ });
+ });
+
+ it("shows the text editor when focused (transitions from pills)", async () => {
+ const expr = makeExpressionEntry("Revenue + Costs", [
+ m("metric:1"),
+ op("+"),
+ m("metric:2"),
+ ]);
+ const { user } = setup({
+ entries: [revenueEntry, costsEntry, expr],
+ });
+
+ await user.click(screen.getByTestId("metric-expression-pill"));
+
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+ });
+
+ it("opens the search dropdown when typing in the editor", async () => {
+ const { user } = setup({ entries: [] });
+
+ const input = screen.getByTestId("metrics-viewer-search-input");
+ await user.type(input, "R");
+
+ await waitFor(() => {
+ expect(screen.getByTestId("search-dropdown")).toBeInTheDocument();
+ });
+ });
+});
+
+// ── Blur / unfocus behavior ─────────────────────────────────────────────────
+
+describe("blur behavior", () => {
+ it("collapses back to pill view on blur when text is unchanged", async () => {
+ const { user } = setup({
+ entries: [revenueEntry],
+ selectedMetrics: [revenue],
+ });
+
+ await user.click(screen.getByTestId("metric-pill"));
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+
+ await user.tab();
+
+ expect(
+ screen.queryByTestId("metrics-viewer-search-input"),
+ ).not.toBeInTheDocument();
+ expect(screen.getByTestId("metric-pill")).toBeInTheDocument();
+ });
+
+ it("shows the Run button when formula is dirty", async () => {
+ const { user } = setup({
+ entries: [revenueEntry],
+ selectedMetrics: [revenue],
+ });
+
+ // Click pill → transitions to editor
+ await user.click(screen.getByTestId("metric-pill"));
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+
+ // Directly change the textarea value to simulate editing
+ const input = screen.getByTestId("metrics-viewer-search-input");
+ fireEvent.change(input, { target: { value: "Revenue + Costs" } });
+
+ await waitFor(() => {
+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();
+ });
+ });
+
+ it("does not show the Run button when focused if formula is unchanged", async () => {
+ const expr = makeExpressionEntry("Revenue + Costs", [
+ m("metric:1"),
+ op("+"),
+ m("metric:2"),
+ ]);
+ const { user } = setup({
+ entries: [revenueEntry, costsEntry, expr],
+ });
+
+ await user.click(screen.getByTestId("metric-expression-pill"));
+ expect(await screen.findByRole("textbox")).toBeInTheDocument();
+
+ expect(
+ screen.queryByTestId("run-expression-button"),
+ ).not.toBeInTheDocument();
+ });
+});
+
+// ── Run button and validation ───────────────────────────────────────────────
+
+describe("run button and validation", () => {
+ it("collapses and commits when Run is clicked with a valid expression", async () => {
+ const onFormulaEntitiesChange = jest.fn();
+ const { user } = setup({
+ entries: [revenueEntry],
+ selectedMetrics: [revenue],
+ onFormulaEntitiesChange,
+ });
+
+ // Click pill → transitions to editor
+ await user.click(screen.getByTestId("metric-pill"));
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+
+ // Directly change the textarea value to something different
+ const input = screen.getByTestId("metrics-viewer-search-input");
+ fireEvent.change(input, { target: { value: "Revenue, Revenue" } });
+
+ await waitFor(() => {
+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();
+ });
+
+ await user.click(screen.getByTestId("run-expression-button"));
+
+ await waitFor(() => {
+ expect(onFormulaEntitiesChange).toHaveBeenCalled();
+ });
+ });
+
+ it("removes unreferenced metrics when Run commits a new expression", async () => {
+ const onRemoveMetric = jest.fn();
+ const onFormulaEntitiesChange = jest.fn();
+ const { user } = setup({
+ entries: [revenueEntry, costsEntry],
+ selectedMetrics: [revenue, costs],
+ onRemoveMetric,
+ onFormulaEntitiesChange,
+ });
+
+ // Click a pill to transition to the editor
+ const pills = screen.getAllByTestId("metric-pill");
+ await user.click(pills[0]);
+
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+
+ // Directly change the textarea value to only reference Revenue (not Costs)
+ const input = screen.getByTestId("metrics-viewer-search-input");
+ fireEvent.change(input, { target: { value: "Revenue" } });
+
+ await waitFor(() => {
+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();
+ });
+
+ await user.click(screen.getByTestId("run-expression-button"));
+
+ await waitFor(() => {
+ // Costs (metric:2) is no longer referenced after text was replaced
+ expect(onRemoveMetric).toHaveBeenCalledWith(2, "metric");
+ });
+ });
+});
+
+// ── Removing items ──────────────────────────────────────────────────────────
+
+describe("removing pills", () => {
+ it("calls onRemoveMetric and onFormulaEntitiesChange when removing a standalone MetricPill", async () => {
+ const onRemoveMetric = jest.fn();
+ const onFormulaEntitiesChange = jest.fn();
+ const { user } = setup({
+ entries: [revenueEntry],
+ selectedMetrics: [revenue],
+ onRemoveMetric,
+ onFormulaEntitiesChange,
+ });
+
+ await user.click(screen.getByRole("button", { name: "remove" }));
+
+ expect(onRemoveMetric).toHaveBeenCalledWith(1, "metric");
+ expect(onFormulaEntitiesChange).toHaveBeenCalledWith(
+ [],
+ new Map(), // slot mapping: no slots remain
+ );
+ });
+
+ it("removes a MetricPill from a two-item list, keeping the other metric", async () => {
+ const onRemoveMetric = jest.fn();
+ const onFormulaEntitiesChange = jest.fn();
+ const { user } = setup({
+ entries: [revenueEntry, costsEntry],
+ selectedMetrics: [revenue, costs],
+ onRemoveMetric,
+ onFormulaEntitiesChange,
+ });
+
+ const removeButtons = screen.getAllByRole("button", { name: "remove" });
+ // Remove the first item (Revenue)
+ await user.click(removeButtons[0]);
+
+ expect(onRemoveMetric).toHaveBeenCalledWith(1, "metric");
+ expect(onFormulaEntitiesChange).toHaveBeenCalledWith(
+ [costsEntry],
+ new Map([[1, 0]]), // slot mapping: Costs moved from slot 1 → 0
+ );
+ });
+
+ it("calls onRemoveMetric for all metrics in an expression pill when removed", async () => {
+ const onRemoveMetric = jest.fn();
+ const onFormulaEntitiesChange = jest.fn();
+ const expr = makeExpressionEntry("Revenue + Costs", [
+ m("metric:1"),
+ op("+"),
+ m("metric:2"),
+ ]);
+ const { user } = setup({
+ entries: [revenueEntry, costsEntry, expr],
+ selectedMetrics: [revenue, costs],
+ onRemoveMetric,
+ onFormulaEntitiesChange,
+ });
+
+ // The expression pill's remove button
+ const exprPill = screen.getByTestId("metric-expression-pill");
+ const removeButton = within(exprPill).getByRole("button");
+ await user.click(removeButton);
+
+ // Both Revenue and Costs are only referenced in the expression (the metric entries remain)
+ // Since revenueEntry and costsEntry still exist in remaining definitions,
+ // they should NOT be removed
+ expect(onFormulaEntitiesChange).toHaveBeenCalled();
+ });
+});
+
+// ── Expression pill display after Run ────────────────────────────────────────
+
+describe("expression pill display after committing a formula", () => {
+ it("preserves metric entries so the expression pill displays full metric names", async () => {
+ const metricA = makeMetric(1, "MetricA");
+ const metricB = makeMetric(2, "MetricB");
+ const metricC = makeMetric(3, "MetricC");
+ const metricAEntry = makeMetricEntry(metricA);
+ const metricBEntry = makeMetricEntry(metricB);
+ const metricCEntry = makeMetricEntry(metricC);
+
+ const onFormulaEntitiesChange = jest.fn();
+
+ const { user } = setup({
+ entries: [metricAEntry, metricBEntry, metricCEntry],
+ selectedMetrics: [metricA, metricB, metricC],
+ onFormulaEntitiesChange,
+ });
+
+ // Click a pill to transition to the editor
+ const pills = screen.getAllByTestId("metric-pill");
+ await user.click(pills[0]);
+
+ await waitFor(() => {
+ expect(
+ screen.getByTestId("metrics-viewer-search-input"),
+ ).toBeInTheDocument();
+ });
+
+ // Type the expression formula
+ const input = screen.getByTestId("metrics-viewer-search-input");
+ fireEvent.change(input, {
+ target: {
+ value: `${[metricA, metricB, metricC].map((m) => m.name).join(", ")}, (MetricA + MetricB) / MetricC`,
+ },
+ });
+
+ // Run button should appear (formula is dirty)
+ await waitFor(() => {
+ expect(screen.getByTestId("run-expression-button")).toBeInTheDocument();
+ });
+
+ // Click Run to commit
+ await user.click(screen.getByTestId("run-expression-button"));
+
+ // The committed formula entities should include the metric entries referenced
+ // by the expression so that buildExpressionText can resolve their names.
+ await waitFor(() => {
+ expect(onFormulaEntitiesChange).toHaveBeenCalled();
+ });
+
+ const committedEntities = onFormulaEntitiesChange.mock.calls[
+ onFormulaEntitiesChange.mock.calls.length - 1
+ ][0] as MetricsViewerFormulaEntity[];
+
+ // Must contain the 3 metric entries plus the expression entry
+ const metricDefs = committedEntities.filter(isMetricEntry);
+ const exprDefs = committedEntities.filter(isExpressionEntry);
+
+ expect(metricDefs).toHaveLength(3);
+ expect(exprDefs).toHaveLength(1);
+
+ // The expression entry should have the correct tokens
+ const expr = exprDefs[0];
+ expect(expr.tokens).toEqual([
+ { type: "open-paren" },
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "close-paren" },
+ { type: "operator", op: "/" },
+ { type: "metric", sourceId: "metric:3", count: 1 },
+ ]);
+ expect(expr.name).toBe("(MetricA + MetricB) / MetricC");
+ });
+});
+
+// ── Typing / onChange ───────────────────────────────────────────────────────
+
+describe("typing in the text input", () => {
+ it("does not call onFormulaEntitiesChange as the user types (deferred to Run)", async () => {
+ const onFormulaEntitiesChange = jest.fn();
+ const { user } = setup({
+ entries: [],
+ onFormulaEntitiesChange,
+ });
+
+ const input = screen.getByRole("textbox");
+ await user.type(input, "R");
+
+ expect(onFormulaEntitiesChange).not.toHaveBeenCalled();
+ });
+
+ it("opens the search dropdown on input", async () => {
+ const { user } = setup({ entries: [] });
+
+ const input = screen.getByRole("textbox");
+ await user.type(input, "Rev");
+
+ expect(screen.getByTestId("search-dropdown")).toBeInTheDocument();
+ expect(screen.getByTestId("search-dropdown")).toHaveAttribute(
+ "data-search-text",
+ "Rev",
+ );
+ });
+});
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/editorExtensions.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/editorExtensions.ts
new file mode 100644
index 00000000000..dbf4e7ebe62
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/editorExtensions.ts
@@ -0,0 +1,62 @@
+import { history, redo, undo } from "@codemirror/commands";
+import type { Extension } from "@codemirror/state";
+import { keymap, placeholder } from "@codemirror/view";
+import { t } from "ttag";
+
+import { errorHighlight } from "./errorHighlight";
+import { metricTokenHighlight } from "./metricTokenHighlight";
+import { operatorHighlight } from "./operatorHighlight";
+
+type EditorExtensionRefs = {
+ dropdownHasSelectionRef: { current: boolean };
+ handleRunRef: { current: () => void };
+ isOpenRef: { current: boolean };
+};
+
+export function buildEditorExtensions(
+ formulaEntityCount: number,
+ refs: EditorExtensionRefs,
+): Extension[] {
+ return [
+ history(),
+ operatorHighlight,
+ errorHighlight,
+ metricTokenHighlight,
+ placeholder(formulaEntityCount === 0 ? t`Search for metrics...` : ""),
+ // Prevent Enter from creating newlines; trigger run when dirty.
+ // If the dropdown has a keyboard-highlighted item, skip running —
+ // let the dropdown's Enter handler select the item instead.
+ keymap.of([
+ { key: "Mod-z", run: undo, preventDefault: true },
+ { key: "Mod-Shift-z", run: redo, preventDefault: true },
+ {
+ key: "Enter",
+ run: () => {
+ if (!refs.dropdownHasSelectionRef.current) {
+ refs.handleRunRef.current();
+ }
+ return true;
+ },
+ },
+ // don't move the cursor when using the arrow keys to navigate the dropdown
+ {
+ key: "ArrowDown",
+ run: () => {
+ if (refs.isOpenRef.current) {
+ return true;
+ }
+ return false;
+ },
+ },
+ {
+ key: "ArrowUp",
+ run: () => {
+ if (refs.isOpenRef.current) {
+ return true;
+ }
+ return false;
+ },
+ },
+ ]),
+ ];
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/errorHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/errorHighlight.ts
new file mode 100644
index 00000000000..ad8e62d3e62
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/errorHighlight.ts
@@ -0,0 +1,83 @@
+import { StateEffect, StateField } from "@codemirror/state";
+import {
+ Decoration,
+ type DecorationSet,
+ EditorView,
+ hoverTooltip,
+} from "@codemirror/view";
+
+import type { ErrorRange } from "../utils";
+
+import S from "./MetricSearchInput.module.css";
+
+const errorMark = Decoration.mark({ class: S.cmErrorUnderline });
+
+export const setErrorDecoration = StateEffect.define<ErrorRange[]>();
+
+/** Stores error ranges with messages for tooltip lookup. */
+const errorRangesField = StateField.define<ErrorRange[]>({
+ create: () => [],
+ update(ranges, tr) {
+ if (tr.docChanged) {
+ return [];
+ }
+ for (const effect of tr.effects) {
+ if (effect.is(setErrorDecoration)) {
+ return effect.value;
+ }
+ }
+ return ranges;
+ },
+});
+
+/** Builds mark decorations from stored error ranges. */
+const errorDecorationField = StateField.define<DecorationSet>({
+ create: () => Decoration.none,
+ update(deco, tr) {
+ if (tr.docChanged) {
+ return Decoration.none;
+ }
+ for (const effect of tr.effects) {
+ if (effect.is(setErrorDecoration)) {
+ if (effect.value.length === 0) {
+ return Decoration.none;
+ }
+ const docLen = tr.newDoc.length;
+ // Ranges must be sorted and non-overlapping for Decoration.set
+ const marks = [...effect.value]
+ .filter((r) => r.from < r.to && r.from >= 0 && r.to <= docLen)
+ .sort((a, b) => a.from - b.from)
+ .map((r) => errorMark.range(r.from, r.to));
+ return marks.length > 0 ? Decoration.set(marks) : Decoration.none;
+ }
+ }
+ return deco;
+ },
+ provide: (f) => EditorView.decorations.from(f),
+});
+
+/** Shows the error message in a tooltip when hovering over an underlined range. */
+const errorHoverTooltip = hoverTooltip((view, pos) => {
+ const ranges = view.state.field(errorRangesField);
+ const match = ranges.find((r) => r.from <= pos && pos < r.to);
+ if (!match) {
+ return null;
+ }
+ return {
+ pos: match.from,
+ end: match.to,
+ above: true,
+ create() {
+ const dom = document.createElement("div");
+ dom.className = S.cmErrorTooltip;
+ dom.textContent = match.message;
+ return { dom };
+ },
+ };
+});
+
+export const errorHighlight = [
+ errorRangesField,
+ errorDecorationField,
+ errorHoverTooltip,
+];
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts
new file mode 100644
index 00000000000..c2f34d1e8dc
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/metricTokenHighlight.ts
@@ -0,0 +1,305 @@
+import {
+ MapMode,
+ RangeSet,
+ RangeValue,
+ StateEffect,
+ StateField,
+} from "@codemirror/state";
+import {
+ Decoration,
+ type DecorationSet,
+ EditorView,
+ WidgetType,
+ keymap,
+} from "@codemirror/view";
+
+import type { MetricDefinition } from "metabase-lib/metric";
+
+import type {
+ MetricSourceId,
+ MetricsViewerFormulaEntity,
+} from "../../../types/viewer-state";
+import type { MetricIdentityEntry, MetricNameMap } from "../utils";
+import { parseFullTextWithPositions, traverseMetricTokens } from "../utils";
+
+import S from "./MetricSearchInput.module.css";
+
+class MetricTokenWidget extends WidgetType {
+ constructor(readonly name: string) {
+ super();
+ }
+
+ eq(other: MetricTokenWidget) {
+ return this.name === other.name;
+ }
+
+ toDOM() {
+ const span = document.createElement("span");
+ span.className = S.cmMetricToken;
+ span.textContent = this.name;
+ return span;
+ }
+
+ ignoreEvent() {
+ return false;
+ }
+}
+
+export const setMetricNames = StateEffect.define<MetricNameMap>();
+
+const metricNamesField = StateField.define<MetricNameMap>({
+ create: () => ({}),
+ update(entries, tr) {
+ for (const effect of tr.effects) {
+ if (effect.is(setMetricNames)) {
+ return effect.value;
+ }
+ }
+ return entries;
+ },
+});
+
+// ── Identity tracking ──────────────────────────────────────────────────────
+
+class MetricIdentity extends RangeValue {
+ override mapMode = MapMode.TrackDel;
+ // Don't absorb text inserted at range boundaries — the identity
+ // must track exactly the original token span, not grow with adjacent edits.
+ override startSide = 1;
+ override endSide = -1;
+
+ constructor(
+ readonly sourceId: MetricSourceId,
+ readonly definition: MetricDefinition | null,
+ readonly slotIndex: number,
+ ) {
+ super();
+ }
+
+ override eq(other: MetricIdentity) {
+ return (
+ this.sourceId === other.sourceId &&
+ this.definition === other.definition &&
+ this.slotIndex === other.slotIndex
+ );
+ }
+}
+
+export const setMetricIdentities =
+ StateEffect.define<RangeSet<MetricIdentity>>();
+
+export const metricIdentityField = StateField.define<RangeSet<MetricIdentity>>({
+ create: () => RangeSet.empty,
+ update(identities, tr) {
+ for (const effect of tr.effects) {
+ if (effect.is(setMetricIdentities)) {
+ return effect.value;
+ }
+ }
+ if (tr.docChanged) {
+ return identities.map(tr.changes);
+ }
+ return identities;
+ },
+});
+
+export function buildMetricIdentities(
+ text: string,
+ metricNames: MetricNameMap,
+ entities: MetricsViewerFormulaEntity[],
+): RangeSet<MetricIdentity> {
+ const ranges: ReturnType<MetricIdentity["range"]>[] = [];
+ let slotCounter = 0;
+
+ traverseMetricTokens(text, metricNames, entities, (visit) => {
+ const slotIndex = slotCounter++;
+ const sourceId =
+ visit.kind === "standalone" ? visit.entity.id : visit.exprToken.sourceId;
+ const definition =
+ visit.kind === "standalone"
+ ? visit.entity.definition
+ : (visit.exprToken.definition ?? null);
+
+ ranges.push(
+ new MetricIdentity(sourceId, definition, slotIndex).range(
+ visit.positioned.from,
+ visit.positioned.to,
+ ),
+ );
+ });
+
+ return RangeSet.of(ranges, true);
+}
+
+/**
+ * Reads the current metric identities from the CodeMirror state.
+ * Positions are already in current-document coordinates (mapped automatically).
+ */
+export function readMetricIdentities(view: EditorView): MetricIdentityEntry[] {
+ const identities = view.state.field(metricIdentityField);
+ const result: MetricIdentityEntry[] = [];
+ const docLength = view.state.doc.length;
+ identities.between(0, docLength, (from, to, value) => {
+ result.push({
+ sourceId: value.sourceId,
+ from,
+ to,
+ definition: value.definition,
+ slotIndex: value.slotIndex,
+ });
+ });
+ return result;
+}
+
+// ── Token highlighting ─────────────────────────────────────────────────────
+
+type MetricRange = { from: number; to: number; name: string };
+
+function computeMetricTokenRanges(
+ docText: string,
+ docLength: number,
+ metricNames: MetricNameMap,
+): MetricRange[] {
+ if (Object.keys(metricNames).length === 0) {
+ return [];
+ }
+
+ const tokens = parseFullTextWithPositions(docText, metricNames);
+ return tokens
+ .filter(
+ (t) =>
+ t.type === "metric" &&
+ t.from >= 0 &&
+ t.to <= docLength &&
+ t.from < t.to,
+ )
+ .sort((a, b) => a.from - b.from)
+ .map((t) => ({
+ from: t.from,
+ to: t.to,
+ name: docText.slice(t.from, t.to),
+ }));
+}
+
+function rangesToDecorations(ranges: MetricRange[]): DecorationSet {
+ if (ranges.length === 0) {
+ return Decoration.none;
+ }
+ const decorations = ranges.map((r) =>
+ Decoration.replace({
+ widget: new MetricTokenWidget(r.name),
+ }).range(r.from, r.to),
+ );
+ return Decoration.set(decorations);
+}
+
+/** Stores the raw metric ranges for lookup by keymap handlers. */
+const metricTokenRangesField = StateField.define<MetricRange[]>({
+ create: () => [],
+ update(ranges, tr) {
+ const metricNames = tr.state.field(metricNamesField);
+ const metricNamesChanged = tr.effects.some((e) => e.is(setMetricNames));
+ if (tr.docChanged || metricNamesChanged) {
+ return computeMetricTokenRanges(
+ tr.newDoc.toString(),
+ tr.newDoc.length,
+ metricNames,
+ );
+ }
+ return ranges;
+ },
+});
+
+/** Derives replace decorations from the metric ranges field (no re-parse). */
+const metricDecorationsField = StateField.define<DecorationSet>({
+ create: () => Decoration.none,
+ update(deco, tr) {
+ const metricNamesChanged = tr.effects.some((e) => e.is(setMetricNames));
+ if (tr.docChanged || metricNamesChanged) {
+ return rangesToDecorations(tr.state.field(metricTokenRangesField));
+ }
+ return deco;
+ },
+ provide: (f) => EditorView.decorations.from(f),
+});
+
+/**
+ * Find the metric range that the cursor is adjacent to or inside of.
+ * For Backspace: find a range whose `to` equals cursor pos (cursor is right after it),
+ * or a range that contains the cursor.
+ * For Delete: find a range whose `from` equals cursor pos (cursor is right before it),
+ * or a range that contains the cursor.
+ */
+function findAdjacentMetricRange(
+ ranges: MetricRange[],
+ pos: number,
+ direction: "backward" | "forward",
+): MetricRange | undefined {
+ for (const range of ranges) {
+ // Cursor is inside the range
+ if (pos > range.from && pos < range.to) {
+ return range;
+ }
+ // Backspace: cursor is right after the range
+ if (direction === "backward" && pos === range.to) {
+ return range;
+ }
+ // Delete: cursor is right before the range
+ if (direction === "forward" && pos === range.from) {
+ return range;
+ }
+ }
+ return undefined;
+}
+
+const metricTokenKeymap = keymap.of([
+ {
+ key: "Backspace",
+ run(view) {
+ const { state } = view;
+ const sel = state.selection.main;
+ if (!sel.empty) {
+ return false;
+ }
+ const ranges = state.field(metricTokenRangesField);
+ const match = findAdjacentMetricRange(ranges, sel.head, "backward");
+ if (!match) {
+ return false;
+ }
+ view.dispatch({
+ changes: { from: match.from, to: match.to },
+ });
+ return true;
+ },
+ },
+ {
+ key: "Delete",
+ run(view) {
+ const { state } = view;
+ const sel = state.selection.main;
+ if (!sel.empty) {
+ return false;
+ }
+ const ranges = state.field(metricTokenRangesField);
+ const match = findAdjacentMetricRange(ranges, sel.head, "forward");
+ if (!match) {
+ return false;
+ }
+ view.dispatch({
+ changes: { from: match.from, to: match.to },
+ });
+ return true;
+ },
+ },
+]);
+
+export const metricTokenHighlight = [
+ metricNamesField,
+ metricIdentityField,
+ metricTokenRangesField,
+ metricDecorationsField,
+ EditorView.atomicRanges.of((view) =>
+ view.state.field(metricDecorationsField),
+ ),
+ metricTokenKeymap,
+];
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/operatorHighlight.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/operatorHighlight.ts
new file mode 100644
index 00000000000..6b150b3cc16
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/operatorHighlight.ts
@@ -0,0 +1,40 @@
+import { RangeSetBuilder } from "@codemirror/state";
+import {
+ Decoration,
+ type DecorationSet,
+ type EditorView,
+ ViewPlugin,
+ type ViewUpdate,
+} from "@codemirror/view";
+
+import { isMathExpressionOperator } from "metabase-types/api";
+
+import S from "./MetricSearchInput.module.css";
+
+const operatorMark = Decoration.mark({ class: S.cmOperator });
+
+function buildDecorations(view: EditorView): DecorationSet {
+ const builder = new RangeSetBuilder<Decoration>();
+ const text = view.state.doc.toString();
+ for (let i = 0; i < text.length; i++) {
+ if (isMathExpressionOperator(text[i])) {
+ builder.add(i, i + 1, operatorMark);
+ }
+ }
+ return builder.finish();
+}
+
+export const operatorHighlight = ViewPlugin.fromClass(
+ class {
+ decorations: DecorationSet;
+ constructor(view: EditorView) {
+ this.decorations = buildDecorations(view);
+ }
+ update(update: ViewUpdate) {
+ if (update.docChanged) {
+ this.decorations = buildDecorations(update.view);
+ }
+ }
+ },
+ { decorations: (v) => v.decorations },
+);
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts
new file mode 100644
index 00000000000..7ed1f27a89e
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useFormulaEditor.ts
@@ -0,0 +1,594 @@
+import { isolateHistory } from "@codemirror/commands";
+import { EditorSelection } from "@codemirror/state";
+import type { ReactCodeMirrorRef } from "@uiw/react-codemirror";
+import type { MutableRefObject } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import type {
+ MetricSourceId,
+ MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
+ SelectedMetric,
+} from "../../../types/viewer-state";
+import { isExpressionEntry, isMetricEntry } from "../../../types/viewer-state";
+import { computeMetricSlots } from "../../../utils/metric-slots";
+import {
+ createMeasureSourceId,
+ createMetricSourceId,
+} from "../../../utils/source-ids";
+import {
+ type MetricNameMap,
+ applyTrackedDefinitions,
+ buildFullText,
+ cleanupParens,
+ findInvalidRanges,
+ getWordAtCursor,
+ parseFullText,
+ removeUnmatchedParens,
+} from "../utils";
+
+import { setErrorDecoration } from "./errorHighlight";
+import {
+ buildMetricIdentities,
+ readMetricIdentities,
+ setMetricIdentities,
+ setMetricNames,
+} from "./metricTokenHighlight";
+
+type UseFormulaEditorParams = {
+ formulaEntities: MetricsViewerFormulaEntity[];
+ onFormulaEntitiesChange: (
+ entities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) => void;
+ selectedMetrics: SelectedMetric[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ metricNames: MetricNameMap;
+ metricNamesRef: MutableRefObject<MetricNameMap>;
+ handleAddMetric: (metric: SelectedMetric) => void;
+ handleRemoveMetric: (
+ metricId: number,
+ sourceType: "metric" | "measure",
+ ) => void;
+ editorRef: React.RefObject<ReactCodeMirrorRef | null>;
+ containerRef: React.RefObject<HTMLDivElement | null>;
+};
+
+export type UseFormulaEditorResult = {
+ editText: string;
+ isFocused: boolean;
+ isOpen: boolean;
+ setIsOpen: (open: boolean) => void;
+ currentWord: string;
+ validationError: string | null;
+ anchorRect: { left: number; top: number };
+ isExpressionDirty: boolean;
+ pendingFocusRef: MutableRefObject<boolean>;
+ handleInputFocus: () => void;
+ handleInputBlur: () => void;
+ handleChange: (newText: string) => void;
+ handleSelect: (metric: SelectedMetric) => void;
+ handleRemoveItem: (itemIndex: number) => void;
+ handleContainerClick: (e: React.MouseEvent) => void;
+ handleEditorClick: () => void;
+ handleEditorKeyDown: (e: React.KeyboardEvent) => void;
+ handleDropdownHasSelectionChange: (hasSelection: boolean) => void;
+ handleRun: () => void;
+ // Refs needed by editorExtensions builder
+ handleRunRef: MutableRefObject<() => void>;
+ isOpenRef: MutableRefObject<boolean>;
+ dropdownHasSelectionRef: MutableRefObject<boolean>;
+};
+
+export function useFormulaEditor({
+ formulaEntities,
+ onFormulaEntitiesChange,
+ selectedMetrics,
+ definitions,
+ metricNames,
+ metricNamesRef,
+ handleAddMetric,
+ handleRemoveMetric,
+ editorRef,
+ containerRef,
+}: UseFormulaEditorParams): UseFormulaEditorResult {
+ // editText is the full expression as plain text — only meaningful while focused
+ const [editText, setEditText] = useState("");
+ // currentWord is the word under the cursor, used as the dropdown search query
+ const [currentWord, setCurrentWord] = useState("");
+ const [isOpen, setIsOpen] = useState(false);
+ const isOpenRef = useRef(isOpen);
+ isOpenRef.current = isOpen;
+ const [isFocused, setIsFocused] = useState(false);
+ const [validationError, setValidationError] = useState<string | null>(null);
+ // Pixel position (viewport-relative) of the current word's left edge and
+ // line bottom — used to anchor the search dropdown at the cursor word.
+ const [anchorRect, setAnchorRect] = useState<{ left: number; top: number }>({
+ left: 0,
+ top: 0,
+ });
+
+ const pendingFocusRef = useRef(false);
+ // Refs for reading latest values in callbacks without stale closures
+ const editTextRef = useRef(editText);
+ editTextRef.current = editText;
+ const formulaEntitiesRef = useRef(formulaEntities);
+ formulaEntitiesRef.current = formulaEntities;
+ const definitionsRef = useRef(definitions);
+ definitionsRef.current = definitions;
+ // Tracks whether an editing session is active. Set to true only once
+ // handleInputFocus initializes the session; set back to false in commitAndCollapse.
+ // Used to prevent autoFocus / view.focus() re-entrancy from reinitializing text.
+ const isEditingSessionActiveRef = useRef(false);
+ // Tracks whether the dropdown has a keyboard-highlighted item.
+ // When true, Enter should select from the dropdown, not run the expression.
+ const dropdownHasSelectionRef = useRef(false);
+
+ const handleRunRef = useRef<() => void>(() => {});
+ // Text captured at focus time — used to detect whether the user actually
+ // changed the expression and therefore needs to click "Run" to commit.
+ const [textAtFocus, setTextAtFocus] = useState("");
+ const textAtFocusRef = useRef(textAtFocus);
+ textAtFocusRef.current = textAtFocus;
+ // Explicitly tracks whether the expression was modified during this editing
+ // session (metric selected from dropdown, or text typed). Avoids timing
+ // issues with comparing editText vs textAtFocus across async state updates.
+ const [isExpressionDirty, setIsExpressionDirty] = useState(false);
+
+ // Clean up parens per expression entry (only when not actively editing)
+ useEffect(() => {
+ if (isFocused) {
+ return;
+ }
+ let changed = false;
+ const cleaned = formulaEntities.map((entry) => {
+ if (!isExpressionEntry(entry)) {
+ return entry;
+ }
+ const cleanedTokens = cleanupParens(removeUnmatchedParens(entry.tokens));
+ if (cleanedTokens !== entry.tokens) {
+ changed = true;
+ return { ...entry, tokens: cleanedTokens };
+ }
+ return entry;
+ });
+ if (changed) {
+ onFormulaEntitiesChange(cleaned);
+ }
+ }, [isFocused, formulaEntities, onFormulaEntitiesChange]);
+
+ // Focus the editor after transitioning from collapsed → expanded mode
+ useEffect(() => {
+ if (isFocused && pendingFocusRef.current) {
+ pendingFocusRef.current = false;
+ editorRef.current?.view?.focus();
+ }
+ }, [isFocused, editorRef]);
+
+ const handleInputFocus = useCallback(() => {
+ // If an editing session is already active (e.g. focus returning from a
+ // dropdown item click via view.focus()), do not reset the text or the
+ // committed baseline.
+ if (isEditingSessionActiveRef.current) {
+ return;
+ }
+ isEditingSessionActiveRef.current = true;
+ const fullText = buildFullText(
+ formulaEntitiesRef.current,
+ metricNamesRef.current,
+ );
+ setTextAtFocus(fullText);
+ setIsFocused(true);
+ setEditText(fullText);
+ setValidationError(null);
+ setIsExpressionDirty(false);
+ // After CodeMirror renders the initial text, position the caret and
+ // create an undo boundary. The @uiw/react-codemirror value sync adds
+ // to the undo history, so without isolateHistory("before"), a quick
+ // Cmd+Z after deleting a metric token would undo both the deletion
+ // AND the initial text insertion (they'd be grouped together).
+ setTimeout(() => {
+ const view = editorRef.current?.view;
+ if (view) {
+ const endPos = view.state.doc.length;
+ const identities = buildMetricIdentities(
+ fullText,
+ metricNamesRef.current,
+ formulaEntitiesRef.current,
+ );
+ view.dispatch({
+ selection: EditorSelection.cursor(endPos),
+ effects: [
+ setMetricNames.of(metricNamesRef.current),
+ setMetricIdentities.of(identities),
+ ],
+ annotations: isolateHistory.of("full"),
+ });
+ const coords = view.coordsAtPos(endPos);
+ if (coords) {
+ setAnchorRect({ left: coords.left, top: coords.bottom });
+ }
+ }
+ }, 0);
+ }, [editorRef, metricNamesRef]);
+
+ /** Commits the current text: parses formula entities, removes unreferenced metrics, and collapses. */
+ const commitAndCollapse = useCallback(() => {
+ const newText = editTextRef.current;
+ const parsedEntities = parseFullText(newText, metricNamesRef.current);
+
+ // Read tracked identities from the CodeMirror StateField —
+ // positions are already mapped through all edits automatically.
+ const view = editorRef.current?.view;
+ const trackedIdentities = view ? readMetricIdentities(view) : [];
+
+ const { entities: reconciledEntities, slotMapping } =
+ applyTrackedDefinitions(
+ parsedEntities,
+ trackedIdentities,
+ newText,
+ metricNamesRef.current,
+ );
+
+ // Find which metric sourceIds are referenced in the parsed entities
+ const referencedSourceIds = new Set<MetricSourceId>();
+ for (const entry of reconciledEntities) {
+ if (isMetricEntry(entry)) {
+ referencedSourceIds.add(entry.id);
+ } else if (isExpressionEntry(entry)) {
+ for (const token of entry.tokens) {
+ if (token.type === "metric") {
+ referencedSourceIds.add(token.sourceId);
+ }
+ }
+ }
+ }
+
+ // Remove unreferenced metrics from definitions
+ for (const entry of Object.values(definitionsRef.current)) {
+ if (!referencedSourceIds.has(entry.id)) {
+ const metricId = selectedMetrics.find((m) => {
+ const sid =
+ m.sourceType === "metric"
+ ? createMetricSourceId(m.id)
+ : createMeasureSourceId(m.id);
+ return sid === entry.id;
+ });
+ if (metricId) {
+ handleRemoveMetric(metricId.id, metricId.sourceType);
+ }
+ }
+ }
+
+ onFormulaEntitiesChange(reconciledEntities, slotMapping);
+ isEditingSessionActiveRef.current = false;
+ setIsFocused(false);
+ setIsOpen(false);
+ setCurrentWord("");
+ setEditText("");
+ setValidationError(null);
+ setIsExpressionDirty(false);
+ }, [
+ editorRef,
+ metricNamesRef,
+ handleRemoveMetric,
+ onFormulaEntitiesChange,
+ selectedMetrics,
+ ]);
+
+ const handleInputBlur = useCallback(() => {
+ // If the text hasn't changed since focus, collapse back to pills view
+ // without requiring the user to click "Run".
+ if (
+ editTextRef.current === textAtFocusRef.current &&
+ !dropdownHasSelectionRef.current
+ ) {
+ isEditingSessionActiveRef.current = false;
+ setIsFocused(false);
+ setIsOpen(false);
+ setCurrentWord("");
+ setEditText("");
+ setValidationError(null);
+ setIsExpressionDirty(false);
+ return;
+ }
+
+ // Text was modified — validate on blur but do NOT commit.
+ // The expression is only executed when the user explicitly clicks "Run".
+ const invalidRanges = findInvalidRanges(
+ editTextRef.current,
+ metricNamesRef.current,
+ );
+ if (invalidRanges.length > 0) {
+ setValidationError(invalidRanges[0].message);
+ return;
+ }
+
+ setValidationError(null);
+ }, [metricNamesRef]);
+
+ const handleChange = useCallback(
+ (newText: string) => {
+ setEditText(newText);
+ setValidationError(null);
+ if (newText !== textAtFocusRef.current) {
+ setIsExpressionDirty(true);
+ }
+
+ // Extract the word at the cursor for the dropdown search
+ const view = editorRef.current?.view;
+ const cursorPos = view?.state.selection.main.head ?? newText.length;
+ const { word, start: wordStart } = getWordAtCursor(
+ newText,
+ cursorPos,
+ metricNamesRef.current,
+ );
+ // Anchor the dropdown at the word's left edge / line bottom in the viewport
+ if (view) {
+ const coords = view.coordsAtPos(wordStart);
+ if (coords) {
+ setAnchorRect({ left: coords.left, top: coords.bottom });
+ }
+ }
+ setCurrentWord(word);
+ setIsOpen(true);
+ },
+ [editorRef, metricNamesRef],
+ );
+
+ const handleSelect = useCallback(
+ (metric: SelectedMetric) => {
+ const view = editorRef.current?.view;
+ if (!view) {
+ return;
+ }
+ const docText = view.state.doc.toString();
+ const cursorPos = view.state.selection.main.head;
+ const { start, end } = getWordAtCursor(
+ docText,
+ cursorPos,
+ metricNamesRef.current,
+ );
+
+ const metricName = metric.name ?? "";
+
+ // Check if we need to auto-insert a separator before this metric.
+ const textBeforeWord = docText.slice(0, start).trimEnd();
+ const lastChar = textBeforeWord[textBeforeWord.length - 1];
+ const NO_COMMA_CHARS = new Set(["+", "-", "*", "/", "(", ","]);
+ const needsComma =
+ textBeforeWord.length > 0 && !NO_COMMA_CHARS.has(lastChar);
+
+ // Dispatch through the view (not setEditText) — the value-prop sync
+ // in @uiw/react-codemirror does a full doc replacement that destroys
+ // all RangeSet-tracked identities.
+ let insertText: string;
+ let replaceFrom: number;
+ let newCursorPos: number;
+ if (needsComma) {
+ insertText = ", " + metricName;
+ replaceFrom = textBeforeWord.length;
+ newCursorPos = replaceFrom + insertText.length;
+ } else {
+ insertText = metricName;
+ replaceFrom = start;
+ newCursorPos = start + metricName.length;
+ }
+
+ view.dispatch({
+ changes: { from: replaceFrom, to: end, insert: insertText },
+ selection: EditorSelection.cursor(newCursorPos),
+ });
+
+ setIsExpressionDirty(true);
+ handleAddMetric(metric);
+
+ setCurrentWord("");
+ setIsOpen(false);
+ dropdownHasSelectionRef.current = false;
+
+ // Return focus to the editor after dropdown closes
+ setTimeout(() => {
+ editorRef.current?.view?.focus();
+ }, 0);
+ },
+ [editorRef, metricNamesRef, handleAddMetric],
+ );
+
+ // Remove one formula entity by index
+ const handleRemoveItem = useCallback(
+ (itemIndex: number) => {
+ const removedEntry = formulaEntities[itemIndex];
+ const newFormulaEntities = formulaEntities.filter(
+ (_, i) => i !== itemIndex,
+ );
+
+ // Find sourceIds that were only referenced by the removed entry
+ const removedSourceIds = new Set<MetricSourceId>();
+ if (isMetricEntry(removedEntry)) {
+ removedSourceIds.add(removedEntry.id);
+ } else if (isExpressionEntry(removedEntry)) {
+ for (const token of removedEntry.tokens) {
+ if (token.type === "metric") {
+ removedSourceIds.add(token.sourceId);
+ }
+ }
+ }
+
+ // Check if any of those sourceIds are still referenced
+ const stillReferenced = new Set<MetricSourceId>();
+ for (const entry of newFormulaEntities) {
+ if (isMetricEntry(entry)) {
+ stillReferenced.add(entry.id);
+ } else if (isExpressionEntry(entry)) {
+ for (const token of entry.tokens) {
+ if (token.type === "metric") {
+ stillReferenced.add(token.sourceId);
+ }
+ }
+ }
+ }
+
+ // Remove unreferenced metrics from definitions
+ for (const sourceId of removedSourceIds) {
+ if (!stillReferenced.has(sourceId)) {
+ const metric = selectedMetrics.find((m) => {
+ const sid =
+ m.sourceType === "metric"
+ ? createMetricSourceId(m.id)
+ : createMeasureSourceId(m.id);
+ return sid === sourceId;
+ });
+ if (metric) {
+ handleRemoveMetric(metric.id, metric.sourceType);
+ }
+ }
+ }
+
+ // Build slot mapping for the removal: surviving old slots map to their
+ // new (shifted) indices. Slots from the removed entity are absent.
+ const oldSlots = computeMetricSlots(formulaEntities);
+ const slotMapping = new Map<number, number>();
+ let newIdx = 0;
+ for (const slot of oldSlots) {
+ if (slot.entityIndex === itemIndex) {
+ continue; // removed
+ }
+ slotMapping.set(slot.slotIndex, newIdx++);
+ }
+
+ onFormulaEntitiesChange(newFormulaEntities, slotMapping);
+ },
+ [
+ formulaEntities,
+ selectedMetrics,
+ handleRemoveMetric,
+ onFormulaEntitiesChange,
+ ],
+ );
+
+ const handleContainerClick = useCallback(
+ (e: React.MouseEvent) => {
+ // Ignore clicks originating from portal-rendered content (e.g. context
+ // menus, breakout pickers). These fire "click outside" on the container
+ // but should not switch the input into text-editing mode.
+ if (
+ containerRef.current &&
+ e.target instanceof Node &&
+ !containerRef.current.contains(e.target)
+ ) {
+ return;
+ }
+ const view = editorRef.current?.view;
+ if (view) {
+ view.focus();
+ } else {
+ // Editor not rendered yet (collapsed mode) — transition to expanded
+ pendingFocusRef.current = true;
+ setIsFocused(true);
+ }
+ },
+ [containerRef, editorRef],
+ );
+
+ const handleEditorClick = useCallback(() => {
+ const view = editorRef.current?.view;
+ if (!view) {
+ return;
+ }
+ // Re-extract word at the new cursor position after a click
+ const cursorPos = view.state.selection.main.head;
+ const text = view.state.doc.toString();
+ const { word, start: wordStart } = getWordAtCursor(
+ text,
+ cursorPos,
+ metricNamesRef.current,
+ );
+ // Update the anchor position so the dropdown is correctly placed
+ const coords = view.coordsAtPos(wordStart);
+ if (coords) {
+ setAnchorRect({ left: coords.left, top: coords.bottom });
+ }
+ setCurrentWord(word);
+ setIsOpen(true);
+ }, [editorRef, metricNamesRef]);
+
+ const handleEditorKeyDown = useCallback((e: React.KeyboardEvent) => {
+ if (e.key === "Escape") {
+ setIsOpen(false);
+ }
+ }, []);
+
+ const handleDropdownHasSelectionChange = useCallback(
+ (hasSelection: boolean) => {
+ dropdownHasSelectionRef.current = hasSelection;
+ },
+ [],
+ );
+
+ /** Validate the expression and either show an error or commit + run the query. */
+ const handleRun = useCallback(() => {
+ // Check for unknown / invalid tokens in the raw text first, before
+ // parseFullText strips them. This catches trailing junk like "!!!"
+ // that would otherwise be silently dropped.
+ const invalidRanges = findInvalidRanges(
+ editTextRef.current,
+ metricNamesRef.current,
+ );
+ if (invalidRanges.length > 0) {
+ setValidationError(invalidRanges[0].message);
+ return;
+ }
+
+ setValidationError(null);
+ commitAndCollapse();
+ }, [commitAndCollapse, metricNamesRef]);
+ handleRunRef.current = handleRun;
+
+ // Sync validation error into the CodeMirror decoration field
+ useEffect(() => {
+ const view = editorRef.current?.view;
+ if (!view) {
+ return;
+ }
+ const ranges =
+ validationError !== null
+ ? findInvalidRanges(editTextRef.current, metricNamesRef.current)
+ : [];
+ view.dispatch({ effects: setErrorDecoration.of(ranges) });
+ }, [validationError, editorRef, metricNamesRef]);
+
+ // Sync metric entries into the CodeMirror state for atomic token ranges
+ useEffect(() => {
+ const view = editorRef.current?.view;
+ if (!view || !isFocused) {
+ return;
+ }
+ view.dispatch({ effects: setMetricNames.of(metricNames) });
+ }, [metricNames, isFocused, editorRef]);
+
+ return {
+ editText,
+ isFocused,
+ isOpen,
+ setIsOpen,
+ currentWord,
+ validationError,
+ anchorRect,
+ isExpressionDirty,
+ pendingFocusRef,
+ handleInputFocus,
+ handleInputBlur,
+ handleChange,
+ handleSelect,
+ handleRemoveItem,
+ handleContainerClick,
+ handleEditorClick,
+ handleEditorKeyDown,
+ handleDropdownHasSelectionChange,
+ handleRun,
+ handleRunRef,
+ isOpenRef,
+ dropdownHasSelectionRef,
+ };
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useMetricNameTracking.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useMetricNameTracking.ts
new file mode 100644
index 00000000000..18fdd50885e
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/MetricSearchInput/useMetricNameTracking.ts
@@ -0,0 +1,112 @@
+import type { MutableRefObject } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
+
+import type { MetricDefinition } from "metabase-lib/metric";
+
+import type {
+ MetricSourceId,
+ MetricsViewerDefinitionEntry,
+ SelectedMetric,
+} from "../../../types/viewer-state";
+import { getDefinitionName } from "../../../utils/definition-builder";
+import { createSourceId } from "../../../utils/source-ids";
+import type { MetricNameMap } from "../utils";
+
+type UseMetricNameTrackingParams = {
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ onAddMetric: (metric: SelectedMetric) => void;
+ onRemoveMetric: (metricId: number, sourceType: "metric" | "measure") => void;
+ onSwapMetric: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;
+};
+
+type UseMetricNameTrackingResult = {
+ metricNames: MetricNameMap;
+ metricNamesRef: MutableRefObject<MetricNameMap>;
+ handleAddMetric: (metric: SelectedMetric) => void;
+ handleRemoveMetric: (
+ metricId: number,
+ sourceType: "metric" | "measure",
+ ) => void;
+ handleSwapMetric: (
+ oldMetric: SelectedMetric,
+ newMetric: SelectedMetric,
+ ) => void;
+};
+
+export function useMetricNameTracking({
+ definitions,
+ onAddMetric,
+ onRemoveMetric,
+ onSwapMetric,
+}: UseMetricNameTrackingParams): UseMetricNameTrackingResult {
+ const [localMetricNames, setLocalMetricNames] = useState<MetricNameMap>({});
+
+ const metricNames: MetricNameMap = useMemo(
+ () => ({
+ ...localMetricNames,
+ ...Object.fromEntries(
+ Object.values(definitions)
+ .filter(
+ (e): e is { id: MetricSourceId; definition: MetricDefinition } =>
+ e.definition !== null,
+ )
+ .map((e) => [e.id, getDefinitionName(e.definition)])
+ .filter(([, name]) => name !== null),
+ ),
+ }),
+ [localMetricNames, definitions],
+ );
+
+ const metricNamesRef = useRef<MetricNameMap>(metricNames);
+ metricNamesRef.current = metricNames;
+
+ const handleAddMetric = useCallback(
+ (metric: SelectedMetric) => {
+ onAddMetric(metric);
+ if (metric.name != null) {
+ setLocalMetricNames((prev) => ({
+ ...prev,
+ [createSourceId(metric.id, metric.sourceType)]: metric.name!,
+ }));
+ }
+ },
+ [onAddMetric],
+ );
+
+ const handleRemoveMetric = useCallback(
+ (metricId: number, sourceType: "metric" | "measure") => {
+ onRemoveMetric(metricId, sourceType);
+ const sourceId = createSourceId(metricId, sourceType);
+ setLocalMetricNames((prev) => {
+ const next = { ...prev };
+ delete next[sourceId];
+ return next;
+ });
+ },
+ [onRemoveMetric],
+ );
+
+ const handleSwapMetric = useCallback(
+ (oldMetric: SelectedMetric, newMetric: SelectedMetric) => {
+ onSwapMetric(oldMetric, newMetric);
+ setLocalMetricNames((prev) => {
+ const next = { ...prev };
+ delete next[createSourceId(oldMetric.id, oldMetric.sourceType)];
+ if (newMetric.name != null) {
+ next[createSourceId(newMetric.id, newMetric.sourceType)] =
+ newMetric.name;
+ }
+ return next;
+ });
+ },
+ [onSwapMetric],
+ );
+
+ return {
+ metricNames,
+ metricNamesRef,
+ handleAddMetric,
+ handleRemoveMetric,
+ handleSwapMetric,
+ };
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts
index 6184bc2dfa4..18017cbc645 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/index.ts
@@ -1 +1 @@
-export { MetricSearchInput as MetricSearch } from "./MetricSearchInput";
+export { MetricSearchInput } from "./MetricSearchInput";
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts
index b3825272b6d..7b1e85b39b2 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.ts
@@ -1,25 +1,511 @@
-import type { SelectedMetric } from "../../types/viewer-state";
-
-export function getSelectedMetricIds(
- selectedMetrics: SelectedMetric[],
-): Set<number> {
- return new Set(
- selectedMetrics
- .filter((metric) => metric.sourceType === "metric")
- .map((metric) => metric.id),
- );
+import { t } from "ttag";
+
+import type { MetricDefinition } from "metabase-lib/metric";
+import * as LibMetric from "metabase-lib/metric";
+import { MATH_OPERATORS, isMathOperator } from "metabase-types/api";
+
+import type {
+ ExpressionDefinitionEntry,
+ ExpressionSubToken,
+ MetricDefinitionEntry,
+ MetricSourceId,
+ MetricsViewerFormulaEntity,
+} from "../../types/viewer-state";
+import { isExpressionEntry, isMetricEntry } from "../../types/viewer-state";
+import { stampMetricCounts } from "../../utils/expression";
+
+export type MetricNameMap = Partial<Record<MetricSourceId, string>>;
+
+/**
+ * Returns an array of human-readable expression strings interleaved with numbers
+ * identifying when metrics are used multiple times in the expression.
+ */
+export function buildExpressionForPill(
+ tokens: ExpressionSubToken[],
+ metricNames: MetricNameMap,
+): (string | number)[] {
+ const result: (string | number)[] = [];
+ let curr = "";
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i];
+ const prev = tokens[i - 1];
+ const needsSpace =
+ i > 0 && prev?.type !== "open-paren" && token.type !== "close-paren";
+ if (needsSpace) {
+ curr += " ";
+ }
+ if (token.type === "open-paren") {
+ curr += "(";
+ } else if (token.type === "close-paren") {
+ curr += ")";
+ } else if (token.type === "operator") {
+ curr += token.op;
+ } else if (token.type === "metric") {
+ const name = metricNames[token.sourceId];
+ curr += name ?? "";
+ if (token.count > 1) {
+ result.push(curr);
+ curr = "";
+ result.push(token.count);
+ }
+ } else if (token.type === "constant") {
+ curr += String(token.value);
+ }
+ }
+ result.push(curr);
+ return result;
+}
+
+/**
+ * Builds a human-readable expression string from a single expression's sub-tokens
+ */
+export function buildExpressionText(
+ tokens: ExpressionSubToken[],
+ metricNames: MetricNameMap,
+): string {
+ return buildExpressionForPill(tokens, metricNames)
+ .filter((x) => typeof x === "string")
+ .join("");
+}
+
+export function buildFullText(
+ formulaEntities: MetricsViewerFormulaEntity[],
+ metricNames: MetricNameMap,
+): string {
+ return formulaEntities
+ .map((entity) => {
+ if (isExpressionEntry(entity)) {
+ return buildExpressionText(entity.tokens, metricNames);
+ }
+ if (isMetricEntry(entity)) {
+ return metricNames[entity.id] ?? "";
+ }
+ return "";
+ })
+ .join(", ");
+}
+
+const COMMA = ",";
+
+const PAREN_DELIMITERS = ["(", ")"] as const;
+const NON_COMMA_DELIMITERS = new Set<string>([
+ ...MATH_OPERATORS,
+ ...PAREN_DELIMITERS,
+]);
+const EXPRESSION_DELIMITERS = new Set<string>([...NON_COMMA_DELIMITERS, COMMA]);
+
+/** Returns true for characters that form word continuations (letters, digits, underscore). */
+function isWordChar(ch: string): boolean {
+ return /\w/.test(ch);
+}
+
+/**
+ * Extracts the "word" (potential metric name) at the given cursor position,
+ * using expression delimiters as boundaries.
+ *
+ * Spaces are NOT delimiters so that multi-word metric names like "Page Views"
+ * are returned as a single word. Surrounding whitespace is trimmed.
+ *
+ * When `metricEntries` is provided, commas are only treated as delimiters
+ * when they are real item separators — i.e. the text before the comma forms
+ * a complete token (known metric, number, or closing paren). This allows
+ * metric names containing commas (e.g. "Revenue, Total") to be typed and
+ * searched as a single word.
+ */
+export function getWordAtCursor(
+ text: string,
+ cursorPos: number,
+ metricNames?: MetricNameMap,
+): { word: string; start: number; end: number } {
+ // Build a set of metric names (lowercased) for quick lookup.
+ let metricNamesLower: Set<string> | null = null;
+ if (metricNames && Object.values(metricNames).length > 0) {
+ metricNamesLower = new Set(
+ Object.values(metricNames)
+ .map((name) => name?.toLowerCase() ?? "")
+ .filter((n) => n.length > 0),
+ );
+ }
+
+ /**
+ * Decides whether the comma at `pos` is a separator (delimiter) rather
+ * than part of a metric name being typed.
+ *
+ * A comma is a separator when the trimmed text before it ends with:
+ * - a known metric name,
+ * - a numeric constant, or
+ * - a closing parenthesis.
+ *
+ * Otherwise the comma is likely inside a metric name the user is still
+ * typing (e.g. "Revenue," as part of "Revenue, Total").
+ */
+ const isCommaASeparator = (commaPos: number): boolean => {
+ if (!metricNamesLower) {
+ return true; // no entries → fall back to always splitting on commas
+ }
+
+ const before = text.slice(0, commaPos).trimEnd();
+ if (before.length === 0) {
+ return true;
+ }
+
+ const lastCh = before[before.length - 1];
+ // After a closing paren → separator
+ if (lastCh === ")") {
+ return true;
+ }
+ // After a digit → separator (number constant)
+ if (/\d/.test(lastCh)) {
+ return true;
+ }
+ // Check if `before` ends with a known metric name
+ const beforeLower = before.toLowerCase();
+ for (const name of metricNamesLower) {
+ const charBeforeName = before[before.length - name.length - 1];
+ const isAtTextStart = before.length === name.length;
+ const hasDelimiterBefore =
+ NON_COMMA_DELIMITERS.has(charBeforeName) ||
+ charBeforeName === COMMA ||
+ charBeforeName === " ";
+ const endsWithMetricName =
+ beforeLower.endsWith(name) && (isAtTextStart || hasDelimiterBefore);
+ if (endsWithMetricName) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ const isDelimiter = (pos: number): boolean => {
+ const ch = text[pos];
+ if (NON_COMMA_DELIMITERS.has(ch)) {
+ return true;
+ }
+ if (ch === COMMA) {
+ return isCommaASeparator(pos);
+ }
+ return false;
+ };
+
+ let start = cursorPos;
+ while (start > 0 && !isDelimiter(start - 1)) {
+ start--;
+ }
+
+ let end = cursorPos;
+ while (end < text.length && !isDelimiter(end)) {
+ end++;
+ }
+
+ const rawWord = text.slice(start, end);
+ const trimmedWord = rawWord.trim();
+ const leadingSpaces = rawWord.length - rawWord.trimStart().length;
+
+ return {
+ word: trimmedWord,
+ start: start + leadingSpaces,
+ end: start + leadingSpaces + trimmedWord.length,
+ };
+}
+
+/**
+ * Returns positions of commas in the text that are NOT inside a metric token.
+ * These are the real item separators. Metric names may contain commas (e.g.
+ * "Revenue, Total") — those commas are consumed by the greedy metric matcher
+ * in `parseFullTextWithPositions` and must not be treated as separators.
+ */
+function findSeparatorCommaPositions(
+ text: string,
+ allTokens: PositionedToken[],
+): number[] {
+ const metricRanges = allTokens.filter((t) => t.type === "metric");
+ const commas: number[] = [];
+ for (let i = 0; i < text.length; i++) {
+ const isComma = text[i] === COMMA;
+ const isInsideMetricToken = metricRanges.some(
+ (r) => i >= r.from && i < r.to,
+ );
+ if (isComma && !isInsideMetricToken) {
+ commas.push(i);
+ }
+ }
+ return commas;
+}
+
+/**
+ * Groups an array of positioned tokens into segments split by separator commas.
+ */
+function groupTokensBySegment(
+ allTokens: PositionedToken[],
+ separatorPositions: number[],
+): PositionedToken[][] {
+ const segments: PositionedToken[][] = [];
+ let current: PositionedToken[] = [];
+ let commaIdx = 0;
+
+ for (const token of allTokens) {
+ while (
+ commaIdx < separatorPositions.length &&
+ token.from > separatorPositions[commaIdx]
+ ) {
+ segments.push(current);
+ current = [];
+ commaIdx++;
+ }
+ current.push(token);
+ }
+ segments.push(current);
+ return segments;
+}
+
+type MetricPositionedToken = PositionedToken & { type: "metric" };
+
+type MetricSubToken = Extract<ExpressionSubToken, { type: "metric" }>;
+
+export type MetricTokenVisit =
+ | {
+ kind: "standalone";
+ positioned: MetricPositionedToken;
+ entity: MetricDefinitionEntry;
+ }
+ | {
+ kind: "expression";
+ positioned: MetricPositionedToken;
+ entity: ExpressionDefinitionEntry;
+ exprToken: MetricSubToken;
+ exprTokenIndex: number;
+ };
+
+/**
+ * Parses text into segments aligned with entities, then calls `visitor`
+ * for each metric token with its positioned counterpart and parent entity.
+ */
+export function traverseMetricTokens(
+ text: string,
+ metricNames: MetricNameMap,
+ entities: MetricsViewerFormulaEntity[],
+ visitor: (visit: MetricTokenVisit) => void,
+): void {
+ const allTokens = parseFullTextWithPositions(text, metricNames);
+ const separators = findSeparatorCommaPositions(text, allTokens);
+ const segments = groupTokensBySegment(allTokens, separators);
+
+ let entityIndex = 0;
+ for (const segmentTokens of segments) {
+ if (segmentTokens.length === 0) {
+ continue;
+ }
+
+ const entity = entities[entityIndex++];
+ if (!entity) {
+ continue;
+ }
+
+ const metricTokens = segmentTokens.filter(
+ (token): token is MetricPositionedToken => token.type === "metric",
+ );
+
+ if (isMetricEntry(entity)) {
+ const positioned = metricTokens[0];
+ if (!positioned) {
+ continue;
+ }
+ visitor({ kind: "standalone", positioned, entity });
+ continue;
+ }
+
+ if (!isExpressionEntry(entity)) {
+ continue;
+ }
+
+ let metricIdx = 0;
+ for (let tokenIndex = 0; tokenIndex < entity.tokens.length; tokenIndex++) {
+ const exprToken = entity.tokens[tokenIndex];
+ if (exprToken.type !== "metric") {
+ continue;
+ }
+ const positioned = metricTokens[metricIdx++];
+ if (!positioned) {
+ continue;
+ }
+ visitor({
+ kind: "expression",
+ positioned,
+ entity,
+ exprToken,
+ exprTokenIndex: tokenIndex,
+ });
+ }
+ }
}
-export function getSelectedMeasureIds(
- selectedMetrics: SelectedMetric[],
-): Set<number> {
- return new Set(
- selectedMetrics
- .filter((metric) => metric.sourceType === "measure")
- .map((metric) => metric.id),
+/** Strip position info from a positioned token, dropping unknown tokens. */
+function stripPositions(token: PositionedToken): ExpressionSubToken | null {
+ switch (token.type) {
+ case "metric":
+ return { type: "metric", sourceId: token.sourceId, count: 0 };
+ case "operator":
+ return { type: "operator", op: token.op };
+ case "constant":
+ return { type: "constant", value: token.value };
+ case "open-paren":
+ return { type: "open-paren" };
+ case "close-paren":
+ return { type: "close-paren" };
+ case "unknown":
+ return null;
+ }
+}
+
+/**
+ * Parses a full expression text (with ", " separating items) into a
+ * `MetricsViewerFormulaEntity[]`. Each comma-separated segment becomes
+ * either a standalone metric entry (if it matches a single metric name) or
+ * an expression entry (if it contains operators / multiple operands).
+ *
+ * Metric names are matched greedily, longest first, so names containing
+ * operators (e.g. "Year-to-Date") or commas (e.g. "Revenue, Total") are
+ * handled correctly — metrics are identified before commas are used as
+ * separators.
+ */
+export function parseFullText(
+ text: string,
+ metricNames: MetricNameMap,
+): MetricsViewerFormulaEntity[] {
+ const allTokens = parseFullTextWithPositions(text, metricNames);
+ const separators = findSeparatorCommaPositions(text, allTokens);
+ const segments = groupTokensBySegment(allTokens, separators);
+ const result: MetricsViewerFormulaEntity[] = [];
+
+ for (const segmentTokens of segments) {
+ if (segmentTokens.length === 0) {
+ continue;
+ }
+
+ const subTokens = stampMetricCounts(
+ segmentTokens
+ .map(stripPositions)
+ .filter((t): t is ExpressionSubToken => t !== null),
+ );
+
+ // Single metric reference without operators → standalone metric entry
+ const firstToken = subTokens[0];
+ if (subTokens.length === 1 && firstToken.type === "metric") {
+ const name = metricNames[firstToken.sourceId];
+ if (name) {
+ result.push({
+ id: firstToken.sourceId,
+ type: "metric",
+ definition: null,
+ });
+ continue;
+ }
+ }
+
+ // Multiple tokens or operators → expression entry
+ const name = buildExpressionText(subTokens, metricNames);
+ result.push({
+ id: `expression:${name}`,
+ type: "expression",
+ name,
+ tokens: subTokens,
+ });
+ }
+
+ return result;
+}
+
+/**
+ * Removes unmatched parentheses from a sub-token stream.
+ */
+export function removeUnmatchedParens(
+ tokens: ExpressionSubToken[],
+): ExpressionSubToken[] {
+ const openStack: number[] = [];
+ const matchedIndices = new Set<number>();
+
+ tokens.forEach((token, i) => {
+ if (token.type === "open-paren") {
+ openStack.push(i);
+ } else if (token.type === "close-paren") {
+ if (openStack.length > 0) {
+ matchedIndices.add(openStack.pop()!);
+ matchedIndices.add(i);
+ }
+ }
+ });
+
+ const hasDangling = tokens.some(
+ (token, i) =>
+ (token.type === "open-paren" || token.type === "close-paren") &&
+ !matchedIndices.has(i),
+ );
+
+ if (!hasDangling) {
+ return tokens;
+ }
+
+ return tokens.filter((token, i) =>
+ token.type !== "open-paren" && token.type !== "close-paren"
+ ? true
+ : matchedIndices.has(i),
);
}
+/**
+ * Removes unnecessary parentheses from a sub-token stream.
+ * Parens are unnecessary when they contain 0 or 1 operand tokens.
+ */
+export function cleanupParens(
+ tokens: ExpressionSubToken[],
+): ExpressionSubToken[] {
+ let current = tokens;
+ let changed = true;
+
+ while (changed) {
+ changed = false;
+
+ for (let i = 0; i < current.length; i++) {
+ if (current[i].type !== "open-paren") {
+ continue;
+ }
+
+ let depth = 1;
+ let j = i + 1;
+ while (j < current.length && depth > 0) {
+ if (current[j].type === "open-paren") {
+ depth++;
+ } else if (current[j].type === "close-paren") {
+ depth--;
+ }
+ j++;
+ }
+
+ if (depth !== 0) {
+ continue;
+ }
+
+ const closeIdx = j - 1;
+ const content = current.slice(i + 1, closeIdx);
+ const operandCount = content.filter(
+ (tok) => tok.type === "metric" || tok.type === "constant",
+ ).length;
+
+ if (operandCount <= 1) {
+ current = [
+ ...current.slice(0, i),
+ ...content,
+ ...current.slice(closeIdx + 1),
+ ];
+ changed = true;
+ break;
+ }
+ }
+ }
+
+ return current;
+}
+
export type ExcludeMetric = {
id: number;
sourceType: "metric" | "measure";
@@ -30,19 +516,473 @@ type SearchResultLike = {
model: "metric" | "measure";
};
+// ── Positioned token type (internal) ────────────────────────────────────────
+
+export type PositionedToken = (
+ | ExpressionSubToken
+ | { type: "unknown"; text: string }
+) & { from: number; to: number };
+
+function isDigit(ch: string | undefined): boolean {
+ return ch !== undefined && ch >= "0" && ch <= "9";
+}
+
+function skipDigits(text: string, index: number): number {
+ while (index < text.length && isDigit(text[index])) {
+ index++;
+ }
+ return index;
+}
+
+function consumeNumber(text: string, startIndex: number): number | null {
+ let index = startIndex;
+
+ const startsWithDot = text[index] === "." && isDigit(text[index + 1]);
+ if (!startsWithDot && !isDigit(text[index])) {
+ return null;
+ }
+
+ index = skipDigits(text, index);
+
+ if (text[index] === "." && isDigit(text[index + 1])) {
+ index = skipDigits(text, index + 1);
+ }
+
+ return index;
+}
+
+/** Same as the main parser but records character positions for each token. */
+export function parseFullTextWithPositions(
+ text: string,
+ metricNames: MetricNameMap,
+): PositionedToken[] {
+ const sortedMetrics = Object.entries(metricNames)
+ .map(([id, name]) => ({ id, name: (name ?? "").toLowerCase() }))
+ .filter(
+ (m): m is { id: MetricSourceId; name: string } =>
+ (m.name?.length ?? 0) > 0,
+ )
+ .sort((a, b) => b.name.length - a.name.length);
+
+ const lower = text.toLowerCase();
+ const tokens: PositionedToken[] = [];
+ let i = 0;
+
+ while (i < text.length) {
+ const ch = text[i];
+
+ const isWhitespace = ch === " " || ch === "\t";
+ if (isWhitespace) {
+ i++;
+ continue;
+ }
+
+ // Commas are item separators — tracked for position-based splitting
+ // but NOT emitted as a token type (no more "separator" tokens).
+ if (ch === COMMA) {
+ i++;
+ continue;
+ }
+
+ if (ch === "(") {
+ tokens.push({ type: "open-paren", from: i, to: i + 1 });
+ i++;
+ continue;
+ }
+
+ if (ch === ")") {
+ tokens.push({ type: "close-paren", from: i, to: i + 1 });
+ i++;
+ continue;
+ }
+
+ if (isMathOperator(ch)) {
+ const lastToken = tokens.length > 0 ? tokens[tokens.length - 1] : null;
+ const isUnaryContext =
+ lastToken === null ||
+ lastToken.type === "operator" ||
+ lastToken.type === "open-paren";
+
+ if (ch === "-" && isUnaryContext) {
+ const endIndex = consumeNumber(text, i + 1);
+ if (endIndex !== null) {
+ tokens.push({
+ type: "constant",
+ value: parseFloat(text.slice(i, endIndex)),
+ from: i,
+ to: endIndex,
+ });
+ i = endIndex;
+ continue;
+ }
+ }
+
+ tokens.push({
+ type: "operator",
+ op: ch,
+ from: i,
+ to: i + 1,
+ });
+ i++;
+ continue;
+ }
+
+ const isNumberStart = isDigit(ch) || (ch === "." && isDigit(text[i + 1]));
+ if (isNumberStart) {
+ const endIndex = consumeNumber(text, i)!;
+ tokens.push({
+ type: "constant",
+ value: parseFloat(text.slice(i, endIndex)),
+ from: i,
+ to: endIndex,
+ });
+ i = endIndex;
+ continue;
+ }
+
+ let matched = false;
+ for (const { name, id } of sortedMetrics) {
+ if (lower.startsWith(name, i)) {
+ const nextI = i + name.length;
+ const nextCh = text[nextI];
+ // Accept the match unless the next character continues an
+ // alphanumeric word (e.g. "Revenue" inside "Revenues").
+ const isWordBoundary =
+ !nextCh || !isWordChar(nextCh) || !isWordChar(name[name.length - 1]);
+ if (isWordBoundary) {
+ tokens.push({
+ type: "metric",
+ sourceId: id,
+ count: 0,
+ from: i,
+ to: nextI,
+ });
+ i = nextI;
+ matched = true;
+ break;
+ }
+ }
+ }
+
+ if (!matched) {
+ // Collect consecutive unrecognized characters into a single unknown token
+ const start = i;
+ i++;
+ while (i < text.length) {
+ const char = text[i];
+ const isTokenBoundary =
+ EXPRESSION_DELIMITERS.has(char) || char === " " || isDigit(char);
+ if (isTokenBoundary) {
+ break;
+ }
+ // Check if a metric name starts here — if so, stop the unknown span
+ let metricStartsHere = false;
+ for (const { name } of sortedMetrics) {
+ if (lower.startsWith(name, i)) {
+ const nameEndIndex = i + name.length;
+ const afterNameChar = text[nameEndIndex];
+ const isMetricBoundary =
+ !afterNameChar ||
+ afterNameChar === " " ||
+ EXPRESSION_DELIMITERS.has(afterNameChar);
+ if (isMetricBoundary) {
+ metricStartsHere = true;
+ break;
+ }
+ }
+ }
+ if (metricStartsHere) {
+ break;
+ }
+ i++;
+ }
+ tokens.push({
+ type: "unknown",
+ text: text.slice(start, i),
+ from: start,
+ to: i,
+ });
+ }
+ }
+
+ return tokens;
+}
+
+export type ErrorRange = { from: number; to: number; message: string };
+
+/**
+ * Returns character ranges of invalid tokens in the expression text, each
+ * annotated with an error message. Used to apply red-underline decorations
+ * and hover tooltips in the CodeMirror editor.
+ *
+ * Splits by comma to validate each item independently.
+ */
+export function findInvalidRanges(
+ text: string,
+ metricNames: MetricNameMap,
+): ErrorRange[] {
+ const allTokens = parseFullTextWithPositions(text, metricNames);
+ const separators = findSeparatorCommaPositions(text, allTokens);
+ const segments = groupTokensBySegment(allTokens, separators);
+
+ const invalid: ErrorRange[] = [];
+
+ for (const itemTokens of segments) {
+ if (itemTokens.length === 0) {
+ continue;
+ }
+
+ const itemInvalid: ErrorRange[] = [];
+
+ // Unmatched parentheses
+ const openStack: PositionedToken[] = [];
+ for (const token of itemTokens) {
+ if (token.type === "open-paren") {
+ openStack.push(token);
+ } else if (token.type === "close-paren") {
+ if (openStack.length === 0) {
+ itemInvalid.push({
+ from: token.from,
+ to: token.to,
+ message: t`Unmatched closing parenthesis`,
+ });
+ } else {
+ openStack.pop();
+ }
+ }
+ }
+ for (const token of openStack) {
+ itemInvalid.push({
+ from: token.from,
+ to: token.to,
+ message: t`Unmatched opening parenthesis`,
+ });
+ }
+
+ // Token predecessor validity
+ let prevSignificant: PositionedToken | null = null;
+ for (const token of itemTokens) {
+ if (token.type === "unknown") {
+ prevSignificant = token;
+ continue;
+ }
+
+ const prevType = prevSignificant?.type ?? null;
+
+ if (
+ token.type === "metric" ||
+ token.type === "constant" ||
+ token.type === "open-paren"
+ ) {
+ if (
+ prevType !== null &&
+ prevType !== "open-paren" &&
+ prevType !== "operator" &&
+ prevType !== "unknown"
+ ) {
+ itemInvalid.push({
+ from: token.from,
+ to: token.to,
+ message: t`Missing operator`,
+ });
+ }
+ } else if (token.type === "operator") {
+ if (
+ prevType !== "metric" &&
+ prevType !== "constant" &&
+ prevType !== "close-paren" &&
+ prevType !== "unknown"
+ ) {
+ itemInvalid.push({
+ from: token.from,
+ to: token.to,
+ message: t`Missing operand`,
+ });
+ }
+ } else if (token.type === "close-paren") {
+ if (
+ prevType !== "metric" &&
+ prevType !== "constant" &&
+ prevType !== "close-paren" &&
+ prevType !== "unknown"
+ ) {
+ itemInvalid.push({
+ from:
+ prevType === "open-paren"
+ ? (prevSignificant?.from ?? token.from)
+ : token.from,
+ to: token.to,
+ message:
+ prevType === "open-paren"
+ ? t`Empty parentheses`
+ : t`Missing operand before closing parenthesis`,
+ });
+ }
+ }
+ prevSignificant = token;
+ }
+
+ if (prevSignificant?.type === "operator") {
+ itemInvalid.push({
+ from: prevSignificant.from,
+ to: prevSignificant.to,
+ message: t`Expression cannot end with an operator`,
+ });
+ }
+
+ for (const token of itemTokens) {
+ if (token.type === "unknown") {
+ itemInvalid.push({
+ from: token.from,
+ to: token.to,
+ message: t`Unknown token: "${token.text}"`,
+ });
+ }
+ }
+
+ const hasMetric = itemTokens.some((tok) => tok.type === "metric");
+ if (!hasMetric && itemInvalid.length === 0) {
+ itemInvalid.push({
+ from: itemTokens[0].from,
+ to: itemTokens[itemTokens.length - 1].to,
+ message: t`Expression must contain at least one metric`,
+ });
+ }
+
+ invalid.push(...itemInvalid);
+ }
+
+ return invalid;
+}
+
export function filterSearchResults<T extends SearchResultLike>(
results: T[],
- selectedMetricIds: Set<number>,
- selectedMeasureIds: Set<number>,
+ selectedMetricIds?: Set<number>,
+ selectedMeasureIds?: Set<number>,
excludeMetric?: ExcludeMetric,
): T[] {
- return results.filter(
- (result) =>
- (result.model === "metric"
- ? !selectedMetricIds.has(result.id)
- : !selectedMeasureIds.has(result.id)) &&
- (!excludeMetric ||
- result.id !== excludeMetric.id ||
- result.model !== excludeMetric.sourceType),
+ return results.filter((result) => {
+ const isAlreadySelected =
+ result.model === "metric"
+ ? selectedMetricIds?.has(result.id)
+ : selectedMeasureIds?.has(result.id);
+ const isExcluded =
+ excludeMetric &&
+ result.id === excludeMetric.id &&
+ result.model === excludeMetric.sourceType;
+ return !isAlreadySelected && !isExcluded;
+ });
+}
+
+export type MetricIdentityEntry = {
+ sourceId: MetricSourceId;
+ from: number;
+ to: number;
+ definition: MetricDefinition | null;
+ slotIndex: number;
+};
+
+export function stripDefinitionProjections(
+ definition: MetricDefinition,
+): MetricDefinition {
+ const projections = LibMetric.projections(definition);
+ if (projections.length === 0) {
+ return definition;
+ }
+ return projections.reduce(
+ (def, projection) => LibMetric.removeClause(def, projection),
+ definition,
);
}
+
+const getPositionKey = (from: number, to: number) => `${from}:${to}`;
+
+export interface ApplyTrackedDefinitionsResult {
+ entities: MetricsViewerFormulaEntity[];
+ /** Maps old slot index → new slot index for matched metric tokens. */
+ slotMapping: Map<number, number>;
+}
+
+export function applyTrackedDefinitions(
+ newEntities: MetricsViewerFormulaEntity[],
+ trackedIdentities: MetricIdentityEntry[],
+ text: string,
+ metricNames: MetricNameMap,
+): ApplyTrackedDefinitionsResult {
+ const identityByPosition = new Map<
+ string,
+ { definition: MetricDefinition | null; slotIndex: number }
+ >();
+ for (const identity of trackedIdentities) {
+ identityByPosition.set(getPositionKey(identity.from, identity.to), {
+ definition: identity.definition,
+ slotIndex: identity.slotIndex,
+ });
+ }
+
+ const metricOverrides = new Map<
+ MetricsViewerFormulaEntity,
+ MetricDefinition | null
+ >();
+ const exprTokenOverrides = new Map<
+ MetricsViewerFormulaEntity,
+ Map<number, MetricDefinition | undefined>
+ >();
+ const slotMapping = new Map<number, number>();
+ let newSlotCounter = 0;
+
+ traverseMetricTokens(text, metricNames, newEntities, (visit) => {
+ const newSlotIndex = newSlotCounter++;
+ const key = getPositionKey(visit.positioned.from, visit.positioned.to);
+ const tracked = identityByPosition.get(key);
+
+ if (tracked) {
+ slotMapping.set(tracked.slotIndex, newSlotIndex);
+ }
+
+ if (!tracked) {
+ return;
+ }
+
+ if (visit.kind === "standalone") {
+ metricOverrides.set(visit.entity, tracked.definition ?? null);
+ return;
+ }
+
+ let tokenMap = exprTokenOverrides.get(visit.entity);
+ if (!tokenMap) {
+ tokenMap = new Map();
+ exprTokenOverrides.set(visit.entity, tokenMap);
+ }
+ // remove any existing breakouts - not supported in math expressions
+ const definition =
+ tracked.definition != null
+ ? stripDefinitionProjections(tracked.definition)
+ : undefined;
+ tokenMap.set(visit.exprTokenIndex, definition);
+ });
+
+ const entities = newEntities.map((entity) => {
+ if (metricOverrides.has(entity)) {
+ return { ...entity, definition: metricOverrides.get(entity) ?? null };
+ }
+
+ const tokenMap = exprTokenOverrides.get(entity);
+ if (tokenMap && isExpressionEntry(entity)) {
+ const newTokens = entity.tokens.map((token, index) => {
+ if (!tokenMap.has(index)) {
+ return token;
+ }
+ return { ...token, definition: tokenMap.get(index) };
+ });
+ const hasChanges = newTokens.some(
+ (token, index) => token !== entity.tokens[index],
+ );
+ return hasChanges ? { ...entity, tokens: newTokens } : entity;
+ }
+
+ return entity;
+ });
+
+ return { entities, slotMapping };
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts
index 4a5b1aabe77..141d5f18c16 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearch/utils.unit.spec.ts
@@ -1,68 +1,40 @@
-import type { SelectedMetric } from "../../types/viewer-state";
+import * as LibMetric from "metabase-lib/metric";
+import type {
+ ExpressionDefinitionEntry,
+ ExpressionSubToken,
+ MetricDefinitionEntry,
+ MetricSourceId,
+ MetricsViewerFormulaEntity,
+} from "../../types/viewer-state";
+import { isExpressionEntry } from "../../types/viewer-state";
import {
+ GEO_METRIC,
+ REVENUE_METRIC,
+ createMetricMetadata,
+ setupDefinition,
+ setupDefinitionWithBreakout,
+} from "../../utils/__tests__/test-helpers";
+
+import type { MetricIdentityEntry, MetricNameMap } from "./utils";
+import {
+ applyTrackedDefinitions,
+ buildExpressionText,
+ cleanupParens,
filterSearchResults,
- getSelectedMeasureIds,
- getSelectedMetricIds,
+ findInvalidRanges,
+ getWordAtCursor,
+ parseFullText,
} from "./utils";
-function makeSelectedMetric(
- overrides: Partial<SelectedMetric> &
- Pick<SelectedMetric, "id" | "sourceType">,
-): SelectedMetric {
- return { name: "Test", ...overrides };
-}
+jest.mock("../../utils/definition-builder", () => ({
+ getDefinitionName: (def: any) => def?.["display-name"] ?? null,
+}));
function makeSearchResult(id: number, model: "metric" | "measure") {
return { id, model, name: `Result ${id}` };
}
-describe("getSelectedMetricIds", () => {
- it("returns Set of IDs for metrics only", () => {
- const selected: SelectedMetric[] = [
- makeSelectedMetric({ id: 1, sourceType: "metric" }),
- makeSelectedMetric({ id: 2, sourceType: "measure" }),
- makeSelectedMetric({ id: 3, sourceType: "metric" }),
- ];
- const result = getSelectedMetricIds(selected);
- expect(result).toEqual(new Set([1, 3]));
- });
-
- it("returns empty Set for empty array", () => {
- expect(getSelectedMetricIds([])).toEqual(new Set());
- });
-
- it("returns empty Set when no metrics exist", () => {
- const selected: SelectedMetric[] = [
- makeSelectedMetric({ id: 1, sourceType: "measure" }),
- ];
- expect(getSelectedMetricIds(selected)).toEqual(new Set());
- });
-});
-
-describe("getSelectedMeasureIds", () => {
- it("returns Set of IDs for measures only", () => {
- const selected: SelectedMetric[] = [
- makeSelectedMetric({ id: 1, sourceType: "metric" }),
- makeSelectedMetric({ id: 2, sourceType: "measure" }),
- makeSelectedMetric({ id: 5, sourceType: "measure" }),
- ];
- const result = getSelectedMeasureIds(selected);
- expect(result).toEqual(new Set([2, 5]));
- });
-
- it("returns empty Set for empty array", () => {
- expect(getSelectedMeasureIds([])).toEqual(new Set());
- });
-
- it("returns empty Set when no measures exist", () => {
- const selected: SelectedMetric[] = [
- makeSelectedMetric({ id: 1, sourceType: "metric" }),
- ];
- expect(getSelectedMeasureIds(selected)).toEqual(new Set());
- });
-});
-
describe("filterSearchResults", () => {
const results = [
makeSearchResult(1, "metric"),
@@ -123,3 +95,1133 @@ describe("filterSearchResults", () => {
]);
});
});
+
+describe("cleanupParens", () => {
+ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({
+ type: "metric",
+ sourceId,
+ count: 1,
+ });
+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({
+ type: "operator",
+ op: o,
+ });
+ const open: ExpressionSubToken = { type: "open-paren" };
+ const close: ExpressionSubToken = { type: "close-paren" };
+
+ it("returns empty array unchanged", () => {
+ expect(cleanupParens([])).toEqual([]);
+ });
+
+ it("returns same reference when no cleanup needed", () => {
+ const tokens: ExpressionSubToken[] = [
+ m("metric:1"),
+ op("+"),
+ m("metric:2"),
+ ];
+ expect(cleanupParens(tokens)).toBe(tokens);
+ });
+
+ it("removes empty parentheses", () => {
+ expect(cleanupParens([open, close])).toEqual([]);
+ });
+
+ it("removes parentheses around a single metric", () => {
+ expect(cleanupParens([open, m("metric:1"), close])).toEqual([
+ m("metric:1"),
+ ]);
+ });
+
+ it("keeps parentheses around multiple metrics", () => {
+ const tokens = [open, m("metric:1"), op("+"), m("metric:2"), close];
+ expect(cleanupParens(tokens)).toEqual(tokens);
+ });
+
+ it("removes nested single-metric parens", () => {
+ // ((A)) → A
+ expect(cleanupParens([open, open, m("metric:1"), close, close])).toEqual([
+ m("metric:1"),
+ ]);
+ });
+
+ it("removes inner single-metric parens but keeps outer multi-metric parens", () => {
+ // (A + (B)) → (A + B)
+ expect(
+ cleanupParens([
+ open,
+ m("metric:1"),
+ op("+"),
+ open,
+ m("metric:2"),
+ close,
+ close,
+ ]),
+ ).toEqual([open, m("metric:1"), op("+"), m("metric:2"), close]);
+ });
+
+ it("removes single-metric parens in a larger expression", () => {
+ // (A) + B → A + B
+ expect(
+ cleanupParens([open, m("metric:1"), close, op("+"), m("metric:2")]),
+ ).toEqual([m("metric:1"), op("+"), m("metric:2")]);
+ });
+
+ it("removes multiple independent single-metric paren groups", () => {
+ // (A) + (B) → A + B
+ expect(
+ cleanupParens([
+ open,
+ m("metric:1"),
+ close,
+ op("+"),
+ open,
+ m("metric:2"),
+ close,
+ ]),
+ ).toEqual([m("metric:1"), op("+"), m("metric:2")]);
+ });
+
+ it("keeps parentheses around a metric and a constant (two operands)", () => {
+ // (A * 0.85) stays — two operands inside
+ const k = (v: number): ExpressionSubToken => ({
+ type: "constant",
+ value: v,
+ });
+ expect(
+ cleanupParens([open, m("metric:1"), op("*"), k(0.85), close]),
+ ).toEqual([open, m("metric:1"), op("*"), k(0.85), close]);
+ });
+
+ it("removes parentheses around a lone constant (one operand)", () => {
+ const k = (v: number): ExpressionSubToken => ({
+ type: "constant",
+ value: v,
+ });
+ expect(cleanupParens([open, k(1), close])).toEqual([k(1)]);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// buildExpressionText — constants
+// ---------------------------------------------------------------------------
+
+describe("buildExpressionText", () => {
+ const metricNames: MetricNameMap = {
+ "metric:1": "Revenue",
+ "metric:2": "Costs",
+ };
+
+ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({
+ type: "metric",
+ sourceId,
+ count: 1,
+ });
+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({
+ type: "operator",
+ op: o,
+ });
+ const k = (v: number): ExpressionSubToken => ({
+ type: "constant",
+ value: v,
+ });
+ const open: ExpressionSubToken = { type: "open-paren" };
+ const close: ExpressionSubToken = { type: "close-paren" };
+
+ it("renders a metric scaled by a decimal constant", () => {
+ expect(
+ buildExpressionText([m("metric:1"), op("*"), k(0.85)], metricNames),
+ ).toBe("Revenue * 0.85");
+ });
+
+ it("renders an integer constant", () => {
+ expect(
+ buildExpressionText([m("metric:1"), op("*"), k(100)], metricNames),
+ ).toBe("Revenue * 100");
+ });
+
+ it("renders constants inside parentheses", () => {
+ // (Revenue + Costs) * 0.85
+ expect(
+ buildExpressionText(
+ [open, m("metric:1"), op("+"), m("metric:2"), close, op("*"), k(0.85)],
+ metricNames,
+ ),
+ ).toBe("(Revenue + Costs) * 0.85");
+ });
+
+ it("renders a constant divided by a metric", () => {
+ expect(
+ buildExpressionText([k(1), op("/"), m("metric:1")], metricNames),
+ ).toBe("1 / Revenue");
+ });
+});
+
+// ---------------------------------------------------------------------------
+// parseFullText — numeric literals
+// ---------------------------------------------------------------------------
+
+describe("parseFullText — numeric literal parsing", () => {
+ const metricNames: MetricNameMap = {
+ "metric:1": "Revenue",
+ "metric:2": "Costs",
+ };
+
+ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({
+ type: "metric",
+ sourceId,
+ count: 1,
+ });
+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({
+ type: "operator",
+ op: o,
+ });
+ const k = (v: number): ExpressionSubToken => ({
+ type: "constant",
+ value: v,
+ });
+
+ it("parses a metric multiplied by a decimal constant", () => {
+ const result = parseFullText("Revenue * 0.85", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [m("metric:1"), op("*"), k(0.85)],
+ });
+ });
+
+ it("parses a metric multiplied by an integer constant", () => {
+ const result = parseFullText("Revenue * 100", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [m("metric:1"), op("*"), k(100)],
+ });
+ });
+
+ it("parses a constant on the left side", () => {
+ const result = parseFullText("0.5 * Revenue", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [k(0.5), op("*"), m("metric:1")],
+ });
+ });
+
+ it("parses a constant inside parentheses — (Revenue + Costs) * 0.85", () => {
+ const result = parseFullText("(Revenue + Costs) * 0.85", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [
+ { type: "open-paren" },
+ m("metric:1"),
+ op("+"),
+ m("metric:2"),
+ { type: "close-paren" },
+ op("*"),
+ k(0.85),
+ ],
+ });
+ });
+
+ it("parses multiple constants in one expression", () => {
+ // 0.5 * Revenue + 0.5 * Costs
+ const result = parseFullText("0.5 * Revenue + 0.5 * Costs", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [
+ k(0.5),
+ op("*"),
+ m("metric:1"),
+ op("+"),
+ k(0.5),
+ op("*"),
+ m("metric:2"),
+ ],
+ });
+ });
+
+ it("handles an integer that looks like it could start a decimal (no dot follows)", () => {
+ // "1 + Revenue" — "1" is an integer with no fractional part
+ const result = parseFullText("1 + Revenue", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [k(1), op("+"), m("metric:1")],
+ });
+ });
+
+ it("parses a leading-dot decimal like .5", () => {
+ const result = parseFullText(".5 * Revenue", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [k(0.5), op("*"), m("metric:1")],
+ });
+ });
+
+ it("parses a metric multiplied by a leading-dot decimal", () => {
+ const result = parseFullText("Revenue * .85", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [m("metric:1"), op("*"), k(0.85)],
+ });
+ });
+
+ it("parses a negative leading-dot decimal", () => {
+ const result = parseFullText("-.5 * Revenue", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [k(-0.5), op("*"), m("metric:1")],
+ });
+ });
+
+ it("does not parse a trailing dot as part of the number", () => {
+ // "1." — trailing dot with no digit after it; "1" is the constant, "." is
+ // dropped (unknown tokens are filtered out of committed data)
+ const result = parseFullText("1.", metricNames);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [k(1)],
+ });
+ });
+
+ it("parses constants and metrics as separate items separated by a comma", () => {
+ // "Revenue * 0.85, Costs"
+ const result = parseFullText("Revenue * 0.85, Costs", metricNames);
+ expect(result).toHaveLength(2);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [m("metric:1"), op("*"), k(0.85)],
+ });
+ // "Costs" is a standalone metric
+ expect(result[1]).toMatchObject({
+ type: "metric",
+ id: "metric:2",
+ });
+ });
+
+ it("round-trips through buildExpressionText", () => {
+ const text = "(Revenue + Costs) * 0.85";
+ const result = parseFullText(text, metricNames);
+ expect(result).toHaveLength(1);
+ const entry = result[0];
+ if (entry.type === "expression") {
+ // eslint-disable-next-line jest/no-conditional-expect
+ expect(buildExpressionText(entry.tokens, metricNames)).toBe(text);
+ } else {
+ throw new Error("Expected expression entry");
+ }
+ });
+});
+
+// ---------------------------------------------------------------------------
+// parseFullText — negative numbers
+// ---------------------------------------------------------------------------
+
+describe("parseFullText — negative numbers", () => {
+ const metricNames: MetricNameMap = {
+ "metric:1": "Revenue",
+ "metric:2": "Costs",
+ };
+
+ const metric = (sourceId: MetricSourceId): ExpressionSubToken => ({
+ type: "metric",
+ sourceId,
+ count: 1,
+ });
+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({
+ type: "operator",
+ op: o,
+ });
+ const constant = (v: number): ExpressionSubToken => ({
+ type: "constant",
+ value: v,
+ });
+ const open: ExpressionSubToken = { type: "open-paren" };
+ const close: ExpressionSubToken = { type: "close-paren" };
+
+ it("parses a standalone negative integer", () => {
+ const result = parseFullText("-50", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:-50",
+ type: "expression",
+ name: "-50",
+ tokens: [constant(-50)],
+ },
+ ]);
+ });
+
+ it("parses metric plus negative constant", () => {
+ const result = parseFullText("Revenue + -50", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:Revenue + -50",
+ type: "expression",
+ name: "Revenue + -50",
+ tokens: [metric("metric:1"), op("+"), constant(-50)],
+ },
+ ]);
+ });
+
+ it("parses metric multiplied by negative decimal", () => {
+ const result = parseFullText("Revenue * -0.85", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:Revenue * -0.85",
+ type: "expression",
+ name: "Revenue * -0.85",
+ tokens: [metric("metric:1"), op("*"), constant(-0.85)],
+ },
+ ]);
+ });
+
+ it("parses negative constant at the start of expression", () => {
+ const result = parseFullText("-50 * Revenue", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:-50 * Revenue",
+ type: "expression",
+ name: "-50 * Revenue",
+ tokens: [constant(-50), op("*"), metric("metric:1")],
+ },
+ ]);
+ });
+
+ it("parses negative constant after open-paren", () => {
+ const result = parseFullText("(-50 + Revenue)", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:(-50 + Revenue)",
+ type: "expression",
+ name: "(-50 + Revenue)",
+ tokens: [open, constant(-50), op("+"), metric("metric:1"), close],
+ },
+ ]);
+ });
+
+ it("parses subtraction of a negative constant", () => {
+ const result = parseFullText("Revenue - -50", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:Revenue - -50",
+ type: "expression",
+ name: "Revenue - -50",
+ tokens: [metric("metric:1"), op("-"), constant(-50)],
+ },
+ ]);
+ });
+
+ it("round-trips negative constants through buildExpressionText", () => {
+ const text = "Revenue + -50";
+ const result = parseFullText(text, metricNames);
+ expect(result).toHaveLength(1);
+ const entry = result[0];
+ if (entry.type === "expression") {
+ // eslint-disable-next-line jest/no-conditional-expect
+ expect(buildExpressionText(entry.tokens, metricNames)).toBe(text);
+ } else {
+ throw new Error("Expected expression entry");
+ }
+ });
+
+ it.each([
+ "-50 * Revenue",
+ "Revenue + -50",
+ "Revenue - -50",
+ "(-50 + Revenue)",
+ "Revenue * -0.85",
+ ])("does not report validation errors for: %s", (text) => {
+ expect(findInvalidRanges(text, metricNames)).toEqual([]);
+ });
+
+ it("parses metric minus negative constant without spaces (Revenue--50)", () => {
+ const result = parseFullText("Revenue--50", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:Revenue - -50",
+ type: "expression",
+ name: "Revenue - -50",
+ tokens: [metric("metric:1"), op("-"), constant(-50)],
+ },
+ ]);
+ });
+
+ it("parses metric minus negative decimal without spaces (Revenue--0.5)", () => {
+ const result = parseFullText("Revenue--0.5", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:Revenue - -0.5",
+ type: "expression",
+ name: "Revenue - -0.5",
+ tokens: [metric("metric:1"), op("-"), constant(-0.5)],
+ },
+ ]);
+ });
+
+ it("does not report validation errors for Revenue--50", () => {
+ expect(findInvalidRanges("Revenue--50", metricNames)).toEqual([]);
+ });
+
+ it("still treats minus as binary operator after a metric", () => {
+ const result = parseFullText("Revenue - 50", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:Revenue - 50",
+ type: "expression",
+ name: "Revenue - 50",
+ tokens: [metric("metric:1"), op("-"), constant(50)],
+ },
+ ]);
+ });
+
+ it("still treats minus as binary operator after a constant", () => {
+ const result = parseFullText("100 - Revenue", metricNames);
+ expect(result).toEqual([
+ {
+ id: "expression:100 - Revenue",
+ type: "expression",
+ name: "100 - Revenue",
+ tokens: [constant(100), op("-"), metric("metric:1")],
+ },
+ ]);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// parseFullText — metric names containing commas
+// ---------------------------------------------------------------------------
+
+describe("parseFullText — metric names with commas", () => {
+ const m = (sourceId: MetricSourceId): ExpressionSubToken => ({
+ type: "metric",
+ sourceId,
+ count: 1,
+ });
+ const op = (o: "+" | "-" | "*" | "/"): ExpressionSubToken => ({
+ type: "operator",
+ op: o,
+ });
+ const k = (v: number): ExpressionSubToken => ({
+ type: "constant",
+ value: v,
+ });
+
+ it("parses a single metric whose name contains a comma", () => {
+ const names: MetricNameMap = {
+ "metric:10": "Revenue, Total",
+ "metric:2": "Costs",
+ };
+ const result = parseFullText("Revenue, Total", names);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });
+ });
+
+ it("parses metric-with-comma followed by another metric", () => {
+ const names: MetricNameMap = {
+ "metric:10": "Revenue, Total",
+ "metric:2": "Costs",
+ };
+ const result = parseFullText("Revenue, Total, Costs", names);
+ expect(result).toHaveLength(2);
+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });
+ expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });
+ });
+
+ it("parses metric-with-comma in an expression", () => {
+ const names: MetricNameMap = {
+ "metric:10": "Revenue, Total",
+ "metric:2": "Costs",
+ };
+ const result = parseFullText("Revenue, Total + Costs", names);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [m("metric:10"), op("+"), m("metric:2")],
+ });
+ });
+
+ it("parses two metrics whose names each contain commas", () => {
+ const names: MetricNameMap = {
+ "metric:10": "Revenue, Total",
+ "metric:11": "Costs, Annual",
+ };
+ const result = parseFullText("Revenue, Total, Costs, Annual", names);
+ expect(result).toHaveLength(2);
+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });
+ expect(result[1]).toMatchObject({ type: "metric", id: "metric:11" });
+ });
+
+ it("prefers longer metric name over shorter one when both match", () => {
+ // "Revenue, Total" should match as one metric, not "Revenue" + separator
+ const names: MetricNameMap = {
+ "metric:10": "Revenue, Total",
+ "metric:1": "Revenue",
+ "metric:2": "Costs",
+ };
+ const result = parseFullText("Revenue, Total, Costs", names);
+ expect(result).toHaveLength(2);
+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:10" });
+ expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });
+ });
+
+ it("falls back to shorter metric when longer does not match", () => {
+ // Only "Revenue" is known, not "Revenue, Total"
+ const names: MetricNameMap = { "metric:1": "Revenue", "metric:2": "Costs" };
+ const result = parseFullText("Revenue, Costs", names);
+ expect(result).toHaveLength(2);
+ expect(result[0]).toMatchObject({ type: "metric", id: "metric:1" });
+ expect(result[1]).toMatchObject({ type: "metric", id: "metric:2" });
+ });
+
+ it("handles metric-with-comma multiplied by a constant", () => {
+ const names: MetricNameMap = { "metric:10": "Revenue, Total" };
+ const result = parseFullText("Revenue, Total * 0.85", names);
+ expect(result).toHaveLength(1);
+ expect(result[0]).toMatchObject({
+ type: "expression",
+ tokens: [m("metric:10"), op("*"), k(0.85)],
+ });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// findInvalidRanges — unknown token detection
+// ---------------------------------------------------------------------------
+
+describe("findInvalidRanges — unknown token detection", () => {
+ const metricNames: MetricNameMap = {
+ "metric:1": "Revenue",
+ "metric:2": "Costs",
+ };
+
+ it("returns no errors for valid expression", () => {
+ expect(findInvalidRanges("Revenue + Costs", metricNames)).toEqual([]);
+ });
+
+ it("returns no errors for valid expression with constant", () => {
+ expect(findInvalidRanges("Revenue * 0.85", metricNames)).toEqual([]);
+ });
+
+ it("flags a single unknown word", () => {
+ const errors = findInvalidRanges("Revenue + xyz", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 10,
+ to: 13,
+ message: expect.stringContaining("xyz"),
+ });
+ });
+
+ it("flags unknown text that is not a known metric", () => {
+ const errors = findInvalidRanges("Foo", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ message: expect.stringContaining("Foo"),
+ });
+ });
+
+ it("flags multiple unknown tokens in different segments", () => {
+ const errors = findInvalidRanges("abc, def", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(2);
+ });
+
+ it("flags unknown token mixed with valid tokens", () => {
+ const errors = findInvalidRanges("Revenue + unknown + Costs", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ message: expect.stringContaining("unknown"),
+ });
+ });
+
+ it("does not flag numbers as unknown", () => {
+ expect(findInvalidRanges("Revenue * 100", metricNames)).toEqual([]);
+ });
+
+ it("does not flag parentheses as unknown", () => {
+ expect(findInvalidRanges("(Revenue + Costs)", metricNames)).toEqual([]);
+ });
+
+ it("does not flag operators as unknown", () => {
+ expect(findInvalidRanges("Revenue + Costs - Revenue", metricNames)).toEqual(
+ [],
+ );
+ });
+
+ it("flags unknown token at the start of expression", () => {
+ const errors = findInvalidRanges("xyz + Revenue", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 0,
+ to: 3,
+ message: expect.stringContaining("xyz"),
+ });
+ });
+
+ it("returns both structural and unknown errors", () => {
+ // "xyz +" has an unknown token AND a trailing operator
+ const errors = findInvalidRanges("xyz +", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(2);
+ const messages = errors.map((e) => e.message);
+ expect(messages.some((m) => m.includes("xyz"))).toBe(true);
+ expect(messages.some((m) => m.includes("end with an operator"))).toBe(true);
+ });
+
+ it("flags trailing characters after a metric name with special chars", () => {
+ const names: MetricNameMap = { "metric:99": "People Q H2 Orders, Count!" };
+ const errors = findInvalidRanges("People Q H2 Orders, Count!!!!", names);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 26,
+ to: 29,
+ message: expect.stringContaining("!!!"),
+ });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// findInvalidRanges — predecessor validation
+// ---------------------------------------------------------------------------
+
+describe("findInvalidRanges — predecessor validation", () => {
+ const metricNames: MetricNameMap = {
+ "metric:1": "Revenue",
+ "metric:2": "Costs",
+ };
+
+ it("flags missing operator between metric and constant", () => {
+ const errors = findInvalidRanges("Revenue 2", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 8,
+ to: 9,
+ message: expect.stringContaining("Missing operator"),
+ });
+ });
+
+ it("flags missing operator between two metrics", () => {
+ const errors = findInvalidRanges("Revenue Costs", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 8,
+ to: 13,
+ message: expect.stringContaining("Missing operator"),
+ });
+ });
+
+ it("flags missing operator between constant and metric", () => {
+ const errors = findInvalidRanges("2 Revenue", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 2,
+ to: 9,
+ message: expect.stringContaining("Missing operator"),
+ });
+ });
+
+ it("flags missing operator between close-paren and metric", () => {
+ const errors = findInvalidRanges("(Revenue + Costs) Revenue", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 18,
+ to: 25,
+ message: expect.stringContaining("Missing operator"),
+ });
+ });
+
+ it("flags operator before closing parenthesis", () => {
+ const errors = findInvalidRanges("(Revenue +)", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 10,
+ to: 11,
+ message: expect.stringContaining("closing parenthesis"),
+ });
+ });
+
+ it("flags consecutive operators", () => {
+ const errors = findInvalidRanges("Revenue + + Costs", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(1);
+ const messages = errors.map((e) => e.message);
+ expect(messages.some((m) => m.includes("Missing operand"))).toBe(true);
+ });
+
+ it("flags operator after opening parenthesis", () => {
+ const errors = findInvalidRanges("(+ Revenue)", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(1);
+ const messages = errors.map((e) => e.message);
+ expect(messages.some((m) => m.includes("Missing operand"))).toBe(true);
+ });
+
+ it("flags empty parentheses", () => {
+ const errors = findInvalidRanges("Revenue + ()", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(1);
+ const messages = errors.map((e) => e.message);
+ expect(messages.some((m) => m.includes("Empty parentheses"))).toBe(true);
+ });
+
+ it("flags leading operator", () => {
+ const errors = findInvalidRanges("+ Revenue", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(1);
+ const messages = errors.map((e) => e.message);
+ expect(messages.some((m) => m.includes("Missing operand"))).toBe(true);
+ });
+
+ it("flags trailing operator", () => {
+ const errors = findInvalidRanges("Revenue +", metricNames);
+ expect(errors.length).toBeGreaterThanOrEqual(1);
+ const messages = errors.map((e) => e.message);
+ expect(messages.some((m) => m.includes("end with an operator"))).toBe(true);
+ });
+
+ it("flags constants-only expression as missing metric", () => {
+ const errors = findInvalidRanges("2 + 2", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ message: expect.stringContaining("at least one metric"),
+ });
+ });
+
+ it("flags unmatched opening parenthesis", () => {
+ const errors = findInvalidRanges("(Revenue + Costs", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 0,
+ to: 1,
+ message: expect.stringContaining("Unmatched opening parenthesis"),
+ });
+ });
+
+ it("flags unmatched closing parenthesis", () => {
+ const errors = findInvalidRanges("Revenue + Costs)", metricNames);
+ expect(errors).toHaveLength(1);
+ expect(errors[0]).toMatchObject({
+ from: 15,
+ to: 16,
+ message: expect.stringContaining("Unmatched closing parenthesis"),
+ });
+ });
+
+ it("accepts valid nested parentheses", () => {
+ expect(findInvalidRanges("(2 * (Revenue + Costs))", metricNames)).toEqual(
+ [],
+ );
+ });
+
+ it("accepts close-paren followed by operator", () => {
+ expect(findInvalidRanges("(Revenue + Costs) * 2", metricNames)).toEqual([]);
+ });
+});
+
+describe("getWordAtCursor — comma handling with metric entries", () => {
+ const commaMetricNames: MetricNameMap = { "metric:99": "Revenue, Total" };
+
+ it("without entries, comma is always a delimiter", () => {
+ const text = "Revenue, Total";
+ // cursor at end
+ const result = getWordAtCursor(text, text.length);
+ expect(result.word).toBe("Total");
+ });
+
+ it("with entries, comma inside a known metric name is not a delimiter", () => {
+ const text = "Revenue, Total";
+ const result = getWordAtCursor(text, text.length, commaMetricNames);
+ expect(result.word).toBe("Revenue, Total");
+ });
+
+ it("with entries, separator comma between two metrics is still a delimiter", () => {
+ const text = "Revenue, Orders";
+ // cursor at end (inside "Orders")
+ const result = getWordAtCursor(text, text.length, {
+ "metric:1": "Revenue",
+ "metric:2": "Orders",
+ });
+ expect(result.word).toBe("Orders");
+ });
+
+ it("treats comma as part of metric name when typing a partial match", () => {
+ // User is typing "Revenue, T" which is a prefix of "Revenue, Total"
+ // The comma is NOT a separator because "Revenue" alone is not a known
+ // metric in this set — the only known metric is "Revenue, Total".
+ const text = "Revenue, T";
+ const result = getWordAtCursor(text, text.length, commaMetricNames);
+ expect(result.word).toBe("Revenue, T");
+ });
+
+ it("math-operator delimiters still work with metric entries", () => {
+ const text = "Revenue, Total + 1";
+ const result = getWordAtCursor(text, text.length, commaMetricNames);
+ expect(result.word).toBe("1");
+ });
+
+ it("returns full metric name when cursor is in the middle", () => {
+ const text = "Revenue, Total";
+ // cursor after the comma+space (position 9, inside "Total")
+ const result = getWordAtCursor(text, 9, commaMetricNames);
+ expect(result.word).toBe("Revenue, Total");
+ });
+});
+
+function sourceId(id: number): MetricSourceId {
+ return `metric:${id}`;
+}
+
+function getExprTokenDefinitions(
+ entities: MetricsViewerFormulaEntity[],
+ entityIndex: number,
+): (LibMetric.MetricDefinition | undefined)[] {
+ const entity = entities[entityIndex];
+ if (!isExpressionEntry(entity)) {
+ return [];
+ }
+ return entity.tokens
+ .filter((token) => token.type === "metric")
+ .map((token) =>
+ token.type === "metric" ? (token.definition ?? undefined) : undefined,
+ );
+}
+
+let nextSlotIndex = 0;
+
+function identity(
+ metricSourceId: MetricSourceId,
+ from: number,
+ to: number,
+ definition: MetricDefinitionEntry["definition"] = null,
+ slotIndex: number = nextSlotIndex++,
+): MetricIdentityEntry {
+ return { sourceId: metricSourceId, from, to, definition, slotIndex };
+}
+
+describe("applyTrackedDefinitions", () => {
+ beforeEach(() => {
+ nextSlotIndex = 0;
+ });
+
+ const metricNames: MetricNameMap = {
+ [sourceId(1)]: "Revenue",
+ [sourceId(2)]: "Geo Revenue",
+ };
+ const metadata = createMetricMetadata([REVENUE_METRIC, GEO_METRIC]);
+ const revenueDef = setupDefinition(metadata, REVENUE_METRIC.id);
+ const revenueBreakoutDef = setupDefinitionWithBreakout(
+ metadata,
+ REVENUE_METRIC.id,
+ 0,
+ );
+ const geoBreakoutDef = setupDefinitionWithBreakout(
+ metadata,
+ GEO_METRIC.id,
+ 0,
+ );
+
+ it("returns empty array for empty inputs", () => {
+ const result = applyTrackedDefinitions([], [], "", metricNames);
+ expect(result.entities).toEqual([]);
+ expect(result.slotMapping.size).toBe(0);
+ });
+
+ it("applies tracked definition to a standalone metric by position", () => {
+ const text = "Revenue";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ expect(entities).toHaveLength(1);
+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(
+ revenueBreakoutDef,
+ );
+ });
+
+ it("preserves null definition when tracked identity has null", () => {
+ const text = "Revenue";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 0, 7, null)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ expect((entities[0] as MetricDefinitionEntry).definition).toBeNull();
+ });
+
+ it("leaves entity unchanged when no tracked identity matches its position", () => {
+ const text = "Revenue";
+ const parsed = parseFullText(text, metricNames);
+ const { entities } = applyTrackedDefinitions(parsed, [], text, metricNames);
+ expect(entities).toEqual(parsed);
+ });
+
+ it("matches definitions by exact position for comma-separated metrics", () => {
+ const text = "Revenue, Geo Revenue";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [
+ identity(sourceId(1), 0, 7, revenueBreakoutDef),
+ identity(sourceId(2), 9, 20, geoBreakoutDef),
+ ];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(
+ revenueBreakoutDef,
+ );
+ expect((entities[1] as MetricDefinitionEntry).definition).toBe(
+ geoBreakoutDef,
+ );
+ });
+
+ it("strips breakout projections from expression token definitions", () => {
+ const text = "Revenue + 5";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ const [tokenDef] = getExprTokenDefinitions(entities, 0);
+ expect(tokenDef).toBeDefined();
+ expect(LibMetric.projections(tokenDef!)).toEqual([]);
+ });
+
+ it("preserves non-breakout definitions on expression tokens", () => {
+ const text = "Revenue + 5";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 0, 7, revenueDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ const [tokenDef] = getExprTokenDefinitions(entities, 0);
+ expect(tokenDef).toBe(revenueDef);
+ });
+
+ it("preserves reference identity for expression entries when no tokens change", () => {
+ const text = "Revenue + 5";
+ const parsed = parseFullText(text, metricNames);
+ const { entities } = applyTrackedDefinitions(parsed, [], text, metricNames);
+ expect(entities[0]).toBe(parsed[0]);
+ });
+
+ it("does not touch non-metric tokens inside expressions", () => {
+ const text = "Revenue + 5";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 0, 7, revenueDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ const resultExpr = entities[0] as ExpressionDefinitionEntry;
+ const parsedExpr = parsed[0] as ExpressionDefinitionEntry;
+ expect(resultExpr.tokens[1]).toBe(parsedExpr.tokens[1]);
+ expect(resultExpr.tokens[2]).toBe(parsedExpr.tokens[2]);
+ });
+
+ it("applies definition only to standalone metric, not expression token at different position", () => {
+ const text = "Revenue, Revenue + 5";
+ const parsed = parseFullText(text, metricNames);
+ // Only the standalone Revenue (0-7) has a tracked identity
+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(
+ revenueBreakoutDef,
+ );
+ const [tokenDef] = getExprTokenDefinitions(entities, 1);
+ expect(tokenDef).toBeUndefined();
+ });
+
+ it("does not carry definition to a token at a non-matching position", () => {
+ // Tracked identity at [100,107] — token was deleted (TrackDel).
+ // New Revenue at [0,7] is a fresh instance, gets no override.
+ const text = "Revenue";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 100, 107, revenueDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ expect((entities[0] as MetricDefinitionEntry).definition).not.toBe(
+ revenueDef,
+ );
+ });
+
+ it("newly added duplicate of same metric gets no definition from the tracked one", () => {
+ const text = "Revenue, Revenue";
+ const parsed = parseFullText(text, metricNames);
+ // Only one tracked identity at position [0,7]
+ const tracked = [identity(sourceId(1), 0, 7, revenueBreakoutDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ // First Revenue at [0,7] — exact position match
+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(
+ revenueBreakoutDef,
+ );
+ // Second Revenue at [9,16] — no match, independent new instance
+ expect((entities[1] as MetricDefinitionEntry).definition).not.toBe(
+ revenueBreakoutDef,
+ );
+ });
+
+ it("preserves definition when token survives edit (position tracked by RangeSet)", () => {
+ // "Revenue + 5" — Revenue token at [0,7] survived the edit
+ const text = "Revenue + 5";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [identity(sourceId(1), 0, 7, revenueDef)];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ const [tokenDef] = getExprTokenDefinitions(entities, 0);
+ expect(tokenDef).toBe(revenueDef);
+ });
+
+ it("two instances of same metric at different positions keep independent definitions", () => {
+ const text = "Revenue, Revenue";
+ const parsed = parseFullText(text, metricNames);
+ const tracked = [
+ identity(sourceId(1), 0, 7, revenueBreakoutDef, 0),
+ identity(sourceId(1), 9, 16, revenueDef, 1),
+ ];
+ const { entities } = applyTrackedDefinitions(
+ parsed,
+ tracked,
+ text,
+ metricNames,
+ );
+ expect((entities[0] as MetricDefinitionEntry).definition).toBe(
+ revenueBreakoutDef,
+ );
+ expect((entities[1] as MetricDefinitionEntry).definition).toBe(revenueDef);
+ });
+});
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css
index 4c525827210..31055f77d8d 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.module.css
@@ -10,6 +10,10 @@
border-color: var(--mb-color-brand);
}
+.container:has([data-has-error]) {
+ border-color: var(--mb-color-error);
+}
+
.filterPillsSection {
border-radius: 0 0 var(--mantine-radius-lg) var(--mantine-radius-lg);
}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx
index b9a08e4dc6b..841032339a1 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricSearchPanel/MetricSearchPanel.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
import { t } from "ttag";
import { Box, Button, Flex, Icon, Stack, Text, Tooltip } from "metabase/ui";
@@ -6,79 +6,95 @@ import type { MetricDefinition, ProjectionClause } from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
import type {
+ MetricDefinitionEntry,
MetricSourceId,
MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
SelectedMetric,
SourceColorMap,
} from "../../types/viewer-state";
+import type { DefinitionSource } from "../../utils/definition-sources";
+import {
+ applyDefinitionToFormulaEntities,
+ getDefinitionSources,
+} from "../../utils/definition-sources";
import { FilterPopover } from "../FilterPopover";
-import type { DefinitionSource } from "../FilterPopover/FilterPopoverContent";
-import { MetricSearch } from "../MetricSearch";
+import { MetricSearchInput as MetricSearch } from "../MetricSearch";
import { MetricsFilterPills } from "../MetricsFilterPills";
import S from "./MetricSearchPanel.module.css";
type MetricSearchPanelProps = {
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ formulaEntities: MetricsViewerFormulaEntity[];
+ onFormulaEntitiesChange: (
+ entities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) => void;
selectedMetrics: SelectedMetric[];
metricColors: SourceColorMap;
- definitions: MetricsViewerDefinitionEntry[];
onAddMetric: (metric: SelectedMetric) => void;
onRemoveMetric: (metricId: number, sourceType: "metric" | "measure") => void;
onSwapMetric: (oldMetric: SelectedMetric, newMetric: SelectedMetric) => void;
onSetBreakout: (
- id: MetricSourceId,
+ entity: MetricDefinitionEntry,
dimension: ProjectionClause | undefined,
) => void;
- onUpdateDefinition: (
- id: MetricSourceId,
- definition: MetricDefinition,
- ) => void;
};
export function MetricSearchPanel({
+ definitions,
+ formulaEntities,
+ onFormulaEntitiesChange,
selectedMetrics,
metricColors,
- definitions,
onAddMetric,
onRemoveMetric,
onSwapMetric,
onSetBreakout,
- onUpdateDefinition,
}: MetricSearchPanelProps) {
const [isFilterPillsExpanded, setIsFilterPillsExpanded] = useState(true);
- const readyDefinitions = useMemo(
- () =>
- definitions.filter(
- (definition): definition is DefinitionSource =>
- definition.definition != null,
- ),
- [definitions],
+ const definitionSources = useMemo(
+ () => getDefinitionSources(formulaEntities, definitions),
+ [formulaEntities, definitions],
);
const filterCount = useMemo(
() =>
- readyDefinitions.reduce(
- (count, definition) =>
- count + LibMetric.filters(definition.definition).length,
+ definitionSources.reduce(
+ (count, source) => count + LibMetric.filters(source.definition).length,
0,
),
- [readyDefinitions],
+ [definitionSources],
+ );
+
+ const handleSourceDefinitionChange = useCallback(
+ (source: DefinitionSource, newDefinition: MetricDefinition) => {
+ onFormulaEntitiesChange(
+ applyDefinitionToFormulaEntities(
+ formulaEntities,
+ source,
+ newDefinition,
+ ),
+ );
+ },
+ [formulaEntities, onFormulaEntitiesChange],
);
- const hasDefinitions = readyDefinitions.length > 0;
+ const hasDefinitions = definitionSources.length > 0;
const hasFilters = filterCount > 0;
const toggleLabel = isFilterPillsExpanded ? t`Hide filters` : t`Show filters`;
return (
- <Stack gap="sm">
- <Flex align="center" justify="space-between">
+ <Stack gap="md">
+ <Flex align="center" justify="space-between" mih="1.875rem">
<Text fw={700} size="lg">{t`Explore`}</Text>
{hasDefinitions && (
<FilterPopover
- definitions={readyDefinitions}
+ definitionSources={definitionSources}
metricColors={metricColors}
- onUpdateDefinition={onUpdateDefinition}
+ onSourceDefinitionChange={handleSourceDefinitionChange}
>
<Button.Group>
<Button
@@ -87,10 +103,7 @@ export function MetricSearchPanel({
size="xs"
p="sm"
leftSection={
- <Icon
- name={hasFilters ? "filter_plus" : "filter"}
- size={14}
- />
+ <Icon name={hasFilters ? "filter_plus" : "filter"} />
}
className={hasFilters ? S.filterButtonWithCount : undefined}
>
@@ -122,9 +135,11 @@ export function MetricSearchPanel({
<Box className={S.container}>
<Box>
<MetricSearch
+ definitions={definitions}
+ formulaEntities={formulaEntities}
+ onFormulaEntitiesChange={onFormulaEntitiesChange}
selectedMetrics={selectedMetrics}
metricColors={metricColors}
- definitions={definitions}
onAddMetric={onAddMetric}
onRemoveMetric={onRemoveMetric}
onSwapMetric={onSwapMetric}
@@ -139,9 +154,9 @@ export function MetricSearchPanel({
bg="background-filter"
>
<MetricsFilterPills
- definitions={readyDefinitions}
+ definitionSources={definitionSources}
sourceColors={metricColors}
- onUpdateDefinition={onUpdateDefinition}
+ onSourceDefinitionChange={handleSourceDefinitionChange}
/>
</Box>
)}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css
index 1071eb0dae3..9d0aa7903b2 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css
@@ -4,3 +4,7 @@
border: 1px solid var(--mb-color-border-filter);
border-radius: 0.75rem;
}
+
+.root:hover {
+ background-color: var(--mb-color-background-secondary);
+}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx
index 091a41be1c8..9ea8c3deaef 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx
@@ -10,7 +10,7 @@ import S from "./MetricsFilterPill.module.css";
interface MetricsFilterPillProps extends HTMLAttributes<HTMLDivElement> {
colors: string[];
- fallbackIcon: IconName;
+ fallbackIcon?: IconName;
onRemoveClick?: () => void;
}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx
index 1d56b7771b3..6cf22878eb5 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx
@@ -6,7 +6,7 @@ import {
trackMetricsViewerFilterRemoved,
} from "metabase/metrics-viewer/analytics";
import type { IconName } from "metabase/ui";
-import { Popover, Text } from "metabase/ui";
+import { Badge, Flex, Popover, Text } from "metabase/ui";
import * as LibMetric from "metabase-lib/metric";
import { MetricsFilterPill } from "./MetricsFilterPill";
@@ -16,7 +16,9 @@ interface MetricsFilterPillPopoverProps {
definition: LibMetric.MetricDefinition;
filter: LibMetric.FilterClause;
colors: string[];
- icon: IconName;
+ icon?: IconName;
+ metricName?: string;
+ metricCount?: number;
onUpdate: (newFilter: LibMetric.FilterClause) => void;
onRemove: () => void;
}
@@ -26,6 +28,8 @@ export function MetricsFilterPillPopover({
filter,
colors,
icon,
+ metricName,
+ metricCount,
onUpdate,
onRemove,
}: MetricsFilterPillPopoverProps) {
@@ -62,13 +66,30 @@ export function MetricsFilterPillPopover({
onClick={() => setIsOpened((prev) => !prev)}
onRemoveClick={handleRemove}
>
- {displayParts.label}
- {displayParts.value && (
- <Text component="span" fw={700} c="text-filter" fz="sm">
- {" "}
- {displayParts.value}
- </Text>
- )}
+ <Flex align="center" gap="xs">
+ {metricName && (
+ <Text component="span" fw={700} c="inherit" fz="inherit">
+ {metricName}
+ </Text>
+ )}
+ {metricName && (metricCount ?? 0) > 1 && (
+ <Badge
+ circle
+ color="filter"
+ // override background from Badge.config.tsx
+ styles={{ root: { background: "var(--badge-bg)" } }}
+ >
+ {metricCount}
+ </Badge>
+ )}
+ {displayParts.label}
+ {displayParts.value && (
+ <Text component="span" fw={700} c="inherit" fz="inherit">
+ {" "}
+ {displayParts.value}
+ </Text>
+ )}
+ </Flex>
</MetricsFilterPill>
</Popover.Target>
<Popover.Dropdown>
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx
index 0aaf9eff9a2..76f001fdf57 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx
@@ -5,63 +5,67 @@ import { Group } from "metabase/ui";
import type { MetricDefinition } from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
-import type { MetricSourceId, SourceColorMap } from "../../types/viewer-state";
-import { getSourceIcon } from "../../utils/source-ids";
-import type { DefinitionSource } from "../FilterPopover/FilterPopoverContent";
+import type { SourceColorMap } from "../../types/viewer-state";
+import { isExpressionEntry } from "../../types/viewer-state";
+import type { DefinitionSource } from "../../utils/definition-sources";
+import {
+ getDefinitionSourceIcon,
+ getDefinitionSourceName,
+} from "../../utils/definition-sources";
import { MetricsFilterPillPopover } from "./MetricsFilterPillPopover";
interface MetricsFilterPillsProps {
- definitions: DefinitionSource[];
+ definitionSources: DefinitionSource[];
sourceColors: SourceColorMap;
- onUpdateDefinition: (
- id: MetricSourceId,
+ onSourceDefinitionChange: (
+ source: DefinitionSource,
definition: MetricDefinition,
) => void;
}
type FlattenedFilter = {
- entryId: MetricSourceId;
- definition: MetricDefinition;
+ source: DefinitionSource;
filter: LibMetric.FilterClause;
colors: string[];
- icon: IconName;
+ icon?: IconName;
key: string;
+ metricName?: string;
+ metricCount?: number;
};
export function MetricsFilterPills({
- definitions,
+ definitionSources,
sourceColors,
- onUpdateDefinition,
+ onSourceDefinitionChange,
}: MetricsFilterPillsProps) {
const flatFilters = useMemo(
- () => getFlatFilters(definitions, sourceColors),
- [definitions, sourceColors],
+ () => getFlatFilters(definitionSources, sourceColors),
+ [definitionSources, sourceColors],
);
const handleUpdate = useCallback(
(
- entryId: MetricSourceId,
- definition: MetricDefinition,
+ source: DefinitionSource,
oldFilter: LibMetric.FilterClause,
newFilter: LibMetric.FilterClause,
) => {
- const newDef = LibMetric.replaceClause(definition, oldFilter, newFilter);
- onUpdateDefinition(entryId, newDef);
+ const newDef = LibMetric.replaceClause(
+ source.definition,
+ oldFilter,
+ newFilter,
+ );
+ onSourceDefinitionChange(source, newDef);
},
- [onUpdateDefinition],
+ [onSourceDefinitionChange],
);
const handleRemove = useCallback(
- (
- entryId: MetricSourceId,
- definition: MetricDefinition,
- filter: LibMetric.FilterClause,
- ) => {
- const newDef = LibMetric.removeClause(definition, filter);
- onUpdateDefinition(entryId, newDef);
+ (source: DefinitionSource, filter: LibMetric.FilterClause) => {
+ const newDef = LibMetric.removeClause(source.definition, filter);
+ onSourceDefinitionChange(source, newDef);
},
- [onUpdateDefinition],
+ [onSourceDefinitionChange],
);
if (flatFilters.length === 0) {
@@ -73,16 +77,16 @@ export function MetricsFilterPills({
{flatFilters.map((item) => (
<MetricsFilterPillPopover
key={item.key}
- definition={item.definition}
+ definition={item.source.definition}
filter={item.filter}
colors={item.colors}
icon={item.icon}
+ metricName={item.metricName}
+ metricCount={item.metricCount}
onUpdate={(newFilter) =>
- handleUpdate(item.entryId, item.definition, item.filter, newFilter)
- }
- onRemove={() =>
- handleRemove(item.entryId, item.definition, item.filter)
+ handleUpdate(item.source, item.filter, newFilter)
}
+ onRemove={() => handleRemove(item.source, item.filter)}
/>
))}
</Group>
@@ -90,19 +94,28 @@ export function MetricsFilterPills({
}
function getFlatFilters(
- definitions: DefinitionSource[],
+ sources: DefinitionSource[],
sourceColors: SourceColorMap,
): FlattenedFilter[] {
- return definitions.flatMap((definition) => {
- const colors = sourceColors[definition.id] ?? ["var(--mb-color-brand)"];
- const icon = getSourceIcon(definition.id);
- return LibMetric.filters(definition.definition).map((filter, index) => ({
- entryId: definition.id,
- definition: definition.definition,
+ return sources.flatMap((source) => {
+ const colors = sourceColors[source.entityIndex] ?? [
+ "var(--mb-color-text-primary)",
+ ];
+ const icon = getDefinitionSourceIcon(source);
+ const shouldDisplayMetricName =
+ isExpressionEntry(source.entity) &&
+ source.entity.tokens.filter((token) => token.type === "metric").length >
+ 1;
+ return LibMetric.filters(source.definition).map((filter, filterIndex) => ({
+ source,
filter,
colors,
icon,
- key: `${definition.id}-${index}`,
+ key: `${source.index}-${filterIndex}`,
+ metricName: shouldDisplayMetricName
+ ? getDefinitionSourceName(source)
+ : undefined,
+ metricCount: source.token?.count,
}));
});
}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx
index 75e26b96ad8..01d4774e4c3 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/AddDimensionPopover/AddDimensionPopover.tsx
@@ -10,9 +10,11 @@ import type { MetricSourceId } from "../../../types/viewer-state";
import type {
AvailableDimensionsResult,
DimensionPickerItem,
+ DimensionPickerSection,
SourceDisplayInfo,
} from "../../../utils/dimension-picker";
import { buildDimensionPickerSections } from "../../../utils/dimension-picker";
+import { getScalarTabLabel } from "../../../utils/tabs";
import S from "./AddDimensionPopover.module.css";
@@ -21,6 +23,7 @@ type AddDimensionPopoverProps = {
sourceOrder: MetricSourceId[];
sourceDataById: Record<MetricSourceId, SourceDisplayInfo>;
hasMultipleSources: boolean;
+ canAddScalarTab: boolean;
onAddTab: (tabInfo: TabInfo) => void;
};
@@ -30,6 +33,7 @@ export function AddDimensionPopover({
sourceDataById,
hasMultipleSources,
onAddTab,
+ canAddScalarTab,
}: AddDimensionPopoverProps) {
const [isOpen, setIsOpen] = useState(false);
@@ -58,6 +62,26 @@ export function AddDimensionPopover({
[],
);
+ let finalSections: DimensionPickerSection[] = sections;
+ if (canAddScalarTab) {
+ finalSections = [
+ {
+ items: [
+ {
+ name: getScalarTabLabel(),
+ icon: "number",
+ tabInfo: {
+ type: "scalar",
+ label: getScalarTabLabel(),
+ dimensionMapping: {},
+ },
+ },
+ ],
+ },
+ ...sections,
+ ];
+ }
+
return (
<Popover opened={isOpen} onChange={setIsOpen} position="bottom-start">
<Popover.Target>
@@ -73,7 +97,7 @@ export function AddDimensionPopover({
<Popover.Dropdown p={0} className={S.dropdown}>
<AccordionList
className={S.dimensionPicker}
- sections={sections}
+ sections={finalSections}
onChange={handleSelect}
renderItemIcon={renderItemIcon}
alwaysExpanded
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx
index 59f909e9ebc..467746227b0 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabContent/MetricsViewerTabContent.tsx
@@ -1,13 +1,11 @@
import { useCallback, useMemo } from "react";
-import { t } from "ttag";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import { Center, Flex, Stack } from "metabase/ui";
-import { getObjectKeys } from "metabase/utils/objects";
+import { getObjectKeys, getObjectValues } from "metabase/utils/objects";
import { isNotNull } from "metabase/utils/types";
import type { DimensionMetadata, MetricDefinition } from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
-import { isMetric } from "metabase-lib/v1/types/utils/isa";
import type {
CardId,
SingleSeries,
@@ -19,68 +17,50 @@ import type {
MetricSourceId,
MetricsViewerDefinitionEntry,
MetricsViewerDisplayType,
+ MetricsViewerFormulaEntity,
MetricsViewerTabProjectionConfig,
MetricsViewerTabState,
SourceColorMap,
} from "../../../types/viewer-state";
import { getProjectionInfo } from "../../../utils/definition-builder";
import type { DimensionFilterValue } from "../../../utils/dimension-filters";
+import type { MetricSlot } from "../../../utils/metric-slots";
import { buildDimensionItemsFromDefinitions } from "../../../utils/series";
import { DISPLAY_TYPE_REGISTRY, getTabConfig } from "../../../utils/tab-config";
import { MetricControls } from "../../MetricControls";
import { MetricsViewerVisualization } from "../../MetricsViewerVisualization";
type MetricsViewerTabContentProps = {
- definitions: MetricsViewerDefinitionEntry[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ formulaEntities: MetricsViewerFormulaEntity[];
tab: MetricsViewerTabState;
- errorsByDefinitionId: Map<MetricSourceId, string>;
- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>;
+ queriesAreLoading: boolean;
+ queriesError: string | null;
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;
+ metricSlots: MetricSlot[];
series: SingleSeries[];
- cardIdToDefinitionId: Record<CardId, MetricSourceId>;
+ cardIdToEntityIndex: Record<CardId, number>;
sourceColors: SourceColorMap;
- isExecuting: (id: MetricSourceId) => boolean;
onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;
- onDimensionChange: (
- definitionId: MetricSourceId,
- dimension: DimensionMetadata,
- ) => void;
- onDimensionRemove: (definitionId: MetricSourceId) => void;
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ onDimensionRemove: (slotIndex: number) => void;
};
export function MetricsViewerTabContent({
definitions,
+ formulaEntities,
tab,
- errorsByDefinitionId,
- modifiedDefinitions,
+ queriesAreLoading,
+ queriesError,
+ modifiedDefinitionsBySlotIndex,
+ metricSlots,
series: rawSeries,
- cardIdToDefinitionId,
+ cardIdToEntityIndex,
sourceColors,
- isExecuting,
onTabUpdate,
onDimensionChange,
onDimensionRemove,
}: MetricsViewerTabContentProps) {
- const isLoading = useMemo(() => {
- return getObjectKeys(tab.dimensionMapping).some(isExecuting);
- }, [tab.dimensionMapping, isExecuting]);
-
- const firstError = useMemo(() => {
- for (const series of rawSeries) {
- const cols = series.data.cols;
- if (!cols.some((col) => isMetric(col))) {
- return t`Non-numeric metrics are not supported`;
- }
- }
-
- for (const sourceId of getObjectKeys(tab.dimensionMapping)) {
- const err = errorsByDefinitionId.get(sourceId);
- if (err) {
- return err;
- }
- }
- return null;
- }, [tab.dimensionMapping, errorsByDefinitionId, rawSeries]);
-
const dimensionFilter = getTabConfig(tab.type).dimensionPredicate;
const dimensionItems = useMemo(
@@ -88,43 +68,45 @@ export function MetricsViewerTabContent({
buildDimensionItemsFromDefinitions(
definitions,
tab.dimensionMapping,
- modifiedDefinitions,
+ modifiedDefinitionsBySlotIndex,
sourceColors,
+ metricSlots,
+ formulaEntities,
+ tab.projectionConfig,
dimensionFilter,
),
[
definitions,
tab.dimensionMapping,
- modifiedDefinitions,
+ modifiedDefinitionsBySlotIndex,
sourceColors,
+ metricSlots,
+ formulaEntities,
+ tab.projectionConfig,
dimensionFilter,
],
);
const definitionForControls = useMemo((): MetricDefinition | null => {
- for (const sourceId of getObjectKeys(tab.dimensionMapping)) {
- const entry = definitions.find((d) => d.id === sourceId);
- if (!entry) {
- continue;
- }
-
- const modDef = modifiedDefinitions.get(entry.id);
+ for (const key of getObjectKeys(tab.dimensionMapping)) {
+ const slotIndex = Number(key);
+ const modDef = modifiedDefinitionsBySlotIndex.get(slotIndex);
if (!modDef) {
continue;
}
-
const projs = LibMetric.projections(modDef);
if (projs.length > 0) {
return modDef;
}
}
return null;
- }, [definitions, tab.dimensionMapping, modifiedDefinitions]);
+ }, [tab.dimensionMapping, modifiedDefinitionsBySlotIndex]);
const allFilterDimensions = useMemo(() => {
const filterDimensions: DimensionMetadata[] = [];
- for (const sourceId of getObjectKeys(tab.dimensionMapping)) {
- const modDef = modifiedDefinitions.get(sourceId);
+ for (const key of getObjectKeys(tab.dimensionMapping)) {
+ const slotIndex = Number(key);
+ const modDef = modifiedDefinitionsBySlotIndex.get(slotIndex);
if (!modDef) {
continue;
}
@@ -134,7 +116,7 @@ export function MetricsViewerTabContent({
}
}
return filterDimensions;
- }, [tab.dimensionMapping, modifiedDefinitions]);
+ }, [tab.dimensionMapping, modifiedDefinitionsBySlotIndex]);
const updateProjectionConfig = useCallback(
(updates: Partial<MetricsViewerTabProjectionConfig>) => {
@@ -203,16 +185,19 @@ export function MetricsViewerTabContent({
DISPLAY_TYPE_REGISTRY[tab.display].supportsStacking && rawSeries.length > 1;
const isTimeTab = tab.type === "time";
- const mappedDimensionCount = Object.values(tab.dimensionMapping).filter(
+ const mappedDimensionCount = getObjectValues(tab.dimensionMapping).filter(
isNotNull,
).length;
const dimensionRemoveHandler =
mappedDimensionCount > 1 ? onDimensionRemove : undefined;
- if (isLoading || firstError) {
+ if (queriesAreLoading || queriesError) {
return (
<Center h="100%">
- <LoadingAndErrorWrapper loading={isLoading} error={firstError} />
+ <LoadingAndErrorWrapper
+ loading={queriesAreLoading}
+ error={queriesError}
+ />
</Center>
);
}
@@ -230,9 +215,11 @@ export function MetricsViewerTabContent({
onDimensionRemove={dimensionRemoveHandler}
onBrush={isTimeTab ? handleBrush : undefined}
definitions={definitions}
+ formulaEntities={formulaEntities}
+ metricSlots={metricSlots}
tab={tab}
onTabUpdate={onTabUpdate}
- cardIdToDefinitionId={cardIdToDefinitionId}
+ cardIdToEntityIndex={cardIdToEntityIndex}
/>
{definitionForControls && (
<Flex justify="center" align="center">
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx
index dbfcef078fc..c6a0202e0ea 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerTabs/MetricsViewerTabs.tsx
@@ -71,6 +71,8 @@ export function MetricsViewerTabs({
return null;
}
+ const canAddScalarTab = !tabs.some((tab) => tab.type === "scalar");
+
return (
<Tabs
value={activeTabId}
@@ -112,6 +114,7 @@ export function MetricsViewerTabs({
sourceDataById={sourceDataById}
hasMultipleSources={hasMultipleSources}
onAddTab={onAddTab}
+ canAddScalarTab={canAddScalarTab}
/>
)}
</Tabs.List>
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css
index 3306df0469f..dbf276ee408 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.module.css
@@ -6,4 +6,8 @@
background-color: var(--mb-color-background-primary);
overflow: hidden;
height: 100%;
+
+ & :global(.CardVisualization) {
+ padding: 0;
+ }
}
diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx
index a38560e3250..f707ae888bd 100644
--- a/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx
+++ b/frontend/src/metabase/metrics-viewer/components/MetricsViewerVisualization/MetricsViewerVisualization.tsx
@@ -2,11 +2,15 @@ import { useMemo } from "react";
import { noop } from "underscore";
import { DebouncedFrame } from "metabase/common/components/DebouncedFrame";
-import type { DimensionItem } from "metabase/metrics-viewer/components/DimensionPillBar";
+import type { DimensionPillBarItem } from "metabase/metrics-viewer/components/DimensionPillBar";
import { DimensionPillBar } from "metabase/metrics-viewer/components/DimensionPillBar";
-import { DISPLAY_TYPE_REGISTRY } from "metabase/metrics-viewer/utils";
+import {
+ DISPLAY_TYPE_REGISTRY,
+ getTabConfig,
+} from "metabase/metrics-viewer/utils";
import { MetricsViewerClickActionsMode } from "metabase/metrics-viewer/utils/MetricsViewerClickActionsMode";
import { getGridColumns } from "metabase/metrics-viewer/utils/grid-columns";
+import type { MetricSlot } from "metabase/metrics-viewer/utils/metric-slots";
import { Flex, SimpleGrid, Stack, useElementSize } from "metabase/ui";
import Visualization from "metabase/visualizations/components/Visualization";
import type { DimensionMetadata } from "metabase-lib/metric";
@@ -15,6 +19,7 @@ import type { CardId, SingleSeries } from "metabase-types/api";
import type {
MetricSourceId,
MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
MetricsViewerTabState,
} from "../../types/viewer-state";
@@ -22,18 +27,17 @@ import S from "./MetricsViewerVisualization.module.css";
type MetricsViewerVisualizationProps = {
rawSeries: SingleSeries[];
- dimensionItems: DimensionItem[];
- onDimensionChange?: (
- definitionId: MetricSourceId,
- dimension: DimensionMetadata,
- ) => void;
- onDimensionRemove?: (definitionId: MetricSourceId) => void;
+ dimensionItems: DimensionPillBarItem[];
+ onDimensionChange: (slotIndex: number, dimension: DimensionMetadata) => void;
+ onDimensionRemove?: (slotIndex: number) => void;
onBrush?: (range: { start: number; end: number }) => void;
className?: string;
- definitions: MetricsViewerDefinitionEntry[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ formulaEntities: MetricsViewerFormulaEntity[];
+ metricSlots: MetricSlot[];
tab: MetricsViewerTabState;
onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;
- cardIdToDefinitionId: Record<CardId, MetricSourceId>;
+ cardIdToEntityIndex: Record<CardId, number>;
interactive?: boolean;
};
@@ -45,9 +49,11 @@ export function MetricsViewerVisualization({
onBrush,
className,
definitions,
+ formulaEntities,
+ metricSlots,
tab,
onTabUpdate,
- cardIdToDefinitionId,
+ cardIdToEntityIndex,
interactive = true,
}: MetricsViewerVisualizationProps) {
const { ref, width } = useElementSize();
@@ -58,14 +64,32 @@ export function MetricsViewerVisualization({
interactive
? new MetricsViewerClickActionsMode({
definitions,
+ formulaEntities,
+ metricSlots,
tab,
onTabUpdate,
- cardIdToDefinitionId,
+ cardIdToEntityIndex,
})
: undefined,
- [cardIdToDefinitionId, definitions, interactive, onTabUpdate, tab],
+ [
+ definitions,
+ cardIdToEntityIndex,
+ formulaEntities,
+ metricSlots,
+ interactive,
+ onTabUpdate,
+ tab,
+ ],
);
+ const tabConfig = getTabConfig(tab.type);
+ const hasAnyOptions = dimensionItems.some((item) =>
+ item.type === "expression"
+ ? item.metricSources.some((s) => s.availableOptions.length > 0)
+ : item.availableOptions.length > 0,
+ );
+ const hideDimensionPill = tabConfig.minDimensions === 0 && !hasAnyOptions;
+
return (
<Flex
ref={ref}
@@ -114,7 +138,7 @@ export function MetricsViewerVisualization({
</DebouncedFrame>
)}
- {dimensionItems.length > 0 && onDimensionChange && (
+ {!hideDimensionPill && (
<DimensionPillBar
items={dimensionItems}
onDimensionChange={onDimensionChange}
diff --git a/frontend/src/metabase/metrics-viewer/constants.ts b/frontend/src/metabase/metrics-viewer/constants.ts
index 68017697609..98251f232f1 100644
--- a/frontend/src/metabase/metrics-viewer/constants.ts
+++ b/frontend/src/metabase/metrics-viewer/constants.ts
@@ -1,3 +1,3 @@
export const UNBINNED = "__unbinned__" as const;
-export const MAX_AUTO_TABS = 4;
+export const MAX_AUTO_TABS = 5;
diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts b/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts
index a3b1ea5827a..44eb1047b84 100644
--- a/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts
+++ b/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts
@@ -1,108 +1,293 @@
import { useEffect, useMemo } from "react";
+import { t } from "ttag";
import { metricApi } from "metabase/api";
import { getErrorMessage } from "metabase/api/utils/errors";
import { useDispatch, useSelector } from "metabase/utils/redux";
import type { MetricDefinition } from "metabase-lib/metric";
-import type { Dataset, MetricBreakoutValuesResponse } from "metabase-types/api";
+import * as LibMetric from "metabase-lib/metric";
+import { isMetric } from "metabase-lib/v1/types/utils/isa";
+import type {
+ Dataset,
+ ExpressionRef,
+ InstanceFilter,
+ MetricBreakoutValuesResponse,
+ TypedProjection,
+} from "metabase-types/api";
+import type { MetricDatasetRequest } from "metabase-types/api/metric";
import type { State } from "metabase-types/store";
-import type {
- MetricSourceId,
- MetricsViewerDefinitionEntry,
- MetricsViewerTabState,
+import {
+ type ExpressionDefinitionEntry,
+ type MetricSourceId,
+ type MetricsViewerDefinitionEntry,
+ type MetricsViewerFormulaEntity,
+ type MetricsViewerTabState,
+ isExpressionEntry,
+ isMetricEntry,
} from "../types/viewer-state";
import {
getModifiedDefinition,
toJsDefinition,
} from "../utils/definition-cache";
-import { entryHasBreakout } from "../utils/definition-entries";
+import {
+ entryHasBreakout,
+ getEffectiveDefinitionEntry,
+ getEffectiveTokenDefinitionEntry,
+} from "../utils/definition-entries";
+import type { MetricSlot } from "../utils/metric-slots";
+import {
+ computeMetricSlots,
+ findExpressionTokenSlot,
+ findStandaloneSlot,
+} from "../utils/metric-slots";
+import { parseExpression } from "../utils/parse-expression";
+import { getTabConfig } from "../utils/tab-config";
export interface UseDefinitionQueriesResult {
- resultsByDefinitionId: Map<MetricSourceId, Dataset>;
- errorsByDefinitionId: Map<MetricSourceId, string>;
- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>;
- breakoutValuesBySourceId: Map<MetricSourceId, MetricBreakoutValuesResponse>;
- isExecuting: (id: MetricSourceId) => boolean;
+ resultsByEntityIndex: Map<number, Dataset>;
+ queriesAreLoading: boolean;
+ queriesError: string | null;
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;
+ breakoutValuesByEntityIndex: Map<number, MetricBreakoutValuesResponse>;
}
-export function useDefinitionQueries(
- definitions: MetricsViewerDefinitionEntry[],
- tab: MetricsViewerTabState | null,
-): UseDefinitionQueriesResult {
- const dispatch = useDispatch();
+function getModifiedDefinitionForTab(
+ definition: MetricsViewerDefinitionEntry,
+ slotIndex: number,
+ tab: MetricsViewerTabState,
+): MetricDefinition | null {
+ if (!definition.definition) {
+ return null;
+ }
+ const tabConfig = getTabConfig(tab.type);
+ const dimensionId = tab.dimensionMapping[slotIndex];
+ if (!dimensionId) {
+ if (tabConfig.minDimensions > 0) {
+ return null;
+ }
+ return definition.definition;
+ }
+ return getModifiedDefinition(
+ definition.definition,
+ dimensionId,
+ tab.projectionConfig,
+ );
+}
+
+function buildArithmeticRequest(
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ tab: MetricsViewerTabState,
+ entity: ExpressionDefinitionEntry,
+ metricSlots: MetricSlot[],
+ entityIndex: number,
+ datasetRequestsByEntityIndex: Map<number, MetricDatasetRequest>,
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,
+ expressionErrorsByEntityIndex: Map<number, string>,
+): void {
+ const { tokens } = entity;
+
+ // Build leaf refs and projections for each metric occurrence in the expression.
+ // Each occurrence gets its own unique UUID keyed by token position so the same
+ // metric can appear multiple times (e.g. Revenue / Revenue).
+ const leafRefs = new Map<number, ExpressionRef>();
+ const projections: TypedProjection[] = [];
+ const filters: InstanceFilter[] = [];
- const datasetRequests = useMemo(() => {
- if (!tab) {
- return [];
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i];
+ if (token.type !== "metric") {
+ continue;
}
- return definitions.flatMap((entry) => {
- const dimensionId = tab.dimensionMapping[entry.id];
- if (!dimensionId || !entry.definition) {
- return [];
+ const definition = getEffectiveTokenDefinitionEntry(token, definitions);
+ // Find the specific slot for this expression token
+ const tokenSlot = findExpressionTokenSlot(metricSlots, entityIndex, i);
+ const slotIndex = tokenSlot?.slotIndex ?? -1;
+ const modifiedDefinition = getModifiedDefinitionForTab(
+ definition,
+ slotIndex,
+ tab,
+ );
+ if (!modifiedDefinition) {
+ if (!definition.definition) {
+ return; // still loading the metric, not an error
}
-
- const modifiedDefinition = getModifiedDefinition(
- entry.definition,
- dimensionId,
- tab.projectionConfig,
+ expressionErrorsByEntityIndex.set(
+ entityIndex,
+ t`No compatible dimensions`,
);
+ return;
+ }
- if (!modifiedDefinition) {
- return [];
+ modifiedDefinitionsBySlotIndex.set(slotIndex, modifiedDefinition);
+
+ const uuid = `leaf-${i}`;
+ const metricId = LibMetric.sourceMetricId(modifiedDefinition);
+ const measureId = LibMetric.sourceMeasureId(modifiedDefinition);
+
+ if (metricId != null) {
+ leafRefs.set(i, ["metric", { "lib/uuid": uuid }, metricId]);
+ } else if (measureId != null) {
+ leafRefs.set(i, ["measure", { "lib/uuid": uuid }, measureId]);
+ } else {
+ expressionErrorsByEntityIndex.set(entityIndex, t`Invalid expression`);
+ return;
+ }
+
+ const jsdef = toJsDefinition(modifiedDefinition);
+
+ if (jsdef.projections) {
+ for (const proj of jsdef.projections) {
+ projections.push({
+ ...proj,
+ "lib/uuid": uuid,
+ });
}
+ }
+
+ filters.push(
+ ...(jsdef.filters ?? []).map((f) => ({
+ "lib/uuid": uuid,
+ filter: f.filter,
+ })),
+ );
+ }
+ const expr = parseExpression(tokens, leafRefs);
+ if (!expr) {
+ expressionErrorsByEntityIndex.set(entityIndex, t`Invalid expression`);
+ return;
+ }
+
+ datasetRequestsByEntityIndex.set(entityIndex, {
+ definition: {
+ expression: expr,
+ projections,
+ filters,
+ },
+ });
+}
+
+function buildQueryItems(
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ formulaEntities: MetricsViewerFormulaEntity[],
+ tab: MetricsViewerTabState | null,
+): {
+ datasetRequestsByEntityIndex: Map<number, MetricDatasetRequest>;
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;
+ expressionErrorsByEntityIndex: Map<number, string>;
+} {
+ const datasetRequestsByEntityIndex = new Map<number, MetricDatasetRequest>();
+ const modifiedDefinitionsBySlotIndex = new Map<number, MetricDefinition>();
+ const expressionErrorsByEntityIndex = new Map<number, string>();
+
+ if (!tab) {
+ return {
+ datasetRequestsByEntityIndex,
+ modifiedDefinitionsBySlotIndex,
+ expressionErrorsByEntityIndex,
+ };
+ }
+
+ const metricSlots = computeMetricSlots(formulaEntities);
+
+ formulaEntities.forEach((entity, entityIndex) => {
+ if (isMetricEntry(entity)) {
+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);
+ const slot = findStandaloneSlot(metricSlots, entityIndex);
+ if (!slot) {
+ return;
+ }
+ const modifiedDefinition = getModifiedDefinitionForTab(
+ effectiveEntry,
+ slot.slotIndex,
+ tab,
+ );
+ if (!modifiedDefinition) {
+ return;
+ }
const jsDefinition = toJsDefinition(modifiedDefinition);
+ datasetRequestsByEntityIndex.set(entityIndex, {
+ definition: jsDefinition,
+ });
+ modifiedDefinitionsBySlotIndex.set(slot.slotIndex, modifiedDefinition);
+ }
- return [
- {
- sourceId: entry.id,
- modifiedDefinition,
- request: { definition: jsDefinition },
- },
- ];
- });
- }, [definitions, tab]);
+ if (isExpressionEntry(entity)) {
+ buildArithmeticRequest(
+ definitions,
+ tab,
+ entity,
+ metricSlots,
+ entityIndex,
+ // buildArithmeticRequest mutates these
+ datasetRequestsByEntityIndex,
+ modifiedDefinitionsBySlotIndex,
+ expressionErrorsByEntityIndex,
+ );
+ }
+ });
+
+ return {
+ datasetRequestsByEntityIndex,
+ modifiedDefinitionsBySlotIndex,
+ expressionErrorsByEntityIndex,
+ };
+}
+
+export function useDefinitionQueries(
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ formulaEntities: MetricsViewerFormulaEntity[],
+ tab: MetricsViewerTabState | null,
+): UseDefinitionQueriesResult {
+ const dispatch = useDispatch();
+
+ const {
+ datasetRequestsByEntityIndex,
+ modifiedDefinitionsBySlotIndex,
+ expressionErrorsByEntityIndex,
+ } = useMemo(
+ () => buildQueryItems(definitions, formulaEntities, tab),
+ [definitions, formulaEntities, tab],
+ );
const breakoutRequests = useMemo(() => {
- return definitions.flatMap((entry) => {
- if (!entry.definition || !entryHasBreakout(entry)) {
+ return formulaEntities.flatMap((entity, entityIndex) => {
+ if (!isMetricEntry(entity)) {
+ return [];
+ }
+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);
+ if (!effectiveEntry.definition || !entryHasBreakout(effectiveEntry)) {
return [];
}
- const jsDefinition = toJsDefinition(entry.definition);
+ const jsDefinition = toJsDefinition(effectiveEntry.definition);
return [
{
- sourceId: entry.id,
+ entityIndex,
request: { definition: jsDefinition },
},
];
});
- }, [definitions]);
-
- const modifiedDefinitions = useMemo(() => {
- const map = new Map<MetricSourceId, MetricDefinition>();
- for (const { sourceId, modifiedDefinition } of datasetRequests) {
- map.set(sourceId, modifiedDefinition);
- }
- return map;
- }, [datasetRequests]);
+ }, [formulaEntities, definitions]);
useEffect(() => {
- if (datasetRequests.length === 0) {
+ const requestsToMake = [...datasetRequestsByEntityIndex.values()];
+
+ if (requestsToMake.length === 0) {
return;
}
- const subscriptions = datasetRequests.map((query) =>
- dispatch(metricApi.endpoints.getMetricDataset.initiate(query.request)),
+ const subscriptions = requestsToMake.map((request) =>
+ dispatch(metricApi.endpoints.getMetricDataset.initiate(request)),
);
return () => {
subscriptions.forEach((subscription) => subscription.unsubscribe());
};
- }, [datasetRequests, dispatch]);
+ }, [datasetRequestsByEntityIndex, dispatch]);
useEffect(() => {
if (breakoutRequests.length === 0) {
@@ -121,61 +306,77 @@ export function useDefinitionQueries(
}, [breakoutRequests, dispatch]);
const datasetResults = useSelector((state: State) =>
- datasetRequests.map((query) => ({
- sourceId: query.sourceId,
- result: metricApi.endpoints.getMetricDataset.select(query.request)(state),
- })),
+ Array.from(datasetRequestsByEntityIndex.entries()).map(
+ ([entityIndex, request]) => ({
+ entityIndex,
+ result: metricApi.endpoints.getMetricDataset.select(request)(state),
+ }),
+ ),
);
const breakoutResults = useSelector((state: State) =>
breakoutRequests.map((query) => ({
- sourceId: query.sourceId,
+ entityIndex: query.entityIndex,
result: metricApi.endpoints.getMetricBreakoutValues.select(query.request)(
state,
),
})),
);
- const { resultsByDefinitionId, errorsByDefinitionId, isExecuting } =
+ const { resultsByEntityIndex, queriesAreLoading, queriesError } =
useMemo(() => {
- const results = new Map<MetricSourceId, Dataset>();
- const errors = new Map<MetricSourceId, string>();
- const executing = new Set<MetricSourceId>();
+ const resultsByEntityIndex = new Map<number, Dataset>();
+ let queriesAreLoading = false;
+ let queriesError = null;
- for (const { sourceId, result } of datasetResults) {
- if (result.data) {
- results.set(sourceId, result.data);
+ for (const { entityIndex, result } of datasetResults) {
+ if (result.data?.data?.cols?.length) {
+ if (result.data.data.cols.some((col) => isMetric(col))) {
+ resultsByEntityIndex.set(entityIndex, result.data);
+ } else {
+ queriesError = t`Non-numeric metrics are not supported`;
+ }
}
- if (result.error) {
- errors.set(sourceId, getErrorMessage(result.error));
+ if (result.error && queriesError == null) {
+ queriesError = getErrorMessage(result.error);
}
if (result.isLoading || ("isFetching" in result && result.isFetching)) {
- executing.add(sourceId);
+ queriesAreLoading = true;
}
}
+ // only show expression errors if we have no data to show
+ if (
+ !queriesAreLoading &&
+ resultsByEntityIndex.size === 0 &&
+ queriesError == null &&
+ expressionErrorsByEntityIndex.size > 0
+ ) {
+ queriesError = expressionErrorsByEntityIndex.values().next().value!;
+ }
+
return {
- resultsByDefinitionId: results,
- errorsByDefinitionId: errors,
- isExecuting: (id: MetricSourceId) => executing.has(id),
+ resultsByEntityIndex,
+ queriesAreLoading,
+ queriesError,
};
- }, [datasetResults]);
+ }, [datasetResults, expressionErrorsByEntityIndex]);
- const breakoutValuesBySourceId = useMemo(() => {
- const map = new Map<MetricSourceId, MetricBreakoutValuesResponse>();
- for (const { sourceId, result } of breakoutResults) {
+ const breakoutValuesByEntityIndex = useMemo(() => {
+ const map = new Map<number, MetricBreakoutValuesResponse>();
+ for (const { entityIndex, result } of breakoutResults) {
if (result.data) {
- map.set(sourceId, result.data);
+ map.set(entityIndex, result.data);
}
}
return map;
}, [breakoutResults]);
return {
- resultsByDefinitionId,
- errorsByDefinitionId,
- modifiedDefinitions,
- breakoutValuesBySourceId,
- isExecuting,
+ resultsByEntityIndex,
+ queriesAreLoading,
+ queriesError,
+ modifiedDefinitionsBySlotIndex,
+ breakoutValuesByEntityIndex,
};
}
diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts b/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts
index cffca8ccb26..9cadb49821c 100644
--- a/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts
+++ b/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts
@@ -1,6 +1,6 @@
import { useCallback, useMemo } from "react";
-import { getObjectEntries, objectFromEntries } from "metabase/utils/objects";
+import { objectFromEntries } from "metabase/utils/objects";
import { isNotNull } from "metabase/utils/types";
import type {
DimensionMetadata,
@@ -17,45 +17,33 @@ import type {
import type { MetricsViewerPageProps } from "../pages/MetricsViewerPage/MetricsViewerPage";
import type {
+ MetricDefinitionEntry,
MetricSourceId,
MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
MetricsViewerTabState,
SelectedMetric,
SourceBreakoutColorMap,
SourceColorMap,
} from "../types/viewer-state";
-import {
- applyProjection,
- buildBinnedBreakoutDefinition,
- getDefinitionName,
-} from "../utils/definition-builder";
-import { buildDimensionFilterClause } from "../utils/dimension-filters";
-import {
- findBinningStrategy,
- findDimensionById,
- findFilterDimensionById,
- findTemporalBucket,
-} from "../utils/dimension-lookup";
+import { isExpressionEntry, isMetricEntry } from "../types/viewer-state";
+import { getDefinitionName } from "../utils/definition-builder";
import type {
AvailableDimensionsResult,
SourceDisplayInfo,
} from "../utils/dimension-picker";
import { getAvailableDimensionsForPicker } from "../utils/dimension-picker";
+import { type MetricSlot, computeMetricSlots } from "../utils/metric-slots";
import {
- buildRawSeriesFromDefinitions,
+ buildSeries,
computeSourceBreakoutColors,
getSelectedMetricsInfo,
} from "../utils/series";
-import {
- createMeasureSourceId,
- createMetricSourceId,
- createSourceId,
-} from "../utils/source-ids";
+import { createSourceId } from "../utils/source-ids";
import {
type TabInfo,
createTabFromTabInfo,
- getDimensionsByType,
- resolveCommonTabLabel,
+ recomputeTabLabels,
} from "../utils/tabs";
import { useDefinitionQueries } from "./use-definition-queries";
@@ -63,22 +51,23 @@ import { useViewerState } from "./use-viewer-state";
import { type LoadSourcesRequest, useViewerUrl } from "./use-viewer-url";
export interface UseMetricsViewerResult {
- definitions: MetricsViewerDefinitionEntry[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ formulaEntities: MetricsViewerFormulaEntity[];
tabs: MetricsViewerTabState[];
activeTab: MetricsViewerTabState | null;
activeTabId: string | null;
-
+ initialLoadComplete: boolean;
loadingIds: Set<MetricSourceId>;
- resultsByDefinitionId: Map<MetricSourceId, Dataset>;
- errorsByDefinitionId: Map<MetricSourceId, string>;
- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>;
- isExecuting: (id: MetricSourceId) => boolean;
-
+ resultsByEntityIndex: Map<number, Dataset>;
+ queriesAreLoading: boolean;
+ queriesError: string | null;
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;
+ breakoutValuesByEntityIndex: Map<number, MetricBreakoutValuesResponse>;
+ metricSlots: MetricSlot[];
series: SingleSeries[];
- cardIdToDefinitionId: Record<CardId, MetricSourceId>;
+ cardIdToEntityIndex: Record<CardId, number>;
activeBreakoutColors: SourceBreakoutColorMap;
sourceColors: SourceColorMap;
- breakoutValuesBySourceId: Map<MetricSourceId, MetricBreakoutValuesResponse>;
selectedMetrics: SelectedMetric[];
sourceOrder: MetricSourceId[];
sourceDataById: Record<MetricSourceId, SourceDisplayInfo>;
@@ -94,75 +83,18 @@ export interface UseMetricsViewerResult {
updateActiveTab: (updates: Partial<MetricsViewerTabState>) => void;
changeTabDimension: (
tabId: string,
- definitionId: MetricSourceId,
+ slotIndex: number,
dimension: DimensionMetadata,
) => void;
- removeTabDimension: (tabId: string, definitionId: MetricSourceId) => void;
- updateDefinition: (id: MetricSourceId, definition: MetricDefinition) => void;
+ removeTabDimension: (tabId: string, slotIndex: number) => void;
setBreakoutDimension: (
- id: MetricSourceId,
+ entity: MetricDefinitionEntry,
dimension: ProjectionClause | undefined,
) => void;
-}
-
-function buildUrlRestoreTransform(
- sourceId: MetricSourceId,
- request: LoadSourcesRequest,
-): ((definition: MetricDefinition) => MetricDefinition) | undefined {
- const breakoutInfo = request.breakoutBySourceId?.[sourceId];
- const filters = request.filtersBySourceId?.[sourceId];
-
- if (!breakoutInfo && (!filters || filters.length === 0)) {
- return undefined;
- }
-
- return (definition: MetricDefinition): MetricDefinition => {
- let result = definition;
-
- if (breakoutInfo) {
- const dimension = findDimensionById(result, breakoutInfo.dimensionId);
- if (dimension) {
- const dimensionRef = LibMetric.dimensionReference(dimension);
-
- let modifiedRef: LibMetric.ProjectionClause | null = null;
- if (breakoutInfo.temporalUnit) {
- const bucket = findTemporalBucket(
- result,
- dimension,
- breakoutInfo.temporalUnit,
- );
- if (bucket) {
- modifiedRef = LibMetric.withTemporalBucket(dimensionRef, bucket);
- }
- } else if (breakoutInfo.binning) {
- const strategy = findBinningStrategy(
- result,
- dimension,
- breakoutInfo.binning,
- );
- if (strategy) {
- modifiedRef = LibMetric.withBinning(dimensionRef, strategy);
- }
- }
-
- result = modifiedRef
- ? applyProjection(result, modifiedRef)
- : buildBinnedBreakoutDefinition(result, dimensionRef);
- }
- }
-
- if (filters) {
- for (const filter of filters) {
- const dimension = findFilterDimensionById(result, filter.dimensionId);
- if (dimension) {
- const clause = buildDimensionFilterClause(dimension, filter.value);
- result = LibMetric.filter(result, clause);
- }
- }
- }
-
- return result;
- };
+ setFormulaEntities: (
+ entities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) => void;
}
export function useMetricsViewer({
@@ -171,8 +103,10 @@ export function useMetricsViewer({
const {
state,
loadingIds,
+ initialLoadComplete,
+ setInitialLoadComplete,
removeDefinition,
- updateDefinition,
+ setFormulaEntities,
selectTab: changeTab,
addTab,
removeTab,
@@ -190,21 +124,23 @@ export function useMetricsViewer({
const handleLoadSources = useCallback(
(request: LoadSourcesRequest) => {
for (const metricId of request.metricIds) {
- const sourceId = createMetricSourceId(metricId);
- loadAndAddMetric(metricId, buildUrlRestoreTransform(sourceId, request));
+ loadAndAddMetric(metricId);
}
for (const measureId of request.measureIds) {
- const sourceId = createMeasureSourceId(measureId);
- loadAndAddMeasure(
- measureId,
- buildUrlRestoreTransform(sourceId, request),
- );
+ loadAndAddMeasure(measureId);
}
},
[loadAndAddMetric, loadAndAddMeasure],
);
- useViewerUrl(state, initialize, handleLoadSources, location);
+ useViewerUrl(
+ state,
+ initialize,
+ handleLoadSources,
+ location,
+ setFormulaEntities,
+ setInitialLoadComplete,
+ );
const activeTab = useMemo((): MetricsViewerTabState | null => {
if (state.tabs.length === 0) {
@@ -216,42 +152,60 @@ export function useMetricsViewer({
}, [state.tabs, state.selectedTabId]);
const {
- resultsByDefinitionId,
- errorsByDefinitionId,
- modifiedDefinitions,
- breakoutValuesBySourceId,
- isExecuting,
- } = useDefinitionQueries(state.definitions, activeTab);
+ resultsByEntityIndex,
+ queriesAreLoading,
+ queriesError,
+ modifiedDefinitionsBySlotIndex,
+ breakoutValuesByEntityIndex,
+ } = useDefinitionQueries(state.definitions, state.formulaEntities, activeTab);
+
+ const definitionValues = useMemo(
+ () => Object.values(state.definitions),
+ [state.definitions],
+ );
const selectedMetrics = useMemo(
- () => getSelectedMetricsInfo(state.definitions, loadingIds),
- [state.definitions, loadingIds],
+ () => getSelectedMetricsInfo(definitionValues, loadingIds),
+ [definitionValues, loadingIds],
+ );
+
+ const metricSlots = useMemo(
+ () => computeMetricSlots(state.formulaEntities),
+ [state.formulaEntities],
);
const sourceBreakoutColors = useMemo(
() =>
- computeSourceBreakoutColors(state.definitions, breakoutValuesBySourceId),
- [state.definitions, breakoutValuesBySourceId],
+ computeSourceBreakoutColors(
+ state.formulaEntities,
+ state.definitions,
+ breakoutValuesByEntityIndex,
+ ),
+ [state.formulaEntities, state.definitions, breakoutValuesByEntityIndex],
);
- const { series, cardIdToDefinitionId, activeBreakoutColors } = useMemo(() => {
+ const { series, cardIdToEntityIndex, activeBreakoutColors } = useMemo(() => {
if (!activeTab) {
- return { series: [], cardIdToDefinitionId: {}, activeBreakoutColors: {} };
+ return { series: [], cardIdToEntityIndex: {}, activeBreakoutColors: {} };
}
- return buildRawSeriesFromDefinitions(
- state.definitions,
- activeTab.dimensionMapping,
- activeTab.display,
- resultsByDefinitionId,
- modifiedDefinitions,
+ return buildSeries({
+ formulaEntities: state.formulaEntities,
+ definitions: state.definitions,
+ metricSlots,
+ dimensionMapping: activeTab.dimensionMapping,
+ display: activeTab.display,
+ resultsByEntityIndex,
+ modifiedDefinitionsBySlotIndex,
sourceBreakoutColors,
- activeTab.visualizationSettings,
- );
+ extraVizSettings: activeTab.visualizationSettings,
+ });
}, [
+ state.formulaEntities,
state.definitions,
+ metricSlots,
activeTab,
- resultsByDefinitionId,
- modifiedDefinitions,
+ resultsByEntityIndex,
+ modifiedDefinitionsBySlotIndex,
sourceBreakoutColors,
]);
@@ -273,22 +227,37 @@ export function useMetricsViewer({
const definitionsBySourceId = useMemo(
() =>
objectFromEntries(
- state.definitions.map((entry) => [entry.id, entry.definition] as const),
+ definitionValues.map((entry) => [entry.id, entry.definition] as const),
),
- [state.definitions],
+ [definitionValues],
);
- const sourceOrder = useMemo(
- () => state.definitions.map((entry) => entry.id),
- [state.definitions],
- );
+ const sourceOrder = useMemo(() => {
+ const out: MetricSourceId[] = [];
+ const seen = new Set<MetricSourceId>();
+ for (const entry of state.formulaEntities) {
+ if (isMetricEntry(entry) && !seen.has(entry.id)) {
+ out.push(entry.id);
+ seen.add(entry.id);
+ }
+ if (isExpressionEntry(entry)) {
+ for (const token of entry.tokens) {
+ if (token.type === "metric" && !seen.has(token.sourceId)) {
+ out.push(token.sourceId);
+ seen.add(token.sourceId);
+ }
+ }
+ }
+ }
+ return out;
+ }, [state.formulaEntities]);
const sourceDataById = useMemo((): Record<
MetricSourceId,
SourceDisplayInfo
> => {
const result: Record<MetricSourceId, SourceDisplayInfo> = {};
- for (const entry of state.definitions) {
+ for (const entry of definitionValues) {
const { definition } = entry;
if (!definition) {
continue;
@@ -304,7 +273,7 @@ export function useMetricsViewer({
}
}
return result;
- }, [state.definitions]);
+ }, [definitionValues]);
const existingTabDimensionIds = useMemo(
() =>
@@ -316,50 +285,26 @@ export function useMetricsViewer({
[state.tabs],
);
- const effectiveTabs = useMemo(() => {
- const dimsBySource = new Map(
- state.definitions
- .filter((entry) => entry.definition != null)
- .map(
- (entry) =>
- [entry.id, getDimensionsByType(entry.definition!)] as const,
- ),
- );
-
- return state.tabs.map((tab) => {
- const names: string[] = [];
- for (const [sourceId, dimensionId] of getObjectEntries(
- tab.dimensionMapping,
- )) {
- if (dimensionId == null) {
- continue;
- }
- const sourceDimensions = dimsBySource.get(sourceId);
- const dimensionInfo = sourceDimensions?.get(dimensionId);
- if (dimensionInfo) {
- names.push(dimensionInfo.displayName);
- }
- }
- const label = resolveCommonTabLabel(names);
- return label != null && label !== tab.label ? { ...tab, label } : tab;
- });
- }, [state.tabs, state.definitions]);
+ const effectiveTabs = useMemo(
+ () => recomputeTabLabels(state.tabs, state.definitions, metricSlots),
+ [state.tabs, metricSlots, state.definitions],
+ );
const availableDimensions = useMemo(
() =>
getAvailableDimensionsForPicker(
definitionsBySourceId,
- sourceOrder,
+ metricSlots,
existingTabDimensionIds,
),
- [definitionsBySourceId, sourceOrder, existingTabDimensionIds],
+ [definitionsBySourceId, metricSlots, existingTabDimensionIds],
);
const addMetric = useCallback(
(metric: SelectedMetric) => {
const sourceId = createSourceId(metric.id, metric.sourceType);
- if (state.definitions.some((entry) => entry.id === sourceId)) {
+ if (sourceId in state.definitions) {
return;
}
@@ -417,21 +362,22 @@ export function useMetricsViewer({
return {
definitions: state.definitions,
+ formulaEntities: state.formulaEntities,
tabs: effectiveTabs,
activeTab,
activeTabId: state.selectedTabId,
-
+ initialLoadComplete,
loadingIds,
- resultsByDefinitionId,
- errorsByDefinitionId,
- modifiedDefinitions,
- isExecuting,
-
+ resultsByEntityIndex,
+ queriesAreLoading,
+ queriesError,
+ modifiedDefinitionsBySlotIndex,
+ breakoutValuesByEntityIndex,
+ metricSlots,
series,
- cardIdToDefinitionId,
+ cardIdToEntityIndex,
activeBreakoutColors,
sourceColors,
- breakoutValuesBySourceId,
selectedMetrics,
sourceOrder,
sourceDataById,
@@ -447,7 +393,7 @@ export function useMetricsViewer({
updateActiveTab,
changeTabDimension,
removeTabDimension,
- updateDefinition,
setBreakoutDimension,
+ setFormulaEntities,
};
}
diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts
index e9766702638..19903c099ab 100644
--- a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts
+++ b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts
@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
import { measureApi, metricApi } from "metabase/api";
import { getMetadata } from "metabase/selectors/metadata";
@@ -15,19 +15,30 @@ import type { MeasureId } from "metabase-types/api";
import type { MetricId } from "metabase-types/api/metric";
import type {
+ MetricDefinitionEntry,
MetricSourceId,
MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
MetricsViewerPageState,
MetricsViewerTabState,
StoredMetricsViewerTab,
} from "../types/viewer-state";
-import { getInitialMetricsViewerPageState } from "../types/viewer-state";
+import {
+ getInitialMetricsViewerPageState,
+ isExpressionEntry,
+ isMetricEntry,
+} from "../types/viewer-state";
import { buildBinnedBreakoutDefinition } from "../utils/definition-builder";
+import { getEffectiveDefinitionEntry } from "../utils/definition-entries";
+import { computeMetricSlots } from "../utils/metric-slots";
+import { remapDimensionMappings } from "../utils/remap-dimension-mappings";
import {
createMeasureSourceId,
createMetricSourceId,
} from "../utils/source-ids";
+import { getTabConfig } from "../utils/tab-config";
import { computeDefaultTabs, findMatchingDimensionForTab } from "../utils/tabs";
+import { applySerializedDefinitionInfo } from "../utils/url-serialization";
async function loadMetricDefinition(
dispatch: ReturnType<typeof useDispatch>,
@@ -76,61 +87,134 @@ function getValidSelectedTabId(
return selectedTabExists ? currentSelectedId : (newTabs[0]?.id ?? null);
}
-function addDefinitionToTabs(
+/**
+ * For each tab, find slots that have no dimension assigned yet but whose
+ * definition IS loaded, and try to smart-match a dimension using the same
+ * logic as `addDefinitionToTabs`. This handles both timing orderings:
+ * - definition loaded before formula committed (called from setFormulaEntities)
+ * - formula committed before definition loaded (called from updateDefinition)
+ */
+function assignDimensionsForUnmappedSlots(
tabs: MetricsViewerTabState[],
- definitionEntries: MetricsViewerDefinitionEntry[],
- newDefId: MetricSourceId,
- newDef: MetricDefinition,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ formulaEntities: MetricsViewerFormulaEntity[],
): MetricsViewerTabState[] {
- const existingDefinitions = objectFromEntries(
- definitionEntries
- .filter((entry) => entry.id !== newDefId)
- .map((entry) => [entry.id, entry.definition] as const),
- );
+ const slots = computeMetricSlots(formulaEntities);
+ if (slots.length === 0) {
+ return tabs;
+ }
+
+ const slotIndexToSourceId = new Map<number, MetricSourceId>();
+ for (const slot of slots) {
+ slotIndexToSourceId.set(slot.slotIndex, slot.sourceId);
+ }
return tabs.map((tab) => {
- if (newDefId in tab.dimensionMapping || tab.label == null) {
+ if (tab.label == null) {
return tab;
}
- const activeMappings = objectFromEntries(
- getObjectEntries(tab.dimensionMapping).filter(
- (entry): entry is [MetricSourceId, string] => entry[1] != null,
- ),
- );
+ // Collect unmapped slots grouped by sourceId.
+ const unmappedBySource = new Map<
+ MetricSourceId,
+ { slotIndices: number[]; definition: MetricDefinition }
+ >();
+
+ for (const slot of slots) {
+ const existing = tab.dimensionMapping[slot.slotIndex];
+ if (existing !== undefined) {
+ continue; // already mapped (even if null — that's an explicit clear)
+ }
+ const defEntry = definitions[slot.sourceId];
+ if (!defEntry?.definition) {
+ continue; // definition not loaded yet
+ }
+ let group = unmappedBySource.get(slot.sourceId);
+ if (!group) {
+ group = { slotIndices: [], definition: defEntry.definition };
+ unmappedBySource.set(slot.sourceId, group);
+ }
+ group.slotIndices.push(slot.slotIndex);
+ }
+
+ if (unmappedBySource.size === 0) {
+ return tab;
+ }
+
+ // Build stored-tab representation for matching.
+ const activeMappings: Record<number, string> = {};
+ for (const [key, value] of getObjectEntries(tab.dimensionMapping)) {
+ if (value != null) {
+ activeMappings[Number(key)] = value;
+ }
+ }
const storedTab: StoredMetricsViewerTab = {
id: tab.id,
type: tab.type,
label: tab.label,
- dimensionsBySource: activeMappings,
+ dimensionBySlotIndex: activeMappings,
};
- const matchingDimension = findMatchingDimensionForTab(
- newDef,
- storedTab,
- existingDefinitions,
- );
-
- if (matchingDimension) {
- return {
- ...tab,
- dimensionMapping: {
- ...tab.dimensionMapping,
- [newDefId]: matchingDimension,
- },
- };
+ let newMappings: Record<number, string> | null = null;
+
+ for (const [sourceId, { slotIndices, definition }] of unmappedBySource) {
+ const existingDefinitions = objectFromEntries(
+ Object.values(definitions)
+ .filter((entry) => entry.id !== sourceId && entry.definition != null)
+ .map((entry) => [entry.id, entry.definition] as const),
+ );
+
+ const matchingDimension = findMatchingDimensionForTab(
+ definition,
+ storedTab,
+ existingDefinitions,
+ slotIndexToSourceId,
+ );
+
+ if (matchingDimension) {
+ if (!newMappings) {
+ newMappings = {};
+ }
+ for (const idx of slotIndices) {
+ newMappings[idx] = matchingDimension;
+ }
+ }
}
- return tab;
+ if (!newMappings) {
+ return tab;
+ }
+
+ return {
+ ...tab,
+ dimensionMapping: {
+ ...tab.dimensionMapping,
+ ...newMappings,
+ },
+ };
});
}
+function areTabDimensionsValid(tab: MetricsViewerTabState): boolean {
+ const tabConfig = getTabConfig(tab.type);
+ return (
+ Object.values(tab.dimensionMapping).filter(isNotNull).length >=
+ tabConfig.minDimensions
+ );
+}
+
export interface UseViewerStateResult {
state: MetricsViewerPageState;
loadingIds: Set<MetricSourceId>;
+ initialLoadComplete: boolean;
+ setInitialLoadComplete: (initialLoadComplete: boolean) => void;
removeDefinition: (id: MetricSourceId) => void;
updateDefinition: (id: MetricSourceId, definition: MetricDefinition) => void;
+ setFormulaEntities: (
+ entities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) => void;
selectTab: (tabId: string) => void;
addTab: (tab: MetricsViewerTabState) => void;
@@ -138,15 +222,12 @@ export interface UseViewerStateResult {
updateTab: (tabId: string, updates: Partial<MetricsViewerTabState>) => void;
setDefinitionDimension: (
tabId: string,
- definitionId: MetricSourceId,
+ slotIndex: number,
dimension: DimensionMetadata,
) => void;
- removeDefinitionDimension: (
- tabId: string,
- definitionId: MetricSourceId,
- ) => void;
+ removeDefinitionDimension: (tabId: string, slotIndex: number) => void;
setBreakoutDimension: (
- id: MetricSourceId,
+ entity: MetricDefinitionEntry,
dimension: ProjectionClause | undefined,
) => void;
@@ -182,33 +263,23 @@ export function useViewerState(): UseViewerStateResult {
const loadingRef = useRef<Set<MetricSourceId>>(new Set());
const [loadingIds, setLoadingIds] = useState<Set<MetricSourceId>>(new Set());
- const initialize = useCallback(
- (newState: MetricsViewerPageState) => setState(newState),
- [],
- );
+ const [initialLoadComplete, setInitialLoadComplete] = useState(false);
+
+ const initialize: (newState: MetricsViewerPageState) => void = setState;
const addDefinition = useCallback(
(entry: MetricsViewerDefinitionEntry) =>
setState((prev) => {
- if (prev.definitions.some((existing) => existing.id === entry.id)) {
+ if (entry.id in prev.definitions) {
return prev;
}
- const newDefinitions = [...prev.definitions, entry];
-
- if (prev.tabs.length === 0 || !entry.definition) {
- return { ...prev, definitions: newDefinitions };
- }
-
return {
...prev,
- definitions: newDefinitions,
- tabs: addDefinitionToTabs(
- prev.tabs,
- newDefinitions,
- entry.id,
- entry.definition,
- ),
+ definitions: {
+ ...prev.definitions,
+ [entry.id]: entry,
+ },
};
}),
[],
@@ -217,15 +288,36 @@ export function useViewerState(): UseViewerStateResult {
const removeDefinition = useCallback(
(id: MetricSourceId) =>
setState((prev) => {
- const newDefinitions = prev.definitions.filter(
- (entry) => entry.id !== id,
+ const { [id]: _, ...newDefinitions } = prev.definitions;
+
+ // Find slot indices being removed (slots for this sourceId)
+ const slots = computeMetricSlots(prev.formulaEntities);
+ const removedSlotIndices = new Set(
+ slots.filter((s) => s.sourceId === id).map((s) => s.slotIndex),
);
- const newTabs = prev.tabs
- .map((tab) => {
- const { [id]: _, ...rest } = tab.dimensionMapping;
- return { ...tab, dimensionMapping: rest };
- })
- .filter((tab) => Object.values(tab.dimensionMapping).some(isNotNull));
+
+ const newTabs =
+ // scalar tab is always valid, but we want to remove it if there are no definitions
+ // so that adding a new definition triggers computeDefaultTabs
+ Object.keys(newDefinitions).length === 0
+ ? []
+ : prev.tabs
+ .map((tab) => {
+ // Remove entries for removed slot indices.
+ // Don't shift — remapDimensionMappings handles that
+ // when formulaEntities are updated separately.
+ const newMapping: Record<number, string | null> = {};
+ for (const [key, value] of getObjectEntries(
+ tab.dimensionMapping,
+ )) {
+ const idx = Number(key);
+ if (!removedSlotIndices.has(idx)) {
+ newMapping[idx] = value;
+ }
+ }
+ return { ...tab, dimensionMapping: newMapping };
+ })
+ .filter((tab) => areTabDimensionsValid(tab));
return {
...prev,
@@ -240,24 +332,27 @@ export function useViewerState(): UseViewerStateResult {
const updateDefinition = useCallback(
(id: MetricSourceId, definition: MetricDefinition) =>
setState((prev) => {
- const newDefinitions = prev.definitions.map((entry) =>
- entry.id === id ? { ...entry, definition } : entry,
- );
+ const existing = prev.definitions[id];
+ if (!existing) {
+ return prev;
+ }
+
+ const newDefinitions = {
+ ...prev.definitions,
+ [id]: { ...existing, definition },
+ };
if (prev.tabs.length === 0) {
return { ...prev, definitions: newDefinitions };
}
- const updatedTabs = addDefinitionToTabs(
+ const updatedTabs = assignDimensionsForUnmappedSlots(
prev.tabs,
newDefinitions,
- id,
- definition,
+ prev.formulaEntities,
);
- const newTabs = updatedTabs.filter((tab) =>
- Object.values(tab.dimensionMapping).some(isNotNull),
- );
+ const newTabs = updatedTabs.filter((tab) => areTabDimensionsValid(tab));
return {
...prev,
@@ -272,23 +367,53 @@ export function useViewerState(): UseViewerStateResult {
const replaceDefinition = useCallback(
(oldId: MetricSourceId, newEntry: MetricsViewerDefinitionEntry) =>
setState((prev) => {
- const index = prev.definitions.findIndex((entry) => entry.id === oldId);
- if (index === -1) {
+ if (!(oldId in prev.definitions)) {
return prev;
}
- const newDefinitions = [...prev.definitions];
- newDefinitions[index] = newEntry;
+ // Check if any expression token still references the old sourceId.
+ // If so, keep the old definition so the expression remains valid.
+ const expressionStillReferencesOld = prev.formulaEntities.some(
+ (fe) =>
+ fe.type === "expression" &&
+ fe.tokens.some((t) => t.type === "metric" && t.sourceId === oldId),
+ );
+
+ const { [oldId]: _oldDef, ...rest } = prev.definitions;
+ const newDefinitions = expressionStillReferencesOld
+ ? { ...prev.definitions, [newEntry.id]: newEntry }
+ : { ...rest, [newEntry.id]: newEntry };
+
+ // Update formulaEntities: replace standalone metric refs with the new one
+ // (expression tokens keep referencing the old sourceId)
+ const newFormulaEntities = prev.formulaEntities.map((fe) => {
+ if (fe.type === "metric" && fe.id === oldId) {
+ return { ...newEntry, type: "metric" as const };
+ }
+ return fe;
+ });
+ // Find slot indices that were replaced
+ const slots = computeMetricSlots(prev.formulaEntities);
+ const replacedSlotIndices = new Set(
+ slots.filter((s) => s.sourceId === oldId).map((s) => s.slotIndex),
+ );
+
+ // Remove dimension mappings for replaced slot indices (new metric has different dimensions)
const newTabs = prev.tabs.map((tab) => {
- if (!(oldId in tab.dimensionMapping)) {
- return tab;
+ const newMapping = { ...tab.dimensionMapping };
+ for (const idx of replacedSlotIndices) {
+ delete newMapping[idx];
}
- const { [oldId]: _, ...rest } = tab.dimensionMapping;
- return { ...tab, dimensionMapping: rest };
+ return { ...tab, dimensionMapping: newMapping };
});
- return { ...prev, definitions: newDefinitions, tabs: newTabs };
+ return {
+ ...prev,
+ definitions: newDefinitions,
+ formulaEntities: newFormulaEntities,
+ tabs: newTabs,
+ };
}),
[],
);
@@ -304,9 +429,14 @@ export function useViewerState(): UseViewerStateResult {
if (prev.tabs.some((existing) => existing.id === tab.id)) {
return prev;
}
+ const newTabs = assignDimensionsForUnmappedSlots(
+ [...prev.tabs, tab],
+ prev.definitions,
+ prev.formulaEntities,
+ );
return {
...prev,
- tabs: [...prev.tabs, tab],
+ tabs: newTabs,
selectedTabId:
prev.selectedTabId == null ? tab.id : prev.selectedTabId,
};
@@ -343,15 +473,15 @@ export function useViewerState(): UseViewerStateResult {
);
const setDefinitionDimension = useCallback(
- (
- tabId: string,
- definitionId: MetricSourceId,
- dimension: DimensionMetadata,
- ) =>
+ (tabId: string, slotIndex: number, dimension: DimensionMetadata) =>
setState((prev) => {
- const entry = prev.definitions.find(
- (defEntry) => defEntry.id === definitionId,
- );
+ const slots = computeMetricSlots(prev.formulaEntities);
+ const slot = slots[slotIndex];
+ if (!slot) {
+ return prev;
+ }
+
+ const entry = prev.definitions[slot.sourceId];
const def = entry?.definition;
const dimId = def
? LibMetric.dimensionValuesInfo(def, dimension).id
@@ -367,20 +497,12 @@ export function useViewerState(): UseViewerStateResult {
if (tab.id !== tabId) {
return tab;
}
- const previousDimId = tab.dimensionMapping[definitionId];
- const dimensionChanged = previousDimId !== dimId;
return {
...tab,
dimensionMapping: {
...tab.dimensionMapping,
- [definitionId]: dimId,
+ [slotIndex]: dimId,
},
- projectionConfig: dimensionChanged
- ? {
- ...tab.projectionConfig,
- dimensionFilter: undefined,
- }
- : tab.projectionConfig,
};
}),
};
@@ -389,7 +511,7 @@ export function useViewerState(): UseViewerStateResult {
);
const removeDefinitionDimension = useCallback(
- (tabId: string, definitionId: MetricSourceId) =>
+ (tabId: string, slotIndex: number) =>
setState((prev) => ({
...prev,
tabs: prev.tabs.map((tab) => {
@@ -398,47 +520,102 @@ export function useViewerState(): UseViewerStateResult {
}
return {
...tab,
- dimensionMapping: { ...tab.dimensionMapping, [definitionId]: null },
- projectionConfig: {
- ...tab.projectionConfig,
- dimensionFilter: undefined,
- },
+ dimensionMapping: { ...tab.dimensionMapping, [slotIndex]: null },
};
}),
})),
[],
);
- const setBreakoutDimension = useCallback(
- (id: MetricSourceId, dimension: ProjectionClause | undefined) =>
- setState((prev) => ({
- ...prev,
- definitions: prev.definitions.map((entry) => {
- if (entry.id !== id || !entry.definition) {
- return entry;
+ const setFormulaEntities = useCallback(
+ (
+ formulaEntities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) =>
+ setState((prev) => {
+ // When a slotMapping is provided (from commitAndCollapse or
+ // handleRemoveItem), use it to remap dimension mappings efficiently.
+ // Otherwise the caller is not changing entity structure (paren cleanup,
+ // filter/breakout changes, URL restore) so tabs are kept as-is.
+ const reconciledTabs = slotMapping
+ ? remapDimensionMappings(prev.tabs, slotMapping, formulaEntities)
+ : prev.tabs;
+ let tabs = assignDimensionsForUnmappedSlots(
+ reconciledTabs,
+ prev.definitions,
+ formulaEntities,
+ );
+
+ // When tabs are empty (e.g. all metrics were removed then one was
+ // added back), generate default tabs now that formulaEntities includes
+ // the new metric and its definition may already be loaded.
+ if (tabs.length === 0) {
+ const metricSlots = computeMetricSlots(formulaEntities);
+ if (metricSlots.length > 0) {
+ const definitionsBySourceId: Record<
+ MetricSourceId,
+ MetricDefinition | null
+ > = {};
+ for (const [id, entry] of Object.entries(prev.definitions)) {
+ definitionsBySourceId[id as MetricSourceId] =
+ entry.definition ?? null;
+ }
+ tabs = computeDefaultTabs(definitionsBySourceId, metricSlots);
}
+ }
- let newDefinition = entry.definition;
- const existingProjections = LibMetric.projections(newDefinition);
+ return {
+ ...prev,
+ formulaEntities,
+ tabs,
+ };
+ }),
+ [],
+ );
+
+ const setBreakoutDimension = useCallback(
+ (entity: MetricDefinitionEntry, dimension: ProjectionClause | undefined) =>
+ setState((prev) => {
+ const defEntry = getEffectiveDefinitionEntry(entity, prev.definitions);
+ if (!defEntry?.definition) {
+ return prev;
+ }
+
+ const entityIndex = prev.formulaEntities.indexOf(entity);
+ if (entityIndex === -1) {
+ return prev;
+ }
+
+ let newDefinition: MetricDefinition | null = null;
+
+ if (dimension) {
+ let baseDef = defEntry.definition;
+ const existingProjections = LibMetric.projections(baseDef);
for (const proj of existingProjections) {
- newDefinition = LibMetric.removeClause(newDefinition, proj);
+ baseDef = LibMetric.removeClause(baseDef, proj);
}
+ newDefinition = buildBinnedBreakoutDefinition(baseDef, dimension);
+ }
- if (dimension) {
- newDefinition = buildBinnedBreakoutDefinition(
- newDefinition,
- dimension,
- );
- }
+ const newEntities = [...prev.formulaEntities];
+ newEntities[entityIndex] = {
+ ...entity,
+ definition: newDefinition,
+ };
- return { ...entry, definition: newDefinition };
- }),
- })),
+ return {
+ ...prev,
+ formulaEntities: newEntities,
+ };
+ }),
[],
);
const clearLoading = useCallback((id: MetricSourceId) => {
loadingRef.current.delete(id);
+ if (loadingRef.current.size === 0) {
+ setInitialLoadComplete(true);
+ }
setLoadingIds((prev) => {
const next = new Set(prev);
next.delete(id);
@@ -467,25 +644,33 @@ export function useViewerState(): UseViewerStateResult {
// but the temporarily incorrect ordering breaks our handling of the browser's forward/back buttons
// so wrap updateDefinition in a setTimeout to ensure it runs after addDefinition
setTimeout(() => {
- const definition = transform
- ? transform(rawDefinition)
- : rawDefinition;
- updateDefinition(id, definition);
-
- if (stateRef.current.tabs.length === 0) {
- const definitions: Record<MetricSourceId, MetricDefinition | null> =
- {
+ try {
+ const definition = transform
+ ? transform(rawDefinition)
+ : rawDefinition;
+ updateDefinition(id, definition);
+
+ if (stateRef.current.tabs.length === 0) {
+ const definitions: Record<
+ MetricSourceId,
+ MetricDefinition | null
+ > = {
[id]: definition,
};
- const tabs = computeDefaultTabs(definitions, [id]);
- for (const tab of tabs) {
- addTab(tab);
+ const metricSlots = computeMetricSlots(
+ stateRef.current.formulaEntities,
+ );
+ const tabs = computeDefaultTabs(definitions, metricSlots);
+ for (const tab of tabs) {
+ addTab(tab);
+ }
}
+ } finally {
+ clearLoading(id);
}
}, 0);
} catch {
removeDefinition(id);
- } finally {
clearLoading(id);
}
},
@@ -504,17 +689,23 @@ export function useViewerState(): UseViewerStateResult {
loadingRef.current.add(newId);
setLoadingIds((prev) => new Set(prev).add(newId));
- replaceDefinition(oldSourceId, { id: newId, definition: null });
+ replaceDefinition(oldSourceId, {
+ id: newId,
+ definition: null,
+ });
try {
const definition = await loader();
// see comment above setTimeout in loadDefinition
setTimeout(() => {
- updateDefinition(newId, definition);
+ try {
+ updateDefinition(newId, definition);
+ } finally {
+ clearLoading(newId);
+ }
}, 0);
} catch {
removeDefinition(newId);
- } finally {
clearLoading(newId);
}
},
@@ -563,12 +754,70 @@ export function useViewerState(): UseViewerStateResult {
[loadAndReplace, dispatch, store],
);
+ // as definitions load, apply SerializedDefinitionInfo to formulaEntities
+ useEffect(() => {
+ let changed = false;
+ const updatedEntities = state.formulaEntities.map((entity) => {
+ if (
+ isMetricEntry(entity) &&
+ entity.serializedDefinitionInfo &&
+ !entity.definition
+ ) {
+ const baseDef = state.definitions[entity.id]?.definition;
+ if (baseDef) {
+ changed = true;
+ return {
+ ...entity,
+ definition: applySerializedDefinitionInfo(
+ baseDef,
+ entity.serializedDefinitionInfo,
+ ),
+ serializedDefinitionInfo: undefined,
+ };
+ }
+ }
+ if (isExpressionEntry(entity)) {
+ let tokenChanged = false;
+ const updatedTokens = entity.tokens.map((token) => {
+ if (
+ token.type === "metric" &&
+ token.serializedDefinitionInfo &&
+ !token.definition
+ ) {
+ const baseDef = state.definitions[token.sourceId]?.definition;
+ if (baseDef) {
+ tokenChanged = true;
+ changed = true;
+ return {
+ ...token,
+ definition: applySerializedDefinitionInfo(
+ baseDef,
+ token.serializedDefinitionInfo,
+ ),
+ serializedDefinitionInfo: undefined,
+ };
+ }
+ }
+ return token;
+ });
+ return tokenChanged ? { ...entity, tokens: updatedTokens } : entity;
+ }
+ return entity;
+ });
+ if (changed) {
+ setFormulaEntities(updatedEntities);
+ }
+ }, [state.definitions, state.formulaEntities, setFormulaEntities]);
+
return {
state,
loadingIds,
+ initialLoadComplete,
+ setInitialLoadComplete,
removeDefinition,
updateDefinition,
+ setFormulaEntities,
selectTab,
addTab,
diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts
index 0bd707577fe..96c33ec306c 100644
--- a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts
+++ b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-url.ts
@@ -1,38 +1,34 @@
import type { Location } from "history";
import { useEffect, useRef } from "react";
import { push, replace } from "react-router-redux";
+import { t } from "ttag";
+import { useToast } from "metabase/common/hooks";
import { useDispatch } from "metabase/utils/redux";
import * as Urls from "metabase/utils/urls";
-import type { MeasureId, TemporalUnit } from "metabase-types/api";
+import type { MeasureId } from "metabase-types/api";
import type { MetricId } from "metabase-types/api/metric";
-import type {
- MetricSourceId,
- MetricsViewerPageState,
- MetricsViewerTabState,
+import {
+ type MetricsViewerFormulaEntity,
+ type MetricsViewerPageState,
+ type MetricsViewerTabState,
+ isExpressionEntry,
+ isMetricEntry,
} from "../types/viewer-state";
-import type { SourceFilter } from "../utils/dimension-filters";
-import { createSourceId } from "../utils/source-ids";
+import { parseSourceId } from "../utils/source-ids";
import {
type SerializedMetricsViewerPageState,
decodeState,
+ deserializeFormulaEntities,
deserializeTab,
encodeState,
stateToSerializedState,
} from "../utils/url-serialization";
-export interface BreakoutInfo {
- dimensionId: string;
- temporalUnit?: TemporalUnit;
- binning?: string;
-}
-
export interface LoadSourcesRequest {
metricIds: MetricId[];
measureIds: MeasureId[];
- breakoutBySourceId?: Record<MetricSourceId, BreakoutInfo>;
- filtersBySourceId?: Record<MetricSourceId, SourceFilter[]>;
}
export function useViewerUrl(
@@ -40,96 +36,142 @@ export function useViewerUrl(
initialize: (state: MetricsViewerPageState) => void,
onLoadSources: (request: LoadSourcesRequest) => void,
location: Location,
+ setFormulaEntities: (
+ entities: MetricsViewerFormulaEntity[],
+ slotMapping?: Map<number, number>,
+ ) => void,
+ setInitialLoadComplete: (initialLoadComplete: boolean) => void,
): void {
const dispatch = useDispatch();
+ const [sendToast] = useToast();
const lastHashRef = useRef<string | null>(null);
// sync URL to state
useEffect(() => {
- let hash = location.hash.slice(1);
- let serializedState: SerializedMetricsViewerPageState;
-
- if (!hash) {
- const params = new URLSearchParams(location.search);
- const metricId = params.get("metricId");
- if (metricId) {
- serializedState = {
- sources: [{ type: "metric", id: parseInt(metricId, 10) }],
- tabs: [],
- selectedTabId: null,
- };
- const encodedHash = encodeState(serializedState);
- if (encodedHash === undefined) {
- return;
+ try {
+ let hash = location.hash.slice(1);
+ let serializedState: SerializedMetricsViewerPageState;
+
+ if (!hash) {
+ const params = new URLSearchParams(location.search);
+ const metricId = params.get("metricId");
+ if (metricId) {
+ serializedState = {
+ formulaEntities: [{ type: "metric", id: parseInt(metricId, 10) }],
+ tabs: [],
+ selectedTabId: null,
+ };
+ const encodedHash = encodeState(serializedState);
+ if (encodedHash === undefined) {
+ setInitialLoadComplete(true);
+ return;
+ }
+ hash = encodedHash;
+ } else {
+ serializedState = decodeState(hash);
}
- hash = encodedHash;
} else {
serializedState = decodeState(hash);
}
- } else {
- serializedState = decodeState(hash);
- }
- if (hash === lastHashRef.current) {
- return;
- }
- lastHashRef.current = hash;
-
- const metricIds: MetricId[] = [];
- const measureIds: MeasureId[] = [];
- const breakoutBySourceId: Record<MetricSourceId, BreakoutInfo> = {};
- const filtersBySourceId: Record<MetricSourceId, SourceFilter[]> = {};
-
- for (const source of serializedState.sources) {
- const sourceId = createSourceId(source.id, source.type);
-
- if (source.type === "metric") {
- metricIds.push(source.id);
- } else if (source.type === "measure") {
- measureIds.push(source.id);
+ if (hash === lastHashRef.current) {
+ setInitialLoadComplete(true);
+ return;
}
+ lastHashRef.current = hash;
- if (source.breakout) {
- breakoutBySourceId[sourceId] = {
- dimensionId: source.breakout,
- temporalUnit: source.breakoutTemporalUnit,
- binning: source.breakoutBinning,
- };
- }
+ if (serializedState.tabs.length > 0) {
+ const tabs: MetricsViewerTabState[] =
+ serializedState.tabs.map(deserializeTab);
- if (source.filters && source.filters.length > 0) {
- filtersBySourceId[sourceId] = source.filters;
+ initialize({
+ definitions: {},
+ formulaEntities: [],
+ tabs,
+ selectedTabId: serializedState.selectedTabId,
+ });
}
- }
- if (serializedState.tabs.length > 0) {
- const tabs: MetricsViewerTabState[] =
- serializedState.tabs.map(deserializeTab);
+ const metricIds: MetricId[] = [];
+ const measureIds: MeasureId[] = [];
+
+ const restoredFormulaEntities =
+ deserializeFormulaEntities(serializedState);
- initialize({
- definitions: [],
- tabs,
- selectedTabId: serializedState.selectedTabId,
+ restoredFormulaEntities.forEach((entity) => {
+ if (isMetricEntry(entity)) {
+ const { type, id } = parseSourceId(entity.id);
+ if (type === "metric") {
+ metricIds.push(id);
+ } else if (type === "measure") {
+ measureIds.push(id);
+ }
+ }
+ if (isExpressionEntry(entity)) {
+ entity.tokens.forEach((token) => {
+ if (token.type === "metric") {
+ const { type, id } = parseSourceId(token.sourceId);
+ if (type === "metric") {
+ metricIds.push(id);
+ } else if (type === "measure") {
+ measureIds.push(id);
+ }
+ }
+ });
+ }
});
- }
- if (metricIds.length > 0 || measureIds.length > 0) {
- const hasBreakouts = Object.keys(breakoutBySourceId).length > 0;
- const hasFilters = Object.keys(filtersBySourceId).length > 0;
- onLoadSources({
- metricIds,
- measureIds,
- breakoutBySourceId: hasBreakouts ? breakoutBySourceId : undefined,
- filtersBySourceId: hasFilters ? filtersBySourceId : undefined,
+ if (metricIds.length > 0 || measureIds.length > 0) {
+ onLoadSources({
+ metricIds,
+ measureIds,
+ });
+ } else {
+ setInitialLoadComplete(true);
+ }
+
+ if (restoredFormulaEntities.length > 0) {
+ setFormulaEntities(restoredFormulaEntities);
+ }
+ } catch (error) {
+ console.error(error);
+ setInitialLoadComplete(true);
+ sendToast({
+ icon: "warning_triangle_filled",
+ iconColor: "warning",
+ message: t`There was a problem restoring the page state`,
});
}
- }, [location, dispatch, initialize, onLoadSources]);
+ }, [
+ location,
+ dispatch,
+ initialize,
+ onLoadSources,
+ setFormulaEntities,
+ setInitialLoadComplete,
+ sendToast,
+ ]);
// sync state to URL
useEffect(() => {
+ // don't update URL until state is fully resolved
+ // definitions are loaded and there are no outstanding SerializedDefinitionInfos
+ const definitionValues = Object.values(state.definitions);
+ const hasPendingSerializedInfo = state.formulaEntities.some((entity) => {
+ if (isMetricEntry(entity) && entity.serializedDefinitionInfo) {
+ return true;
+ }
+ if (isExpressionEntry(entity)) {
+ return entity.tokens.some(
+ (token) => token.type === "metric" && token.serializedDefinitionInfo,
+ );
+ }
+ return false;
+ });
if (
- state.definitions.length === 0 ||
- state.definitions.some((entry) => entry.definition === null)
+ definitionValues.length === 0 ||
+ definitionValues.some((entry) => entry.definition === null) ||
+ hasPendingSerializedInfo
) {
return;
}
diff --git a/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx b/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx
index 27bc9a64c9f..badb6caa4ab 100644
--- a/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx
+++ b/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx
@@ -1,7 +1,8 @@
import type { Location } from "history";
import { useCallback } from "react";
-import { Box, Flex, Stack } from "metabase/ui";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Box, Center, Flex, Stack } from "metabase/ui";
import {
trackMetricsViewerMetricAdded,
@@ -27,22 +28,27 @@ export type MetricsViewerPageProps = {
};
export function MetricsViewerPage(props: MetricsViewerPageProps) {
+ const useMetricsViewerResult = useMetricsViewer(props);
+
const {
definitions,
+ formulaEntities,
tabs,
activeTab,
activeTabId,
- errorsByDefinitionId,
- modifiedDefinitions,
+ initialLoadComplete,
+ queriesAreLoading,
+ queriesError,
+ modifiedDefinitionsBySlotIndex,
+ metricSlots,
series,
- cardIdToDefinitionId,
+ cardIdToEntityIndex,
activeBreakoutColors,
sourceColors,
selectedMetrics,
sourceOrder,
sourceDataById,
availableDimensions,
- isExecuting,
addMetric,
swapMetric,
removeMetric,
@@ -52,9 +58,9 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {
updateActiveTab,
changeTabDimension,
removeTabDimension,
- updateDefinition,
setBreakoutDimension,
- } = useMetricsViewer(props);
+ setFormulaEntities,
+ } = useMetricsViewerResult;
const handleAddMetric = useCallback(
(metric: SelectedMetric) => {
@@ -72,29 +78,39 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {
[removeMetric],
);
- const hasDefinitions = definitions.length > 0;
- const hasLoadedDefinitions = definitions.some(
+ if (!initialLoadComplete) {
+ // parsing formulas won't work until the initial set of definitions are loaded
+ return (
+ <Center h="100%">
+ <LoadingAndErrorWrapper loading />
+ </Center>
+ );
+ }
+
+ const hasDefinitions = Object.keys(definitions).length > 0;
+ const hasLoadedDefinitions = Object.values(definitions).some(
(entry) => entry.definition != null,
);
return (
<Stack h="100%" gap={0} className={S.root}>
- <Box px="lg" pt="md" flex="0 0 auto">
+ <Box px="xl" pt="md" flex="0 0 auto">
<MetricSearchPanel
+ definitions={definitions}
+ formulaEntities={formulaEntities}
+ onFormulaEntitiesChange={setFormulaEntities}
selectedMetrics={selectedMetrics}
metricColors={sourceColors}
- definitions={definitions}
onAddMetric={handleAddMetric}
onRemoveMetric={handleRemoveMetric}
onSwapMetric={swapMetric}
onSetBreakout={setBreakoutDimension}
- onUpdateDefinition={updateDefinition}
/>
</Box>
<Flex flex="1 1 auto" mih={0}>
<Stack gap={0} flex={1} mih={0} miw={0}>
{hasDefinitions && (
- <Box px="lg" pt="xs" flex="0 0 auto" className={S.tabsBar}>
+ <Box px="lg" pt="sm" flex="0 0 auto" className={S.tabsBar}>
<MetricsViewerTabs
tabs={tabs}
activeTabId={activeTabId}
@@ -123,19 +139,23 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {
) : activeTab ? (
<MetricsViewerTabContent
definitions={definitions}
+ formulaEntities={formulaEntities}
tab={activeTab}
- errorsByDefinitionId={errorsByDefinitionId}
- modifiedDefinitions={modifiedDefinitions}
+ queriesAreLoading={queriesAreLoading}
+ queriesError={queriesError}
+ modifiedDefinitionsBySlotIndex={
+ modifiedDefinitionsBySlotIndex
+ }
+ metricSlots={metricSlots}
series={series}
- cardIdToDefinitionId={cardIdToDefinitionId}
+ cardIdToEntityIndex={cardIdToEntityIndex}
sourceColors={sourceColors}
- isExecuting={isExecuting}
onTabUpdate={updateActiveTab}
- onDimensionChange={(defId, dim) =>
- changeTabDimension(activeTab.id, defId, dim)
+ onDimensionChange={(slotIndex, dim) =>
+ changeTabDimension(activeTab.id, slotIndex, dim)
}
- onDimensionRemove={(defId) =>
- removeTabDimension(activeTab.id, defId)
+ onDimensionRemove={(slotIndex) =>
+ removeTabDimension(activeTab.id, slotIndex)
}
/>
) : hasLoadedDefinitions ? (
@@ -143,6 +163,7 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {
) : null}
</Flex>
<BreakoutLegend
+ formulaEntities={formulaEntities}
definitions={definitions}
activeBreakoutColors={activeBreakoutColors}
/>
diff --git a/frontend/src/metabase/metrics-viewer/types/viewer-state.ts b/frontend/src/metabase/metrics-viewer/types/viewer-state.ts
index 879c3d23bb4..6bb1a8041fb 100644
--- a/frontend/src/metabase/metrics-viewer/types/viewer-state.ts
+++ b/frontend/src/metabase/metrics-viewer/types/viewer-state.ts
@@ -4,30 +4,54 @@ import type {
CardDisplayType,
ConcreteTableId,
DimensionId,
+ MathOperator,
TemporalUnit,
VisualizationSettings,
} from "metabase-types/api";
import type { DimensionFilterValue } from "../utils/dimension-filters";
+import type { SerializedDefinitionInfo } from "../utils/url-serialization";
// ── Core types ──
export type MetricsViewerDisplayType = Extract<
CardDisplayType,
- "line" | "area" | "bar" | "map" | "row" | "pie" | "scatter"
+ "line" | "area" | "bar" | "map" | "scatter" | "scalar"
>;
export type MetricSourceId = `metric:${number}` | `measure:${number}`;
+export type MetricExpressionId = `expression:${string}`;
-export type MetricsViewerTabType = DimensionType;
+export type MetricsViewerTabType = DimensionType | "scalar";
export interface StoredMetricsViewerTab {
id: string;
type: MetricsViewerTabType;
label: string;
- dimensionsBySource: Record<MetricSourceId, DimensionId>;
+ dimensionBySlotIndex: Record<number, DimensionId>;
}
+// ── Expression sub-tokens ──
+
+export type ExpressionMetricSubToken = {
+ type: "metric";
+ sourceId: MetricSourceId;
+ count: number;
+ definition?: MetricDefinition;
+ serializedDefinitionInfo?: SerializedDefinitionInfo;
+};
+
+/**
+ * Tokens that appear inside a single expression formula.
+ * These are the building blocks of an expression definition entry.
+ */
+export type ExpressionSubToken =
+ | ExpressionMetricSubToken
+ | { type: "constant"; value: number }
+ | { type: "operator"; op: MathOperator }
+ | { type: "open-paren" }
+ | { type: "close-paren" };
+
// ── Definition types ──
/**
@@ -45,6 +69,34 @@ export interface MetricsViewerDefinitionEntry {
definition: MetricDefinition | null;
}
+export type MetricDefinitionEntry = MetricsViewerDefinitionEntry & {
+ type: "metric";
+ serializedDefinitionInfo?: SerializedDefinitionInfo;
+};
+
+export type ExpressionDefinitionEntry = {
+ id: MetricExpressionId;
+ type: "expression";
+ name: string;
+ tokens: ExpressionSubToken[];
+};
+
+export type MetricsViewerFormulaEntity =
+ | MetricDefinitionEntry
+ | ExpressionDefinitionEntry;
+
+export function isMetricEntry(
+ entry: MetricsViewerFormulaEntity,
+): entry is MetricDefinitionEntry {
+ return entry.type === "metric";
+}
+
+export function isExpressionEntry(
+ entry: MetricsViewerFormulaEntity,
+): entry is ExpressionDefinitionEntry {
+ return entry.type === "expression";
+}
+
// ── Tab state ──
export interface MetricsViewerTabProjectionConfig {
@@ -59,21 +111,23 @@ export interface MetricsViewerTabState {
label: string | null;
display: MetricsViewerDisplayType;
visualizationSettings?: Partial<VisualizationSettings>;
- dimensionMapping: Record<MetricSourceId, DimensionId | null>;
+ dimensionMapping: Record<number, DimensionId | null>;
projectionConfig: MetricsViewerTabProjectionConfig;
}
// ── Page state ──
export interface MetricsViewerPageState {
- definitions: MetricsViewerDefinitionEntry[];
- tabs: MetricsViewerTabState[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>; // pristine definitions for unique metrics used in formula
+ formulaEntities: MetricsViewerFormulaEntity[]; // specific items used in formula, definitions there contains filters
+ tabs: MetricsViewerTabState[]; // visualization settings for a tab
selectedTabId: string | null;
}
export function getInitialMetricsViewerPageState(): MetricsViewerPageState {
return {
- definitions: [],
+ definitions: {},
+ formulaEntities: [],
tabs: [],
selectedTabId: null,
};
@@ -89,14 +143,15 @@ export type BreakoutColorMap = Map<string, string>;
/**
* Values are either BreakoutColorMap or a single color for non-breakout sources.
*/
-export type SourceBreakoutColorMap = Partial<
- Record<MetricSourceId, BreakoutColorMap | string>
+export type SourceBreakoutColorMap = Record<
+ number,
+ BreakoutColorMap | string | undefined
>;
/**
* For consumers that expect an array of colors and don't care about breakout values.
*/
-export type SourceColorMap = Partial<Record<MetricSourceId, string[]>>;
+export type SourceColorMap = Record<number, string[]>;
// ── Shared display types ──
diff --git a/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts b/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts
index ea66da5d000..07b1558f772 100644
--- a/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/MetricsViewerClickActionsMode.ts
@@ -8,49 +8,63 @@ import type {
import * as LibMetric from "metabase-lib/metric";
import type { CardId, DatetimeUnit, TemporalUnit } from "metabase-types/api";
-import type {
- MetricSourceId,
- MetricsViewerDefinitionEntry,
- MetricsViewerTabState,
+import {
+ type MetricDefinitionEntry,
+ type MetricSourceId,
+ type MetricsViewerDefinitionEntry,
+ type MetricsViewerFormulaEntity,
+ type MetricsViewerTabState,
+ isMetricEntry,
} from "../types/viewer-state";
+import { getEffectiveDefinitionEntry } from "./definition-entries";
import type { DimensionFilterValue } from "./dimension-filters";
import { findDimensionById } from "./dimension-lookup";
+import { type MetricSlot, findStandaloneSlot } from "./metric-slots";
type MetricsViewerClickActionParams = {
- definitions: MetricsViewerDefinitionEntry[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ formulaEntities: MetricsViewerFormulaEntity[];
+ metricSlots: MetricSlot[];
tab: MetricsViewerTabState;
onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;
- cardIdToDefinitionId: Record<CardId, MetricSourceId>;
+ cardIdToEntityIndex: Record<CardId, number>;
};
export class MetricsViewerClickActionsMode implements ClickActionsMode {
- private definitions: MetricsViewerDefinitionEntry[];
+ private definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ private formulaEntities: MetricsViewerFormulaEntity[];
+ private metricSlots: MetricSlot[];
private tab: MetricsViewerTabState;
private onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;
- private cardIdToDefinitionId: Record<CardId, MetricSourceId>;
+ private cardIdToEntityIndex: Record<CardId, number>;
constructor({
definitions,
+ formulaEntities,
+ metricSlots,
tab,
onTabUpdate,
- cardIdToDefinitionId,
+ cardIdToEntityIndex,
}: MetricsViewerClickActionParams) {
this.definitions = definitions;
+ this.formulaEntities = formulaEntities;
+ this.metricSlots = metricSlots;
this.tab = tab;
this.onTabUpdate = onTabUpdate;
- this.cardIdToDefinitionId = cardIdToDefinitionId;
+ this.cardIdToEntityIndex = cardIdToEntityIndex;
}
actionsForClick(clickObject: ClickObject): ClickAction[] {
const cardId = clickObject.cardId;
if (cardId == null) {
return [];
}
- const definition = this.definitions.find(
- (definition) => definition.id === this.cardIdToDefinitionId[cardId],
- );
+ const entityIndex = this.cardIdToEntityIndex[cardId];
+ const entity = this.formulaEntities[entityIndex];
const params = {
definitions: this.definitions,
- definition,
+ entity,
+ entityIndex,
+ metricSlots: this.metricSlots,
tab: this.tab,
onTabUpdate: this.onTabUpdate,
clickObject,
@@ -62,20 +76,25 @@ export class MetricsViewerClickActionsMode implements ClickActionsMode {
}
type GetActionParams = {
- definitions: MetricsViewerDefinitionEntry[];
- definition: MetricsViewerDefinitionEntry | undefined; //definition that was clicked on
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ entity: MetricsViewerFormulaEntity | undefined; //entity that was clicked on
+ entityIndex: number | undefined;
+ metricSlots: MetricSlot[];
tab: MetricsViewerTabState;
onTabUpdate: (updates: Partial<MetricsViewerTabState>) => void;
clickObject: ClickObject;
};
function getZoomInTimeSeriesAction({
- definition,
+ definitions,
+ entity,
+ entityIndex,
+ metricSlots,
tab,
onTabUpdate,
clickObject,
}: GetActionParams): ClickAction | undefined {
- if (!definition || !definition.definition) {
+ if (!entity || entityIndex == null || !isMetricEntry(entity)) {
return;
}
const dimension = clickObject.dimensions?.[0];
@@ -87,7 +106,10 @@ function getZoomInTimeSeriesAction({
return;
}
const nextTemporalUnit = getNextTemporalUnit(
- definition,
+ definitions,
+ entity,
+ entityIndex,
+ metricSlots,
tab,
currentTemporalUnit,
);
@@ -163,12 +185,22 @@ const nextTemporalUnitMap: Partial<Record<TemporalUnit, TemporalUnit>> = {
};
function getNextTemporalUnit(
- entry: MetricsViewerDefinitionEntry,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ entity: MetricDefinitionEntry,
+ entityIndex: number,
+ metricSlots: MetricSlot[],
tab: MetricsViewerTabState,
currentUnit: TemporalUnit,
): TemporalUnit | undefined {
- const definition = entry.definition;
- const dimensionId = tab.dimensionMapping[entry.id];
+ const definition = getEffectiveDefinitionEntry(
+ entity,
+ definitions,
+ )?.definition;
+ const slot = findStandaloneSlot(metricSlots, entityIndex);
+ if (!slot) {
+ return undefined;
+ }
+ const dimensionId = tab.dimensionMapping[slot.slotIndex];
if (!definition || !dimensionId) {
return undefined;
}
diff --git a/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts b/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts
index 6ef73199dab..e10d3ab5fed 100644
--- a/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/definition-entries.ts
@@ -1,6 +1,11 @@
import * as LibMetric from "metabase-lib/metric";
-import type { MetricsViewerDefinitionEntry } from "../types/viewer-state";
+import type {
+ ExpressionMetricSubToken,
+ MetricDefinitionEntry,
+ MetricSourceId,
+ MetricsViewerDefinitionEntry,
+} from "../types/viewer-state";
export function getEntryBreakout(
entry: MetricsViewerDefinitionEntry,
@@ -15,3 +20,41 @@ export function getEntryBreakout(
export function entryHasBreakout(entry: MetricsViewerDefinitionEntry): boolean {
return getEntryBreakout(entry) !== undefined;
}
+
+/**
+ * Returns a definition entry with the "effective" definition for a formula entity.
+ * If the entity has a per-instance definition (e.g. with breakout applied), uses that.
+ * Otherwise falls back to the pristine definition from the shared definitions map.
+ */
+export function getEffectiveDefinitionEntry(
+ entity: MetricDefinitionEntry,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+): MetricDefinitionEntry {
+ return {
+ ...entity,
+ definition: entity.definition ?? definitions[entity.id]?.definition ?? null,
+ };
+}
+
+export function getEffectiveTokenDefinitionEntry(
+ token: ExpressionMetricSubToken,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+): MetricsViewerDefinitionEntry {
+ return {
+ id: token.sourceId,
+ definition:
+ token.definition ?? definitions[token.sourceId]?.definition ?? null,
+ };
+}
+
+/**
+ * Narrows a definition entry to one that has a non-null definition.
+ * Useful for filtering arrays/maps of entries to only those with loaded definitions.
+ */
+export function isLoadedEntry(
+ entry: MetricsViewerDefinitionEntry,
+): entry is MetricsViewerDefinitionEntry & {
+ definition: NonNullable<MetricsViewerDefinitionEntry["definition"]>;
+} {
+ return entry.definition != null;
+}
diff --git a/frontend/src/metabase/metrics-viewer/utils/definition-sources.ts b/frontend/src/metabase/metrics-viewer/utils/definition-sources.ts
new file mode 100644
index 00000000000..357e68000e1
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/definition-sources.ts
@@ -0,0 +1,126 @@
+import { t } from "ttag";
+
+import type { MetricDefinition } from "metabase-lib/metric";
+import * as LibMetric from "metabase-lib/metric";
+
+import {
+ type ExpressionMetricSubToken,
+ type MetricSourceId,
+ type MetricsViewerDefinitionEntry,
+ type MetricsViewerFormulaEntity,
+ isExpressionEntry,
+ isMetricEntry,
+} from "../types/viewer-state";
+
+import {
+ getEffectiveDefinitionEntry,
+ getEffectiveTokenDefinitionEntry,
+} from "./definition-entries";
+
+export type DefinitionSource = {
+ index: number;
+ id: MetricSourceId;
+ definition: MetricDefinition;
+ entity: MetricsViewerFormulaEntity;
+ entityIndex: number;
+ token?: ExpressionMetricSubToken;
+};
+
+export function getDefinitionSources(
+ formulaEntities: MetricsViewerFormulaEntity[],
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+): DefinitionSource[] {
+ type MaybeDefinitionSource = Omit<
+ DefinitionSource,
+ "definition" | "index"
+ > & {
+ definition: DefinitionSource["definition"] | null;
+ };
+ const maybeDefinitionSources = formulaEntities.flatMap<MaybeDefinitionSource>(
+ (entity, index) => {
+ if (isMetricEntry(entity)) {
+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);
+ return [
+ {
+ id: entity.id,
+ definition: effectiveEntry.definition,
+ entity,
+ entityIndex: index,
+ },
+ ];
+ }
+ if (isExpressionEntry(entity)) {
+ return entity.tokens
+ .filter((token) => token.type === "metric")
+ .map((token) => {
+ const effectiveEntry = getEffectiveTokenDefinitionEntry(
+ token,
+ definitions,
+ );
+ return {
+ id: token.sourceId,
+ definition: effectiveEntry.definition,
+ entity,
+ entityIndex: index,
+ token,
+ };
+ });
+ }
+ return [];
+ },
+ );
+ // Assign stable indices before filtering so they don't shift as definitions
+ // load asynchronously (formulaEntities are stable while the popover is open).
+ return maybeDefinitionSources
+ .map((source, index) => ({ ...source, index }))
+ .filter((source): source is DefinitionSource => source.definition != null);
+}
+
+/**
+ * Produces an updated formulaEntities array with a new definition applied
+ * to the entity/token identified by the given DefinitionSource.
+ */
+export function applyDefinitionToFormulaEntities(
+ formulaEntities: MetricsViewerFormulaEntity[],
+ source: DefinitionSource,
+ newDefinition: MetricDefinition,
+): MetricsViewerFormulaEntity[] {
+ return formulaEntities.map((entity, index) => {
+ if (index !== source.entityIndex) {
+ return entity;
+ }
+ if (isMetricEntry(entity)) {
+ return { ...entity, definition: newDefinition };
+ }
+ if (isExpressionEntry(entity)) {
+ return {
+ ...entity,
+ tokens: entity.tokens.map((token) =>
+ token === source.token
+ ? { ...token, definition: newDefinition }
+ : token,
+ ),
+ };
+ }
+ return entity;
+ });
+}
+
+export function getDefinitionSourceName(source: DefinitionSource): string {
+ const metric = LibMetric.sourceMetricOrMeasureMetadata(source.definition);
+ if (metric) {
+ const metricInfo = LibMetric.displayInfo(source.definition, metric);
+ return metricInfo.displayName;
+ }
+ return t`Unknown`;
+}
+
+export function getDefinitionSourceIcon(
+ source: DefinitionSource,
+): "metric" | "ruler" | undefined {
+ if (isMetricEntry(source.entity)) {
+ const metricId = LibMetric.sourceMetricId(source.definition);
+ return metricId != null ? "metric" : "ruler";
+ }
+ return undefined;
+}
diff --git a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts
index eb27761e05f..664355dc8a9 100644
--- a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.ts
@@ -13,6 +13,7 @@ import type {
MetricsViewerTabType,
} from "../types/viewer-state";
+import type { MetricSlot } from "./metric-slots";
import { type TabInfo, getDimensionIcon, getDimensionsByType } from "./tabs";
// ── Dimension picker ──
@@ -36,17 +37,18 @@ interface DimensionEntry {
tabType: MetricsViewerTabType;
group?: DimensionGroup;
sourceId: MetricSourceId;
+ slotIndex: number;
}
function collectAllDimensionEntries(
- sourceOrder: MetricSourceId[],
+ metricSlots: MetricSlot[],
definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,
existingTabDimensionIds: Set<string>,
): DimensionEntry[] {
const entries: DimensionEntry[] = [];
- for (const sourceId of sourceOrder) {
- const def = definitionsBySourceId[sourceId];
+ for (const slot of metricSlots) {
+ const def = definitionsBySourceId[slot.sourceId];
if (!def) {
continue;
}
@@ -63,7 +65,8 @@ function collectAllDimensionEntries(
icon: getDimensionIcon(info.dimensionMetadata),
tabType: info.dimensionType,
group: info.group,
- sourceId,
+ sourceId: slot.sourceId,
+ slotIndex: slot.slotIndex,
});
}
}
@@ -92,17 +95,17 @@ function groupBySource(entries: DimensionEntry[]): DimensionEntry[][] {
export function getAvailableDimensionsForPicker(
definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,
- sourceOrder: MetricSourceId[],
+ metricSlots: MetricSlot[],
existingTabDimensionIds: Set<string>,
): AvailableDimensionsResult {
const result: AvailableDimensionsResult = { shared: [], bySource: {} };
- if (sourceOrder.length === 0) {
+ if (metricSlots.length === 0) {
return result;
}
const entries = collectAllDimensionEntries(
- sourceOrder,
+ metricSlots,
definitionsBySourceId,
existingTabDimensionIds,
);
@@ -123,7 +126,7 @@ export function getAvailableDimensionsForPicker(
type: first.tabType,
label: first.label,
dimensionMapping: Object.fromEntries(
- group.map((entry) => [entry.sourceId, entry.id]),
+ group.map((entry) => [entry.slotIndex, entry.id]),
),
},
});
@@ -136,7 +139,7 @@ export function getAvailableDimensionsForPicker(
tabInfo: {
type: entry.tabType,
label: entry.label,
- dimensionMapping: { [entry.sourceId]: entry.id },
+ dimensionMapping: { [entry.slotIndex]: entry.id },
},
});
}
@@ -146,8 +149,8 @@ export function getAvailableDimensionsForPicker(
result.shared.sort((first, second) =>
first.tabInfo.label.localeCompare(second.tabInfo.label),
);
- for (const sourceId of sourceOrder) {
- result.bySource[sourceId]?.sort((first, second) =>
+ for (const slot of metricSlots) {
+ result.bySource[slot.sourceId]?.sort((first, second) =>
first.tabInfo.label.localeCompare(second.tabInfo.label),
);
}
diff --git a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts
index 48bf268a400..08adf01cc55 100644
--- a/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/dimension-picker.unit.spec.ts
@@ -42,7 +42,7 @@ const REVENUE_DIMENSIONS = [
tabInfo: {
type: "numeric",
label: "Amount",
- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-amount" },
+ dimensionMapping: { 0: "dim-amount" },
},
},
{
@@ -51,7 +51,7 @@ const REVENUE_DIMENSIONS = [
tabInfo: {
type: "category",
label: "Category",
- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-category" },
+ dimensionMapping: { 0: "dim-category" },
},
},
{
@@ -60,7 +60,7 @@ const REVENUE_DIMENSIONS = [
tabInfo: {
type: "time",
label: "Created At",
- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-created-at" },
+ dimensionMapping: { 0: "dim-created-at" },
},
},
{
@@ -69,7 +69,7 @@ const REVENUE_DIMENSIONS = [
tabInfo: {
type: "boolean",
label: "Is Active",
- dimensionMapping: { [REVENUE_SOURCE_ID]: "dim-active" },
+ dimensionMapping: { 0: "dim-active" },
},
},
];
@@ -81,7 +81,7 @@ const ORDERS_DIMENSIONS = [
tabInfo: {
type: "time",
label: "Created At",
- dimensionMapping: { [ORDERS_SOURCE_ID]: "dim-created-at" },
+ dimensionMapping: { 0: "dim-created-at" },
},
},
{
@@ -90,7 +90,7 @@ const ORDERS_DIMENSIONS = [
tabInfo: {
type: "category",
label: "Status",
- dimensionMapping: { [ORDERS_SOURCE_ID]: "dim-status" },
+ dimensionMapping: { 0: "dim-status" },
},
},
];
@@ -105,7 +105,7 @@ describe("getAvailableDimensionsForPicker", () => {
it("returns dimensions for a single metric source", () => {
const result = getAvailableDimensionsForPicker(
{ [REVENUE_SOURCE_ID]: revenueDefinition },
- [REVENUE_SOURCE_ID],
+ [{ slotIndex: 0, entityIndex: 0, sourceId: REVENUE_SOURCE_ID }],
new Set(),
);
@@ -120,7 +120,7 @@ describe("getAvailableDimensionsForPicker", () => {
it("returns dimensions for a second metric source", () => {
const result = getAvailableDimensionsForPicker(
{ [ORDERS_SOURCE_ID]: ordersDefinition },
- [ORDERS_SOURCE_ID],
+ [{ slotIndex: 0, entityIndex: 0, sourceId: ORDERS_SOURCE_ID }],
new Set(),
);
@@ -138,7 +138,10 @@ describe("getAvailableDimensionsForPicker", () => {
[REVENUE_SOURCE_ID]: revenueDefinition,
[ORDERS_SOURCE_ID]: ordersDefinition,
},
- [REVENUE_SOURCE_ID, ORDERS_SOURCE_ID],
+ [
+ { slotIndex: 0, entityIndex: 0, sourceId: REVENUE_SOURCE_ID },
+ { slotIndex: 1, entityIndex: 1, sourceId: ORDERS_SOURCE_ID },
+ ],
new Set(),
);
@@ -146,7 +149,26 @@ describe("getAvailableDimensionsForPicker", () => {
shared: [],
bySource: {
[REVENUE_SOURCE_ID]: REVENUE_DIMENSIONS,
- [ORDERS_SOURCE_ID]: ORDERS_DIMENSIONS,
+ [ORDERS_SOURCE_ID]: [
+ {
+ icon: "calendar",
+ group: undefined,
+ tabInfo: {
+ type: "time",
+ label: "Created At",
+ dimensionMapping: { 1: "dim-created-at" },
+ },
+ },
+ {
+ icon: "string",
+ group: undefined,
+ tabInfo: {
+ type: "category",
+ label: "Status",
+ dimensionMapping: { 1: "dim-status" },
+ },
+ },
+ ],
},
});
});
@@ -158,7 +180,7 @@ describe("getAvailableDimensionsForPicker", () => {
const result = getAvailableDimensionsForPicker(
{ [REVENUE_SOURCE_ID]: revenueDefinition },
- [REVENUE_SOURCE_ID],
+ [{ slotIndex: 0, entityIndex: 0, sourceId: REVENUE_SOURCE_ID }],
new Set(allIds),
);
diff --git a/frontend/src/metabase/metrics-viewer/utils/expression.ts b/frontend/src/metabase/metrics-viewer/utils/expression.ts
new file mode 100644
index 00000000000..57c98b39bee
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/expression.ts
@@ -0,0 +1,23 @@
+import type { ExpressionSubToken, MetricSourceId } from "../types/viewer-state";
+
+/**
+ * Stamps sequential occurrence counts on metric tokens so that duplicate
+ * metrics within an expression can be disambiguated in the UI
+ * (e.g. "Revenue / Revenue (2)").
+ *
+ * Call this once when finalising a token array — after parsing user input
+ * or deserialising from the URL.
+ */
+export function stampMetricCounts(
+ tokens: ExpressionSubToken[],
+): ExpressionSubToken[] {
+ const counts = new Map<MetricSourceId, number>();
+ return tokens.map((token) => {
+ if (token.type === "metric") {
+ const count = (counts.get(token.sourceId) ?? 0) + 1;
+ counts.set(token.sourceId, count);
+ return { ...token, count };
+ }
+ return token;
+ });
+}
diff --git a/frontend/src/metabase/metrics-viewer/utils/legend.ts b/frontend/src/metabase/metrics-viewer/utils/legend.ts
index 0d465dadf3f..a4cd139292d 100644
--- a/frontend/src/metabase/metrics-viewer/utils/legend.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/legend.ts
@@ -1,13 +1,20 @@
import * as LibMetric from "metabase-lib/metric";
-import type {
- MetricsViewerDefinitionEntry,
- SourceBreakoutColorMap,
+import {
+ type MetricSourceId,
+ type MetricsViewerDefinitionEntry,
+ type MetricsViewerFormulaEntity,
+ type SourceBreakoutColorMap,
+ isExpressionEntry,
} from "../types/viewer-state";
+import { isMetricEntry } from "../types/viewer-state";
import { getDefinitionName } from "./definition-builder";
-import { entryHasBreakout, getEntryBreakout } from "./definition-entries";
-import { getSingleColor } from "./series";
+import {
+ entryHasBreakout,
+ getEffectiveDefinitionEntry,
+ getEntryBreakout,
+} from "./definition-entries";
export interface LegendItem {
label: string;
@@ -15,43 +22,77 @@ export interface LegendItem {
}
export interface LegendGroup {
+ key: number;
header: string;
subtitle?: string;
items: LegendItem[];
}
export function buildLegendGroups(
- definitions: MetricsViewerDefinitionEntry[],
+ formulaEntities: MetricsViewerFormulaEntity[],
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
activeBreakoutColors: SourceBreakoutColorMap,
): LegendGroup[] {
- // if the breakout has more than MAX_SERIES values, we don't show the breakout
- // in that case, the value in activeBreakoutColors is a string
- const hasAnyBreakout = definitions.some(
- (entry) =>
- entryHasBreakout(entry) && activeBreakoutColors[entry.id] instanceof Map,
- );
+ const hasAnyBreakout = formulaEntities.some((entity, entityIndex) => {
+ if (!isMetricEntry(entity)) {
+ return false;
+ }
+ return (
+ entryHasBreakout(getEffectiveDefinitionEntry(entity, definitions)) &&
+ activeBreakoutColors[entityIndex] instanceof Map
+ );
+ });
+
if (!hasAnyBreakout) {
return [];
}
const groups: LegendGroup[] = [];
- for (const entry of definitions) {
- if (!entry.definition) {
- continue;
+ formulaEntities.forEach((entity, entityIndex) => {
+ const colors = activeBreakoutColors[entityIndex];
+
+ const getNextColor = () => {
+ return typeof colors === "string"
+ ? colors
+ : colors instanceof Map
+ ? colors.values().next().value
+ : undefined;
+ };
+
+ if (isExpressionEntry(entity)) {
+ const color = getNextColor();
+
+ if (!color) {
+ return;
+ }
+
+ groups.push({
+ key: entityIndex,
+ header: entity.name,
+ items: [{ label: entity.name, color }],
+ });
+ return;
+ }
+
+ const effectiveEntry = getEffectiveDefinitionEntry(entity, definitions);
+ if (!effectiveEntry.definition) {
+ return;
}
- const colors = activeBreakoutColors[entry.id];
- const definitionName = getDefinitionName(entry.definition);
- const breakoutProjection = getEntryBreakout(entry);
+ const pristineDef = definitions[entity.id];
+ const definitionName = getDefinitionName(
+ pristineDef?.definition ?? effectiveEntry.definition,
+ );
+ const breakoutProjection = getEntryBreakout(effectiveEntry);
if (breakoutProjection && colors instanceof Map) {
const rawDimension = LibMetric.projectionDimension(
- entry.definition,
+ effectiveEntry.definition,
breakoutProjection,
);
const dimensionInfo = rawDimension
- ? LibMetric.displayInfo(entry.definition, rawDimension)
+ ? LibMetric.displayInfo(effectiveEntry.definition, rawDimension)
: null;
const items: LegendItem[] = Array.from(colors.entries()).map(
@@ -64,25 +105,28 @@ export function buildLegendGroups(
const header =
dimensionInfo?.longDisplayName ?? dimensionInfo?.displayName;
if (!header) {
- continue;
+ return;
}
groups.push({
+ key: entityIndex,
header,
subtitle: definitionName ?? undefined,
items,
});
} else {
- const color = getSingleColor(colors);
- if (!color || !definitionName) {
- continue;
+ const color = getNextColor();
+
+ if (!definitionName || !color) {
+ return;
}
groups.push({
+ key: entityIndex,
header: definitionName,
items: [{ label: definitionName, color }],
});
}
- }
+ });
return groups;
}
diff --git a/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts
index d2425371787..6b3edc08544 100644
--- a/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/legend.unit.spec.ts
@@ -7,6 +7,8 @@ import {
} from "metabase-types/api/mocks/metric";
import type {
+ MetricDefinitionEntry,
+ MetricSourceId,
MetricsViewerDefinitionEntry,
SourceBreakoutColorMap,
} from "../types/viewer-state";
@@ -84,32 +86,44 @@ describe("buildLegendGroups", () => {
const metadata = createMetadata([REVENUE_METRIC]);
const definition = setupDefinition(metadata, REVENUE_METRIC.id);
- const definitions: MetricsViewerDefinitionEntry[] = [
- { id: "metric:1", definition },
- ];
+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {
+ "metric:1": { id: "metric:1", definition },
+ };
const activeBreakoutColors: SourceBreakoutColorMap = {
- "metric:1": "#509EE3",
+ 0: "#509EE3",
};
- expect(buildLegendGroups(definitions, activeBreakoutColors)).toEqual([]);
+ const formulaEntities: MetricDefinitionEntry[] = [
+ { id: "metric:1", type: "metric", definition: null },
+ ];
+
+ expect(
+ buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),
+ ).toEqual([]);
});
it("returns empty array when activeBreakoutColors has only string values", () => {
const metadata = createMetadata([REVENUE_METRIC]);
- const revenueDefinition = setupDefinitionWithBreakout(
+ const definition = setupDefinitionWithBreakout(
metadata,
REVENUE_METRIC.id,
1,
);
- const definitions: MetricsViewerDefinitionEntry[] = [
- { id: "metric:1", definition: revenueDefinition },
- ];
+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {
+ "metric:1": { id: "metric:1", definition },
+ };
const activeBreakoutColors: SourceBreakoutColorMap = {
- "metric:1": "#509EE3",
+ 0: "#509EE3",
};
- expect(buildLegendGroups(definitions, activeBreakoutColors)).toEqual([]);
+ const formulaEntities: MetricDefinitionEntry[] = [
+ { id: "metric:1", type: "metric", definition: null },
+ ];
+
+ expect(
+ buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),
+ ).toEqual([]);
});
it("builds legend groups for definitions with and without breakouts", () => {
@@ -121,21 +135,33 @@ describe("buildLegendGroups", () => {
);
const ordersDefinition = setupDefinition(metadata, ORDERS_METRIC.id);
- const definitions: MetricsViewerDefinitionEntry[] = [
- { id: "metric:1", definition: revenueDefinition },
- { id: "metric:2", definition: ordersDefinition },
+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> = {
+ "metric:1": { id: "metric:1", definition: revenueDefinition },
+ "metric:2": { id: "metric:2", definition: ordersDefinition },
+ };
+
+ const formulaEntities: MetricDefinitionEntry[] = [
+ {
+ id: "metric:1",
+ type: "metric",
+ definition: revenueDefinition,
+ },
+ { id: "metric:2", type: "metric", definition: null },
];
const activeBreakoutColors: SourceBreakoutColorMap = {
- "metric:1": new Map([
+ 0: new Map([
["Gadgets", "#509EE3"],
["Widgets", "#88BF4D"],
]),
- "metric:2": "#A989C5",
+ 1: "#A989C5",
};
- expect(buildLegendGroups(definitions, activeBreakoutColors)).toEqual([
+ expect(
+ buildLegendGroups(formulaEntities, definitions, activeBreakoutColors),
+ ).toEqual([
{
+ key: 0,
header: "Category",
subtitle: "Revenue",
items: [
@@ -144,6 +170,7 @@ describe("buildLegendGroups", () => {
],
},
{
+ key: 1,
header: "Orders",
items: [{ label: "Orders", color: "#A989C5" }],
},
diff --git a/frontend/src/metabase/metrics-viewer/utils/metric-slots.ts b/frontend/src/metabase/metrics-viewer/utils/metric-slots.ts
new file mode 100644
index 00000000000..c1c3f751599
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/metric-slots.ts
@@ -0,0 +1,92 @@
+import type {
+ MetricSourceId,
+ MetricsViewerFormulaEntity,
+} from "../types/viewer-state";
+import { isExpressionEntry, isMetricEntry } from "../types/viewer-state";
+
+/**
+ * A metric slot represents a single position in the formula where a metric
+ * needs a dimension assignment. Standalone metrics produce one slot each;
+ * expression entities produce one slot per metric token (so the same metric
+ * appearing twice in an expression creates two separate slots).
+ *
+ * The `slotIndex` is used as the key in `dimensionMapping`.
+ */
+export type MetricSlot = {
+ /** Sequential index — used as the dimensionMapping key. */
+ slotIndex: number;
+ /** Which formulaEntities entry this slot belongs to. */
+ entityIndex: number;
+ /** The metric's source id (e.g. "metric:42"). */
+ sourceId: MetricSourceId;
+ /**
+ * For expression-token slots, the index within `entity.tokens`.
+ * `undefined` for standalone metric slots.
+ */
+ tokenPosition?: number;
+};
+
+/**
+ * Walk `formulaEntities` and produce a flat list of metric slots.
+ * The returned array's indices equal each slot's `slotIndex`.
+ */
+export function computeMetricSlots(
+ formulaEntities: MetricsViewerFormulaEntity[],
+): MetricSlot[] {
+ const slots: MetricSlot[] = [];
+
+ for (let i = 0; i < formulaEntities.length; i++) {
+ const entity = formulaEntities[i];
+
+ if (isMetricEntry(entity)) {
+ slots.push({
+ slotIndex: slots.length,
+ entityIndex: i,
+ sourceId: entity.id,
+ });
+ } else if (isExpressionEntry(entity)) {
+ for (let j = 0; j < entity.tokens.length; j++) {
+ const token = entity.tokens[j];
+ if (token.type === "metric") {
+ slots.push({
+ slotIndex: slots.length,
+ entityIndex: i,
+ sourceId: token.sourceId,
+ tokenPosition: j,
+ });
+ }
+ }
+ }
+ }
+
+ return slots;
+}
+
+/** Find the slot for a standalone metric at the given entity index. */
+export function findStandaloneSlot(
+ slots: MetricSlot[],
+ entityIndex: number,
+): MetricSlot | undefined {
+ return slots.find(
+ (s) => s.entityIndex === entityIndex && s.tokenPosition === undefined,
+ );
+}
+
+/** Find the slot for an expression token at the given entity + token position. */
+export function findExpressionTokenSlot(
+ slots: MetricSlot[],
+ entityIndex: number,
+ tokenPosition: number,
+): MetricSlot | undefined {
+ return slots.find(
+ (s) => s.entityIndex === entityIndex && s.tokenPosition === tokenPosition,
+ );
+}
+
+/** Get all slots belonging to a given entity index. */
+export function slotsForEntity(
+ slots: MetricSlot[],
+ entityIndex: number,
+): MetricSlot[] {
+ return slots.filter((s) => s.entityIndex === entityIndex);
+}
diff --git a/frontend/src/metabase/metrics-viewer/utils/parse-expression.ts b/frontend/src/metabase/metrics-viewer/utils/parse-expression.ts
new file mode 100644
index 00000000000..b7c5cba041d
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/parse-expression.ts
@@ -0,0 +1,112 @@
+import type { ExpressionRef, MathOperator } from "metabase-types/api";
+
+import type { ExpressionSubToken } from "../types/viewer-state";
+
+type ParseCtx = {
+ tokens: ExpressionSubToken[];
+ pos: number;
+ leafRefs: Map<number, ExpressionRef>;
+};
+
+function parseTerm(ctx: ParseCtx): ExpressionRef | number | null {
+ if (ctx.pos >= ctx.tokens.length) {
+ return null;
+ }
+ const token = ctx.tokens[ctx.pos];
+
+ if (token.type === "metric") {
+ const tokenPos = ctx.pos;
+ ctx.pos++;
+ return ctx.leafRefs.get(tokenPos) ?? null;
+ }
+
+ if (token.type === "constant") {
+ ctx.pos++;
+ return token.value;
+ }
+
+ if (token.type === "open-paren") {
+ ctx.pos++;
+ const expr = parseExpressionWithContext(ctx);
+ if (
+ ctx.pos < ctx.tokens.length &&
+ ctx.tokens[ctx.pos].type === "close-paren"
+ ) {
+ ctx.pos++;
+ }
+ return expr;
+ }
+
+ return null;
+}
+
+const PRECEDENCE: Record<MathOperator, number> = {
+ "+": 1,
+ "-": 1,
+ "*": 2,
+ "/": 2,
+};
+
+function isOperatorAtPrecedence(ctx: ParseCtx, level: number): boolean {
+ if (ctx.pos >= ctx.tokens.length) {
+ return false;
+ }
+ const token = ctx.tokens[ctx.pos];
+ return token.type === "operator" && PRECEDENCE[token.op] === level;
+}
+
+function parseFactor(ctx: ParseCtx): ExpressionRef | number | null {
+ let left = parseTerm(ctx);
+ if (left == null) {
+ return null;
+ }
+
+ while (isOperatorAtPrecedence(ctx, 2)) {
+ const op = (ctx.tokens[ctx.pos] as { type: "operator"; op: MathOperator })
+ .op;
+ ctx.pos++;
+ const right = parseTerm(ctx);
+ if (right == null) {
+ return null;
+ }
+ left = [op, {}, left, right];
+ }
+
+ return left;
+}
+
+function parseExpressionWithContext(ctx: ParseCtx): ExpressionRef | null {
+ let left = parseFactor(ctx);
+ if (left == null) {
+ return null;
+ }
+
+ while (isOperatorAtPrecedence(ctx, 1)) {
+ const op = (ctx.tokens[ctx.pos] as { type: "operator"; op: MathOperator })
+ .op;
+ ctx.pos++;
+ const right = parseFactor(ctx);
+ if (right == null) {
+ return null;
+ }
+ left = [op, {}, left, right];
+ }
+
+ if (typeof left === "number") {
+ return null;
+ }
+
+ return left;
+}
+
+export function parseExpression(
+ tokens: ExpressionSubToken[],
+ leafRefs: Map<number, ExpressionRef>,
+): ExpressionRef | null {
+ const ctx: ParseCtx = { tokens, pos: 0, leafRefs };
+ const result = parseExpressionWithContext(ctx);
+ if (ctx.pos < tokens.length) {
+ return null;
+ }
+ return result;
+}
diff --git a/frontend/src/metabase/metrics-viewer/utils/parse-expression.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/parse-expression.unit.spec.ts
new file mode 100644
index 00000000000..f3659791200
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/parse-expression.unit.spec.ts
@@ -0,0 +1,260 @@
+import type { ExpressionRef } from "metabase-types/api";
+
+import type { ExpressionSubToken } from "../types/viewer-state";
+
+import { parseExpression } from "./parse-expression";
+import { parseSourceId } from "./source-ids";
+
+function createLeafRefs(
+ tokens: ExpressionSubToken[],
+): Map<number, ExpressionRef> {
+ const leafRefs = new Map<number, ExpressionRef>();
+ for (let i = 0; i < tokens.length; i++) {
+ const token = tokens[i];
+ if (token.type === "metric") {
+ const uuid = `leaf-${i}`;
+ const { id, type } = parseSourceId(token.sourceId);
+
+ if (type === "metric") {
+ leafRefs.set(i, ["metric", { "lib/uuid": uuid }, id]);
+ } else if (type === "measure") {
+ leafRefs.set(i, ["measure", { "lib/uuid": uuid }, id]);
+ }
+ }
+ }
+ return leafRefs;
+}
+
+// remove options to make comparisons easier
+function stripOptions(expr: ExpressionRef | number | null): any {
+ if (typeof expr === "number" || expr === null) {
+ return expr;
+ }
+ if (expr[0] === "metric" || expr[0] === "measure") {
+ return [expr[0], expr[2]];
+ }
+ return [expr[0], stripOptions(expr[2]), stripOptions(expr[3])];
+}
+
+describe("parseExpression", () => {
+ it("should parse a simple expression", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual(["+", ["metric", 1], ["metric", 2]]);
+ });
+
+ it("should handle parens", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "-" },
+ { type: "open-paren" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "measure:3", count: 1 },
+ { type: "close-paren" },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "-",
+ ["metric", 1],
+ ["+", ["metric", 2], ["measure", 3]],
+ ]);
+ });
+
+ it("should handle a single metric", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual(["metric", 1]);
+ });
+
+ it("should return null for invalid input", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(expr).toBeNull();
+ });
+
+ // A + B * C => A + (B * C)
+ it("should respect precedence: + before *", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:3", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "+",
+ ["metric", 1],
+ ["*", ["metric", 2], ["metric", 3]],
+ ]);
+ });
+
+ // A * B + C => (A * B) + C
+ it("should respect precedence: * before +", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:3", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "+",
+ ["*", ["metric", 1], ["metric", 2]],
+ ["metric", 3],
+ ]);
+ });
+
+ // A - B / C => A - (B / C)
+ it("should respect precedence: - before /", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "-" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "operator", op: "/" },
+ { type: "metric", sourceId: "metric:3", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "-",
+ ["metric", 1],
+ ["/", ["metric", 2], ["metric", 3]],
+ ]);
+ });
+
+ // A * B + C * D => (A * B) + (C * D)
+ it("should handle multiple high-precedence groups", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:3", count: 1 },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:4", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "+",
+ ["*", ["metric", 1], ["metric", 2]],
+ ["*", ["metric", 3], ["metric", 4]],
+ ]);
+ });
+
+ // (A + B) * C => parens override precedence
+ it("should allow parens to override precedence", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "open-paren" },
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ { type: "close-paren" },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:3", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "*",
+ ["+", ["metric", 1], ["metric", 2]],
+ ["metric", 3],
+ ]);
+ });
+
+ it("should handle constants in precedence expressions", () => {
+ // A + 2 * B => A + (2 * B)
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "constant", value: 2 },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "+",
+ ["metric", 1],
+ ["*", 2, ["metric", 2]],
+ ]);
+ });
+
+ // 8 - 3 - 2 => (8 - 3) - 2 = 3, not 8 - (3 - 2) = 7
+ it("should associate subtraction left-to-right", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "constant", value: 8 },
+ { type: "operator", op: "-" },
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "-" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "-",
+ ["-", 8, ["metric", 1]],
+ ["metric", 2],
+ ]);
+ });
+
+ // 8 / 4 / 2 => (8 / 4) / 2 = 1, not 8 / (4 / 2) = 4
+ it("should associate division left-to-right", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "constant", value: 8 },
+ { type: "operator", op: "/" },
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "/" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "/",
+ ["/", 8, ["metric", 1]],
+ ["metric", 2],
+ ]);
+ });
+
+ it("should return null when tokens are not fully consumed", () => {
+ // "Metric1 2" — two operands with no operator
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "constant", value: 2 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(expr).toBeNull();
+ });
+
+ it("should return null for metric followed by another metric without operator", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(expr).toBeNull();
+ });
+
+ // 6 / 2 * 3 => (6 / 2) * 3 = 9, not 6 / (2 * 3) = 1
+ it("should associate mixed * and / left-to-right", () => {
+ const tokens: ExpressionSubToken[] = [
+ { type: "constant", value: 6 },
+ { type: "operator", op: "/" },
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ];
+ const expr = parseExpression(tokens, createLeafRefs(tokens));
+ expect(stripOptions(expr)).toEqual([
+ "*",
+ ["/", 6, ["metric", 1]],
+ ["metric", 2],
+ ]);
+ });
+});
diff --git a/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.ts b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.ts
new file mode 100644
index 00000000000..2e31da82022
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.ts
@@ -0,0 +1,82 @@
+import { getObjectEntries } from "metabase/utils/objects";
+
+import type {
+ MetricSourceId,
+ MetricsViewerFormulaEntity,
+ MetricsViewerTabState,
+} from "../types/viewer-state";
+
+import type { MetricSlot } from "./metric-slots";
+import { computeMetricSlots } from "./metric-slots";
+
+/**
+ * Look through the already-remapped entries for a slot with the same
+ * sourceId and return its dimension id.
+ */
+function findSiblingDimension(
+ mapping: Record<number, string | null>,
+ slots: MetricSlot[],
+ targetSourceId: MetricSourceId,
+): string | null | undefined {
+ for (const [idxStr, dimId] of Object.entries(mapping)) {
+ const idx = Number(idxStr);
+ const slot = slots.find((s) => s.slotIndex === idx);
+ if (slot && slot.sourceId === targetSourceId) {
+ return dimId;
+ }
+ }
+ return undefined; // no sibling found — leave unmapped
+}
+
+/**
+ * Remap dimension mappings using a precomputed old→new slot index mapping
+ * (produced by `applyTrackedDefinitions`). This is the fast path used when
+ * the slot mapping is available from CodeMirror position tracking.
+ *
+ * 1. Remap existing entries via the slot mapping (simple lookup).
+ * 2. Inherit sibling dimensions for unmapped new slots.
+ */
+export function remapDimensionMappings(
+ tabs: MetricsViewerTabState[],
+ slotMapping: Map<number, number>,
+ newEntities: MetricsViewerFormulaEntity[],
+): MetricsViewerTabState[] {
+ const newSlots = computeMetricSlots(newEntities);
+
+ return tabs.map((tab) => {
+ const newMapping: Record<number, string | null> = {};
+ let changed = false;
+
+ // 1. Remap existing entries from old slot index → new slot index
+ for (const [oldKey, dimId] of getObjectEntries(tab.dimensionMapping)) {
+ const oldSlotIndex = Number(oldKey);
+ const newSlotIndex = slotMapping.get(oldSlotIndex);
+ if (newSlotIndex == null) {
+ changed = true;
+ continue; // slot was removed
+ }
+ if (newSlotIndex !== oldSlotIndex) {
+ changed = true;
+ }
+ newMapping[newSlotIndex] = dimId;
+ }
+
+ // 2. Inherit sibling dimensions for unmapped new slots
+ for (const slot of newSlots) {
+ if (slot.slotIndex in newMapping) {
+ continue;
+ }
+ const siblingDimId = findSiblingDimension(
+ newMapping,
+ newSlots,
+ slot.sourceId,
+ );
+ if (siblingDimId !== undefined) {
+ newMapping[slot.slotIndex] = siblingDimId;
+ changed = true;
+ }
+ }
+
+ return changed ? { ...tab, dimensionMapping: newMapping } : tab;
+ });
+}
diff --git a/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.unit.spec.ts
new file mode 100644
index 00000000000..de770b904fc
--- /dev/null
+++ b/frontend/src/metabase/metrics-viewer/utils/remap-dimension-mappings.unit.spec.ts
@@ -0,0 +1,178 @@
+import type {
+ MetricDefinitionEntry,
+ MetricSourceId,
+ MetricsViewerTabState,
+} from "../types/viewer-state";
+
+import { remapDimensionMappings } from "./remap-dimension-mappings";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function metric(sourceId: MetricSourceId): MetricDefinitionEntry {
+ return { id: sourceId, type: "metric", definition: null as any };
+}
+
+function makeTab(
+ overrides: Partial<MetricsViewerTabState> = {},
+): MetricsViewerTabState {
+ return {
+ id: "tab-1",
+ type: "time",
+ label: "By Month",
+ display: "line",
+ dimensionMapping: {},
+ projectionConfig: {},
+ ...overrides,
+ };
+}
+
+const REVENUE: MetricSourceId = "metric:1" as MetricSourceId;
+const ORDERS: MetricSourceId = "metric:2" as MetricSourceId;
+const COSTS: MetricSourceId = "metric:3" as MetricSourceId;
+
+// ---------------------------------------------------------------------------
+// remapDimensionMappings — fast path using precomputed slot mapping
+// ---------------------------------------------------------------------------
+
+describe("remapDimensionMappings", () => {
+ it("returns same tab objects when slot mapping is identity", () => {
+ const entities = [metric(REVENUE), metric(ORDERS)];
+ const tab = makeTab({
+ dimensionMapping: { 0: "created_at", 1: "created_at" },
+ });
+ const slotMapping = new Map([
+ [0, 0],
+ [1, 1],
+ ]);
+
+ const result = remapDimensionMappings([tab], slotMapping, entities);
+
+ expect(result[0]).toBe(tab); // referential equality
+ });
+
+ it("remaps indices when slots shift", () => {
+ // Old: [Revenue(0), Orders(1), Costs(2)], New: [Orders(0), Costs(1)]
+ // Revenue removed, Orders 1→0, Costs 2→1
+ const next = [metric(ORDERS), metric(COSTS)];
+ const tab = makeTab({
+ dimensionMapping: { 0: "dim-rev", 1: "dim-ord", 2: "dim-cost" },
+ });
+ const slotMapping = new Map([
+ [1, 0], // Orders: old 1 → new 0
+ [2, 1], // Costs: old 2 → new 1
+ // Revenue (old 0) not in map — removed
+ ]);
+
+ const result = remapDimensionMappings([tab], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({
+ 0: "dim-ord",
+ 1: "dim-cost",
+ });
+ });
+
+ it("remaps indices when entities are reordered", () => {
+ const next = [metric(ORDERS), metric(REVENUE)]; // swapped
+ const tab = makeTab({
+ dimensionMapping: { 0: "dim-rev", 1: "dim-ord" },
+ });
+ const slotMapping = new Map([
+ [0, 1], // Revenue: old 0 → new 1
+ [1, 0], // Orders: old 1 → new 0
+ ]);
+
+ const result = remapDimensionMappings([tab], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({
+ 0: "dim-ord",
+ 1: "dim-rev",
+ });
+ });
+
+ it("inherits sibling dimension for a new slot with same sourceId", () => {
+ const next = [metric(REVENUE), metric(REVENUE)]; // second instance added
+ const tab = makeTab({
+ dimensionMapping: { 0: "created_at" },
+ });
+ const slotMapping = new Map([
+ [0, 0], // original Revenue stays at 0
+ // slot 1 is new — not in the mapping
+ ]);
+
+ const result = remapDimensionMappings([tab], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({
+ 0: "created_at",
+ 1: "created_at", // inherited from sibling
+ });
+ });
+
+ it("does not add mapping for a brand-new metric with no sibling", () => {
+ const next = [metric(REVENUE), metric(ORDERS)]; // Orders is new
+ const tab = makeTab({
+ dimensionMapping: { 0: "created_at" },
+ });
+ const slotMapping = new Map([
+ [0, 0], // Revenue stays
+ // slot 1 (Orders) is new with no sibling
+ ]);
+
+ const result = remapDimensionMappings([tab], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({ 0: "created_at" });
+ });
+
+ it("reconciles multiple tabs independently", () => {
+ const next = [metric(ORDERS), metric(REVENUE)]; // swapped
+ const tab1 = makeTab({
+ id: "tab-1",
+ dimensionMapping: { 0: "dim-rev", 1: "dim-ord" },
+ });
+ const tab2 = makeTab({
+ id: "tab-2",
+ dimensionMapping: { 0: "cat-rev", 1: "cat-ord" },
+ });
+ const slotMapping = new Map([
+ [0, 1],
+ [1, 0],
+ ]);
+
+ const result = remapDimensionMappings([tab1, tab2], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({
+ 0: "dim-ord",
+ 1: "dim-rev",
+ });
+ expect(result[1].dimensionMapping).toEqual({
+ 0: "cat-ord",
+ 1: "cat-rev",
+ });
+ });
+
+ it("handles empty slot mapping (all entities new)", () => {
+ const next = [metric(REVENUE)];
+ const tab = makeTab({ dimensionMapping: { 0: "created_at" } });
+ const slotMapping = new Map<number, number>();
+
+ const result = remapDimensionMappings([tab], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({});
+ });
+
+ it("inherits null dimension from sibling", () => {
+ const next = [metric(REVENUE), metric(REVENUE)];
+ const tab = makeTab({
+ dimensionMapping: { 0: null },
+ });
+ const slotMapping = new Map([[0, 0]]);
+
+ const result = remapDimensionMappings([tab], slotMapping, next);
+
+ expect(result[0].dimensionMapping).toEqual({
+ 0: null,
+ 1: null,
+ });
+ });
+});
diff --git a/frontend/src/metabase/metrics-viewer/utils/series.ts b/frontend/src/metabase/metrics-viewer/utils/series.ts
index 08dc2e578cc..3989d8fa886 100644
--- a/frontend/src/metabase/metrics-viewer/utils/series.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/series.ts
@@ -1,5 +1,13 @@
+import { t } from "ttag";
+
import type { DimensionOption } from "metabase/common/components/DimensionPill";
-import type { DimensionItem } from "metabase/metrics-viewer/components/DimensionPillBar";
+import type {
+ DimensionPillBarItem,
+ ExpressionDimensionItem,
+ ExpressionMetricSource,
+ MetricDimensionItem,
+} from "metabase/metrics-viewer/components/DimensionPillBar";
+import type { IconName } from "metabase/ui";
import { getColorsForValues } from "metabase/ui/colors/charts";
import { getColorplethColorScale } from "metabase/visualizations/components/ChoroplethMap";
import {
@@ -7,7 +15,7 @@ import {
getBreakoutSeriesName,
} from "metabase/visualizations/echarts/cartesian/model/series";
import { MAX_SERIES } from "metabase/visualizations/lib/utils";
-import type { DimensionMetadata, MetricDefinition } from "metabase-lib/metric";
+import type { MetricDefinition } from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
import type {
Card,
@@ -21,82 +29,321 @@ import type {
RowValues,
SeriesSettings,
SingleSeries,
+ TemporalUnit,
VisualizationDisplay,
VisualizationSettings,
} from "metabase-types/api";
-import type {
- BreakoutColorMap,
- MetricSourceId,
- MetricsViewerDefinitionEntry,
- MetricsViewerDisplayType,
- SelectedMetric,
- SourceBreakoutColorMap,
- SourceColorMap,
+import {
+ type BreakoutColorMap,
+ type ExpressionDefinitionEntry,
+ type MetricDefinitionEntry,
+ type MetricSourceId,
+ type MetricsViewerDefinitionEntry,
+ type MetricsViewerDisplayType,
+ type MetricsViewerFormulaEntity,
+ type SelectedMetric,
+ type SourceBreakoutColorMap,
+ type SourceColorMap,
+ isExpressionEntry,
+ isMetricEntry,
} from "../types/viewer-state";
import { getDefinitionName } from "./definition-builder";
-import { entryHasBreakout, getEntryBreakout } from "./definition-entries";
+import { getModifiedDefinition } from "./definition-cache";
+import {
+ entryHasBreakout,
+ getEffectiveDefinitionEntry,
+ getEntryBreakout,
+} from "./definition-entries";
import { findDimensionById } from "./dimension-lookup";
+import { type MetricSlot, slotsForEntity } from "./metric-slots";
import { nextSyntheticCardId, parseSourceId } from "./source-ids";
import { DISPLAY_TYPE_REGISTRY } from "./tab-config";
import { getDimensionIcon } from "./tabs";
-function getDefinitionCardId(def: MetricDefinition): number | null {
- const metricId = LibMetric.sourceMetricId(def);
- if (metricId != null) {
- return metricId;
+interface BuildSeriesParams {
+ formulaEntities: MetricsViewerFormulaEntity[];
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+ resultsByEntityIndex: Map<number, Dataset>;
+ metricSlots: MetricSlot[];
+ dimensionMapping: Record<number, DimensionId | null>;
+ display: MetricsViewerDisplayType;
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;
+ sourceBreakoutColors: SourceBreakoutColorMap;
+ extraVizSettings?: Partial<VisualizationSettings>;
+}
+
+export function buildSeries({
+ formulaEntities,
+ definitions,
+ resultsByEntityIndex,
+ metricSlots,
+ dimensionMapping,
+ display,
+ modifiedDefinitionsBySlotIndex,
+ sourceBreakoutColors,
+ extraVizSettings,
+}: BuildSeriesParams): {
+ series: SingleSeries[];
+ cardIdToEntityIndex: Record<CardId, number>;
+ activeBreakoutColors: SourceBreakoutColorMap;
+} {
+ const uniqueNamesByEntityIndex = computeUniqueEntityNames(
+ formulaEntities,
+ definitions,
+ );
+ const displayType = DISPLAY_TYPE_REGISTRY[display];
+
+ let isFirstSeries = true;
+ const cardIdToEntityIndex: Record<CardId, number> = {};
+ const activeBreakoutColors: SourceBreakoutColorMap = {};
+
+ const series = Array.from(resultsByEntityIndex.entries()).flatMap(
+ ([entityIndex, result]) => {
+ let vizSettings: VisualizationSettings | null = null;
+ const entity = formulaEntities[entityIndex];
+
+ const name = uniqueNamesByEntityIndex.get(entityIndex);
+ if (!name) {
+ return [];
+ }
+
+ const colors = sourceBreakoutColors[entityIndex];
+ const color = getSingleColor(colors);
+ const hasBreakout =
+ isMetricEntry(entity) &&
+ entryHasBreakout(getEffectiveDefinitionEntry(entity, definitions)) &&
+ result.data.rows.length > 0;
+ const breakoutIsSameAsDimension =
+ hasBreakout && result.data.cols.length === 2;
+ const nativeBreakout =
+ hasBreakout &&
+ !breakoutIsSameAsDimension &&
+ displayType.supportsMultipleSeries;
+ const needsManualBreakoutSplit = hasBreakout && !nativeBreakout;
+
+ if (nativeBreakout) {
+ vizSettings = buildCartesianVizSettings(
+ result.data,
+ true,
+ formulaEntities.length > 1,
+ name,
+ colors instanceof Map ? colors : undefined,
+ );
+ } else {
+ vizSettings = getVizSettings(
+ dimensionMapping,
+ display,
+ modifiedDefinitionsBySlotIndex,
+ metricSlots
+ .filter((slot) => slot.entityIndex === entityIndex)
+ .map((slot) => slot.slotIndex),
+ );
+ }
+ if (!vizSettings) {
+ return [];
+ }
+ const cardId = nextSyntheticCardId();
+
+ const seriesKey = isFirstSeries ? result.data.cols[1]?.name : name;
+
+ const singleSeries: SingleSeries = {
+ card: createSeriesCard(cardId, name, display, {
+ ...vizSettings,
+ ...(nativeBreakout
+ ? {}
+ : computeColorVizSettings({
+ displayType: display,
+ seriesKey,
+ color,
+ })),
+ ...extraVizSettings,
+ }),
+ data: result.data,
+ };
+
+ let entrySeries: SingleSeries[];
+ if (needsManualBreakoutSplit && colors instanceof Map) {
+ const { series, activeBreakoutColorMap } = splitByBreakout(
+ singleSeries,
+ formulaEntities.length,
+ isFirstSeries,
+ colors,
+ vizSettings,
+ );
+ entrySeries = series;
+ activeBreakoutColors[entityIndex] = activeBreakoutColorMap;
+ } else {
+ entrySeries = [singleSeries];
+ if (hasBreakout && !needsManualBreakoutSplit && colors instanceof Map) {
+ activeBreakoutColors[entityIndex] = filterBreakoutColorsByData(
+ colors,
+ result.data,
+ );
+ } else {
+ activeBreakoutColors[entityIndex] = color;
+ }
+ }
+
+ isFirstSeries = false;
+
+ for (const series of entrySeries) {
+ cardIdToEntityIndex[series.card.id] = entityIndex;
+ }
+ return entrySeries;
+ },
+ );
+
+ if (series.length > 1 && displayType.combineSettings) {
+ series[0].card.visualization_settings = displayType.combineSettings(
+ series.map((s) => s.card.visualization_settings),
+ );
}
- const measureId = LibMetric.sourceMeasureId(def);
- if (measureId != null) {
- return nextSyntheticCardId();
+
+ return { series, cardIdToEntityIndex, activeBreakoutColors };
+}
+
+function getVizSettings(
+ dimensionMapping: Record<number, DimensionId | null>,
+ display: MetricsViewerDisplayType,
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,
+ slotIndices: number[],
+): VisualizationSettings | null {
+ const displayConfig = DISPLAY_TYPE_REGISTRY[display];
+ for (const slotIndex of slotIndices) {
+ const modifiedDefinition = modifiedDefinitionsBySlotIndex.get(slotIndex);
+ if (!modifiedDefinition) {
+ continue;
+ }
+ const dimensionId = dimensionMapping[slotIndex];
+ if (displayConfig.dimensionRequired) {
+ if (!dimensionId) {
+ continue;
+ }
+ const dimension = findDimensionById(modifiedDefinition, dimensionId);
+ if (!dimension) {
+ continue;
+ }
+ return displayConfig.getSettings(modifiedDefinition, dimension);
+ }
+ return displayConfig.getSettings(modifiedDefinition);
}
return null;
}
+/**
+ * Compute unique display names for each formula entity, disambiguating
+ * duplicate names by appending " (N)" starting from the second occurrence.
+ * This ensures that `card.name` (used by `keyForSingleSeries` for color
+ * resolution) is unique for each entity.
+ */
+export function computeUniqueEntityNames(
+ formulaEntities: MetricsViewerFormulaEntity[],
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+): Map<number, string> {
+ const rawNames: { entityIndex: number; name: string }[] = [];
+ const totalCounts = new Map<string, number>();
+
+ formulaEntities.forEach((entity, index) => {
+ let name;
+ if (isMetricEntry(entity)) {
+ const effectiveDef = getEffectiveDefinitionEntry(entity, definitions);
+ if (effectiveDef?.definition) {
+ name = getDefinitionName(effectiveDef.definition);
+ if (name) {
+ rawNames.push({ entityIndex: index, name });
+ }
+ }
+ } else if (isExpressionEntry(entity)) {
+ name = entity.name;
+ rawNames.push({ entityIndex: index, name: entity.name });
+ }
+
+ if (name) {
+ totalCounts.set(name, (totalCounts.get(name) ?? 0) + 1);
+ }
+ });
+
+ // Assign unique names: first occurrence keeps original, subsequent get " (N)"
+ const result = new Map<number, string>();
+ const seenCounts = new Map<string, number>();
+ for (const { entityIndex, name } of rawNames) {
+ const occurrence = (seenCounts.get(name) ?? 0) + 1;
+ seenCounts.set(name, occurrence);
+ if ((totalCounts.get(name) ?? 0) > 1 && occurrence > 1) {
+ result.set(entityIndex, `${name} (${occurrence})`);
+ } else {
+ result.set(entityIndex, name);
+ }
+ }
+
+ return result;
+}
+
interface SourceColorEntry {
- sourceId: MetricSourceId;
+ entityIndex: number;
keys: string[];
keyToBreakoutValue: Record<string, string>;
}
export function computeSourceBreakoutColors(
- definitions: MetricsViewerDefinitionEntry[],
- breakoutValuesBySourceId?: Map<MetricSourceId, MetricBreakoutValuesResponse>,
+ formulaEntities: MetricsViewerFormulaEntity[],
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ breakoutValuesByEntityIndex?: Map<number, MetricBreakoutValuesResponse>,
): SourceBreakoutColorMap {
+ const uniqueNames = computeUniqueEntityNames(formulaEntities, definitions);
+
const entries: SourceColorEntry[] = [];
- for (const entry of definitions) {
- if (!entry.definition) {
+ for (
+ let entityIndex = 0;
+ entityIndex < formulaEntities.length;
+ entityIndex++
+ ) {
+ const entity = formulaEntities[entityIndex];
+ const uniqueName = uniqueNames.get(entityIndex);
+ if (!uniqueName) {
continue;
}
- const displayName = getDefinitionName(entry.definition);
- if (!displayName) {
- continue;
+
+ if (isMetricEntry(entity)) {
+ const effectiveDef = getEffectiveDefinitionEntry(entity, definitions);
+ if (!effectiveDef?.definition) {
+ continue;
+ }
+
+ const response = breakoutValuesByEntityIndex?.get(entityIndex);
+ if (
+ entryHasBreakout(effectiveDef) &&
+ response &&
+ response.values.length > 0
+ ) {
+ const keys: string[] = [];
+ const keyToBreakoutValue: Record<string, string> = {};
+ response.values.forEach((val) => {
+ const breakoutValue = formatBreakoutValue(val, response.col);
+ const key = getBreakoutSeriesName(
+ val,
+ response.col,
+ uniqueNames.size > 1,
+ uniqueName,
+ );
+ keys.push(key);
+ keyToBreakoutValue[key] = breakoutValue;
+ });
+ entries.push({ entityIndex, keys, keyToBreakoutValue });
+ } else {
+ entries.push({
+ entityIndex,
+ keys: [uniqueName],
+ keyToBreakoutValue: {},
+ });
+ }
}
- const response = breakoutValuesBySourceId?.get(entry.id);
- if (entryHasBreakout(entry) && response && response.values.length > 0) {
- const keys: string[] = [];
- const keyToBreakoutValue: Record<string, string> = {};
- response.values.forEach((val) => {
- const breakoutValue = formatBreakoutValue(val, response.col);
- const key = getBreakoutSeriesName(
- val,
- response.col,
- definitions.length > 1,
- displayName,
- );
- keys.push(key);
- keyToBreakoutValue[key] = breakoutValue;
- });
- entries.push({ sourceId: entry.id, keys, keyToBreakoutValue });
- } else {
- entries.push({
- sourceId: entry.id,
- keys: [displayName],
- keyToBreakoutValue: {},
- });
+ if (isExpressionEntry(entity)) {
+ entries.push({ entityIndex, keys: [uniqueName], keyToBreakoutValue: {} });
}
}
@@ -111,9 +358,9 @@ export function computeSourceBreakoutColors(
const result: SourceBreakoutColorMap = {};
for (const entry of entries) {
if (entry.keys.length === 1) {
- result[entry.sourceId] = colorMapping[entry.keys[0]];
+ result[entry.entityIndex] = colorMapping[entry.keys[0]];
} else {
- result[entry.sourceId] = new Map(
+ result[entry.entityIndex] = new Map(
Object.entries(entry.keyToBreakoutValue).map(([key, breakoutValue]) => [
breakoutValue,
colorMapping[key],
@@ -183,6 +430,7 @@ export function splitByBreakout(
seriesCount: number,
isFirstSeries: boolean,
breakoutColorMap: BreakoutColorMap,
+ vizSettings: VisualizationSettings,
): {
series: SingleSeries[];
activeBreakoutColorMap: BreakoutColorMap | string | undefined;
@@ -209,7 +457,7 @@ export function splitByBreakout(
if (rowsByBreakoutValue.size > MAX_SERIES) {
return {
series: [series],
- activeBreakoutColorMap: getSingleColor(breakoutColorMap),
+ activeBreakoutColorMap: breakoutColorMap.values().next().value,
};
}
}
@@ -247,6 +495,7 @@ export function splitByBreakout(
id: nextSyntheticCardId(),
name,
visualization_settings: {
+ ...vizSettings,
...computeColorVizSettings({
displayType: card.display,
seriesKey,
@@ -308,161 +557,6 @@ function createSeriesCard(
} as Card;
}
-export function buildRawSeriesFromDefinitions(
- definitions: MetricsViewerDefinitionEntry[],
- dimensionMapping: Record<MetricSourceId, DimensionId | null>,
- display: MetricsViewerDisplayType,
- resultsByDefinitionId: Map<MetricSourceId, Dataset>,
- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>,
- sourceBreakoutColors: SourceBreakoutColorMap,
- extraVizSettings?: Partial<VisualizationSettings>,
-): {
- series: SingleSeries[];
- cardIdToDefinitionId: Record<CardId, MetricSourceId>;
- activeBreakoutColors: SourceBreakoutColorMap;
-} {
- const firstSettingsEntry = definitions.reduce<{
- def: MetricDefinition;
- dimension: DimensionMetadata;
- } | null>((found, entry) => {
- if (found) {
- return found;
- }
- const dimensionId = dimensionMapping[entry.id];
- if (!dimensionId || !entry.definition) {
- return null;
- }
- const dimension = findDimensionById(entry.definition, dimensionId);
- if (!dimension) {
- return null;
- }
- const def = modifiedDefinitions.get(entry.id);
- if (!def) {
- return null;
- }
- return { def, dimension };
- }, null);
-
- if (!firstSettingsEntry) {
- return { series: [], cardIdToDefinitionId: {}, activeBreakoutColors: {} };
- }
-
- const displayType = DISPLAY_TYPE_REGISTRY[display];
- const baseSettings = displayType.getSettings(
- firstSettingsEntry.def,
- firstSettingsEntry.dimension,
- );
-
- let isFirstSeries = true;
- const cardIdToDefinitionId: Record<CardId, MetricSourceId> = {};
- const activeBreakoutColors: SourceBreakoutColorMap = {};
-
- const series = definitions.flatMap((entry) => {
- const dimensionId = dimensionMapping[entry.id];
- if (!dimensionId || !entry.definition) {
- return [];
- }
-
- const modDef = modifiedDefinitions.get(entry.id);
- const result = resultsByDefinitionId.get(entry.id);
- if (!modDef || !result?.data?.cols?.length) {
- return [];
- }
-
- if (LibMetric.projections(modDef).length === 0) {
- return [];
- }
-
- const cardId = getDefinitionCardId(entry.definition);
- if (cardId == null) {
- return [];
- }
-
- const name = getDefinitionName(entry.definition);
- if (!name) {
- return [];
- }
-
- const colors = sourceBreakoutColors[entry.id];
- const color = getSingleColor(colors);
- const hasBreakout = entryHasBreakout(entry) && result.data.rows.length > 0;
- const breakoutIsSameAsDimension =
- hasBreakout && result.data.cols.length === 2;
- const nativeBreakout =
- hasBreakout &&
- !breakoutIsSameAsDimension &&
- displayType.supportsMultipleSeries;
- const needsManualBreakoutSplit = hasBreakout && !nativeBreakout;
-
- let vizSettings: VisualizationSettings;
- if (nativeBreakout) {
- vizSettings = buildCartesianVizSettings(
- result.data,
- true,
- definitions.length > 1,
- name,
- colors instanceof Map ? colors : undefined,
- );
- } else {
- const seriesKey = isFirstSeries ? result.data.cols[1].name : name;
- vizSettings = {
- ...baseSettings,
- ...computeColorVizSettings({
- displayType: display,
- seriesKey,
- color,
- }),
- };
- }
-
- if (extraVizSettings) {
- vizSettings = { ...vizSettings, ...extraVizSettings };
- }
-
- const singleSeries: SingleSeries = {
- card: createSeriesCard(cardId, name, display, vizSettings),
- data: result.data,
- };
-
- let entrySeries: SingleSeries[];
- if (needsManualBreakoutSplit && colors instanceof Map) {
- const { series, activeBreakoutColorMap } = splitByBreakout(
- singleSeries,
- definitions.length,
- isFirstSeries,
- colors,
- );
- entrySeries = series;
- activeBreakoutColors[entry.id] = activeBreakoutColorMap;
- } else {
- entrySeries = [singleSeries];
- if (hasBreakout && !needsManualBreakoutSplit && colors instanceof Map) {
- activeBreakoutColors[entry.id] = filterBreakoutColorsByData(
- colors,
- result.data,
- );
- } else {
- activeBreakoutColors[entry.id] = color;
- }
- }
- isFirstSeries = false;
-
- for (const s of entrySeries) {
- cardIdToDefinitionId[s.card.id] = entry.id;
- }
-
- return entrySeries;
- });
-
- if (series.length > 1 && displayType.combineSettings) {
- series[0].card.visualization_settings = displayType.combineSettings(
- series.map((s) => s.card.visualization_settings),
- );
- }
-
- return { series, cardIdToDefinitionId, activeBreakoutColors };
-}
-
export function computeBreakoutColorSettings(
breakoutColors: BreakoutColorMap,
breakoutCol: DatasetColumn,
@@ -552,69 +646,245 @@ function computeAvailableOptions(
});
}
+/**
+ * Builds dimension items for the pill bar. Standalone metrics produce one
+ * `DimensionItem` each. Expression entities produce one
+ * `ExpressionDimensionItem` that groups all constituent metric-token slots
+ * into a single pill with per-metric accordion sections.
+ */
export function buildDimensionItemsFromDefinitions(
- definitions: MetricsViewerDefinitionEntry[],
- dimensionMapping: Record<MetricSourceId, DimensionId | null>,
- modifiedDefinitions: Map<MetricSourceId, MetricDefinition>,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ dimensionMapping: Record<number, DimensionId | null>,
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,
sourceColors: SourceColorMap,
+ metricSlots: MetricSlot[],
+ formulaEntities: MetricsViewerFormulaEntity[],
+ projectionConfig: { temporalUnit?: TemporalUnit; binningStrategy?: string },
dimensionFilter?: (dimension: LibMetric.DimensionMetadata) => boolean,
-): DimensionItem[] {
- return definitions.flatMap((entry): DimensionItem[] => {
- if (!entry.definition) {
- return [];
+): DimensionPillBarItem[] {
+ const items: DimensionPillBarItem[] = [];
+
+ // Track which entity indices we've already emitted items for.
+ const processedEntityIndices = new Set<number>();
+
+ for (const slot of metricSlots) {
+ // Skip if we already processed this entity index.
+ if (processedEntityIndices.has(slot.entityIndex)) {
+ continue;
}
- const dimensionId = dimensionMapping[entry.id];
- const entryColors = sourceColors[entry.id];
- const modifiedDefinition = modifiedDefinitions.get(entry.id);
+ const entity = formulaEntities[slot.entityIndex];
+
+ if (isExpressionEntry(entity)) {
+ // Expression entity — gather all token slots for this entity and
+ // produce a single ExpressionDimensionItem.
+ processedEntityIndices.add(slot.entityIndex);
+
+ const entitySlots = slotsForEntity(metricSlots, slot.entityIndex);
+ const metricSources = buildExpressionMetricSources(
+ entitySlots,
+ definitions,
+ dimensionMapping,
+ sourceColors,
+ projectionConfig,
+ entity,
+ dimensionFilter,
+ );
- if (dimensionId != null && modifiedDefinition) {
- const projections = LibMetric.projections(modifiedDefinition);
- if (projections.length === 0) {
- return [];
- }
+ // Derive aggregate label and icon from selected dimensions.
+ const selectedLabels = metricSources
+ .map((s) => s.currentDimensionLabel)
+ .filter(Boolean);
+ const uniqueLabels = [...new Set(selectedLabels)];
+ const label =
+ uniqueLabels.length === 1
+ ? uniqueLabels[0]
+ : uniqueLabels.length > 1
+ ? t`Multiple dimensions`
+ : undefined;
+ const selectedIcons = metricSources
+ .map((s) => s.currentDimensionIcon)
+ .filter(Boolean);
+ const uniqueIcons = [...new Set(selectedIcons)];
+ const icon = uniqueIcons.length === 1 ? uniqueIcons[0] : undefined;
+
+ const expressionColors = sourceColors[slot.entityIndex];
+
+ items.push({
+ type: "expression",
+ id: slot.entityIndex,
+ colors: expressionColors,
+ label,
+ icon,
+ metricSources,
+ } satisfies ExpressionDimensionItem);
+ }
- const projectionDimension = LibMetric.projectionDimension(
- modifiedDefinition,
- projections[0],
+ if (isMetricEntry(entity)) {
+ processedEntityIndices.add(slot.entityIndex);
+
+ const item = buildStandaloneDimensionItem(
+ entity,
+ slot,
+ definitions,
+ dimensionMapping,
+ modifiedDefinitionsBySlotIndex,
+ sourceColors,
+ dimensionFilter,
);
- if (!projectionDimension) {
- return [];
+ if (item) {
+ items.push(item);
}
+ }
+ }
- const dimensionInfo = LibMetric.displayInfo(
- modifiedDefinition,
- projectionDimension,
- );
+ return items;
+}
- return [
- {
- id: entry.id,
- label: dimensionInfo.longDisplayName,
- icon: getDimensionIcon(projectionDimension),
- colors: entryColors,
- availableOptions: computeAvailableOptions(
- entry,
- modifiedDefinition,
- dimensionFilter,
- ),
- },
- ];
+function buildStandaloneDimensionItem(
+ entity: MetricDefinitionEntry,
+ slot: MetricSlot,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ dimensionMapping: Record<number, DimensionId | null>,
+ modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,
+ sourceColors: SourceColorMap,
+ dimensionFilter?: (dimension: LibMetric.DimensionMetadata) => boolean,
+): MetricDimensionItem | null {
+ const defEntry = getEffectiveDefinitionEntry(entity, definitions);
+ if (!defEntry?.definition) {
+ return null;
+ }
+
+ const effectiveEntry: MetricsViewerDefinitionEntry = {
+ id: slot.sourceId,
+ definition: defEntry.definition,
+ };
+
+ const dimensionId = dimensionMapping[slot.slotIndex];
+ const entryColors = sourceColors[slot.entityIndex];
+ const modifiedDefinition = modifiedDefinitionsBySlotIndex.get(slot.slotIndex);
+
+ if (dimensionId != null && modifiedDefinition) {
+ const projections = LibMetric.projections(modifiedDefinition);
+ if (projections.length === 0) {
+ return null;
}
- const availableOptions = computeAvailableOptions(
- entry,
+ const projectionDimension = LibMetric.projectionDimension(
+ modifiedDefinition,
+ projections[0],
+ );
+ if (!projectionDimension) {
+ return null;
+ }
+
+ const dimensionInfo = LibMetric.displayInfo(
+ modifiedDefinition,
+ projectionDimension,
+ );
+
+ return {
+ id: slot.slotIndex,
+ type: "metric",
+ label: dimensionInfo.longDisplayName,
+ icon: getDimensionIcon(projectionDimension),
+ colors: entryColors,
+ availableOptions: computeAvailableOptions(
+ effectiveEntry,
+ modifiedDefinition,
+ dimensionFilter,
+ ),
+ };
+ }
+
+ return {
+ id: slot.slotIndex,
+ type: "metric",
+ label: undefined,
+ icon: undefined,
+ colors: entryColors,
+ availableOptions: computeAvailableOptions(
+ effectiveEntry,
undefined,
dimensionFilter,
- );
+ ),
+ };
+}
+
+function buildExpressionMetricSources(
+ entitySlots: MetricSlot[],
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ dimensionMapping: Record<number, DimensionId | null>,
+ sourceColors: SourceColorMap,
+ projectionConfig: { temporalUnit?: TemporalUnit; binningStrategy?: string },
+ entity: ExpressionDefinitionEntry,
+ dimensionFilter?: (dimension: LibMetric.DimensionMetadata) => boolean,
+): ExpressionMetricSource[] {
+ return entitySlots.flatMap((slot): ExpressionMetricSource[] => {
+ const defEntry = definitions[slot.sourceId];
+ if (!defEntry?.definition) {
+ return [];
+ }
+
+ const effectiveEntry: MetricsViewerDefinitionEntry = {
+ id: slot.sourceId,
+ definition: defEntry.definition,
+ };
+
+ const dimensionId = dimensionMapping[slot.slotIndex];
+ const entryColors = sourceColors[slot.entityIndex];
+ const metricName = getDefinitionName(defEntry.definition) ?? slot.sourceId;
+
+ // Compute modified definition on the fly for expression token slots.
+ let modifiedDefinition: MetricDefinition | undefined;
+ if (dimensionId) {
+ modifiedDefinition =
+ getModifiedDefinition(
+ defEntry.definition,
+ dimensionId,
+ projectionConfig,
+ ) ?? undefined;
+ }
+
+ let currentDimensionLabel: string | undefined;
+ let currentDimensionIcon: IconName | undefined;
+ if (dimensionId != null && modifiedDefinition) {
+ const projections = LibMetric.projections(modifiedDefinition);
+ if (projections.length > 0) {
+ const projDim = LibMetric.projectionDimension(
+ modifiedDefinition,
+ projections[0],
+ );
+ if (projDim) {
+ currentDimensionLabel = LibMetric.displayInfo(
+ modifiedDefinition,
+ projDim,
+ ).longDisplayName;
+ currentDimensionIcon = getDimensionIcon(projDim);
+ }
+ }
+ }
return [
{
- id: entry.id,
- label: undefined,
- icon: undefined,
+ slotIndex: slot.slotIndex,
+ sourceId: slot.sourceId,
+ metricName,
+ metricCount: (() => {
+ if (slot.tokenPosition == null) {
+ return undefined;
+ }
+ const token = entity.tokens[slot.tokenPosition];
+ return token?.type === "metric" ? token.count : undefined;
+ })(),
colors: entryColors,
- availableOptions,
+ currentDimensionLabel,
+ currentDimensionIcon,
+ availableOptions: computeAvailableOptions(
+ effectiveEntry,
+ modifiedDefinition,
+ dimensionFilter,
+ ),
},
];
});
diff --git a/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts
index 60e88743d29..3712ffcd96e 100644
--- a/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts
@@ -1,6 +1,7 @@
import type {
MetricBreakoutValuesResponse,
RowValues,
+ VisualizationSettings,
} from "metabase-types/api";
import { createMockColumn } from "metabase-types/api/mocks";
import { createMockDatasetData } from "metabase-types/api/mocks/dataset";
@@ -46,6 +47,7 @@ const metricCol = createMockColumn({
});
const CARD_OPTS = { id: 1, name: "Revenue", display: "line" } as const;
+const EMPTY_VIZ: VisualizationSettings = {};
function makeColorMap(values: string[]): BreakoutColorMap {
const palette = [
@@ -79,6 +81,7 @@ describe("splitByBreakout", () => {
1,
true,
makeColorMap(["Gadgets", "Widgets"]),
+ EMPTY_VIZ,
);
expect(result).toHaveLength(2);
@@ -114,6 +117,7 @@ describe("splitByBreakout", () => {
2,
true,
makeColorMap(["Gadgets", "Widgets"]),
+ EMPTY_VIZ,
);
expect(result[0].card.name).toBe("Revenue: Gadgets");
@@ -139,6 +143,7 @@ describe("splitByBreakout", () => {
1,
true,
makeColorMap(["Gadgets", "Widgets"]),
+ EMPTY_VIZ,
);
expect(result).toHaveLength(2);
@@ -172,6 +177,7 @@ describe("splitByBreakout", () => {
1,
true,
makeColorMap(["Gadgets", "Widgets"]),
+ EMPTY_VIZ,
);
const ids = result.map((s) => s.card.id);
@@ -190,7 +196,13 @@ describe("splitByBreakout", () => {
});
const colorMap = makeColorMap(["Gadgets", "Widgets"]);
- const { series: result } = splitByBreakout(series, 1, true, colorMap);
+ const { series: result } = splitByBreakout(
+ series,
+ 1,
+ true,
+ colorMap,
+ EMPTY_VIZ,
+ );
expect(result[0].card.visualization_settings.series_settings).toBeDefined();
expect(result[1].card.visualization_settings.series_settings).toBeDefined();
@@ -208,6 +220,7 @@ describe("splitByBreakout", () => {
1,
true,
makeColorMap(values),
+ EMPTY_VIZ,
);
expect(result).toHaveLength(1);
@@ -230,6 +243,7 @@ describe("splitByBreakout", () => {
1,
true,
makeColorMap(["Gadgets", "Widgets"]),
+ EMPTY_VIZ,
);
expect(result[0].data.cols).toBe(result[1].data.cols);
@@ -257,6 +271,7 @@ describe("splitByBreakout", () => {
1,
true,
colorMap,
+ EMPTY_VIZ,
);
expect(result).toHaveLength(1);
@@ -280,7 +295,13 @@ describe("splitByBreakout", () => {
["Widgets", "#88BF4D"],
]);
- const { series: result } = splitByBreakout(series, 1, true, colorMap);
+ const { series: result } = splitByBreakout(
+ series,
+ 1,
+ true,
+ colorMap,
+ EMPTY_VIZ,
+ );
expect(result).toHaveLength(2);
// series order follows colorMap iteration order, not data order
@@ -306,19 +327,21 @@ describe("splitByBreakout", () => {
});
describe("computeSourceBreakoutColors", () => {
- it("returns empty object for empty definitions", () => {
- expect(computeSourceBreakoutColors([])).toEqual({});
+ it("returns empty object for empty formula entities", () => {
+ expect(computeSourceBreakoutColors([], {})).toEqual({});
});
it("returns a string color for a definition without breakout", () => {
const metadata = createMetricMetadata([REVENUE_METRIC]);
const definition = setupDefinition(metadata, REVENUE_METRIC.id);
+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
- const result = computeSourceBreakoutColors([
- { id: "metric:1", definition },
- ]);
+ const result = computeSourceBreakoutColors(
+ [{ id: sourceId, type: "metric" as const, definition }],
+ { [sourceId]: { id: sourceId, definition } },
+ );
- expect(typeof result["metric:1"]).toBe("string");
+ expect(typeof result[0]).toBe("string");
});
it("returns a Map for a definition with breakout and breakout values", () => {
@@ -328,13 +351,11 @@ describe("computeSourceBreakoutColors", () => {
REVENUE_METRIC.id,
1,
);
+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
- const breakoutValues = new Map<
- MetricSourceId,
- MetricBreakoutValuesResponse
- >([
+ const breakoutValues = new Map<number, MetricBreakoutValuesResponse>([
[
- "metric:1",
+ 0,
{
values: ["Gadgets", "Widgets"],
col: createMockColumn({
@@ -347,12 +368,13 @@ describe("computeSourceBreakoutColors", () => {
]);
const result = computeSourceBreakoutColors(
- [{ id: "metric:1", definition }],
+ [{ id: sourceId, type: "metric" as const, definition }],
+ { [sourceId]: { id: sourceId, definition } },
breakoutValues,
);
- expect(result["metric:1"]).toBeInstanceOf(Map);
- const colorMap = result["metric:1"] as Map<string, string>;
+ expect(result[0]).toBeInstanceOf(Map);
+ const colorMap = result[0] as Map<string, string>;
expect(colorMap.size).toBe(2);
expect(colorMap.has("Gadgets")).toBe(true);
expect(colorMap.has("Widgets")).toBe(true);
@@ -368,13 +390,12 @@ describe("computeSourceBreakoutColors", () => {
1,
);
const withoutBreakout = setupDefinition(metadata, REVENUE_METRIC.id);
+ const sourceId1: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
+ const sourceId2: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
- const breakoutValues = new Map<
- MetricSourceId,
- MetricBreakoutValuesResponse
- >([
+ const breakoutValues = new Map<number, MetricBreakoutValuesResponse>([
[
- "metric:1",
+ 0,
{
values: ["Gadgets", "Widgets"],
col: createMockColumn({
@@ -388,14 +409,22 @@ describe("computeSourceBreakoutColors", () => {
const result = computeSourceBreakoutColors(
[
- { id: "metric:1", definition: withBreakout },
- { id: "metric:2" as MetricSourceId, definition: withoutBreakout },
+ { id: sourceId1, type: "metric" as const, definition: withBreakout },
+ {
+ id: sourceId2,
+ type: "metric" as const,
+ definition: withoutBreakout,
+ },
],
+ {
+ [sourceId1]: { id: sourceId1, definition: withBreakout },
+ [sourceId2]: { id: sourceId2, definition: withoutBreakout },
+ },
breakoutValues,
);
- expect(result["metric:1"]).toBeInstanceOf(Map);
- expect(typeof result["metric:2" as MetricSourceId]).toBe("string");
+ expect(result[0]).toBeInstanceOf(Map);
+ expect(typeof result[1]).toBe("string");
});
it("falls back to string when breakout definition has no breakout values", () => {
@@ -405,13 +434,15 @@ describe("computeSourceBreakoutColors", () => {
REVENUE_METRIC.id,
1,
);
+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
const result = computeSourceBreakoutColors(
- [{ id: "metric:1", definition }],
+ [{ id: sourceId, type: "metric" as const, definition }],
+ { [sourceId]: { id: sourceId, definition } },
new Map(),
);
- expect(typeof result["metric:1"]).toBe("string");
+ expect(typeof result[0]).toBe("string");
});
});
diff --git a/frontend/src/metabase/metrics-viewer/utils/tab-config.ts b/frontend/src/metabase/metrics-viewer/utils/tab-config.ts
index 82482d8d2b3..f84ca6a21c7 100644
--- a/frontend/src/metabase/metrics-viewer/utils/tab-config.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/tab-config.ts
@@ -12,6 +12,7 @@ import type {
MetricsViewerTabType,
} from "../types/viewer-state";
+import { getDefinitionColumnName } from "./definition-builder";
import { getMapRegionForDimension } from "./geo-dimensions";
// ── Types ──
@@ -21,17 +22,28 @@ export interface ChartTypeOption {
icon: IconName;
}
-interface DisplayTypeDefinition {
- supportsMultipleSeries: boolean;
- supportsStacking: boolean;
- getSettings: (
- def: MetricDefinition,
- dimension: DimensionMetadata,
- ) => VisualizationSettings;
- combineSettings?: (
- settings: VisualizationSettings[],
- ) => VisualizationSettings;
-}
+type DisplayTypeDefinition =
+ | {
+ dimensionRequired: true;
+ supportsMultipleSeries: boolean;
+ supportsStacking: boolean;
+ getSettings: (
+ def: MetricDefinition,
+ dimension: DimensionMetadata,
+ ) => VisualizationSettings;
+ combineSettings?: (
+ settings: VisualizationSettings[],
+ ) => VisualizationSettings;
+ }
+ | {
+ dimensionRequired: false;
+ supportsMultipleSeries: boolean;
+ supportsStacking: boolean;
+ getSettings: (def: MetricDefinition) => VisualizationSettings;
+ combineSettings?: (
+ settings: VisualizationSettings[],
+ ) => VisualizationSettings;
+ };
interface BaseTabTypeDefinition {
type: MetricsViewerTabType;
@@ -40,6 +52,8 @@ interface BaseTabTypeDefinition {
dimensionSubtype?: (dimension: DimensionMetadata) => string | null;
defaultDisplayType: MetricsViewerDisplayType;
availableDisplayTypes: ChartTypeOption[];
+ minDimensions: number;
+ index?: number;
}
interface AggregateTabType extends BaseTabTypeDefinition {
@@ -82,6 +96,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [
fixedId: "time",
defaultDisplayType: "line",
availableDisplayTypes: STANDARD_CHART_TYPES,
+ minDimensions: 1,
},
{
type: "geo",
@@ -92,6 +107,18 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [
dimensionSubtype: getGeoSubtype,
defaultDisplayType: "map",
availableDisplayTypes: GEO_CHART_TYPES,
+ minDimensions: 1,
+ },
+ {
+ type: "scalar",
+ autoCreate: true,
+ matchMode: "aggregate",
+ fixedId: "scalar",
+ dimensionPredicate: () => false,
+ defaultDisplayType: "scalar",
+ availableDisplayTypes: [{ type: "scalar", icon: "number" }],
+ index: 5,
+ minDimensions: 0,
},
{
type: "category",
@@ -100,6 +127,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [
matchMode: "exact-column",
defaultDisplayType: "bar",
availableDisplayTypes: STANDARD_CHART_TYPES,
+ minDimensions: 1,
},
{
type: "boolean",
@@ -108,6 +136,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [
matchMode: "exact-column",
defaultDisplayType: "bar",
availableDisplayTypes: STANDARD_CHART_TYPES,
+ minDimensions: 1,
},
{
type: "numeric",
@@ -116,6 +145,7 @@ export const TAB_TYPE_REGISTRY: TabTypeDefinition[] = [
matchMode: "exact-column",
defaultDisplayType: "bar",
availableDisplayTypes: NUMERIC_CHART_TYPES,
+ minDimensions: 1,
},
];
@@ -162,13 +192,6 @@ function getChartSettings(
};
}
-function getPieSettings(
- _def: MetricDefinition,
- _dimension: DimensionMetadata,
-): VisualizationSettings {
- return {};
-}
-
function getScatterSettings(
def: MetricDefinition,
dimension: DimensionMetadata,
@@ -201,6 +224,12 @@ function getMapSettings(
};
}
+function getScalarSettings(def: MetricDefinition): VisualizationSettings {
+ return {
+ "scalar.field": getDefinitionColumnName(def) ?? undefined,
+ };
+}
+
function combineColors(
settings: VisualizationSettings[],
): VisualizationSettings {
@@ -221,41 +250,43 @@ export const DISPLAY_TYPE_REGISTRY: Record<
DisplayTypeDefinition
> = {
line: {
+ dimensionRequired: true,
supportsMultipleSeries: true,
supportsStacking: true,
getSettings: getChartSettings,
combineSettings: combineColors,
},
area: {
+ dimensionRequired: true,
supportsMultipleSeries: true,
supportsStacking: true,
getSettings: getChartSettings,
combineSettings: combineColors,
},
bar: {
+ dimensionRequired: true,
supportsMultipleSeries: true,
supportsStacking: true,
getSettings: getChartSettings,
combineSettings: combineColors,
},
- row: {
- supportsMultipleSeries: true,
- supportsStacking: false,
- getSettings: getChartSettings,
- },
scatter: {
+ dimensionRequired: true,
supportsMultipleSeries: true,
- supportsStacking: false,
+ supportsStacking: true,
getSettings: getScatterSettings,
+ combineSettings: combineColors,
},
map: {
+ dimensionRequired: true,
supportsMultipleSeries: false,
- supportsStacking: false,
+ supportsStacking: true,
getSettings: getMapSettings,
},
- pie: {
+ scalar: {
+ dimensionRequired: false,
supportsMultipleSeries: false,
- supportsStacking: false,
- getSettings: getPieSettings,
+ supportsStacking: true,
+ getSettings: getScalarSettings,
},
};
diff --git a/frontend/src/metabase/metrics-viewer/utils/tabs.ts b/frontend/src/metabase/metrics-viewer/utils/tabs.ts
index 5e3781c6ae4..8b27a1cb5a8 100644
--- a/frontend/src/metabase/metrics-viewer/utils/tabs.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/tabs.ts
@@ -1,3 +1,5 @@
+import { t } from "ttag";
+
import type { DimensionDescriptor } from "metabase/metrics/common/utils/dimension-descriptors";
import { getDimensionDescriptors } from "metabase/metrics/common/utils/dimension-descriptors";
import { GEO_SUBTYPE_PRIORITY } from "metabase/metrics/common/utils/dimension-types";
@@ -9,11 +11,13 @@ import * as LibMetric from "metabase-lib/metric";
import { MAX_AUTO_TABS } from "../constants";
import type {
MetricSourceId,
+ MetricsViewerDefinitionEntry,
MetricsViewerTabState,
MetricsViewerTabType,
StoredMetricsViewerTab,
} from "../types/viewer-state";
+import type { MetricSlot } from "./metric-slots";
import {
TAB_TYPE_REGISTRY,
type TabTypeDefinition,
@@ -108,18 +112,58 @@ export function resolveCommonTabLabel(names: string[]): string | null {
return bestName;
}
+/**
+ * Recompute tab labels from the current dimension mappings.
+ * Returns a new array only if at least one label changed.
+ */
+export function recomputeTabLabels(
+ tabs: MetricsViewerTabState[],
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+ metricSlots: MetricSlot[],
+): MetricsViewerTabState[] {
+ const dimsBySlotIndex = new Map<
+ number,
+ Map<string, ViewerDimensionDescriptor>
+ >();
+ for (const slot of metricSlots) {
+ const entry = definitions[slot.sourceId];
+ if (entry?.definition) {
+ dimsBySlotIndex.set(
+ slot.slotIndex,
+ getDimensionsByType(entry.definition),
+ );
+ }
+ }
+
+ let changed = false;
+ const result = tabs.map((tab) => {
+ const names = resolveTabDimensionNames(
+ tab.dimensionMapping,
+ dimsBySlotIndex,
+ );
+ const label = resolveCommonTabLabel(names);
+ if (label != null && label !== tab.label) {
+ changed = true;
+ return { ...tab, label };
+ }
+ return tab;
+ });
+
+ return changed ? result : tabs;
+}
+
// ── Default tab computation ──
-function getDimensionDescriptorsBySource(
+function getDimensionDescriptorsBySlotIndex(
definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,
- sourceOrder: MetricSourceId[],
-): Map<MetricSourceId, Map<string, DimensionDescriptor>> {
- const result = new Map<MetricSourceId, Map<string, DimensionDescriptor>>();
+ metricSlots: MetricSlot[],
+): Map<number, Map<string, DimensionDescriptor>> {
+ const result = new Map<number, Map<string, DimensionDescriptor>>();
- for (const sourceId of sourceOrder) {
- const def = definitionsBySourceId[sourceId];
+ for (const slot of metricSlots) {
+ const def = definitionsBySourceId[slot.sourceId];
if (def) {
- result.set(sourceId, getDimensionDescriptors(def));
+ result.set(slot.slotIndex, getDimensionDescriptors(def));
}
}
@@ -127,13 +171,19 @@ function getDimensionDescriptorsBySource(
}
function resolveTabDimensionNames(
- dimensionMapping: Record<MetricSourceId, string>,
- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,
+ dimensionMapping: Record<number, string | null>,
+ dimensionsBySlotIndex: Map<number, Map<string, DimensionDescriptor>>,
): string[] {
const names: string[] = [];
- for (const [sourceId, dimensionId] of getObjectEntries(dimensionMapping)) {
- const dimensionInfo = dimensionsBySource.get(sourceId)?.get(dimensionId);
+ for (const [key, dimensionId] of getObjectEntries(dimensionMapping)) {
+ if (dimensionId == null) {
+ continue;
+ }
+ const slotIndex = Number(key);
+ const dimensionInfo = dimensionsBySlotIndex
+ .get(slotIndex)
+ ?.get(dimensionId);
if (dimensionInfo) {
names.push(dimensionInfo.displayName);
}
@@ -181,52 +231,68 @@ function pickBestGeoSubtype(found: Set<string>): string | null {
return found.size > 0 ? (found.values().next().value ?? null) : null;
}
-function computeBestSubtypeAcrossSources(
- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,
+function collectSubtypes(
+ dimensions: Map<string, DimensionDescriptor>,
type: MetricsViewerTabType,
getSubtype: (dimension: DimensionMetadata) => string | null,
-): string | null {
- const found = new Set<string>();
-
- for (const [, dimensions] of dimensionsBySource) {
- for (const [, info] of dimensions) {
- if (info.dimensionType === type) {
- const subtype = getSubtype(info.dimensionMetadata);
- if (subtype) {
- found.add(subtype);
- }
+ into: Set<string>,
+): void {
+ for (const [, info] of dimensions) {
+ if (info.dimensionType === type) {
+ const subtype = getSubtype(info.dimensionMetadata);
+ if (subtype) {
+ into.add(subtype);
}
}
}
+}
+function computeBestSubtypeAcrossSources(
+ dimensionsByEntityIndex: Map<number, Map<string, DimensionDescriptor>>,
+ type: MetricsViewerTabType,
+ getSubtype: (dimension: DimensionMetadata) => string | null,
+): string | null {
+ const found = new Set<string>();
+ for (const [, dimensions] of dimensionsByEntityIndex) {
+ collectSubtypes(dimensions, type, getSubtype, found);
+ }
return pickBestGeoSubtype(found);
}
function findReferenceAcrossSources(
- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,
- sourceOrder: MetricSourceId[],
+ dimensionsByEntityIndex: Map<number, Map<string, DimensionDescriptor>>,
+ entityOrder: number[],
type: MetricsViewerTabType,
-): { sourceId: MetricSourceId; dimension: DimensionDescriptor } | null {
- for (const sourceId of sourceOrder) {
- const dimensions = dimensionsBySource.get(sourceId);
+): { entityIndex: number; dimension: DimensionDescriptor } | null {
+ for (const entityIndex of entityOrder) {
+ const dimensions = dimensionsByEntityIndex.get(entityIndex);
if (!dimensions) {
continue;
}
const defaultDimension = findDimensionOfType(dimensions, type, true);
if (defaultDimension) {
- return { sourceId, dimension: defaultDimension };
+ return { entityIndex, dimension: defaultDimension };
}
}
return null;
}
+/**
+ * Find the best matching dimension in `dimensions` for a given `reference`.
+ *
+ * Match priority: exact source > case-insensitive name > compatible type.
+ * When `getSubtype` is provided, name and type matches also require the
+ * subtype to agree (used for geo dimension matching).
+ */
function findSourceMatch(
dimensions: Map<string, DimensionDescriptor>,
type: MetricsViewerTabType,
reference: DimensionDescriptor,
+ getSubtype?: (dimension: DimensionMetadata) => string | null,
): DimensionDescriptor | null {
let nameMatch: DimensionDescriptor | null = null;
- const referenceName = reference.name;
+ let typeMatch: DimensionDescriptor | null = null;
+ const referenceName = reference.name.toLowerCase();
for (const [, info] of dimensions) {
if (info.dimensionType !== type) {
@@ -240,24 +306,49 @@ function findSourceMatch(
) {
return info;
}
- if (!nameMatch && referenceName && info.name === referenceName) {
- nameMatch = info;
+ if (
+ !nameMatch &&
+ referenceName &&
+ info.name.toLowerCase() === referenceName
+ ) {
+ if (
+ !getSubtype ||
+ getSubtype(info.dimensionMetadata) ===
+ getSubtype(reference.dimensionMetadata)
+ ) {
+ nameMatch = info;
+ }
+ }
+ if (
+ !typeMatch &&
+ LibMetric.isCompatibleType(
+ info.dimensionMetadata,
+ reference.dimensionMetadata,
+ )
+ ) {
+ if (
+ !getSubtype ||
+ getSubtype(info.dimensionMetadata) ===
+ getSubtype(reference.dimensionMetadata)
+ ) {
+ typeMatch = info;
+ }
}
}
- return nameMatch;
+ return nameMatch ?? typeMatch;
}
function resolveAggregateDimensionMapping(
- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,
- sourceOrder: MetricSourceId[],
+ dimensionsByEntityIndex: Map<number, Map<string, DimensionDescriptor>>,
+ entityOrder: number[],
config: TabTypeDefinition,
-): Record<MetricSourceId, string> {
- const mapping: Record<MetricSourceId, string> = {};
+): Record<number, string> {
+ const mapping: Record<number, string> = {};
if (config.dimensionSubtype) {
const targetSubtype = computeBestSubtypeAcrossSources(
- dimensionsBySource,
+ dimensionsByEntityIndex,
config.type,
config.dimensionSubtype,
);
@@ -265,8 +356,8 @@ function resolveAggregateDimensionMapping(
return mapping;
}
- for (const sourceId of sourceOrder) {
- const dimensions = dimensionsBySource.get(sourceId);
+ for (const entityIndex of entityOrder) {
+ const dimensions = dimensionsByEntityIndex.get(entityIndex);
if (!dimensions) {
continue;
}
@@ -277,7 +368,7 @@ function resolveAggregateDimensionMapping(
targetSubtype,
);
if (match) {
- mapping[sourceId] = match.id;
+ mapping[entityIndex] = match.id;
}
}
@@ -285,21 +376,21 @@ function resolveAggregateDimensionMapping(
}
const reference = findReferenceAcrossSources(
- dimensionsBySource,
- sourceOrder,
+ dimensionsByEntityIndex,
+ entityOrder,
config.type,
);
if (reference) {
- mapping[reference.sourceId] = reference.dimension.id;
+ mapping[reference.entityIndex] = reference.dimension.id;
}
- for (const sourceId of sourceOrder) {
- if (mapping[sourceId]) {
+ for (const entityIndex of entityOrder) {
+ if (mapping[entityIndex]) {
continue;
}
- const dimensions = dimensionsBySource.get(sourceId);
+ const dimensions = dimensionsByEntityIndex.get(entityIndex);
if (!dimensions) {
continue;
}
@@ -312,7 +403,7 @@ function resolveAggregateDimensionMapping(
findDimensionOfType(dimensions, config.type);
if (match) {
- mapping[sourceId] = match.id;
+ mapping[entityIndex] = match.id;
}
}
@@ -320,24 +411,24 @@ function resolveAggregateDimensionMapping(
}
function collectUniqueExactDimensions(
- dimensionsBySource: Map<MetricSourceId, Map<string, DimensionDescriptor>>,
- sourceOrder: MetricSourceId[],
+ dimensionsBySlotIndex: Map<number, Map<string, DimensionDescriptor>>,
+ slotOrder: number[],
type: MetricsViewerTabType,
): Map<
string,
- { displayName: string; sourceIds: MetricSourceId[]; canListValues: boolean }
+ { displayName: string; slotIndices: number[]; canListValues: boolean }
> {
const unique = new Map<
string,
{
displayName: string;
- sourceIds: MetricSourceId[];
+ slotIndices: number[];
canListValues: boolean;
}
>();
- for (const sourceId of sourceOrder) {
- const dimensions = dimensionsBySource.get(sourceId);
+ for (const slotIndex of slotOrder) {
+ const dimensions = dimensionsBySlotIndex.get(slotIndex);
if (!dimensions) {
continue;
}
@@ -349,14 +440,14 @@ function collectUniqueExactDimensions(
const existing = unique.get(info.id);
if (existing) {
- existing.sourceIds.push(sourceId);
+ existing.slotIndices.push(slotIndex);
if (info.canListValues) {
existing.canListValues = true;
}
} else {
unique.set(info.id, {
displayName: info.displayName,
- sourceIds: [sourceId],
+ slotIndices: [slotIndex],
canListValues: info.canListValues ?? false,
});
}
@@ -368,21 +459,23 @@ function collectUniqueExactDimensions(
export function computeDefaultTabs(
definitionsBySourceId: Record<MetricSourceId, MetricDefinition | null>,
- sourceOrder: MetricSourceId[],
+ metricSlots: MetricSlot[],
): MetricsViewerTabState[] {
- if (sourceOrder.length === 0) {
+ if (metricSlots.length === 0) {
return [];
}
- const dimensionsBySource = getDimensionDescriptorsBySource(
+ const slotOrder = metricSlots.map((s) => s.slotIndex);
+
+ const dimensionsBySlotIndex = getDimensionDescriptorsBySlotIndex(
definitionsBySourceId,
- sourceOrder,
+ metricSlots,
);
- if (dimensionsBySource.size === 0) {
+ if (dimensionsBySlotIndex.size === 0) {
return [];
}
- const tabs: MetricsViewerTabState[] = [];
+ const tabs: (MetricsViewerTabState & { index?: number })[] = [];
for (const config of TAB_TYPE_REGISTRY) {
if (!config.autoCreate || tabs.length >= MAX_AUTO_TABS) {
@@ -391,29 +484,33 @@ export function computeDefaultTabs(
if (config.matchMode === "aggregate") {
const mapping = resolveAggregateDimensionMapping(
- dimensionsBySource,
- sourceOrder,
+ dimensionsBySlotIndex,
+ slotOrder,
config,
);
- if (Object.keys(mapping).length === 0) {
+ if (Object.keys(mapping).length < config.minDimensions) {
continue;
}
- const names = resolveTabDimensionNames(mapping, dimensionsBySource);
+ const names = resolveTabDimensionNames(mapping, dimensionsBySlotIndex);
tabs.push({
id: config.fixedId,
type: config.type,
- label: resolveCommonTabLabel(names),
+ label:
+ config.type === "scalar"
+ ? getScalarTabLabel()
+ : resolveCommonTabLabel(names),
display: config.defaultDisplayType,
dimensionMapping: mapping,
projectionConfig: {},
+ index: config.index,
});
continue;
}
const uniqueDimensions = collectUniqueExactDimensions(
- dimensionsBySource,
- sourceOrder,
+ dimensionsBySlotIndex,
+ slotOrder,
config.type,
);
@@ -426,14 +523,17 @@ export function computeDefaultTabs(
},
);
- for (const [dimensionId, { displayName, sourceIds }] of sortedDimensions) {
+ for (const [
+ dimensionId,
+ { displayName, slotIndices },
+ ] of sortedDimensions) {
if (tabs.length >= MAX_AUTO_TABS) {
break;
}
- const mapping: Record<MetricSourceId, string> = {};
- for (const sourceId of sourceIds) {
- mapping[sourceId] = dimensionId;
+ const mapping: Record<number, string> = {};
+ for (const slotIndex of slotIndices) {
+ mapping[slotIndex] = dimensionId;
}
tabs.push({
@@ -443,11 +543,14 @@ export function computeDefaultTabs(
display: config.defaultDisplayType,
dimensionMapping: mapping,
projectionConfig: {},
+ index: config.index,
});
}
}
- return tabs;
+ tabs.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+
+ return tabs.map(({ index, ...tab }) => tab);
}
// ── Manual tab creation ──
@@ -455,13 +558,16 @@ export function computeDefaultTabs(
export interface TabInfo {
type: MetricsViewerTabType;
label: string;
- dimensionMapping: Record<MetricSourceId, string>;
+ dimensionMapping: Record<number, string>;
}
export function createTabFromTabInfo(
tabInfo: TabInfo,
): MetricsViewerTabState | null {
const { type, label, dimensionMapping } = tabInfo;
+ if (type === "scalar") {
+ return createScalarTab();
+ }
const id = Object.values(dimensionMapping)[0];
if (id == null) {
return null;
@@ -477,20 +583,45 @@ export function createTabFromTabInfo(
};
}
+function createScalarTab(): MetricsViewerTabState | null {
+ const config = getTabConfig("scalar");
+ if (config.matchMode !== "aggregate") {
+ return null;
+ }
+ return {
+ id: config.fixedId,
+ type: config.type,
+ label: getScalarTabLabel(),
+ display: config.defaultDisplayType,
+ dimensionMapping: {},
+ projectionConfig: {},
+ };
+}
+
+export function getScalarTabLabel() {
+ return t`Totals`;
+}
+
// ── Tab dimension matching ──
function findSubtypeFromExistingTab(
tab: StoredMetricsViewerTab,
getSubtype: (dimension: DimensionMetadata) => string | null,
baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,
+ slotIndexToSourceId?: Map<number, MetricSourceId>,
): string | null {
- if (!baseDefinitions) {
+ if (!baseDefinitions || !slotIndexToSourceId) {
return null;
}
- for (const [sourceId, dimensionName] of getObjectEntries(
- tab.dimensionsBySource,
+ for (const [key, dimensionName] of getObjectEntries(
+ tab.dimensionBySlotIndex,
)) {
+ const slotIndex = Number(key);
+ const sourceId = slotIndexToSourceId.get(slotIndex);
+ if (!sourceId) {
+ continue;
+ }
const def = baseDefinitions[sourceId];
if (!def) {
continue;
@@ -505,21 +636,12 @@ function findSubtypeFromExistingTab(
}
function findBestSubtypeInDimensions(
- dimensionsByType: Map<string, DimensionDescriptor>,
+ dimensions: Map<string, DimensionDescriptor>,
tabType: MetricsViewerTabType,
getSubtype: (dimension: DimensionMetadata) => string | null,
): string | null {
const found = new Set<string>();
-
- for (const [, info] of dimensionsByType) {
- if (info.dimensionType === tabType) {
- const subtype = getSubtype(info.dimensionMetadata);
- if (subtype) {
- found.add(subtype);
- }
- }
- }
-
+ collectSubtypes(dimensions, tabType, getSubtype, found);
return pickBestGeoSubtype(found);
}
@@ -527,14 +649,20 @@ function findReferenceFromTab(
tab: StoredMetricsViewerTab,
type: MetricsViewerTabType,
baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,
+ slotIndexToSourceId?: Map<number, MetricSourceId>,
): DimensionDescriptor | null {
- if (!baseDefinitions) {
+ if (!baseDefinitions || !slotIndexToSourceId) {
return null;
}
- for (const [sourceId, dimensionName] of getObjectEntries(
- tab.dimensionsBySource,
+ for (const [key, dimensionName] of getObjectEntries(
+ tab.dimensionBySlotIndex,
)) {
+ const entityIndex = Number(key);
+ const sourceId = slotIndexToSourceId.get(entityIndex);
+ if (!sourceId) {
+ continue;
+ }
const def = baseDefinitions[sourceId];
if (!def) {
continue;
@@ -548,52 +676,21 @@ function findReferenceFromTab(
return null;
}
-function findDimensionBySourceMatch(
- dimensionsByType: Map<string, DimensionDescriptor>,
- reference: DimensionDescriptor,
- getSubtype?: (dimension: DimensionMetadata) => string | null,
-): string | null {
- let nameMatch: DimensionDescriptor | null = null;
-
- for (const [, info] of dimensionsByType) {
- if (info.dimensionType !== reference.dimensionType) {
- continue;
- }
- if (
- LibMetric.isSameSource(
- info.dimensionMetadata,
- reference.dimensionMetadata,
- )
- ) {
- return info.id;
- }
- if (
- !nameMatch &&
- info.name.toLowerCase() === reference.name.toLowerCase()
- ) {
- if (
- !getSubtype ||
- getSubtype(info.dimensionMetadata) ===
- getSubtype(reference.dimensionMetadata)
- ) {
- nameMatch = info;
- }
- }
- }
-
- return nameMatch?.id ?? null;
-}
-
function resolveSubtypeFallback(
dimensionsByType: Map<string, DimensionDescriptor>,
tabType: MetricsViewerTabType,
getSubtype: (dimension: DimensionMetadata) => string | null,
tab: StoredMetricsViewerTab,
baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,
+ slotIndexToSourceId?: Map<number, MetricSourceId>,
): string | null {
const targetSubtype =
- findSubtypeFromExistingTab(tab, getSubtype, baseDefinitions) ??
- findBestSubtypeInDimensions(dimensionsByType, tabType, getSubtype);
+ findSubtypeFromExistingTab(
+ tab,
+ getSubtype,
+ baseDefinitions,
+ slotIndexToSourceId,
+ ) ?? findBestSubtypeInDimensions(dimensionsByType, tabType, getSubtype);
if (!targetSubtype) {
return null;
@@ -609,15 +706,21 @@ function findExactColumnMatch(
dimensions: Map<string, DimensionDescriptor>,
tab: StoredMetricsViewerTab,
baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,
+ slotIndexToSourceId?: Map<number, MetricSourceId>,
): string | null {
const exactMatch = dimensions.get(tab.id);
if (exactMatch?.dimensionType === tab.type) {
return exactMatch.id;
}
- const reference = findReferenceFromTab(tab, tab.type, baseDefinitions);
+ const reference = findReferenceFromTab(
+ tab,
+ tab.type,
+ baseDefinitions,
+ slotIndexToSourceId,
+ );
if (reference) {
- return findDimensionBySourceMatch(dimensions, reference);
+ return findSourceMatch(dimensions, tab.type, reference)?.id ?? null;
}
return null;
@@ -628,8 +731,14 @@ function findAggregateMatch(
tab: StoredMetricsViewerTab,
config: TabTypeDefinition,
baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,
+ slotIndexToSourceId?: Map<number, MetricSourceId>,
): string | null {
- const reference = findReferenceFromTab(tab, config.type, baseDefinitions);
+ const reference = findReferenceFromTab(
+ tab,
+ config.type,
+ baseDefinitions,
+ slotIndexToSourceId,
+ );
const defaultMatch = findDimensionOfType(dimensions, config.type, true);
if (defaultMatch) {
@@ -637,13 +746,14 @@ function findAggregateMatch(
}
if (reference) {
- const sourceMatch = findDimensionBySourceMatch(
+ const sourceMatch = findSourceMatch(
dimensions,
+ config.type,
reference,
config.dimensionSubtype,
);
if (sourceMatch) {
- return sourceMatch;
+ return sourceMatch.id;
}
}
@@ -654,6 +764,7 @@ function findAggregateMatch(
config.dimensionSubtype,
tab,
baseDefinitions,
+ slotIndexToSourceId,
);
if (subtypeMatch) {
return subtypeMatch;
@@ -667,13 +778,25 @@ export function findMatchingDimensionForTab(
def: MetricDefinition,
tab: StoredMetricsViewerTab,
baseDefinitions?: Record<MetricSourceId, MetricDefinition | null>,
+ slotIndexToSourceId?: Map<number, MetricSourceId>,
): string | null {
const dimensions = getDimensionsByType(def);
- const config = TAB_TYPE_REGISTRY.find((config) => config.type === tab.type);
+ const config = getTabConfig(tab.type);
if (config?.matchMode !== "aggregate") {
- return findExactColumnMatch(dimensions, tab, baseDefinitions);
+ return findExactColumnMatch(
+ dimensions,
+ tab,
+ baseDefinitions,
+ slotIndexToSourceId,
+ );
}
- return findAggregateMatch(dimensions, tab, config, baseDefinitions);
+ return findAggregateMatch(
+ dimensions,
+ tab,
+ config,
+ baseDefinitions,
+ slotIndexToSourceId,
+ );
}
diff --git a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts b/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts
index 8b25e1a0530..70e3c8a918b 100644
--- a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts
@@ -2,20 +2,47 @@ import { b64url_to_utf8, utf8_to_b64url } from "metabase/utils/encoding";
import { getObjectEntries } from "metabase/utils/objects";
import type { MetricDefinition } from "metabase-lib/metric";
import * as LibMetric from "metabase-lib/metric";
-import type { TemporalUnit, VisualizationSettings } from "metabase-types/api";
+import type {
+ MathOperator,
+ TemporalUnit,
+ VisualizationSettings,
+} from "metabase-types/api";
import type {
+ ExpressionSubToken,
+ MetricExpressionId,
MetricSourceId,
+ MetricsViewerDefinitionEntry,
MetricsViewerDisplayType,
+ MetricsViewerFormulaEntity,
MetricsViewerPageState,
MetricsViewerTabState,
MetricsViewerTabType,
} from "../types/viewer-state";
+import { isExpressionEntry, isMetricEntry } from "../types/viewer-state";
+import {
+ applyProjection,
+ buildBinnedBreakoutDefinition,
+} from "../utils/definition-builder";
+import {
+ buildDimensionFilterClause,
+ extractDefinitionFilters,
+} from "../utils/dimension-filters";
import { defineCompactSchema } from "./compact-schema";
-import { getEntryBreakout } from "./definition-entries";
+import {
+ getEffectiveDefinitionEntry,
+ getEffectiveTokenDefinitionEntry,
+ getEntryBreakout,
+} from "./definition-entries";
import type { DimensionFilterValue } from "./dimension-filters";
-import { extractDefinitionFilters } from "./dimension-filters";
+import {
+ findBinningStrategy,
+ findDimensionById,
+ findFilterDimensionById,
+ findTemporalBucket,
+} from "./dimension-lookup";
+import { stampMetricCounts } from "./expression";
function reviveFilter(filter: DimensionFilterValue): DimensionFilterValue {
if (filter.type === "specific-date" || filter.type === "time") {
@@ -36,8 +63,90 @@ function reviveFilter(filter: DimensionFilterValue): DimensionFilterValue {
return filter;
}
+/**
+ * When we deserialize an entity, we can't apply breakouts or filters until the definition has loaded.
+ * So we store them and apply them lazily after the definition has loaded.
+ */
+export interface SerializedDefinitionInfo {
+ breakout?: string;
+ breakoutTemporalUnit?: TemporalUnit;
+ breakoutBinning?: string;
+ filters?: SerializedUrlFilter[];
+}
+
+export function applySerializedDefinitionInfo(
+ definition: MetricDefinition,
+ {
+ breakout,
+ breakoutTemporalUnit,
+ breakoutBinning,
+ filters,
+ }: SerializedDefinitionInfo,
+): MetricDefinition {
+ let result = definition;
+
+ if (breakout) {
+ const dimension = findDimensionById(result, breakout);
+ if (dimension) {
+ const dimensionRef = LibMetric.dimensionReference(dimension);
+
+ let modifiedRef: LibMetric.ProjectionClause | null = null;
+ if (breakoutTemporalUnit) {
+ const bucket = findTemporalBucket(
+ result,
+ dimension,
+ breakoutTemporalUnit,
+ );
+ if (bucket) {
+ modifiedRef = LibMetric.withTemporalBucket(dimensionRef, bucket);
+ }
+ } else if (breakoutBinning) {
+ const strategy = findBinningStrategy(
+ result,
+ dimension,
+ breakoutBinning,
+ );
+ if (strategy) {
+ modifiedRef = LibMetric.withBinning(dimensionRef, strategy);
+ }
+ }
+
+ result = modifiedRef
+ ? applyProjection(result, modifiedRef)
+ : buildBinnedBreakoutDefinition(result, dimensionRef);
+ }
+ }
+
+ if (filters) {
+ for (const filter of filters) {
+ const dimension = findFilterDimensionById(result, filter.dimensionId);
+ if (dimension) {
+ const clause = buildDimensionFilterClause(dimension, filter.value);
+ result = LibMetric.filter(result, clause);
+ }
+ }
+ }
+
+ return result;
+}
+
// ── Serialized types (internal, URL-facing) ──
+interface SerializedExpressionSubToken {
+ type: "metric" | "constant" | "operator" | "open-paren" | "close-paren";
+ sourceId?: string;
+ op?: MathOperator;
+ value?: number;
+ filters?: SerializedUrlFilter[];
+}
+
+interface SerializedExpressionEntry {
+ type: "expression";
+ id: string;
+ name: string;
+ tokens: SerializedExpressionSubToken[];
+}
+
interface SerializedUrlFilter {
dimensionId: string;
value: DimensionFilterValue;
@@ -52,8 +161,10 @@ interface SerializedSource {
filters?: SerializedUrlFilter[];
}
+type SerializedFormulaEntity = SerializedExpressionEntry | SerializedSource;
+
interface SerializedTabDef {
- definitionId: MetricSourceId;
+ slotIndex: number;
dimensionId?: string;
}
@@ -74,11 +185,113 @@ interface SerializedTab {
}
export interface SerializedMetricsViewerPageState {
- sources: SerializedSource[];
+ formulaEntities: SerializedFormulaEntity[];
tabs: SerializedTab[];
selectedTabId: string | null;
}
+// ── Expression sub-token helpers ──
+
+function serializeSubToken(
+ token: ExpressionSubToken,
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>,
+): SerializedExpressionSubToken {
+ if (token.type === "metric") {
+ const effectiveEntry = getEffectiveTokenDefinitionEntry(token, definitions);
+ if (!effectiveEntry.definition) {
+ return { type: "metric", sourceId: token.sourceId };
+ }
+ const serializedSource = definitionToSource(effectiveEntry.definition);
+ if (!serializedSource) {
+ return { type: "metric", sourceId: token.sourceId };
+ }
+ const annotatedSource = annotateSource(serializedSource, effectiveEntry);
+ return {
+ type: "metric",
+ sourceId: token.sourceId,
+ filters: annotatedSource.filters,
+ };
+ }
+ if (token.type === "constant") {
+ return { type: "constant", value: token.value };
+ }
+ if (token.type === "operator") {
+ return { type: "operator", op: token.op };
+ }
+ return { type: token.type };
+}
+
+function deserializeSubToken(
+ token: SerializedExpressionSubToken,
+): ExpressionSubToken | null {
+ if (token.type === "metric" && token.sourceId) {
+ return {
+ type: "metric",
+ sourceId: token.sourceId as MetricSourceId,
+ count: 0,
+ serializedDefinitionInfo: token.filters
+ ? {
+ filters: token.filters,
+ }
+ : undefined,
+ };
+ }
+ if (token.type === "constant" && token.value !== undefined) {
+ return { type: "constant", value: token.value };
+ }
+ if (token.type === "operator" && token.op) {
+ return { type: "operator", op: token.op };
+ }
+ if (token.type === "open-paren") {
+ return { type: "open-paren" };
+ }
+ if (token.type === "close-paren") {
+ return { type: "close-paren" };
+ }
+ return null;
+}
+
+export function deserializeFormulaEntities(
+ serializedState: SerializedMetricsViewerPageState,
+): MetricsViewerFormulaEntity[] {
+ const entities: MetricsViewerFormulaEntity[] = [];
+
+ for (const entity of serializedState.formulaEntities) {
+ if (entity.type === "metric" || entity.type === "measure") {
+ entities.push({
+ id:
+ entity.type === "metric"
+ ? `metric:${entity.id}`
+ : `measure:${entity.id}`,
+ type: "metric" as const,
+ definition: null,
+ serializedDefinitionInfo:
+ entity.breakout || entity.filters
+ ? {
+ breakout: entity.breakout,
+ breakoutTemporalUnit: entity.breakoutTemporalUnit,
+ breakoutBinning: entity.breakoutBinning,
+ filters: entity.filters,
+ }
+ : undefined,
+ });
+ }
+ if (entity.type === "expression") {
+ entities.push({
+ id: entity.id as MetricExpressionId,
+ type: "expression" as const,
+ name: entity.name,
+ tokens: stampMetricCounts(
+ entity.tokens
+ .map(deserializeSubToken)
+ .filter((t): t is ExpressionSubToken => t !== null),
+ ),
+ });
+ }
+ }
+ return entities;
+}
+
// ── Conversion functions ──
function definitionToSource(def: MetricDefinition): SerializedSource | null {
@@ -111,8 +324,8 @@ function tabToSerializedTab(tab: MetricsViewerTabState): SerializedTab {
? { visualizationSettings: tab.visualizationSettings }
: {}),
definitions: getObjectEntries(tab.dimensionMapping).map(
- ([sourceId, dimensionId]) => ({
- definitionId: sourceId,
+ ([key, dimensionId]) => ({
+ slotIndex: Number(key),
...(dimensionId != null ? { dimensionId } : {}),
}),
),
@@ -129,9 +342,9 @@ function tabToSerializedTab(tab: MetricsViewerTabState): SerializedTab {
export function deserializeTab(
serializedTab: SerializedTab,
): MetricsViewerTabState {
- const dimensionMapping: Record<MetricSourceId, string | null> = {};
+ const dimensionMapping: Record<number, string | null> = {};
for (const serializedDefinition of serializedTab.definitions) {
- dimensionMapping[serializedDefinition.definitionId] =
+ dimensionMapping[serializedDefinition.slotIndex] =
serializedDefinition.dimensionId ?? null;
}
return {
@@ -151,71 +364,98 @@ export function deserializeTab(
};
}
-export function stateToSerializedState(
- state: MetricsViewerPageState,
-): SerializedMetricsViewerPageState {
- return {
- sources: state.definitions.flatMap((entry) => {
- if (!entry.definition) {
- return [];
- }
- const source = definitionToSource(entry.definition);
- if (!source) {
- return [];
- }
- const breakoutProjection = getEntryBreakout(entry);
- if (breakoutProjection) {
- const rawDim = LibMetric.projectionDimension(
+function annotateSource(
+ source: SerializedSource,
+ entry: MetricsViewerDefinitionEntry,
+): SerializedSource {
+ if (!entry.definition) {
+ return source;
+ }
+
+ const breakoutProjection = getEntryBreakout(entry);
+ if (breakoutProjection) {
+ const rawDim = LibMetric.projectionDimension(
+ entry.definition,
+ breakoutProjection,
+ );
+ if (rawDim) {
+ const dimInfo = LibMetric.dimensionValuesInfo(entry.definition, rawDim);
+ source.breakout = dimInfo.id;
+
+ if (LibMetric.temporalBucket(breakoutProjection)) {
+ const buckets = LibMetric.availableTemporalBuckets(
entry.definition,
- breakoutProjection,
+ rawDim,
);
- if (rawDim) {
- const dimInfo = LibMetric.dimensionValuesInfo(
- entry.definition,
- rawDim,
- );
- source.breakout = dimInfo.id;
-
- if (LibMetric.temporalBucket(breakoutProjection)) {
- const buckets = LibMetric.availableTemporalBuckets(
- entry.definition,
- rawDim,
- );
- for (const bucket of buckets) {
- const info = LibMetric.displayInfo(entry.definition, bucket);
- if (info.selected) {
- source.breakoutTemporalUnit = info.shortName;
- break;
- }
- }
+ for (const bucket of buckets) {
+ const info = LibMetric.displayInfo(entry.definition, bucket);
+ if (info.selected) {
+ source.breakoutTemporalUnit = info.shortName;
+ break;
}
+ }
+ }
- if (LibMetric.binning(breakoutProjection)) {
- const strategies = LibMetric.availableBinningStrategies(
- entry.definition,
- rawDim,
- );
- for (const strategy of strategies) {
- const info = LibMetric.displayInfo(entry.definition, strategy);
- if (info.selected) {
- source.breakoutBinning = info.displayName;
- break;
- }
- }
+ if (LibMetric.binning(breakoutProjection)) {
+ const strategies = LibMetric.availableBinningStrategies(
+ entry.definition,
+ rawDim,
+ );
+ for (const strategy of strategies) {
+ const info = LibMetric.displayInfo(entry.definition, strategy);
+ if (info.selected) {
+ source.breakoutBinning = info.displayName;
+ break;
}
}
}
+ }
+ }
+
+ const definitionFilters = extractDefinitionFilters(entry.definition);
+ if (definitionFilters.length > 0) {
+ source.filters = definitionFilters.map((filter) => ({
+ dimensionId: filter.dimensionId,
+ value: filter.value,
+ }));
+ }
+
+ return source;
+}
- const definitionFilters = extractDefinitionFilters(entry.definition);
- if (definitionFilters.length > 0) {
- source.filters = definitionFilters.map((filter) => ({
- dimensionId: filter.dimensionId,
- value: filter.value,
- }));
+export function stateToSerializedState(
+ state: MetricsViewerPageState,
+): SerializedMetricsViewerPageState {
+ const formulaEntities: SerializedFormulaEntity[] = [];
+
+ for (const entity of state.formulaEntities) {
+ if (isMetricEntry(entity)) {
+ const effectiveEntry = getEffectiveDefinitionEntry(
+ entity,
+ state.definitions,
+ );
+ if (!effectiveEntry.definition) {
+ continue;
+ }
+ const source = definitionToSource(effectiveEntry.definition);
+ if (!source) {
+ continue;
}
+ formulaEntities.push(annotateSource(source, effectiveEntry));
+ } else if (isExpressionEntry(entity)) {
+ formulaEntities.push({
+ type: "expression",
+ id: entity.id,
+ name: entity.name,
+ tokens: entity.tokens.map((token) =>
+ serializeSubToken(token, state.definitions),
+ ),
+ });
+ }
+ }
- return [source];
- }),
+ return {
+ formulaEntities,
tabs: state.tabs.map(tabToSerializedTab),
selectedTabId: state.selectedTabId,
};
@@ -228,17 +468,28 @@ const sourceFilterSchema = defineCompactSchema<SerializedUrlFilter>({
value: { key: "v" },
});
-const sourceSchema = defineCompactSchema<SerializedSource>({
+const expressionSubTokenSchema =
+ defineCompactSchema<SerializedExpressionSubToken>({
+ type: "t",
+ sourceId: { key: "s", optional: true },
+ op: { key: "o", optional: true },
+ value: { key: "v", optional: true },
+ filters: { key: "F", schema: sourceFilterSchema, optional: true },
+ });
+
+const formulaEntitySchema = defineCompactSchema<SerializedFormulaEntity>({
type: "t",
id: "i",
breakout: { key: "b", optional: true },
breakoutTemporalUnit: { key: "u", optional: true },
breakoutBinning: { key: "B", optional: true },
filters: { key: "F", schema: sourceFilterSchema, optional: true },
+ name: { key: "n", optional: true },
+ tokens: { key: "T", schema: expressionSubTokenSchema, optional: true },
});
const tabDefSchema = defineCompactSchema<SerializedTabDef>({
- definitionId: "i",
+ slotIndex: "i",
dimensionId: { key: "d", optional: true },
});
@@ -263,7 +514,7 @@ const tabSchema = defineCompactSchema<SerializedTab>({
});
const rootSchema = defineCompactSchema<SerializedMetricsViewerPageState>({
- sources: { key: "s", schema: sourceSchema, default: [] },
+ formulaEntities: { key: "f", schema: formulaEntitySchema, default: [] },
tabs: { key: "t", schema: tabSchema, default: [] },
selectedTabId: { key: "a", default: null },
});
@@ -271,7 +522,7 @@ const rootSchema = defineCompactSchema<SerializedMetricsViewerPageState>({
// ── Encode / decode ──
function emptyState(): SerializedMetricsViewerPageState {
- return { sources: [], tabs: [], selectedTabId: null };
+ return { formulaEntities: [], tabs: [], selectedTabId: null };
}
// After JSON.parse, Date values are ISO strings. Walk the decoded state and revive them.
@@ -280,17 +531,35 @@ function reviveStateDates(
): SerializedMetricsViewerPageState {
return {
...state,
- sources: state.sources.map((source) =>
- source.filters
- ? {
- ...source,
- filters: source.filters.map((filter) => ({
- ...filter,
- value: reviveFilter(filter.value),
- })),
- }
- : source,
- ),
+ formulaEntities: state.formulaEntities.map((entity) => {
+ if ("filters" in entity && entity.filters) {
+ return {
+ ...entity,
+ filters: entity.filters.map((filter) => ({
+ ...filter,
+ value: reviveFilter(filter.value),
+ })),
+ };
+ }
+ if ("tokens" in entity && entity.tokens) {
+ return {
+ ...entity,
+ tokens: entity.tokens.map((token) => {
+ if ("filters" in token && token.filters) {
+ return {
+ ...token,
+ filters: token.filters.map((filter) => ({
+ ...filter,
+ value: reviveFilter(filter.value),
+ })),
+ };
+ }
+ return token;
+ }),
+ };
+ }
+ return entity;
+ }),
tabs: state.tabs.map((tab) =>
tab.projectionConfig?.dimensionFilter
? {
diff --git a/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts
index 649c017ee4f..12deaec9b99 100644
--- a/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/url-serialization.unit.spec.ts
@@ -2,6 +2,7 @@ import type { DimensionFilterValue } from "./dimension-filters";
import {
type SerializedMetricsViewerPageState,
decodeState,
+ deserializeFormulaEntities,
encodeState,
} from "./url-serialization";
@@ -15,9 +16,9 @@ function encodeStateOrThrow(state: SerializedMetricsViewerPageState): string {
describe("url-serialization", () => {
describe("encodeState / decodeState round-trip", () => {
- it("round-trips a state with sources and tabs", () => {
+ it("round-trips a state with formula entities and tabs", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{ type: "metric", id: 1, breakout: "dim-1" },
{ type: "measure", id: 42 },
],
@@ -27,9 +28,7 @@ describe("url-serialization", () => {
type: "time",
label: "By Month",
display: "bar",
- definitions: [
- { definitionId: "metric:1", dimensionId: "created_at" },
- ],
+ definitions: [{ slotIndex: 0, dimensionId: "created_at" }],
projectionConfig: {
temporalUnit: "month",
},
@@ -43,9 +42,9 @@ describe("url-serialization", () => {
expect(decoded).toEqual(state);
});
- it("round-trips a source with breakoutTemporalUnit", () => {
+ it("round-trips a metric with breakoutTemporalUnit", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{
type: "metric",
id: 1,
@@ -62,9 +61,9 @@ describe("url-serialization", () => {
expect(decoded).toEqual(state);
});
- it("round-trips a source with breakoutBinning", () => {
+ it("round-trips a metric with breakoutBinning", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{
type: "metric",
id: 2,
@@ -81,9 +80,9 @@ describe("url-serialization", () => {
expect(decoded).toEqual(state);
});
- it("round-trips a source with both breakoutTemporalUnit and breakoutBinning", () => {
+ it("round-trips a metric with both breakoutTemporalUnit and breakoutBinning", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{
type: "metric",
id: 3,
@@ -103,7 +102,7 @@ describe("url-serialization", () => {
it("round-trips an empty state", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [],
+ formulaEntities: [],
tabs: [],
selectedTabId: null,
};
@@ -113,9 +112,9 @@ describe("url-serialization", () => {
expect(decoded).toEqual(state);
});
- it("round-trips sources with filters", () => {
+ it("round-trips metrics with filters", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{
type: "metric",
id: 5,
@@ -140,12 +139,104 @@ describe("url-serialization", () => {
const decoded = decodeState(hash);
expect(decoded).toEqual(state);
});
+
+ it("round-trips expressions in formula entities", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ { type: "metric", id: 1 },
+ { type: "metric", id: 2 },
+ {
+ type: "expression",
+ id: "expression:Revenue + Costs",
+ name: "Revenue + Costs",
+ tokens: [
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2" },
+ ],
+ },
+ ],
+ tabs: [],
+ selectedTabId: null,
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
+ });
+
+ it("round-trips an expression with parentheses", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ { type: "metric", id: 1 },
+ { type: "metric", id: 2 },
+ { type: "metric", id: 3 },
+ {
+ type: "expression",
+ id: "expression:(A + B) * C",
+ name: "(A + B) * C",
+ tokens: [
+ { type: "open-paren" },
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2" },
+ { type: "close-paren" },
+ { type: "operator", op: "*" },
+ { type: "metric", sourceId: "metric:3" },
+ ],
+ },
+ ],
+ tabs: [],
+ selectedTabId: null,
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
+ });
+
+ it("round-trips expression tokens with filters", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [
+ {
+ type: "metric",
+ sourceId: "metric:1",
+ filters: [
+ {
+ dimensionId: "category",
+ value: {
+ type: "string",
+ operator: "=",
+ values: ["Gadget"],
+ options: {},
+ },
+ },
+ ],
+ },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2" },
+ ],
+ },
+ ],
+ tabs: [],
+ selectedTabId: null,
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
+ });
});
describe("decodeState with empty/invalid input", () => {
it("returns empty state for empty string", () => {
expect(decodeState("")).toEqual({
- sources: [],
+ formulaEntities: [],
tabs: [],
selectedTabId: null,
});
@@ -153,7 +244,7 @@ describe("url-serialization", () => {
it("returns empty state for invalid base64", () => {
expect(decodeState("!!!not-valid-base64!!!")).toEqual({
- sources: [],
+ formulaEntities: [],
tabs: [],
selectedTabId: null,
});
@@ -162,7 +253,7 @@ describe("url-serialization", () => {
it("returns empty state for valid base64 but invalid JSON", () => {
const hash = btoa("not json");
expect(decodeState(hash)).toEqual({
- sources: [],
+ formulaEntities: [],
tabs: [],
selectedTabId: null,
});
@@ -178,7 +269,7 @@ describe("url-serialization", () => {
describe("Unicode round-trip", () => {
it("survives non-ASCII metric labels in tabs", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [{ type: "metric", id: 1 }],
+ formulaEntities: [{ type: "metric", id: 1 }],
tabs: [
{
id: "tab-1",
@@ -198,7 +289,7 @@ describe("url-serialization", () => {
it("survives CJK characters", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [{ type: "metric", id: 1 }],
+ formulaEntities: [{ type: "metric", id: 1 }],
tabs: [
{
id: "tab-1",
@@ -218,7 +309,7 @@ describe("url-serialization", () => {
it("survives emoji characters", () => {
const state: SerializedMetricsViewerPageState = {
- sources: [{ type: "metric", id: 1 }],
+ formulaEntities: [{ type: "metric", id: 1 }],
tabs: [
{
id: "tab-1",
@@ -240,7 +331,7 @@ describe("url-serialization", () => {
describe("Date filter revival through encode/decode", () => {
function roundTripFilter(filter: DimensionFilterValue) {
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{
type: "metric",
id: 1,
@@ -250,8 +341,43 @@ describe("url-serialization", () => {
tabs: [],
selectedTabId: null,
};
- return decodeState(encodeStateOrThrow(state)).sources[0].filters![0]
- .value;
+ const decoded = decodeState(encodeStateOrThrow(state));
+ const entity = decoded.formulaEntities[0];
+ if (entity.type === "expression") {
+ throw new Error("Expected metric entity");
+ }
+ return entity.filters![0].value;
+ }
+
+ function roundTripTokenFilter(filter: DimensionFilterValue) {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [
+ {
+ type: "metric",
+ sourceId: "metric:1",
+ filters: [{ dimensionId: "created_at", value: filter }],
+ },
+ ],
+ },
+ ],
+ tabs: [],
+ selectedTabId: null,
+ };
+ const decoded = decodeState(encodeStateOrThrow(state));
+ const entity = decoded.formulaEntities[0];
+ if (entity.type !== "expression") {
+ throw new Error("Expected expression entity");
+ }
+ const token = entity.tokens[0];
+ if (!("filters" in token) || !token.filters) {
+ throw new Error("Expected token with filters");
+ }
+ return token.filters[0].value;
}
it("revives specific-date Date values after encode/decode", () => {
@@ -301,6 +427,30 @@ describe("url-serialization", () => {
expect(roundTripFilter(filter)).toEqual(filter);
});
+
+ it("revives specific-date Date values on expression token filters", () => {
+ const filter: DimensionFilterValue = {
+ type: "specific-date",
+ operator: "between",
+ values: [
+ new Date("2024-01-01T00:00:00Z"),
+ new Date("2024-12-31T23:59:59Z"),
+ ],
+ hasTime: false,
+ };
+
+ expect(roundTripTokenFilter(filter)).toEqual(filter);
+ });
+
+ it("revives time Date values on expression token filters", () => {
+ const filter: DimensionFilterValue = {
+ type: "time",
+ operator: ">",
+ values: [new Date("2024-06-15T10:30:00Z")],
+ };
+
+ expect(roundTripTokenFilter(filter)).toEqual(filter);
+ });
});
describe("BigInt filter revival through encode/decode", () => {
@@ -311,7 +461,7 @@ describe("url-serialization", () => {
values: [BigInt("9007199254740993"), BigInt("-9007199254740993")],
};
const state: SerializedMetricsViewerPageState = {
- sources: [
+ formulaEntities: [
{
type: "metric",
id: 1,
@@ -323,7 +473,183 @@ describe("url-serialization", () => {
};
const decoded = decodeState(encodeStateOrThrow(state));
- expect(decoded.sources[0].filters![0].value).toEqual(filter);
+ const entity = decoded.formulaEntities[0];
+ if (entity.type === "expression") {
+ throw new Error("Expected metric entity");
+ }
+ expect(entity.filters![0].value).toEqual(filter);
+ });
+ });
+
+ describe("expression with duplicate metrics and different breakouts", () => {
+ it("round-trips an expression where the same metric appears twice with different dimension mappings", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:Revenue + Revenue",
+ name: "Revenue + Revenue",
+ tokens: [
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:1" },
+ ],
+ },
+ ],
+ tabs: [
+ {
+ id: "tab-time",
+ type: "time",
+ label: "By Time",
+ display: "line",
+ definitions: [
+ { slotIndex: 0, dimensionId: "created_at" },
+ { slotIndex: 1, dimensionId: "updated_at" },
+ ],
+ },
+ ],
+ selectedTabId: "tab-time",
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
+ });
+
+ it("round-trips an expression where the same metric appears twice with different filters on each token", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:Revenue filtered",
+ name: "Revenue filtered",
+ tokens: [
+ {
+ type: "metric",
+ sourceId: "metric:1",
+ filters: [
+ {
+ dimensionId: "category",
+ value: {
+ type: "string",
+ operator: "=",
+ values: ["Gadget"],
+ options: {},
+ },
+ },
+ ],
+ },
+ { type: "operator", op: "-" },
+ {
+ type: "metric",
+ sourceId: "metric:1",
+ filters: [
+ {
+ dimensionId: "category",
+ value: {
+ type: "string",
+ operator: "=",
+ values: ["Widget"],
+ options: {},
+ },
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ tabs: [],
+ selectedTabId: null,
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
+ });
+
+ it("preserves per-slot dimension mappings when same metric has different breakouts across multiple tabs", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:A + A",
+ name: "A + A",
+ tokens: [
+ { type: "metric", sourceId: "metric:5" },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:5" },
+ ],
+ },
+ ],
+ tabs: [
+ {
+ id: "tab-time",
+ type: "time",
+ label: "By Time",
+ display: "line",
+ definitions: [
+ { slotIndex: 0, dimensionId: "created_at" },
+ { slotIndex: 1, dimensionId: "shipped_at" },
+ ],
+ },
+ {
+ id: "tab-cat",
+ type: "category",
+ label: "By Category",
+ display: "bar",
+ definitions: [
+ { slotIndex: 0, dimensionId: "product_category" },
+ { slotIndex: 1, dimensionId: "user_state" },
+ ],
+ },
+ ],
+ selectedTabId: "tab-cat",
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
+ });
+
+ it("round-trips a mix of standalone metric and expression with a duplicate of that metric", () => {
+ const state: SerializedMetricsViewerPageState = {
+ formulaEntities: [
+ {
+ type: "metric",
+ id: 1,
+ breakout: "created_at",
+ breakoutTemporalUnit: "month",
+ },
+ {
+ type: "expression",
+ id: "expression:A + A",
+ name: "A + A",
+ tokens: [
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:1" },
+ ],
+ },
+ ],
+ tabs: [
+ {
+ id: "tab-time",
+ type: "time",
+ label: "By Month",
+ display: "line",
+ definitions: [
+ { slotIndex: 0, dimensionId: "created_at" },
+ { slotIndex: 1, dimensionId: "created_at" },
+ { slotIndex: 2, dimensionId: "updated_at" },
+ ],
+ },
+ ],
+ selectedTabId: "tab-time",
+ };
+
+ const hash = encodeStateOrThrow(state);
+ const decoded = decodeState(hash);
+ expect(decoded).toEqual(state);
});
});
@@ -332,8 +658,312 @@ describe("url-serialization", () => {
const first = decodeState("");
const second = decodeState("");
expect(first).not.toBe(second);
- expect(first.sources).not.toBe(second.sources);
+ expect(first.formulaEntities).not.toBe(second.formulaEntities);
expect(first.tabs).not.toBe(second.tabs);
});
});
+
+ describe("deserializeFormulaEntities", () => {
+ function emptyState(
+ overrides: Partial<SerializedMetricsViewerPageState> = {},
+ ): SerializedMetricsViewerPageState {
+ return {
+ formulaEntities: [],
+ tabs: [],
+ selectedTabId: null,
+ ...overrides,
+ };
+ }
+
+ it("returns empty array for empty state", () => {
+ expect(deserializeFormulaEntities(emptyState())).toEqual([]);
+ });
+
+ it("returns metric entities for metric/measure formula entities", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ { type: "metric", id: 1 },
+ { type: "measure", id: 42 },
+ ],
+ }),
+ );
+ expect(result).toEqual([
+ { id: "metric:1", type: "metric", definition: null },
+ { id: "measure:42", type: "metric", definition: null },
+ ]);
+ });
+
+ it("deserializes expression entries with metric tokens", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ { type: "metric", id: 1 },
+ { type: "metric", id: 2 },
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2" },
+ ],
+ },
+ ],
+ }),
+ );
+ expect(result).toEqual([
+ { id: "metric:1", type: "metric", definition: null },
+ { id: "metric:2", type: "metric", definition: null },
+ {
+ id: "expression:test",
+ type: "expression",
+ name: "test",
+ tokens: [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "metric", sourceId: "metric:2", count: 1 },
+ ],
+ },
+ ]);
+ });
+
+ it("deserializes parentheses", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [{ type: "open-paren" }, { type: "close-paren" }],
+ },
+ ],
+ }),
+ );
+ const expressions = result.filter((e) => e.type === "expression");
+ expect(expressions).toHaveLength(1);
+ expect(expressions[0]).toMatchObject({
+ tokens: [{ type: "open-paren" }, { type: "close-paren" }],
+ });
+ });
+
+ it("skips metric tokens with missing sourceId", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [{ type: "metric" } as any],
+ },
+ ],
+ }),
+ );
+ const expressions = result.filter((e) => e.type === "expression");
+ expect(expressions[0]).toMatchObject({ tokens: [] });
+ });
+
+ it("skips operator tokens with missing op", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [{ type: "operator" } as any],
+ },
+ ],
+ }),
+ );
+ const expressions = result.filter((e) => e.type === "expression");
+ expect(expressions[0]).toMatchObject({ tokens: [] });
+ });
+
+ it("preserves formula entity order with expression before metric", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:Total",
+ name: "Total",
+ tokens: [
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "+" },
+ { type: "constant", value: 10 },
+ ],
+ },
+ { type: "metric", id: 1 },
+ ],
+ }),
+ );
+ expect(result).toEqual([
+ {
+ id: "expression:Total",
+ type: "expression",
+ name: "Total",
+ tokens: [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "+" },
+ { type: "constant", value: 10 },
+ ],
+ },
+ { id: "metric:1", type: "metric", definition: null },
+ ]);
+ });
+
+ it("preserves formula entity order with metric before expression", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ { type: "metric", id: 1 },
+ {
+ type: "expression",
+ id: "expression:Total",
+ name: "Total",
+ tokens: [
+ { type: "metric", sourceId: "metric:1" },
+ { type: "operator", op: "*" },
+ { type: "constant", value: 2 },
+ ],
+ },
+ ],
+ }),
+ );
+ expect(result).toEqual([
+ { id: "metric:1", type: "metric", definition: null },
+ {
+ id: "expression:Total",
+ type: "expression",
+ name: "Total",
+ tokens: [
+ { type: "metric", sourceId: "metric:1", count: 1 },
+ { type: "operator", op: "*" },
+ { type: "constant", value: 2 },
+ ],
+ },
+ ]);
+ });
+
+ it("populates serializedDefinitionInfo for metrics with breakout", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "metric",
+ id: 1,
+ breakout: "created_at",
+ breakoutTemporalUnit: "month",
+ },
+ ],
+ }),
+ );
+ expect(result).toEqual([
+ {
+ id: "metric:1",
+ type: "metric",
+ definition: null,
+ serializedDefinitionInfo: {
+ breakout: "created_at",
+ breakoutTemporalUnit: "month",
+ },
+ },
+ ]);
+ });
+
+ it("populates serializedDefinitionInfo for metrics with filters", () => {
+ const filters = [
+ {
+ dimensionId: "category",
+ value: {
+ type: "string",
+ operator: "=",
+ values: ["Gadget"],
+ options: {},
+ },
+ },
+ ];
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "metric",
+ id: 5,
+ filters: filters as any,
+ },
+ ],
+ }),
+ );
+ expect(result).toEqual([
+ {
+ id: "metric:5",
+ type: "metric",
+ definition: null,
+ serializedDefinitionInfo: {
+ filters,
+ },
+ },
+ ]);
+ });
+
+ it("populates serializedDefinitionInfo on expression tokens with filters", () => {
+ const tokenFilters = [
+ {
+ dimensionId: "category",
+ value: {
+ type: "string",
+ operator: "=",
+ values: ["Widget"],
+ options: {},
+ },
+ },
+ ];
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [
+ {
+ type: "expression",
+ id: "expression:test",
+ name: "test",
+ tokens: [
+ {
+ type: "metric",
+ sourceId: "metric:1",
+ filters: tokenFilters as any,
+ },
+ ],
+ },
+ ],
+ }),
+ );
+ const expression = result[0];
+ if (expression.type !== "expression") {
+ throw new Error("Expected expression entity");
+ }
+ const metricToken = expression.tokens[0];
+ if (metricToken.type !== "metric") {
+ throw new Error("Expected metric token");
+ }
+ expect(metricToken.serializedDefinitionInfo).toEqual({
+ filters: tokenFilters,
+ });
+ });
+
+ it("omits serializedDefinitionInfo for metrics without breakout or filters", () => {
+ const result = deserializeFormulaEntities(
+ emptyState({
+ formulaEntities: [{ type: "metric", id: 1 }],
+ }),
+ );
+ expect(result[0]).toEqual({
+ id: "metric:1",
+ type: "metric",
+ definition: null,
+ });
+ });
+ });
});
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.module.css b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.module.css
deleted file mode 100644
index 3bd7a2442fe..00000000000
--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.module.css
+++ /dev/null
@@ -1,13 +0,0 @@
-.dimensionList {
- max-width: 100%;
- color: var(--mb-color-brand);
-}
-
-.metricListItem {
- cursor: pointer;
- border-radius: var(--mantine-radius-sm);
-
- &:hover {
- background-color: var(--mb-color-background-hover);
- }
-}
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.tsx b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.tsx
deleted file mode 100644
index 5082da99cf6..00000000000
--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/FilterDimensionPicker.tsx
+++ /dev/null
@@ -1,132 +0,0 @@
-import { useCallback, useMemo, useState } from "react";
-import { t } from "ttag";
-
-import { AccordionList } from "metabase/common/components/AccordionList";
-import { getDimensionIcon } from "metabase/metrics/utils/dimensions";
-import {
- Box,
- Flex,
- Icon,
- PopoverBackButton,
- Text,
- UnstyledButton,
-} from "metabase/ui";
-import type * as LibMetric from "metabase-lib/metric";
-
-import { FILTER_PICKER_WIDTH } from "../constants";
-
-import S from "./FilterDimensionPicker.module.css";
-import type { DimensionListItem, DimensionSection } from "./types";
-import { getMetricGroups } from "./utils";
-
-interface FilterDimensionPickerProps {
- definitions: LibMetric.MetricDefinition[];
- onSelect: (
- definition: LibMetric.MetricDefinition,
- definitionIndex: number,
- dimension: LibMetric.DimensionMetadata,
- ) => void;
-}
-
-export function FilterDimensionPicker({
- definitions,
- onSelect,
-}: FilterDimensionPickerProps) {
- const [selectedGroupIndex, setSelectedGroupIndex] = useState<number | null>(
- null,
- );
-
- const metricGroups = useMemo(
- () => getMetricGroups(definitions),
- [definitions],
- );
-
- const handleSelect = useCallback(
- (item: DimensionListItem) => {
- onSelect(item.definition, item.definitionIndex, item.dimension);
- },
- [onSelect],
- );
-
- const renderItemIcon = useCallback((item: DimensionListItem) => {
- const icon = getDimensionIcon(item.dimension);
- return <Icon name={icon} size={18} />;
- }, []);
-
- if (definitions.length === 0) {
- return null;
- }
-
- if (metricGroups.length === 1) {
- const group = metricGroups[0];
- return (
- <AccordionList<DimensionListItem, DimensionSection>
- className={S.dimensionList}
- sections={group.sections}
- onChange={handleSelect}
- renderItemName={(item) => item.name}
- renderItemDescription={() => undefined}
- renderItemIcon={renderItemIcon}
- width={FILTER_PICKER_WIDTH}
- maxHeight={Infinity}
- itemTestId="dimension-list-item"
- alwaysExpanded
- />
- );
- }
-
- if (selectedGroupIndex != null) {
- const group = metricGroups[selectedGroupIndex];
- return (
- <Box>
- <Box px="md" py="sm">
- <PopoverBackButton onClick={() => setSelectedGroupIndex(null)}>
- {group.metricName}
- </PopoverBackButton>
- </Box>
- <AccordionList<DimensionListItem, DimensionSection>
- className={S.dimensionList}
- sections={group.sections}
- onChange={handleSelect}
- renderItemName={(item) => item.name}
- renderItemDescription={() => undefined}
- renderItemIcon={renderItemIcon}
- width={FILTER_PICKER_WIDTH}
- maxHeight={Infinity}
- itemTestId="dimension-list-item"
- alwaysExpanded
- />
- </Box>
- );
- }
-
- return (
- <Box>
- <Box px="md" pt="md" pb="sm">
- <Text fw="bold" fz="lg" c="text-primary">
- {t`Pick a metric to filter`}
- </Text>
- </Box>
- {metricGroups.map((group, i) => (
- <UnstyledButton
- key={i}
- className={S.metricListItem}
- w="100%"
- px="md"
- py="sm"
- onClick={() => setSelectedGroupIndex(i)}
- >
- <Flex align="center" justify="space-between">
- <Flex align="center" gap="sm">
- <Icon name={group.icon} c="brand" />
- <Text fw="bold" fz="md">
- {group.metricName}
- </Text>
- </Flex>
- <Icon name="chevronright" c="text-tertiary" />
- </Flex>
- </UnstyledButton>
- ))}
- </Box>
- );
-}
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/index.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/index.ts
deleted file mode 100644
index 1c0f1ecda64..00000000000
--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from "./FilterDimensionPicker";
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts
index b2dbd5dbdca..b1eded004de 100644
--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts
+++ b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts
@@ -11,7 +11,10 @@ export type DimensionListItem = {
export type DimensionSection = BaseSection<DimensionListItem>;
export type MetricGroup = {
+ id: number;
metricName: string;
- icon: "metric" | "ruler";
+ metricCount?: number;
+ icon?: "metric" | "ruler";
+ colors: string[] | undefined;
sections: DimensionSection[];
};
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts
index 800402f9591..e97877737c6 100644
--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts
+++ b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts
@@ -1,13 +1,19 @@
-import { t } from "ttag";
-
+import type { SourceColorMap } from "metabase/metrics-viewer/types/viewer-state";
+import type { DefinitionSource } from "metabase/metrics-viewer/utils/definition-sources";
+import {
+ getDefinitionSourceIcon,
+ getDefinitionSourceName,
+} from "metabase/metrics-viewer/utils/definition-sources";
import * as LibMetric from "metabase-lib/metric";
import type { DimensionListItem, DimensionSection, MetricGroup } from "./types";
export function getMetricGroups(
- definitions: LibMetric.MetricDefinition[],
+ definitionSources: DefinitionSource[],
+ metricColors: SourceColorMap,
): MetricGroup[] {
- return definitions.map((definition, definitionIndex) => {
+ return definitionSources.map((definitionSource, definitionIndex) => {
+ const definition = definitionSource.definition;
const dimensions = LibMetric.filterableDimensions(definition);
const byGroupId = new Map<
@@ -45,25 +51,12 @@ export function getMetricGroups(
}
return {
- metricName: getSectionName(definition),
- icon: getSectionIcon(definition),
+ id: definitionSource.index,
+ metricName: getDefinitionSourceName(definitionSource),
+ metricCount: definitionSource.token?.count,
+ icon: getDefinitionSourceIcon(definitionSource),
+ colors: metricColors[definitionSource.entityIndex],
sections,
};
});
}
-
-export function getSectionName(definition: LibMetric.MetricDefinition): string {
- const metric = LibMetric.sourceMetricOrMeasureMetadata(definition);
- if (metric) {
- const metricInfo = LibMetric.displayInfo(definition, metric);
- return metricInfo.displayName;
- }
- return t`Unknown`;
-}
-
-export function getSectionIcon(
- definition: LibMetric.MetricDefinition,
-): "metric" | "ruler" {
- const metricId = LibMetric.sourceMetricId(definition);
- return metricId != null ? "metric" : "ruler";
-}
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterPicker.tsx b/frontend/src/metabase/metrics/components/FilterPicker/FilterPicker.tsx
deleted file mode 100644
index ee60116010c..00000000000
--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterPicker.tsx
+++ /dev/null
@@ -1,81 +0,0 @@
-import { type Ref, forwardRef, useState } from "react";
-import { t } from "ttag";
-
-import { Button, Icon } from "metabase/ui";
-import type * as LibMetric from "metabase-lib/metric";
-
-import { FilterDimensionPicker } from "./FilterDimensionPicker";
-import { FilterPickerBody } from "./FilterPickerBody";
-
-type FilterPickerProps = {
- definitions: LibMetric.MetricDefinition[];
- onSelect: (
- definition: LibMetric.MetricDefinition,
- definitionIndex: number,
- filter: LibMetric.FilterClause,
- ) => void;
-};
-
-export function FilterPicker({ definitions, onSelect }: FilterPickerProps) {
- const [definition, setDefinition] =
- useState<LibMetric.MetricDefinition | null>(null);
- const [definitionIndex, setDefinitionIndex] = useState<number | null>(null);
- const [dimension, setDimension] =
- useState<LibMetric.DimensionMetadata | null>(null);
-
- const handleDimensionSelect = (
- definition: LibMetric.MetricDefinition,
- definitionIndex: number,
- dimension: LibMetric.DimensionMetadata,
- ) => {
- setDefinition(definition);
- setDefinitionIndex(definitionIndex);
- setDimension(dimension);
- };
-
- const handleFilterSelect = (filter: LibMetric.FilterClause) => {
- if (definition == null || definitionIndex == null) {
- return;
- }
- onSelect(definition, definitionIndex, filter);
- };
-
- const handleBack = () => {
- setDefinition(null);
- setDimension(null);
- };
-
- if (!definition || !dimension) {
- return (
- <FilterDimensionPicker
- definitions={definitions}
- onSelect={handleDimensionSelect}
- />
- );
- }
-
- return (
- <FilterPickerBody
- definition={definition}
- dimension={dimension}
- isNew
- onSelect={handleFilterSelect}
- onBack={handleBack}
- />
- );
-}
-
-type FilterPickerButtonProps = {
- onClick?: () => void;
-};
-
-export const FilterPickerButton = forwardRef(function FilterPickerButton(
- { onClick }: FilterPickerButtonProps,
- ref: Ref<HTMLButtonElement>,
-) {
- return (
- <Button ref={ref} leftSection={<Icon name="filter" />} onClick={onClick}>
- {t`Filter`}
- </Button>
- );
-});
diff --git a/frontend/src/metabase/metrics/components/FilterPicker/index.ts b/frontend/src/metabase/metrics/components/FilterPicker/index.ts
deleted file mode 100644
index 24e7622d588..00000000000
--- a/frontend/src/metabase/metrics/components/FilterPicker/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export * from "./FilterPicker";
diff --git a/frontend/src/metabase/utils/objects.ts b/frontend/src/metabase/utils/objects.ts
index 4e2a2f94efc..1c464d6b314 100644
--- a/frontend/src/metabase/utils/objects.ts
+++ b/frontend/src/metabase/utils/objects.ts
@@ -10,6 +10,10 @@ export const getObjectKeys = <K extends string>(
return Object.keys(obj) as K[];
};
+export const getObjectValues = <V>(obj: Record<string, V>): V[] => {
+ return Object.values(obj) as V[];
+};
+
export const objectFromEntries = <K extends string, V>(
entries: readonly (readonly [K, V])[],
): Record<K, V> => {
diff --git a/frontend/src/metabase/utils/urls/metrics.ts b/frontend/src/metabase/utils/urls/metrics.ts
index 35059f1520a..2440b3785c0 100644
--- a/frontend/src/metabase/utils/urls/metrics.ts
+++ b/frontend/src/metabase/utils/urls/metrics.ts
@@ -1,8 +1,5 @@
import type { DimensionType } from "metabase/metrics/common/utils/dimension-types";
-import type {
- MetricSourceId,
- MetricsViewerDisplayType,
-} from "metabase/metrics-viewer/types/viewer-state";
+import type { MetricsViewerDisplayType } from "metabase/metrics-viewer/types/viewer-state";
import {
type SerializedMetricsViewerPageState,
encodeState,
@@ -40,16 +37,15 @@ export function exploreMetricDimension({
displayType,
label,
}: ExploreMetricDimensionOptions): string {
- const sourceId: MetricSourceId = `metric:${metricId}`;
const state: SerializedMetricsViewerPageState = {
- sources: [{ type: "metric", id: metricId }],
+ formulaEntities: [{ type: "metric", id: metricId }],
tabs: [
{
id: dimensionId,
type: dimensionType,
label: label ?? null,
display: displayType,
- definitions: [{ definitionId: sourceId, dimensionId }],
+ definitions: [{ slotIndex: 0, dimensionId }],
},
],
selectedTabId: dimensionId,
diff --git a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx
index 8605983889e..2e8c2b87fe0 100644
--- a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx
+++ b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx
@@ -16,6 +16,7 @@ export const ScalarRoot = styled.div`
interface ScalarValueWrapperProps {
fontSize?: string | number;
lineHeight?: string;
+ disableHover?: boolean;
}
export const ScalarValueWrapper = styled.h1<ScalarValueWrapperProps>`
@@ -26,6 +27,7 @@ export const ScalarValueWrapper = styled.h1<ScalarValueWrapperProps>`
color: ${({ color }) => color};
&:hover {
- color: var(--mb-color-brand);
+ color: ${({ disableHover }) =>
+ disableHover ? undefined : "var(--mb-color-brand)"};
}
`;
diff --git a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx
index ed94af39afd..6bb484b6da6 100644
--- a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx
+++ b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.tsx
@@ -25,6 +25,7 @@ interface ScalarValueProps {
totalNumGridCols?: number;
fontFamily: string;
color?: string;
+ disableHover?: boolean;
}
export const ScalarValue = ({
@@ -35,6 +36,7 @@ export const ScalarValue = ({
totalNumGridCols,
fontFamily,
color = "inherit",
+ disableHover,
}: ScalarValueProps) => {
const {
other: { number: numberTheme },
@@ -75,6 +77,7 @@ export const ScalarValue = ({
lineHeight={numberTheme?.value?.lineHeight}
data-testid="scalar-value"
color={color}
+ disableHover={disableHover}
>
{value ?? t`null`}
</ScalarValueWrapper>
diff --git a/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts b/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts
index 4065c0e0783..eb077fa54b4 100644
--- a/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts
+++ b/frontend/src/metabase/visualizations/visualizations/CartesianChart/use-chart-events.ts
@@ -200,6 +200,7 @@ export const useChartEvents = (
if (!visualizationIsClickable(clickData)) {
onOpenQuestion(clickData?.cardId);
+ return;
}
onVisualizationClick?.(clickData);
diff --git a/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx b/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx
index 459f5eced25..cb42ab550fe 100644
--- a/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx
+++ b/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx
@@ -87,6 +87,11 @@ export class Scalar extends Component<
},
]) => cols.length < 2,
}),
+ // used by metrics viewer to set the color, overrides "scalar.segments"
+ "scalar.color": {
+ hidden: true,
+ getDefault: () => undefined,
+ },
"scalar.segments": {
get section() {
return t`Conditional colors`;
@@ -205,8 +210,9 @@ export class Scalar extends Component<
segmentIsValid(segment, { allowOpenEnded: true }),
);
- const color = getColor(value, segments);
- const tooltipContent = getTooltipContent(segments);
+ const explicitColor = settings["scalar.color"];
+ const color = explicitColor ?? getColor(value, segments);
+ const tooltipContent = explicitColor ? null : getTooltipContent(segments);
const { displayValue, fullScalarValue } = compactifyValue(
value,
@@ -259,6 +265,7 @@ export class Scalar extends Component<
>
<ScalarValue
color={color}
+ disableHover={!!explicitColor}
fontFamily={fontFamily}
gridSize={gridSize}
height={Math.max(height - PADDING * 2, 0)}
diff --git a/src/metabase/lib_metric/ast/build.cljc b/src/metabase/lib_metric/ast/build.cljc
index fcdfa3b7b4d..d046ca5e934 100644
--- a/src/metabase/lib_metric/ast/build.cljc
+++ b/src/metabase/lib_metric/ast/build.cljc
@@ -340,6 +340,13 @@
(= 3 (count expression))
(#{:metric :measure} (first expression))))
+(defn arithmetic-expression?
+ "Returns true if the expression is an arithmetic node [op opts expr expr ...]."
+ [expression]
+ (and (sequential? expression)
+ (>= (count expression) 4)
+ (operators/arithmetic? (first expression))))
+
(defn expression-leaf-type
"Returns :metric or :measure from an expression leaf."
[expression]
@@ -358,27 +365,15 @@
(when (expression-leaf? expression)
(get (second expression) :lib/uuid)))
-(defn from-definition
- "Create complete AST from MetricDefinition.
- Converts legacy MBQL to MBQL 5 before processing.
-
- Metadata is loaded from the provider using the expression leaf's type and ID.
- Dimensions and dimension-mappings are loaded from the fetched metadata."
- [definition]
- (let [{:keys [expression metadata-provider filters projections]} definition
- leaf-type (expression-leaf-type expression)
- leaf-id (expression-leaf-id expression)
- leaf-uuid (expression-leaf-uuid expression)
- _ (when-not leaf-type
- (throw (ex-info "Arithmetic metric math expressions are not yet supported in AST builder"
- {:expression expression})))
- ;; Load metadata from provider
- source-type (case leaf-type :metric :source/metric :measure :source/measure)
- metadata-type (case leaf-type :metric :metadata/metric :measure :metadata/measure)
- metadata (first (lib.metadata.protocols/metadatas
- metadata-provider
- {:lib/type metadata-type :id #{leaf-id}}))
- ;; Load dimensions/mappings from source metadata
+(defn- build-leaf-ast
+ "Build a complete single-source AST for one expression leaf.
+ Extracted from from-definition for reuse in arithmetic expressions."
+ [leaf-type leaf-id leaf-uuid metadata-provider filters projections]
+ (let [source-type (case leaf-type :metric :source/metric :measure :source/measure)
+ metadata-type (case leaf-type :metric :metadata/metric :measure :metadata/measure)
+ metadata (first (lib.metadata.protocols/metadatas
+ metadata-provider
+ {:lib/type metadata-type :id #{leaf-id}}))
dimensions (lib-metric.dimension/get-persisted-dimensions metadata)
dimension-mappings (lib-metric.dimension/get-persisted-dimension-mappings metadata)
raw-query (case leaf-type
@@ -397,10 +392,57 @@
;; Convert filters and projections to AST nodes
ast-filter (when (seq leaf-filters) (mbql-filters->ast-filter leaf-filters))
ast-group-by (when (seq leaf-projections) (perf/mapv dimension-ref->ast-dimension-ref leaf-projections))]
- {:node/type :ast/root
+ {:node/type :ast/source-query
:source (mbql5-query->source-node source-type leaf-id metadata mbql5-query)
:dimensions (perf/mapv dimension-node (or dimensions []))
:mappings (perf/mapv dimension-mapping-node (or dimension-mappings []))
:filter ast-filter
- :group-by (or ast-group-by [])
+ :group-by (or ast-group-by [])}))
+
+(defn- arithmetic-operator
+ "Returns the arithmetic operator keyword if expression is an arithmetic node, nil otherwise."
+ [expression]
+ (when (arithmetic-expression? expression)
+ (first expression)))
+
+(defn- build-expression-ast
+ "Recursively build expression AST from a metric-math expression tree.
+ For numeric constants, produces :expression/constant.
+ For leaves, calls build-leaf-ast and wraps in :expression/leaf.
+ For arithmetic, recursively builds children and wraps in :expression/arithmetic."
+ [expression metadata-provider filters projections]
+ (cond
+ (number? expression)
+ {:node/type :expression/constant :value expression}
+
+ (expression-leaf-type expression)
+ (let [leaf-type (expression-leaf-type expression)
+ leaf-id (expression-leaf-id expression)
+ leaf-uuid (expression-leaf-uuid expression)
+ sub-ast (build-leaf-ast leaf-type leaf-id leaf-uuid metadata-provider filters projections)]
+ {:node/type :expression/leaf
+ :uuid leaf-uuid
+ :ast sub-ast})
+
+ :else
+ (let [op (arithmetic-operator expression)
+ children (drop 2 expression)]
+ {:node/type :expression/arithmetic
+ :operator op
+ :children (perf/mapv #(build-expression-ast % metadata-provider filters projections) children)})))
+
+(defn from-definition
+ "Create complete AST from MetricDefinition.
+ Converts legacy MBQL to MBQL 5 before processing.
+
+ Metadata is loaded from the provider using the expression leaf's type and ID.
+ Dimensions and dimension-mappings are loaded from the fetched metadata.
+
+ Always produces a unified root shape {:node/type :ast/root, :expression ...}.
+ Single-leaf definitions become a single :expression/leaf node."
+ [definition]
+ (let [{:keys [expression metadata-provider filters projections]} definition
+ expr-ast (build-expression-ast expression metadata-provider filters projections)]
+ {:node/type :ast/root
+ :expression expr-ast
:metadata-provider metadata-provider}))
diff --git a/src/metabase/lib_metric/ast/compile.cljc b/src/metabase/lib_metric/ast/compile.cljc
index 8d2b7f0b83b..e8a7705132c 100644
--- a/src/metabase/lib_metric/ast/compile.cljc
+++ b/src/metabase/lib_metric/ast/compile.cljc
@@ -262,7 +262,7 @@
:stages [stage-0 stage-1]}))
(mu/defn compile-to-mbql
- "Compile AST to MBQL query.
+ "Compile a source-query to MBQL query.
Generates a two-stage query when the source has joins or is based on a
source-card (model / saved question):
@@ -271,11 +271,11 @@
Options:
- :limit - add limit to query"
- [{:keys [source] :as ast} :- ::ast.schema/ast
+ [{:keys [source] :as source-query} :- ::ast.schema/source-query
& {:as opts}]
(if (needs-two-stage? source)
- (compile-two-stage-query ast opts)
- (compile-single-stage-query ast opts)))
+ (compile-two-stage-query source-query opts)
+ (compile-single-stage-query source-query opts)))
;;; -------------------- Values Query Compilation (no aggregation) --------------------
@@ -328,15 +328,15 @@
:stages [stage-0 stage-1]}))
(mu/defn compile-to-values-query
- "Compile AST to MBQL query for fetching distinct values (no aggregation).
+ "Compile a source-query to MBQL query for fetching distinct values (no aggregation).
Like [[compile-to-mbql]] but omits the aggregation clause, producing a query
that returns distinct breakout values instead of aggregated results.
Options:
- :limit - add limit to query"
- [{:keys [source] :as ast} :- ::ast.schema/ast
+ [{:keys [source] :as source-query} :- ::ast.schema/source-query
& {:as opts}]
(if (needs-two-stage? source)
- (compile-two-stage-values-query ast opts)
- (compile-single-stage-values-query ast opts)))
+ (compile-two-stage-values-query source-query opts)
+ (compile-single-stage-values-query source-query opts)))
diff --git a/src/metabase/lib_metric/ast/plan.cljc b/src/metabase/lib_metric/ast/plan.cljc
new file mode 100644
index 00000000000..f3ef8974972
--- /dev/null
+++ b/src/metabase/lib_metric/ast/plan.cljc
@@ -0,0 +1,241 @@
+(ns metabase.lib-metric.ast.plan
+ "Query planning and execution for metric ASTs.
+ Takes an AST (from ast.build/from-definition) and produces a query plan
+ that can be compiled and executed."
+ (:require
+ [clojure.set :as set]
+ [metabase.lib-metric.ast.compile :as ast.compile]
+ [metabase.lib-metric.ast.walk :as ast.walk]
+ [metabase.lib-metric.operators :as operators]
+ [metabase.types.core]
+ [metabase.util.performance :as perf]))
+
+;; Ensure type hierarchy is loaded
+(comment metabase.types.core/keep-me)
+
+;;; -------------------- Plan Data Structures --------------------
+;;;
+;;; Leaf plan (single-source, pass-through):
+;;; {:plan/type :leaf
+;;; :plan/mbql <compiled-mbql-query>}
+;;;
+;;; Arithmetic plan (multi-query):
+;;; {:plan/type :arithmetic
+;;; :plan/expression <expression-node from AST>
+;;; :plan/leaves {"uuid-a" {:leaf/uuid "a" :leaf/mbql <mbql>} ...}
+;;; :plan/breakout-count 2
+;;; :plan/limit 10000}
+
+;;; -------------------- Validation --------------------
+
+(defn- dimension-signature
+ "Build a signature for a group-by dimension ref that captures its type compatibility.
+ Two dimensions are compatible for joining if they have the same effective type
+ and the same bucketing/binning options."
+ [dim-ref sub-ast]
+ (let [dim-id (:dimension-id dim-ref)
+ ;; Look up the dimension node to get effective-type
+ dim-node (perf/some #(when (= dim-id (:id %)) %) (:dimensions sub-ast))
+ ;; Get bucketing/binning from the ref options
+ ref-options (:options dim-ref)]
+ {:effective-type (:effective-type dim-node)
+ :temporal-unit (:temporal-unit ref-options)
+ :binning (:binning ref-options)}))
+
+(defn- collect-leaf-group-bys
+ "Collect group-by info from all expression leaves in an expression AST.
+ Returns a vector of maps with :uuid, :has-group-by, :breakout-count,
+ and :signatures (a vector of dimension signatures in group-by order)."
+ [expression-node]
+ (let [leaves (ast.walk/collect #(= :expression/leaf (:node/type %)) expression-node)]
+ (perf/mapv (fn [leaf]
+ (let [sub-ast (:ast leaf)
+ group-by (:group-by sub-ast)]
+ {:uuid (:uuid leaf)
+ :has-group-by (boolean (seq group-by))
+ :breakout-count (count group-by)
+ :signatures (perf/mapv #(dimension-signature % sub-ast) group-by)}))
+ leaves)))
+
+(defn- effective-types-compatible?
+ "Check if two effective types are compatible for dimension joining.
+ Types are compatible if they are equal, or if both are date/datetime types
+ (Date, DateTime, DateTimeWithLocalTZ, etc.), or if both are time types."
+ [type-a type-b]
+ (or (= type-a type-b)
+ ;; Both have a date component — Date, DateTime, DateTimeWithLocalTZ, etc.
+ (and (isa? type-a :type/HasDate)
+ (isa? type-b :type/HasDate))
+ ;; Both are pure time types — Time, TimeWithLocalTZ
+ (and (isa? type-a :type/Time)
+ (isa? type-b :type/Time))))
+
+(defn- signatures-compatible?
+ "Check if two dimension signatures are compatible for joining.
+ nil values are treated as unknown and compatible with any known value.
+ Only rejects when both sides have known but different values.
+ Effective types are matched using [[effective-types-compatible?]] which allows
+ compatible-but-not-identical temporal types (e.g. Date vs DateTimeWithLocalTZ)."
+ [sig-a sig-b]
+ (and (or (nil? (:effective-type sig-a))
+ (nil? (:effective-type sig-b))
+ (effective-types-compatible? (:effective-type sig-a) (:effective-type sig-b)))
+ (or (nil? (:temporal-unit sig-a))
+ (nil? (:temporal-unit sig-b))
+ (= (:temporal-unit sig-a) (:temporal-unit sig-b)))
+ (or (nil? (:binning sig-a))
+ (nil? (:binning sig-b))
+ (= (:binning sig-a) (:binning sig-b)))))
+
+(defn- all-signatures-compatible?
+ "Check that all leaves' signature vectors are pairwise compatible at each position."
+ [sig-vecs]
+ (let [positions (count (first sig-vecs))]
+ (perf/every? (fn [pos]
+ (let [sigs-at-pos (map #(nth % pos) sig-vecs)]
+ (perf/every? #(signatures-compatible? (first sigs-at-pos) %)
+ (rest sigs-at-pos))))
+ (range positions))))
+
+(defn validate-arithmetic-ast!
+ "Validate that an arithmetic expression AST has consistent group-by dimensions.
+ All leaves must have the same number of breakout dimensions, and those dimensions must be
+ type-compatible (same effective type, temporal unit, and binning) across all leaves.
+ nil values are treated as unknown and compatible with any known value.
+ Throws ex-info with :status-code 400 on validation failure."
+ [expression-node]
+ (let [leaf-infos (collect-leaf-group-bys expression-node)]
+ (let [breakout-counts (map :breakout-count leaf-infos)]
+ (when-not (apply = breakout-counts)
+ (throw (ex-info "All leaves in arithmetic expression must have the same number of breakout dimensions"
+ {:status-code 400
+ :breakout-counts (zipmap (map :uuid leaf-infos) breakout-counts)}))))
+ (let [sig-vecs (map :signatures leaf-infos)]
+ (when-not (all-signatures-compatible? sig-vecs)
+ (throw (ex-info "All leaves in arithmetic expression must have the same breakout dimension types and bucketing"
+ {:status-code 400
+ :signatures (zipmap (map :uuid leaf-infos) sig-vecs)}))))))
+
+;;; -------------------- Plan Construction --------------------
+
+(defn- compile-leaf-queries
+ "Walk the expression AST, compile each leaf's sub-AST to MBQL.
+ Returns a map of {uuid -> {:leaf/uuid uuid :leaf/mbql mbql}}."
+ [expression-node opts]
+ (let [leaves (ast.walk/collect #(= :expression/leaf (:node/type %)) expression-node)]
+ (into {}
+ (map (fn [leaf]
+ (let [uuid (:uuid leaf)
+ mbql (if-let [limit (:limit opts)]
+ (ast.compile/compile-to-mbql (:ast leaf) :limit limit)
+ (ast.compile/compile-to-mbql (:ast leaf)))]
+ [uuid {:leaf/uuid uuid :leaf/mbql mbql}])))
+ leaves)))
+
+(defn- single-leaf?
+ "Returns true if the expression is a single leaf (no arithmetic operator)."
+ [expression-node]
+ (= :expression/leaf (:node/type expression-node)))
+
+(defn plan-from-ast
+ "Take a complete AST (from from-definition) and produce a query plan.
+ Single-leaf expressions produce a :leaf plan.
+ Arithmetic expressions validate and produce an :arithmetic plan.
+
+ Options:
+ - :limit - add limit to compiled queries
+ - :values-only - if true, compile as values query (no aggregation, for breakout values)"
+ [ast & {:as opts}]
+ (let [expression (:expression ast)
+ compile-fn (if (:values-only opts) ast.compile/compile-to-values-query ast.compile/compile-to-mbql)]
+ (if (single-leaf? expression)
+ ;; Single leaf — compile the sub-AST directly
+ {:plan/type :leaf
+ :plan/mbql (if-let [limit (:limit opts)]
+ (compile-fn (:ast expression) :limit limit)
+ (compile-fn (:ast expression)))}
+ ;; Arithmetic — validate and compile each leaf
+ (do
+ (validate-arithmetic-ast! expression)
+ (let [leaf-infos (collect-leaf-group-bys expression)
+ breakout-ct (:breakout-count (first leaf-infos))
+ leaves (compile-leaf-queries expression opts)]
+ {:plan/type :arithmetic
+ :plan/expression expression
+ :plan/leaves leaves
+ :plan/breakout-count breakout-ct
+ :plan/limit (:limit opts)})))))
+
+;;; -------------------- Expression Evaluation --------------------
+
+(defn evaluate-expression
+ "Recursively evaluate an expression AST node given {uuid -> numeric-value}.
+ Returns nil on nil inputs or division by zero.
+ Operator behavior is driven by metadata in [[operators/operator-metadata]]."
+ [expression-node uuid->value]
+ (case (:node/type expression-node)
+ :expression/leaf
+ (get uuid->value (:uuid expression-node))
+
+ :expression/constant
+ (:value expression-node)
+
+ :expression/arithmetic
+ (let [{:keys [operator children]} expression-node
+ child-vals (perf/mapv #(evaluate-expression % uuid->value) children)]
+ (when (perf/every? some? child-vals)
+ (let [f (operators/eval-fn operator)
+ [init & rest-vals] child-vals]
+ (when-not (and (operators/zero-guard? operator)
+ (perf/some zero? rest-vals))
+ (reduce f init rest-vals)))))))
+
+;;; -------------------- Result Joining --------------------
+
+(defn index-result-by-dimensions
+ "Index QP result rows as {dim-value-tuple -> agg-value}.
+ The first `breakout-count` columns are dimension values, the rest is the aggregate."
+ [result breakout-count]
+ (let [rows (perf/get-in result [:data :rows])]
+ (into {}
+ (map (fn [row]
+ [(vec (take breakout-count row))
+ (nth row breakout-count)]))
+ rows)))
+
+(defn join-and-compute
+ "Inner-join all leaf results on dimension tuples, evaluate expression per row.
+ Returns {:cols [...] :rows [...]}."
+ [expression-node leaf-results breakout-count]
+ (let [;; Index each leaf's results by dimension tuple
+ uuid->indexed (into {}
+ (map (fn [[uuid result]]
+ [uuid (index-result-by-dimensions result breakout-count)]))
+ leaf-results)
+ ;; Find dimension tuples present in ALL leaves (inner join)
+ all-dim-tuples (reduce (fn [acc [_uuid indexed]]
+ (if (nil? acc)
+ (set (keys indexed))
+ (set/intersection acc (set (keys indexed)))))
+ nil
+ uuid->indexed)
+ ;; Compute expression for each joined row
+ rows (into []
+ (keep (fn [dim-tuple]
+ (let [uuid->val (into {}
+ (map (fn [[uuid indexed]]
+ [uuid (get indexed dim-tuple)]))
+ uuid->indexed)
+ result (evaluate-expression expression-node uuid->val)]
+ (when (some? result)
+ (conj dim-tuple result)))))
+ (sort all-dim-tuples))
+ ;; Build column metadata from the first leaf's result
+ first-result (val (first leaf-results))
+ source-cols (perf/get-in first-result [:data :cols])
+ breakout-cols (vec (take breakout-count source-cols))
+ ;; Use the last col (aggregate) with a generic name for the computed result
+ agg-col (-> (last source-cols)
+ (assoc :name "expression" :display_name "Expression"))]
+ {:cols (conj breakout-cols agg-col)
+ :rows rows}))
diff --git a/src/metabase/lib_metric/ast/schema.cljc b/src/metabase/lib_metric/ast/schema.cljc
index e4fefb137df..6ab9e75f1db 100644
--- a/src/metabase/lib_metric/ast/schema.cljc
+++ b/src/metabase/lib_metric/ast/schema.cljc
@@ -3,6 +3,7 @@
The AST provides an intermediate representation for metric definitions
that can be walked, transformed, and compiled to MBQL queries."
(:require
+ [metabase.lib-metric.operators :as operators]
[metabase.lib-metric.schema :as lib-metric.schema]
[metabase.util.malli.registry :as mr]))
@@ -247,15 +248,49 @@
"Union of source node types."
[:or ::source-metric ::source-measure])
-;;; -------------------- Root Node --------------------
+;;; -------------------- Expression Nodes --------------------
-(mr/def ::ast
- "Root AST node - the complete metric exploration."
+(mr/def ::source-query
+ "A single-source query node with source, dimensions, mappings, filters, and group-by.
+ Used inside expression leaves as the compilable sub-query."
[:map
- [:node/type [:= :ast/root]]
+ [:node/type [:= :ast/source-query]]
[:source ::source-node]
[:dimensions [:sequential ::dimension-node]]
[:mappings [:sequential ::dimension-mapping-node]]
[:filter {:optional true} [:maybe ::filter-node]]
- [:group-by {:optional true} [:maybe [:sequential ::dimension-ref-node]]]
+ [:group-by {:optional true} [:maybe [:sequential ::dimension-ref-node]]]])
+
+(mr/def ::expression-leaf
+ "A leaf in an expression tree — wraps a source-query."
+ [:map
+ [:node/type [:= :expression/leaf]]
+ [:uuid string?]
+ [:ast ::source-query]])
+
+(mr/def ::expression-constant
+ "A numeric constant in an expression tree."
+ [:map
+ [:node/type [:= :expression/constant]]
+ [:value number?]])
+
+(mr/def ::expression-arithmetic
+ "An arithmetic operation over expression children."
+ [:map
+ [:node/type [:= :expression/arithmetic]]
+ [:operator (into [:enum] (operators/arithmetic-operator-keywords))]
+ [:children [:sequential [:or [:ref ::expression-leaf] [:ref ::expression-arithmetic] [:ref ::expression-constant]]]]])
+
+(mr/def ::expression-node
+ "Union of expression node types."
+ [:or ::expression-leaf ::expression-arithmetic ::expression-constant])
+
+;;; -------------------- Root Node --------------------
+
+(mr/def ::ast
+ "Root AST node - the complete metric exploration.
+ Always has an :expression tree (single leaf or arithmetic)."
+ [:map
+ [:node/type [:= :ast/root]]
+ [:expression ::expression-node]
[:metadata-provider {:optional true} [:maybe :some]]])
diff --git a/src/metabase/lib_metric/ast/walk.cljc b/src/metabase/lib_metric/ast/walk.cljc
index 77bfceada72..6cef5c65f85 100644
--- a/src/metabase/lib_metric/ast/walk.cljc
+++ b/src/metabase/lib_metric/ast/walk.cljc
@@ -60,7 +60,22 @@
(:lat-dimension ast) (update :lat-dimension inner)
(:lon-dimension ast) (update :lon-dimension inner)))
-(defmethod walk-node :ast/root
+;; Expression leaf — walk into the nested AST
+(defmethod walk-node :expression/leaf
+ [inner ast]
+ (update ast :ast inner))
+
+;; Expression constant — no children to walk
+(defmethod walk-node :expression/constant
+ [_inner ast]
+ ast)
+
+;; Expression arithmetic — walk into children
+(defmethod walk-node :expression/arithmetic
+ [inner ast]
+ (update ast :children #(perf/mapv inner %)))
+
+(defmethod walk-node :ast/source-query
[inner ast]
(cond-> ast
(:filter ast) (update :filter inner)
@@ -69,6 +84,10 @@
(:dimensions ast) (update :dimensions #(perf/mapv inner %))
(:mappings ast) (update :mappings #(perf/mapv inner %))))
+(defmethod walk-node :ast/root
+ [inner ast]
+ (update ast :expression inner))
+
(defmethod walk-node :source/any
[inner ast]
(cond-> ast
diff --git a/src/metabase/lib_metric/core.cljc b/src/metabase/lib_metric/core.cljc
index b6a019e2f56..35ee813a334 100644
--- a/src/metabase/lib_metric/core.cljc
+++ b/src/metabase/lib_metric/core.cljc
@@ -11,7 +11,8 @@
or column aliases. Dimension refs `[:dimension {} \"uuid\"]` are resolved to
concrete field refs when the definition is converted to an executable MBQL query."
(:require
- #?@(:clj [[metabase.lib-metric.dimension.jvm :as lib-metric.dimension.jvm]
+ #?@(:clj [[metabase.lib-metric.ast.plan :as ast.plan]
+ [metabase.lib-metric.dimension.jvm :as lib-metric.dimension.jvm]
[metabase.lib-metric.metadata.jvm :as lib-metric.metadata.jvm]
[potemkin :as p]]
:cljs [[metabase.lib-metric.metadata.js :as lib-metric.metadata.js]])
@@ -38,6 +39,8 @@
remove-clause
replace-clause
swap-clauses]
+ [ast.plan
+ join-and-compute]
[lib-metric.definition
expression-leaf-id
expression-leaf-type
@@ -46,11 +49,12 @@
filters
from-measure-metadata
from-metric-metadata
+ projection-valid?
projections
source-measure-id
source-metric-id
- ->mbql-query
- ->values-query]
+ unprojected-sources
+ ->query-plan]
[lib-metric.dimension
dimension
dimensionable-query
diff --git a/src/metabase/lib_metric/definition.cljc b/src/metabase/lib_metric/definition.cljc
index 69749caa442..5c27f7d3a83 100644
--- a/src/metabase/lib_metric/definition.cljc
+++ b/src/metabase/lib_metric/definition.cljc
@@ -2,10 +2,11 @@
"Functions for creating and manipulating MetricDefinitions."
(:require
[metabase.lib-metric.ast.build :as ast.build]
- [metabase.lib-metric.ast.compile :as ast.compile]
+ [metabase.lib-metric.ast.plan :as ast.plan]
[metabase.lib-metric.ast.schema :as ast.schema]
[metabase.lib-metric.schema :as lib-metric.schema]
- [metabase.util.malli :as mu]))
+ [metabase.util.malli :as mu]
+ [metabase.util.performance :as perf]))
(comment ast.schema/keep-me)
@@ -15,6 +16,10 @@
"Returns true if the expression is a single leaf node ([:metric opts id] or [:measure opts id])."
ast.build/expression-leaf?)
+(def arithmetic-expression?
+ "Returns true if the expression is an arithmetic node [op opts expr expr ...]."
+ ast.build/arithmetic-expression?)
+
(def expression-leaf-type
"Returns the type keyword (:metric or :measure) from an expression leaf."
ast.build/expression-leaf-type)
@@ -42,10 +47,9 @@
[expression]
(cond
(nil? expression) []
+ (number? expression) []
(expression-leaf? expression) [expression]
- (and (sequential? expression)
- (#{:+ :- :* :/} (first expression))
- (>= (count expression) 4))
+ (arithmetic-expression? expression)
(into [] (mapcat expression-leaves) (drop 2 expression))
:else (throw (ex-info "Invalid expression: not a leaf or arithmetic node"
{:expression expression}))))
@@ -97,6 +101,36 @@
(when (= :measure (expression-leaf-type expr))
(expression-leaf-id expr))))
+(defn projection-valid?
+ "Returns true when every distinct source leaf in the expression has a non-empty projection defined."
+ [definition]
+ (let [leaves (expression-leaves (:expression definition))
+ projections (or (:projections definition) [])]
+ (perf/every? (fn [leaf]
+ (let [leaf-type (expression-leaf-type leaf)
+ leaf-id (expression-leaf-id leaf)]
+ (perf/some (fn [tp]
+ (and (= leaf-type (:type tp))
+ (= leaf-id (:id tp))
+ (seq (:projection tp))))
+ projections)))
+ leaves)))
+
+(defn unprojected-sources
+ "Returns a vector of expression leaves that are missing projections."
+ [definition]
+ (let [leaves (expression-leaves (:expression definition))
+ projections (or (:projections definition) [])
+ projected? (fn [leaf]
+ (let [leaf-type (expression-leaf-type leaf)
+ leaf-id (expression-leaf-id leaf)]
+ (perf/some (fn [tp]
+ (and (= leaf-type (:type tp))
+ (= leaf-id (:id tp))
+ (seq (:projection tp))))
+ projections)))]
+ (into [] (remove projected?) leaves)))
+
(defn filters
"Get the filter clauses from a metric definition.
Returns the instance-filters vector."
@@ -116,27 +150,13 @@
[definition :- ::lib-metric.schema/metric-definition]
(ast.build/from-definition definition))
-(mu/defn ->mbql-query
- "Convert MetricDefinition to MBQL query via AST."
- ([definition :- ::lib-metric.schema/metric-definition]
- (->mbql-query definition {}))
- ([definition :- ::lib-metric.schema/metric-definition
- opts :- [:map
- [:limit {:optional true} [:maybe pos-int?]]]]
- (let [ast (->ast definition)]
- (if (some? (:limit opts))
- (ast.compile/compile-to-mbql ast :limit (:limit opts))
- (ast.compile/compile-to-mbql ast)))))
-
-(mu/defn ->values-query
- "Convert MetricDefinition to a values-only MBQL query via AST.
- Like [[->mbql-query]] but omits aggregation, returning distinct breakout values."
+(mu/defn ->query-plan
+ "Convert MetricDefinition to a QueryPlan via AST.
+ For single-leaf definitions, returns a :leaf plan with compiled MBQL.
+ For arithmetic expressions, returns an :arithmetic plan with multiple compiled queries."
([definition :- ::lib-metric.schema/metric-definition]
- (->values-query definition {}))
+ (->query-plan definition {}))
([definition :- ::lib-metric.schema/metric-definition
- opts :- [:map
- [:limit {:optional true} [:maybe pos-int?]]]]
+ opts]
(let [ast (->ast definition)]
- (if (some? (:limit opts))
- (ast.compile/compile-to-values-query ast :limit (:limit opts))
- (ast.compile/compile-to-values-query ast)))))
+ (ast.plan/plan-from-ast ast opts))))
diff --git a/src/metabase/lib_metric/hierarchy.cljc b/src/metabase/lib_metric/hierarchy.cljc
index 2ca97a359e2..0847935896b 100644
--- a/src/metabase/lib_metric/hierarchy.cljc
+++ b/src/metabase/lib_metric/hierarchy.cljc
@@ -2,7 +2,7 @@
"Shared keyword hierarchy for lib-metric dispatch.
Provides a hierarchy that can be used for multimethod dispatch and
operator categorization throughout the lib-metric system."
- (:refer-clojure :exclude [derive isa?]))
+ (:refer-clojure :exclude [derive isa? descendants]))
(defonce ^{:doc "Hierarchy for lib-metric dispatch."} hierarchy
(atom (make-hierarchy)))
@@ -17,3 +17,8 @@
"Like [[clojure.core/isa?]], but uses the lib-metric [[hierarchy]]."
[tag parent]
(clojure.core/isa? @hierarchy tag parent))
+
+(defn descendants
+ "Like [[clojure.core/descendants]], but uses the lib-metric [[hierarchy]]."
+ [tag]
+ (clojure.core/descendants @hierarchy tag))
diff --git a/src/metabase/lib_metric/js.cljs b/src/metabase/lib_metric/js.cljs
index 246ea3a9bca..7bd568de8b9 100644
--- a/src/metabase/lib_metric/js.cljs
+++ b/src/metabase/lib_metric/js.cljs
@@ -848,3 +848,18 @@
(boolean
(when (and (seq sources1) (seq sources2))
(some (set sources1) sources2)))))
+
+(defn ^:export isCompatibleType
+ "Check if two dimensions have compatible effective types for cross-database matching.
+ Two date/datetime dimensions are compatible, two time dimensions are compatible,
+ otherwise requires exact type match. Returns false if either type is nil."
+ [dimension1 dimension2]
+ (let [type1 (types.isa/column-type dimension1)
+ type2 (types.isa/column-type dimension2)]
+ (boolean
+ (when (and type1 type2)
+ (or (= type1 type2)
+ (and (isa? type1 :type/HasDate)
+ (isa? type2 :type/HasDate))
+ (and (isa? type1 :type/Time)
+ (isa? type2 :type/Time)))))))
diff --git a/src/metabase/lib_metric/operators.cljc b/src/metabase/lib_metric/operators.cljc
index 4e0ec1f4f25..fc45a0f91f6 100644
--- a/src/metabase/lib_metric/operators.cljc
+++ b/src/metabase/lib_metric/operators.cljc
@@ -1,8 +1,8 @@
(ns metabase.lib-metric.operators
- "Unified operator definitions for lib-metric filters.
+ "Unified operator definitions for lib-metric filters and arithmetic.
Uses lib-metric.hierarchy for category dispatch.
- Operator categories:
+ Filter categories:
- ::nullary - no value argument (:is-null, :not-null, :is-empty, :not-empty)
- ::comparison - single or variadic values (:=, :!=, :<, :<=, :>, :>=)
- ::string-op - string-specific operators (:contains, :does-not-contain, :starts-with, :ends-with)
@@ -11,7 +11,10 @@
- ::compound - logical operators (:and, :or, :not)
- ::multi-value - multi-value operators (:in, :not-in)
- All categories derive from ::filter-operator for display-info compatibility."
+ Arithmetic category:
+ - ::arithmetic - numeric operations (:+, :-, :*, :/)
+
+ All filter categories derive from ::filter-operator for display-info compatibility."
(:require
[metabase.lib-metric.hierarchy :as hierarchy]
[metabase.util.performance :as perf]))
@@ -50,15 +53,25 @@
(doseq [op [:get-day-of-week :get-month :get-hour :get-quarter]]
(hierarchy/derive op ::temporal-extraction))
-;; All operator categories are filter operators (for display-info compatibility)
+;; Arithmetic operators
+(doseq [op [:+ :- :* :/]]
+ (hierarchy/derive op ::arithmetic))
+
+;; All filter categories are filter operators (for display-info compatibility)
(doseq [cat [::nullary ::comparison ::string-op ::range ::temporal ::compound ::multi-value]]
(hierarchy/derive cat ::filter-operator))
;;; -------------------------------------------------- Operator Metadata --------------------------------------------------
(def ^:private operator-metadata
- "Metadata for each filter operator."
- {:is-null {:display-name "is empty" :arity 0 :ast-node-type :filter/null}
+ "Metadata for all operators (filter and arithmetic)."
+ {;; --- Arithmetic operators ---
+ :+ {:display-name "plus" :arity :variadic :eval-fn +}
+ :- {:display-name "minus" :arity :variadic :eval-fn -}
+ :* {:display-name "times" :arity :variadic :eval-fn *}
+ :/ {:display-name "divided by" :arity :variadic :eval-fn (fn [a b] (/ (double a) (double b))) :zero-guard? true}
+ ;; --- Filter operators ---
+ :is-null {:display-name "is empty" :arity 0 :ast-node-type :filter/null}
:not-null {:display-name "is not empty" :arity 0 :ast-node-type :filter/null}
:is-empty {:display-name "is empty" :arity 0 :ast-node-type :filter/null}
:not-empty {:display-name "is not empty" :arity 0 :ast-node-type :filter/null}
@@ -129,6 +142,11 @@
[op]
(hierarchy/isa? op ::filter-operator))
+(defn arithmetic?
+ "Returns true if `op` is an arithmetic operator."
+ [op]
+ (hierarchy/isa? op ::arithmetic))
+
;;; -------------------------------------------------- Query Functions --------------------------------------------------
(defn display-name
@@ -146,6 +164,21 @@
[op]
(perf/get-in operator-metadata [op :ast-node-type]))
+(defn eval-fn
+ "Get the evaluation function for an arithmetic operator."
+ [op]
+ (perf/get-in operator-metadata [op :eval-fn]))
+
+(defn zero-guard?
+ "Returns true if the arithmetic operator needs division-by-zero protection."
+ [op]
+ (perf/get-in operator-metadata [op :zero-guard?]))
+
+(defn arithmetic-operator-keywords
+ "Returns the set of registered arithmetic operator keywords."
+ []
+ (hierarchy/descendants ::arithmetic))
+
;;; -------------------------------------------------- Operators by Dimension Type --------------------------------------------------
(def ^:private operators-by-dimension-type
diff --git a/src/metabase/lib_metric/projection.cljc b/src/metabase/lib_metric/projection.cljc
index cf84cc30efe..26c876c6a2d 100644
--- a/src/metabase/lib_metric/projection.cljc
+++ b/src/metabase/lib_metric/projection.cljc
@@ -118,13 +118,32 @@
(update definition :projections (fnil conj [])
{:type leaf-type :id leaf-id :lib/uuid leaf-uuid :projection [dimension-ref]}))))
+(defn- all-projectable-dimensions
+ "Get all projectable dimensions, handling both single-source and multi-source definitions."
+ [definition]
+ (let [expression (:expression definition)]
+ (if (lib-metric.definition/expression-leaf? expression)
+ (projectable-dimensions definition)
+ ;; Multi-source: collect dimensions from each leaf source
+ (let [leaves (lib-metric.definition/expression-leaves expression)]
+ (into []
+ (mapcat (fn [leaf]
+ (let [leaf-type (lib-metric.definition/expression-leaf-type leaf)
+ leaf-id (lib-metric.definition/expression-leaf-id leaf)
+ source-metadata {:lib/type (case leaf-type
+ :metric :metadata/metric
+ :measure :metadata/measure)
+ :id leaf-id}]
+ (projectable-dimensions-for-source definition source-metadata))))
+ leaves)))))
+
(mu/defn projection-dimension :- [:maybe ::lib-metric.schema/metadata-dimension]
"Get the dimension metadata for a projection clause.
The projection is a dimension-reference [:dimension opts uuid].
Returns the dimension metadata or nil if not found."
[definition :- ::lib-metric.schema/metric-definition
projection-or-reference :- ::lib-metric.schema/dimension-or-reference]
- (let [dimensions (projectable-dimensions definition)
+ (let [dimensions (all-projectable-dimensions definition)
dimension-id (if (map? projection-or-reference)
(:id projection-or-reference)
(projection-dimension-id projection-or-reference))]
diff --git a/src/metabase/lib_metric/schema.cljc b/src/metabase/lib_metric/schema.cljc
index a71bf2b122a..49af2b81716 100644
--- a/src/metabase/lib_metric/schema.cljc
+++ b/src/metabase/lib_metric/schema.cljc
@@ -2,6 +2,7 @@
"Malli schemas for metric dimensions, dimension-mappings, and dimension-references."
(:refer-clojure :exclude [some])
(:require
+ [metabase.lib-metric.operators :as operators]
[metabase.lib.schema.common :as lib.schema.common]
[metabase.lib.schema.id :as lib.schema.id]
[metabase.lib.schema.ref :as lib.schema.ref]
@@ -227,13 +228,16 @@
(mr/def ::arithmetic-operator
"Arithmetic operators for metric math."
- [:enum {:decode/normalize lib.schema.common/normalize-keyword} :+ :- :* :/])
+ (into [:enum {:decode/normalize lib.schema.common/normalize-keyword}]
+ (operators/arithmetic-operator-keywords)))
(defn normalize-math-expression
"Recursively normalize a metric math expression from API format.
- Handles string keys, string operators, and nested expressions."
+ Handles string keys, string operators, nested expressions, and bare numeric constants."
[x]
- (when (sequential? x)
+ (cond
+ (number? x) x
+ (sequential? x)
(let [[first-el] x]
(if (and (>= (count x) 3)
(let [tag (lib.schema.common/normalize-keyword first-el)]
@@ -245,7 +249,8 @@
(let [[op opts & exprs] x]
(into [(lib.schema.common/normalize-keyword op)
(lib.schema.common/normalize-options-map (or opts {}))]
- (map normalize-math-expression exprs))))))))
+ (map normalize-math-expression exprs))))))
+ :else nil))
(mr/def ::metric-math-expression
"A recursive metric math expression tree.
@@ -256,12 +261,13 @@
{:decode/normalize normalize-math-expression}
[:or
::expression-leaf
+ number?
[:and
vector?
[:fn {:error/message "must be arithmetic expression [op opts expr expr ...] with at least 2 operands"}
(fn [x]
(and (>= (count x) 4)
- (#{:+ :- :* :/} (first x))
+ (operators/arithmetic? (first x))
(map? (second x))))]]]])
;;; ------------------------------------------------- Per-Instance Filters -------------------------------------------------
diff --git a/src/metabase/metrics/api.clj b/src/metabase/metrics/api.clj
index 44009909ff1..8e8cfd22c58 100644
--- a/src/metabase/metrics/api.clj
+++ b/src/metabase/metrics/api.clj
@@ -9,6 +9,7 @@
[metabase.metrics.core :as metrics]
[metabase.metrics.permissions :as metrics.perms]
[metabase.query-processor.core :as qp]
+ [metabase.query-processor.pipeline :as qp.pipeline]
[metabase.query-processor.streaming :as qp.streaming]
[metabase.request.core :as request]
[metabase.server.core :as server]
@@ -17,6 +18,8 @@
[metabase.util.malli.schema :as ms]
[toucan2.core :as t2]))
+(set! *warn-on-reflection* true)
+
(mr/def ::Metric
"Schema for a Metric in list responses (without hydrated dimensions)."
[:map
@@ -121,6 +124,9 @@
[:expression ::lib-metric.schema/metric-math-expression]
[:filters {:optional true} [:maybe ::lib-metric.schema/instance-filters]]
[:projections {:optional true} [:maybe ::lib-metric.schema/typed-projections]]]
+ [:fn {:error/message "Expression must contain at least one metric or measure"}
+ (fn [{:keys [expression]}]
+ (seq (collect-expression-leaves expression)))]
[:fn {:error/message "All :lib/uuid values in expression must be unique"}
(fn [{:keys [expression]}]
(let [uuids (collect-expression-uuids expression)]
@@ -181,6 +187,29 @@
:projections (or projections [])
:metadata-provider provider}))
+(defn- execute-leaf-queries
+ "Execute all leaf queries in parallel, collecting results eagerly.
+ Must be called OUTSIDE streaming context to avoid JSON writer conflicts.
+ Returns {uuid -> qp-result}."
+ [leaves]
+ (let [uuid->future (into {}
+ (map (fn [[uuid leaf-plan]]
+ [uuid (future (qp/process-query (qp/userland-query (:leaf/mbql leaf-plan))))]))
+ leaves)]
+ (into {}
+ (map (fn [[uuid f]] [uuid @f]))
+ uuid->future)))
+
+(defn- stream-arithmetic-results
+ "Join leaf results and stream the computed output through the QP reduce pipeline.
+ Called INSIDE streaming context with the rff."
+ [{:keys [plan/expression plan/breakout-count]} uuid->result rff]
+ (let [{:keys [cols rows]} (lib-metric/join-and-compute expression uuid->result breakout-count)
+ reducible (reify clojure.lang.IReduceInit
+ (reduce [_ rf init]
+ (reduce rf init rows)))]
+ (qp.pipeline/*reduce* rff {:cols cols} reducible)))
+
(api.macros/defendpoint :post "/dataset"
:- (server/streaming-response-schema ::DatasetResponse)
"Execute a metric or measure-based query and stream the results.
@@ -193,11 +222,15 @@
[_route-params
_query-params
{:keys [definition]} :- ::DatasetRequest]
- (let [query (-> (lib-metric/metadata-provider)
- (from-api-definition definition)
- (lib-metric/->mbql-query {:limit 10000}))]
- (qp.streaming/streaming-response [rff :api]
- (qp/process-query (qp/userland-query query) rff))))
+ (let [definition (from-api-definition (lib-metric/metadata-provider) definition)
+ plan (lib-metric/->query-plan definition {:limit 10000})]
+ (if (= :leaf (:plan/type plan))
+ (qp.streaming/streaming-response [rff :api]
+ (qp/process-query (qp/userland-query (:plan/mbql plan)) rff))
+ ;; Arithmetic: execute leaf queries BEFORE streaming to avoid JSON writer conflicts
+ (let [uuid->result (execute-leaf-queries (:plan/leaves plan))]
+ (qp.streaming/streaming-response [rff :api]
+ (stream-arithmetic-results plan uuid->result rff))))))
;;; +----------------------------------------------------------------------------------------------------------------+
;;; | Dimension Value Endpoints |
@@ -215,12 +248,11 @@
[_route-params
_query-params
{:keys [definition]} :- ::DatasetRequest]
- (let [query (-> (lib-metric/metadata-provider)
- (from-api-definition definition)
- (lib-metric/->values-query {:limit 100}))
- result (qp/process-query (qp/userland-query query))
- col (first (get-in result [:data :cols]))
- values (mapv first (get-in result [:data :rows]))]
+ (let [definition (from-api-definition (lib-metric/metadata-provider) definition)
+ plan (lib-metric/->query-plan definition {:limit 100 :values-only true})
+ result (qp/process-query (qp/userland-query (:plan/mbql plan)))
+ col (first (get-in result [:data :cols]))
+ values (mapv first (get-in result [:data :rows]))]
{:values values
:col (or col {})}))
diff --git a/test/metabase/lib_metric/ast/build_test.cljc b/test/metabase/lib_metric/ast/build_test.cljc
index 418e70e1f23..fd1b89b02c4 100644
--- a/test/metabase/lib_metric/ast/build_test.cljc
+++ b/test/metabase/lib_metric/ast/build_test.cljc
@@ -137,24 +137,33 @@
(testing "has correct root structure"
(is (= :ast/root (:node/type ast)))
- (is (nil? (:filter ast)))
- (is (= [] (:group-by ast)))
+ (is (some? (:expression ast)))
(is (some? (:metadata-provider ast))))
- (testing "has correct source"
- (let [source (:source ast)]
- (is (= :source/metric (:node/type source)))
- (is (= 42 (:id source)))
- (is (= "Total Revenue" (:name source)))))
+ (testing "expression is a single leaf"
+ (is (= :expression/leaf (get-in ast [:expression :node/type])))
+ (is (string? (get-in ast [:expression :uuid]))))
- (testing "has dimensions as nodes"
- (is (= 2 (count (:dimensions ast))))
- (is (every? #(= :ast/dimension (:node/type %)) (:dimensions ast)))
- (is (= uuid-1 (get-in ast [:dimensions 0 :id]))))
+ (let [source-query (get-in ast [:expression :ast])]
+ (testing "leaf wraps a source-query"
+ (is (= :ast/source-query (:node/type source-query)))
+ (is (nil? (:filter source-query)))
+ (is (= [] (:group-by source-query))))
- (testing "has mappings as nodes"
- (is (= 2 (count (:mappings ast))))
- (is (every? #(= :ast/dimension-mapping (:node/type %)) (:mappings ast))))))
+ (testing "has correct source"
+ (let [source (:source source-query)]
+ (is (= :source/metric (:node/type source)))
+ (is (= 42 (:id source)))
+ (is (= "Total Revenue" (:name source)))))
+
+ (testing "has dimensions as nodes"
+ (is (= 2 (count (:dimensions source-query))))
+ (is (every? #(= :ast/dimension (:node/type %)) (:dimensions source-query)))
+ (is (= uuid-1 (get-in source-query [:dimensions 0 :id]))))
+
+ (testing "has mappings as nodes"
+ (is (= 2 (count (:mappings source-query))))
+ (is (every? #(= :ast/dimension-mapping (:node/type %)) (:mappings source-query)))))))
(deftest ^:parallel from-definition-measure-test
(let [measure-def {:lib/type :metric/definition
@@ -168,10 +177,10 @@
(is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))
(testing "has measure source type"
- (is (= :source/measure (get-in ast [:source :node/type]))))
+ (is (= :source/measure (get-in ast [:expression :ast :source :node/type]))))
(testing "extracts sum aggregation"
- (is (= :aggregation/sum (get-in ast [:source :aggregation :node/type]))))))
+ (is (= :aggregation/sum (get-in ast [:expression :ast :source :aggregation :node/type]))))))
;;; -------------------------------------------------- Dimension Reference Conversion --------------------------------------------------
@@ -377,15 +386,16 @@
(let [definition-with-filters (assoc (sample-definition)
:filters [{:lib/uuid expr-uuid
:filter [:= {} [:dimension {} uuid-1] 42]}])
- ast (ast.build/from-definition definition-with-filters)]
+ ast (ast.build/from-definition definition-with-filters)
+ source-query (get-in ast [:expression :ast])]
(testing "creates valid AST structure with filter"
(is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))
(testing "has filter node"
- (is (some? (:filter ast)))
- (is (= :filter/comparison (get-in ast [:filter :node/type])))
- (is (= := (get-in ast [:filter :operator]))))))
+ (is (some? (:filter source-query)))
+ (is (= :filter/comparison (get-in source-query [:filter :node/type])))
+ (is (= := (get-in source-query [:filter :operator]))))))
(deftest ^:parallel from-definition-with-projections-test
(let [definition-with-projections (assoc (sample-definition)
@@ -394,24 +404,26 @@
:lib/uuid expr-uuid
:projection [[:dimension {} uuid-1]
[:dimension {"temporal-unit" "year"} uuid-2]]}])
- ast (ast.build/from-definition definition-with-projections)]
+ ast (ast.build/from-definition definition-with-projections)
+ source-query (get-in ast [:expression :ast])]
(testing "creates valid AST structure with group-by"
(is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))
(testing "has group-by dimension refs"
- (is (= 2 (count (:group-by ast))))
- (is (every? #(= :ast/dimension-ref (:node/type %)) (:group-by ast)))
- (is (= uuid-1 (get-in ast [:group-by 0 :dimension-id])))
- (is (= {:temporal-unit :year} (get-in ast [:group-by 1 :options]))))))
+ (is (= 2 (count (:group-by source-query))))
+ (is (every? #(= :ast/dimension-ref (:node/type %)) (:group-by source-query)))
+ (is (= uuid-1 (get-in source-query [:group-by 0 :dimension-id])))
+ (is (= {:temporal-unit :year} (get-in source-query [:group-by 1 :options]))))))
(deftest ^:parallel from-definition-loads-dimensions-from-provider-test
(testing "dimensions are loaded from metadata fetched via provider"
(let [definition (sample-definition)
- ast (ast.build/from-definition definition)]
+ ast (ast.build/from-definition definition)
+ source-query (get-in ast [:expression :ast])]
;; Dimensions are loaded from provider -> sample-metric-metadata
- (is (= 2 (count (:dimensions ast))))
- (is (= 2 (count (:mappings ast)))))))
+ (is (= 2 (count (:dimensions source-query))))
+ (is (= 2 (count (:mappings source-query)))))))
;;; -------------------------------------------------- Multi-Stage Source Queries --------------------------------------------------
@@ -441,6 +453,101 @@
:metadata-provider provider}
ast (ast.build/from-definition definition)]
(testing "has joins extracted from stage 0"
- (is (seq (get-in ast [:source :joins]))))
+ (is (seq (get-in ast [:expression :ast :source :joins]))))
(testing "has aggregation extracted from stage 0"
- (is (some? (get-in ast [:source :aggregation])))))))
+ (is (some? (get-in ast [:expression :ast :source :aggregation])))))))
+
+;;; -------------------------------------------------- Arithmetic Expression Building --------------------------------------------------
+
+(def ^:private arith-uuid-a "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+(def ^:private arith-uuid-b "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")
+
+(defn- arithmetic-definition []
+ {:lib/type :metric/definition
+ :expression [:+ {}
+ [:metric {:lib/uuid arith-uuid-a} 42]
+ [:metric {:lib/uuid arith-uuid-b} 42]]
+ :filters []
+ :projections []
+ :metadata-provider (make-test-provider (sample-metric-metadata) (sample-measure-metadata))})
+
+(deftest ^:parallel from-definition-arithmetic-test
+ (let [ast (ast.build/from-definition (arithmetic-definition))]
+
+ (testing "arithmetic expression builds AST with :expression key"
+ (is (= :ast/root (:node/type ast)))
+ (is (some? (:expression ast)))
+ (is (nil? (:source ast))))
+
+ (testing "expression root is arithmetic node"
+ (is (= :expression/arithmetic (get-in ast [:expression :node/type])))
+ (is (= :+ (get-in ast [:expression :operator]))))
+
+ (testing "arithmetic has two children"
+ (is (= 2 (count (get-in ast [:expression :children])))))
+
+ (testing "each child is an expression leaf with complete sub-AST"
+ (doseq [child (get-in ast [:expression :children])]
+ (is (= :expression/leaf (:node/type child)))
+ (is (string? (:uuid child)))
+ (let [sub-ast (:ast child)]
+ (is (= :ast/source-query (:node/type sub-ast)))
+ (is (some? (:source sub-ast)))
+ (is (seq (:dimensions sub-ast)))
+ (is (seq (:mappings sub-ast))))))
+
+ (testing "leaf UUIDs match expression"
+ (let [uuids (set (map :uuid (get-in ast [:expression :children])))]
+ (is (contains? uuids arith-uuid-a))
+ (is (contains? uuids arith-uuid-b))))))
+
+(deftest ^:parallel from-definition-arithmetic-with-filters-test
+ (let [definition (assoc (arithmetic-definition)
+ :filters [{:lib/uuid arith-uuid-a
+ :filter [:= {} [:dimension {} uuid-1] 42]}])
+ ast (ast.build/from-definition definition)]
+
+ (testing "instance filters are partitioned to matching leaf sub-ASTs"
+ (let [children (get-in ast [:expression :children])
+ child-a (first (filter #(= arith-uuid-a (:uuid %)) children))
+ child-b (first (filter #(= arith-uuid-b (:uuid %)) children))]
+ (is (some? (get-in child-a [:ast :filter])))
+ (is (nil? (get-in child-b [:ast :filter])))))))
+
+(deftest ^:parallel from-definition-arithmetic-with-constant-test
+ (let [definition {:lib/type :metric/definition
+ :expression [:* {} [:metric {:lib/uuid arith-uuid-a} 42] 100]
+ :filters []
+ :projections []
+ :metadata-provider (make-test-provider (sample-metric-metadata) (sample-measure-metadata))}
+ ast (ast.build/from-definition definition)]
+
+ (testing "creates valid AST with constant child"
+ (is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))
+
+ (testing "expression root is arithmetic"
+ (is (= :expression/arithmetic (get-in ast [:expression :node/type])))
+ (is (= :* (get-in ast [:expression :operator]))))
+
+ (testing "has one leaf and one constant child"
+ (let [children (get-in ast [:expression :children])]
+ (is (= 2 (count children)))
+ (is (= :expression/leaf (get-in children [0 :node/type])))
+ (is (= :expression/constant (get-in children [1 :node/type])))
+ (is (= 100 (get-in children [1 :value])))))))
+
+(deftest ^:parallel from-definition-arithmetic-with-projections-test
+ (let [definition (assoc (arithmetic-definition)
+ :projections [{:type :metric
+ :id 42
+ :lib/uuid arith-uuid-a
+ :projection [[:dimension {} uuid-1]]}
+ {:type :metric
+ :id 42
+ :lib/uuid arith-uuid-b
+ :projection [[:dimension {} uuid-1]]}])
+ ast (ast.build/from-definition definition)]
+
+ (testing "projections are assigned to matching leaf sub-ASTs"
+ (doseq [child (get-in ast [:expression :children])]
+ (is (= 1 (count (get-in child [:ast :group-by]))))))))
diff --git a/test/metabase/lib_metric/ast/compile_test.cljc b/test/metabase/lib_metric/ast/compile_test.cljc
index 3571eee8881..0481a7cfccf 100644
--- a/test/metabase/lib_metric/ast/compile_test.cljc
+++ b/test/metabase/lib_metric/ast/compile_test.cljc
@@ -12,7 +12,7 @@
(def ^:private dim-ref-2 {:node/type :ast/dimension-ref :dimension-id uuid-2 :options {:temporal-unit :month}})
(def ^:private sample-ast
- {:node/type :ast/root
+ {:node/type :ast/source-query
:source {:node/type :source/metric
:id 42
:name "Test Metric"
@@ -36,8 +36,7 @@
:table-id 100
:column {:node/type :ast/column :id 2}}]
:filter nil
- :group-by []
- :metadata-provider :test-provider})
+ :group-by []})
;;; -------------------------------------------------- Basic Compilation --------------------------------------------------
diff --git a/test/metabase/lib_metric/ast/plan_test.cljc b/test/metabase/lib_metric/ast/plan_test.cljc
new file mode 100644
index 00000000000..9e6f6380d92
--- /dev/null
+++ b/test/metabase/lib_metric/ast/plan_test.cljc
@@ -0,0 +1,233 @@
+(ns metabase.lib-metric.ast.plan-test
+ (:require
+ [clojure.test :refer [deftest is testing]]
+ [metabase.lib-metric.ast.plan :as ast.plan]))
+
+;;; -------------------------------------------------- Test Data --------------------------------------------------
+
+(def ^:private uuid-a "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+(def ^:private uuid-b "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")
+(def ^:private uuid-c "cccccccc-cccc-cccc-cccc-cccccccccccc")
+(def ^:private dim-1 "dddddddd-dddd-dddd-dddd-dddddddddd01")
+(def ^:private dim-2 "dddddddd-dddd-dddd-dddd-dddddddddd02")
+
+(defn- make-leaf-ast
+ "Build a minimal single-source AST for testing.
+ Includes dimension mappings so compile-to-mbql can resolve dimension refs."
+ [group-by-dim-ids]
+ {:node/type :ast/source-query
+ :source {:node/type :source/metric
+ :id 1
+ :name "test"
+ :aggregation {:node/type :aggregation/count}
+ :base-table {:node/type :ast/table :id 1}
+ :metadata {:dataset-query {:database 1}}}
+ :dimensions (mapv (fn [dim-id] {:node/type :ast/dimension :id dim-id}) group-by-dim-ids)
+ :mappings (mapv (fn [dim-id]
+ {:node/type :ast/dimension-mapping
+ :dimension-id dim-id
+ :column {:node/type :ast/column :id 100}})
+ group-by-dim-ids)
+ :group-by (mapv (fn [dim-id] {:node/type :ast/dimension-ref :dimension-id dim-id})
+ group-by-dim-ids)})
+
+(defn- make-expression-leaf
+ ([uuid group-by-dim-ids]
+ {:node/type :expression/leaf
+ :uuid uuid
+ :ast (make-leaf-ast group-by-dim-ids)})
+ ([uuid group-by-dim-ids dim-opts]
+ {:node/type :expression/leaf
+ :uuid uuid
+ :ast (-> (make-leaf-ast group-by-dim-ids)
+ (update :dimensions
+ (fn [dims]
+ (mapv (fn [dim]
+ (merge dim (get dim-opts (:id dim))))
+ dims)))
+ (update :group-by
+ (fn [refs]
+ (mapv (fn [ref]
+ (if-let [opts (get dim-opts (:dimension-id ref))]
+ (cond-> ref
+ (:temporal-unit opts) (assoc-in [:options :temporal-unit] (:temporal-unit opts)))
+ ref))
+ refs))))}))
+
+(defn- make-expression-arithmetic [op children]
+ {:node/type :expression/arithmetic
+ :operator op
+ :children children})
+
+;;; -------------------------------------------------- evaluate-expression --------------------------------------------------
+
+(deftest ^:parallel evaluate-expression-addition-test
+ (testing "addition of two leaves"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])]
+ (is (= 30 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))
+
+(deftest ^:parallel evaluate-expression-subtraction-test
+ (testing "subtraction of two leaves"
+ (let [expr (make-expression-arithmetic :- [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])]
+ (is (= -10 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))
+
+(deftest ^:parallel evaluate-expression-multiplication-test
+ (testing "multiplication of two leaves"
+ (let [expr (make-expression-arithmetic :* [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])]
+ (is (= 200 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))
+
+(deftest ^:parallel evaluate-expression-division-test
+ (testing "division of two leaves"
+ (let [expr (make-expression-arithmetic :/ [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])]
+ (is (= 0.5 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20}))))))
+
+(deftest ^:parallel evaluate-expression-nested-test
+ (testing "nested expression (a + b) * c"
+ (let [inner (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])
+ expr (make-expression-arithmetic :* [inner
+ (make-expression-leaf uuid-c [])])]
+ (is (= 150 (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 20 uuid-c 5}))))))
+
+(deftest ^:parallel evaluate-expression-nil-propagation-test
+ (testing "nil input propagates as nil"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])]
+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b nil})))
+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a nil uuid-b 20})))
+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a 10}))))))
+
+(deftest ^:parallel evaluate-expression-constant-test
+ (testing "constant node returns its value"
+ (is (= 42 (ast.plan/evaluate-expression {:node/type :expression/constant :value 42} {})))))
+
+(deftest ^:parallel evaluate-expression-leaf-times-constant-test
+ (testing "leaf * constant evaluates correctly"
+ (let [expr (make-expression-arithmetic :* [(make-expression-leaf uuid-a [])
+ {:node/type :expression/constant :value 100}])]
+ (is (= 500 (ast.plan/evaluate-expression expr {uuid-a 5}))))))
+
+(deftest ^:parallel validate-arithmetic-ast-with-constants-test
+ (testing "arithmetic with constants + leaves with projections passes validation"
+ (let [expr (make-expression-arithmetic :* [(make-expression-leaf uuid-a [dim-1])
+ {:node/type :expression/constant :value 100}])]
+ (is (nil? (ast.plan/validate-arithmetic-ast! expr))))))
+
+(deftest ^:parallel evaluate-expression-division-by-zero-test
+ (testing "division by zero returns nil"
+ (let [expr (make-expression-arithmetic :/ [(make-expression-leaf uuid-a [])
+ (make-expression-leaf uuid-b [])])]
+ (is (nil? (ast.plan/evaluate-expression expr {uuid-a 10 uuid-b 0}))))))
+
+;;; -------------------------------------------------- index-result-by-dimensions --------------------------------------------------
+
+(deftest ^:parallel index-result-by-dimensions-no-breakouts-test
+ (testing "no breakout columns — single row, empty key"
+ (let [result {:data {:rows [[42]]}}]
+ (is (= {[] 42} (ast.plan/index-result-by-dimensions result 0))))))
+
+(deftest ^:parallel index-result-by-dimensions-with-breakouts-test
+ (testing "two breakout columns"
+ (let [result {:data {:rows [["US" "NY" 100]
+ ["US" "CA" 200]
+ ["UK" "London" 50]]}}]
+ (is (= {["US" "NY"] 100
+ ["US" "CA"] 200
+ ["UK" "London"] 50}
+ (ast.plan/index-result-by-dimensions result 2))))))
+
+;;; -------------------------------------------------- join-and-compute --------------------------------------------------
+
+(deftest ^:parallel join-and-compute-inner-join-test
+ (testing "inner join semantics — only matching dimension tuples"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])
+ (make-expression-leaf uuid-b [dim-1])])
+ leaf-results {uuid-a {:data {:cols [{:name "dim1"} {:name "count"}]
+ :rows [["X" 10] ["Y" 20] ["Z" 30]]}}
+ uuid-b {:data {:cols [{:name "dim1"} {:name "count"}]
+ :rows [["X" 100] ["Y" 200] ["W" 400]]}}}
+ result (ast.plan/join-and-compute expr leaf-results 1)]
+ (is (= [["X" 110] ["Y" 220]]
+ (:rows result))))))
+
+(deftest ^:parallel join-and-compute-empty-results-test
+ (testing "no matching tuples returns empty rows"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])
+ (make-expression-leaf uuid-b [dim-1])])
+ leaf-results {uuid-a {:data {:cols [{:name "dim1"} {:name "count"}]
+ :rows [["X" 10]]}}
+ uuid-b {:data {:cols [{:name "dim1"} {:name "count"}]
+ :rows [["Y" 20]]}}}
+ result (ast.plan/join-and-compute expr leaf-results 1)]
+ (is (= [] (:rows result))))))
+
+;;; -------------------------------------------------- validate-arithmetic-ast! --------------------------------------------------
+
+(deftest ^:parallel validate-arithmetic-ast-mismatched-dims-test
+ (testing "throws 400 when leaves have different number of breakout dimensions"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])
+ (make-expression-leaf uuid-b [dim-1 dim-2])])]
+ (is (thrown-with-msg?
+ #?(:clj clojure.lang.ExceptionInfo :cljs js/Error)
+ #"same number of breakout"
+ (ast.plan/validate-arithmetic-ast! expr))))))
+
+(deftest ^:parallel validate-arithmetic-ast-mismatched-types-test
+ (testing "throws 400 when leaves have same count but different dimension types"
+ (let [expr (make-expression-arithmetic
+ :+ [(make-expression-leaf uuid-a [dim-1] {dim-1 {:effective-type :type/Integer}})
+ (make-expression-leaf uuid-b [dim-1] {dim-1 {:effective-type :type/Text}})])]
+ (is (thrown-with-msg?
+ #?(:clj clojure.lang.ExceptionInfo :cljs js/Error)
+ #"same breakout dimension types"
+ (ast.plan/validate-arithmetic-ast! expr))))))
+
+(deftest ^:parallel validate-arithmetic-ast-compatible-datetime-types-test
+ (testing "accepts compatible date/datetime types across different databases"
+ (let [expr (make-expression-arithmetic
+ :+ [(make-expression-leaf uuid-a [dim-1] {dim-1 {:effective-type :type/Date}})
+ (make-expression-leaf uuid-b [dim-1] {dim-1 {:effective-type :type/DateTimeWithLocalTZ}})])]
+ (is (nil? (ast.plan/validate-arithmetic-ast! expr)))))
+ (testing "rejects incompatible temporal types (date vs time)"
+ (let [expr (make-expression-arithmetic
+ :+ [(make-expression-leaf uuid-a [dim-1] {dim-1 {:effective-type :type/Date}})
+ (make-expression-leaf uuid-b [dim-1] {dim-1 {:effective-type :type/Time}})])]
+ (is (thrown-with-msg?
+ #?(:clj clojure.lang.ExceptionInfo :cljs js/Error)
+ #"same breakout dimension types"
+ (ast.plan/validate-arithmetic-ast! expr))))))
+
+(deftest ^:parallel validate-arithmetic-ast-valid-test
+ (testing "valid arithmetic AST passes validation"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])
+ (make-expression-leaf uuid-b [dim-1])])]
+ (is (nil? (ast.plan/validate-arithmetic-ast! expr))))))
+
+;;; -------------------------------------------------- plan-from-ast --------------------------------------------------
+
+(deftest ^:parallel plan-from-ast-leaf-test
+ (testing "single-source AST produces :leaf plan"
+ (let [ast {:node/type :ast/root
+ :expression {:node/type :expression/leaf
+ :uuid uuid-a
+ :ast (make-leaf-ast [dim-1])}}
+ plan (ast.plan/plan-from-ast ast)]
+ (is (= :leaf (:plan/type plan)))
+ (is (some? (:plan/mbql plan))))))
+
+(deftest ^:parallel plan-from-ast-arithmetic-test
+ (testing "arithmetic AST produces :arithmetic plan"
+ (let [expr (make-expression-arithmetic :+ [(make-expression-leaf uuid-a [dim-1])
+ (make-expression-leaf uuid-b [dim-1])])
+ ast {:node/type :ast/root
+ :expression expr}
+ plan (ast.plan/plan-from-ast ast)]
+ (is (= :arithmetic (:plan/type plan)))
+ (is (= 2 (count (:plan/leaves plan))))
+ (is (= 1 (:plan/breakout-count plan)))
+ (is (contains? (:plan/leaves plan) uuid-a))
+ (is (contains? (:plan/leaves plan) uuid-b)))))
diff --git a/test/metabase/lib_metric/ast/schema_test.cljc b/test/metabase/lib_metric/ast/schema_test.cljc
index 450b2a55fae..1d4cedcaead 100644
--- a/test/metabase/lib_metric/ast/schema_test.cljc
+++ b/test/metabase/lib_metric/ast/schema_test.cljc
@@ -277,6 +277,48 @@
:aggregation {:node/type :aggregation/count}
:base-table {:node/type :ast/table :id 1}})))
+;;; -------------------------------------------------- Expression Constant Nodes --------------------------------------------------
+
+(deftest ^:parallel expression-constant-test
+ (testing "valid expression constant nodes"
+ (are [node] (nil? (me/humanize (mr/explain ::ast.schema/expression-constant node)))
+ {:node/type :expression/constant :value 42}
+ {:node/type :expression/constant :value 3.14}
+ {:node/type :expression/constant :value -7}
+ {:node/type :expression/constant :value 0}))
+ (testing "invalid expression constant nodes"
+ (testing "missing value"
+ (is (some? (me/humanize (mr/explain ::ast.schema/expression-constant
+ {:node/type :expression/constant})))))
+ (testing "non-numeric value"
+ (is (some? (me/humanize (mr/explain ::ast.schema/expression-constant
+ {:node/type :expression/constant :value "nope"})))))))
+
+(deftest ^:parallel expression-arithmetic-with-constant-children-test
+ (let [source {:node/type :source/metric
+ :id 1
+ :aggregation {:node/type :aggregation/count}
+ :base-table {:node/type :ast/table :id 1}}
+ source-query {:node/type :ast/source-query
+ :source source
+ :dimensions []
+ :mappings []}]
+ (testing "arithmetic with constant children validates"
+ (is (nil? (me/humanize (mr/explain ::ast.schema/expression-arithmetic
+ {:node/type :expression/arithmetic
+ :operator :*
+ :children [{:node/type :expression/leaf
+ :uuid "test-uuid"
+ :ast source-query}
+ {:node/type :expression/constant
+ :value 100}]})))))))
+
+(deftest ^:parallel expression-node-includes-constant-test
+ (testing "expression-node union includes constants"
+ (is (nil? (me/humanize (mr/explain ::ast.schema/expression-node
+ {:node/type :expression/constant
+ :value 42}))))))
+
;;; -------------------------------------------------- Root Node --------------------------------------------------
(deftest ^:parallel ast-root-test
@@ -287,31 +329,42 @@
dim {:node/type :ast/dimension :id uuid-1}
mapping {:node/type :ast/dimension-mapping
:dimension-id uuid-1
- :column {:node/type :ast/column :id 1}}]
- (testing "valid root AST"
+ :column {:node/type :ast/column :id 1}}
+ source-query-simple {:node/type :ast/source-query
+ :source source
+ :dimensions []
+ :mappings []}
+ source-query-full {:node/type :ast/source-query
+ :source source
+ :dimensions [dim]
+ :mappings [mapping]
+ :filter {:node/type :filter/comparison
+ :operator :=
+ :dimension {:node/type :ast/dimension-ref :dimension-id uuid-1}
+ :values ["test"]}
+ :group-by [{:node/type :ast/dimension-ref :dimension-id uuid-1}]}]
+ (testing "valid root AST with expression leaf"
(are [node] (nil? (me/humanize (mr/explain ::ast.schema/ast node)))
{:node/type :ast/root
- :source source
- :dimensions []
- :mappings []}
- {:node/type :ast/root
- :source source
- :dimensions [dim]
- :mappings [mapping]
- :filter nil
- :group-by []}
+ :expression {:node/type :expression/leaf
+ :uuid "test-uuid"
+ :ast source-query-simple}}
{:node/type :ast/root
- :source source
- :dimensions [dim]
- :mappings [mapping]
- :filter {:node/type :filter/comparison
- :operator :=
- :dimension {:node/type :ast/dimension-ref :dimension-id uuid-1}
- :values ["test"]}
- :group-by [{:node/type :ast/dimension-ref :dimension-id uuid-1}]}))
+ :expression {:node/type :expression/leaf
+ :uuid "test-uuid"
+ :ast source-query-full}}))
+ (testing "valid root AST with arithmetic expression"
+ (is (nil? (me/humanize (mr/explain ::ast.schema/ast
+ {:node/type :ast/root
+ :expression {:node/type :expression/arithmetic
+ :operator :+
+ :children [{:node/type :expression/leaf
+ :uuid "uuid-a"
+ :ast source-query-simple}
+ {:node/type :expression/leaf
+ :uuid "uuid-b"
+ :ast source-query-simple}]}})))))
(testing "invalid root AST"
- (testing "missing source"
+ (testing "missing expression"
(is (some? (me/humanize (mr/explain ::ast.schema/ast
- {:node/type :ast/root
- :dimensions []
- :mappings []}))))))))
+ {:node/type :ast/root}))))))))
diff --git a/test/metabase/lib_metric/ast/walk_test.cljc b/test/metabase/lib_metric/ast/walk_test.cljc
index d239e363114..33eb417b3d5 100644
--- a/test/metabase/lib_metric/ast/walk_test.cljc
+++ b/test/metabase/lib_metric/ast/walk_test.cljc
@@ -60,8 +60,8 @@
(def ^:private filter-b (comparison-filter :> dim-ref-2 10))
(def ^:private filter-c (string-filter :contains dim-ref-1 "foo"))
-(def ^:private sample-ast
- {:node/type :ast/root
+(def ^:private sample-source-query
+ {:node/type :ast/source-query
:source {:node/type :source/metric
:id 1
:aggregation {:node/type :aggregation/count}
@@ -74,6 +74,12 @@
:filter (and-filter filter-a filter-b)
:group-by [dim-ref-1]})
+(def ^:private sample-ast
+ {:node/type :ast/root
+ :expression {:node/type :expression/leaf
+ :uuid "test-uuid"
+ :ast sample-source-query}})
+
;;; -------------------------------------------------- Predicates --------------------------------------------------
(deftest ^:parallel node?-test
@@ -179,7 +185,7 @@
#(assoc % :transformed true)
sample-ast)]
;; Original filters in :filter/and children should be transformed
- (is (every? :transformed (get-in result [:filter :children]))))))
+ (is (every? :transformed (get-in result [:expression :ast :filter :children]))))))
(deftest ^:parallel transform-by-type-test
(testing "transforms nodes by type"
@@ -228,7 +234,7 @@
placeholder
sample-ast)]
;; filter-a had := operator, should be replaced
- (is (= ["REPLACED"] (get-in result [:filter :children 0 :values]))))))
+ (is (= ["REPLACED"] (get-in result [:expression :ast :filter :children 0 :values]))))))
(deftest ^:parallel remove-filters-test
(testing "removes matching filters from and"
@@ -237,40 +243,42 @@
sample-ast)]
;; filter-b had :> operator, should be removed
;; Since only one child remains, :filter/and should be unwrapped
- (is (= :filter/comparison (get-in result [:filter :node/type])))
- (is (= := (get-in result [:filter :operator])))))
+ (is (= :filter/comparison (get-in result [:expression :ast :filter :node/type])))
+ (is (= := (get-in result [:expression :ast :filter :operator])))))
(testing "removes all filters leaving nil"
(let [all-comparison (ast.walk/remove-filters
#(= :filter/comparison (:node/type %))
sample-ast)]
- (is (nil? (:filter all-comparison)))))
+ (is (nil? (get-in all-comparison [:expression :ast :filter])))))
(testing "handles nested compound filters"
- (let [nested-ast (assoc sample-ast
- :filter (and-filter
- (or-filter filter-a filter-b)
- filter-c))
+ (let [nested-source-query (assoc sample-source-query
+ :filter (and-filter
+ (or-filter filter-a filter-b)
+ filter-c))
+ nested-ast (assoc-in sample-ast [:expression :ast] nested-source-query)
result (ast.walk/remove-filters
#(= :> (:operator %))
nested-ast)]
;; filter-b removed from inner :or, leaving just filter-a
;; Inner :or should unwrap to just filter-a
- (is (= :filter/and (get-in result [:filter :node/type])))
- (is (= 2 (count (get-in result [:filter :children]))))))
+ (is (= :filter/and (get-in result [:expression :ast :filter :node/type])))
+ (is (= 2 (count (get-in result [:expression :ast :filter :children]))))))
(testing "handles nested compound where all inner children are removed"
- (let [nested-ast (assoc sample-ast
- :filter (and-filter
- (or-filter filter-a filter-b)
- filter-c))
+ (let [nested-source-query (assoc sample-source-query
+ :filter (and-filter
+ (or-filter filter-a filter-b)
+ filter-c))
+ nested-ast (assoc-in sample-ast [:expression :ast] nested-source-query)
;; Remove all comparison filters — inner :or loses both children → nil
result (ast.walk/remove-filters
#(= :filter/comparison (:node/type %))
nested-ast)]
;; Only filter-c (string filter) should remain, :and unwrapped
- (is (= :filter/string (get-in result [:filter :node/type])))
- (is (= :contains (get-in result [:filter :operator]))))))
+ (is (= :filter/string (get-in result [:expression :ast :filter :node/type])))
+ (is (= :contains (get-in result [:expression :ast :filter :operator]))))))
;;; -------------------------------------------------- Complex Transformations --------------------------------------------------
@@ -288,21 +296,51 @@
(and-filter existing audit-filter)
audit-filter))))
sample-ast)]
- (is (= audit-filter (get-in result [:source :filters]))))))
+ (is (= audit-filter (get-in result [:expression :ast :source :filters]))))))
+
+(deftest ^:parallel collect-constants-test
+ (testing "collect with :expression/constant pred finds constants"
+ (let [constant-node {:node/type :expression/constant :value 100}
+ arith-ast {:node/type :ast/root
+ :expression {:node/type :expression/arithmetic
+ :operator :*
+ :children [{:node/type :expression/leaf
+ :uuid "test-uuid"
+ :ast sample-source-query}
+ constant-node]}}
+ constants (ast.walk/collect #(= :expression/constant (:node/type %)) arith-ast)]
+ (is (= 1 (count constants)))
+ (is (= 100 (:value (first constants))))))
+ (testing "collect with :expression/leaf pred excludes constants"
+ (let [constant-node {:node/type :expression/constant :value 100}
+ arith-ast {:node/type :ast/root
+ :expression {:node/type :expression/arithmetic
+ :operator :*
+ :children [{:node/type :expression/leaf
+ :uuid "test-uuid"
+ :ast sample-source-query}
+ constant-node]}}
+ leaves (ast.walk/collect #(= :expression/leaf (:node/type %)) arith-ast)]
+ (is (= 1 (count leaves)))
+ (is (= "test-uuid" (:uuid (first leaves)))))))
(deftest ^:parallel dimension-ref-collection-from-filters-test
(testing "can collect dimension refs from filters only"
- (let [filter-only-ast {:node/type :ast/root
- :source (:source sample-ast)
- :dimensions []
- :mappings []
- :filter (and-filter
- (comparison-filter := dim-ref-1 1)
- (comparison-filter := dim-ref-2 2)
- (or-filter
- (comparison-filter := dim-ref-1 3)
- (comparison-filter := dim-ref-2 4)))
- :group-by []}
+ (let [filter-only-source-query {:node/type :ast/source-query
+ :source (:source sample-source-query)
+ :dimensions []
+ :mappings []
+ :filter (and-filter
+ (comparison-filter := dim-ref-1 1)
+ (comparison-filter := dim-ref-2 2)
+ (or-filter
+ (comparison-filter := dim-ref-1 3)
+ (comparison-filter := dim-ref-2 4)))
+ :group-by []}
+ filter-only-ast {:node/type :ast/root
+ :expression {:node/type :expression/leaf
+ :uuid "filter-test-uuid"
+ :ast filter-only-source-query}}
refs (ast.walk/collect-dimension-refs filter-only-ast)]
(is (= 4 (count refs)))
(is (= #{uuid-1 uuid-2} (set (map :dimension-id refs)))))))
diff --git a/test/metabase/lib_metric/definition_test.cljc b/test/metabase/lib_metric/definition_test.cljc
index 664e76cd8a5..eda3d9cbe54 100644
--- a/test/metabase/lib_metric/definition_test.cljc
+++ b/test/metabase/lib_metric/definition_test.cljc
@@ -240,6 +240,13 @@
expr [:* {} inner leaf3]]
(is (= [leaf1 leaf2 leaf3] (lib-metric.definition/expression-leaves expr))))))
+(deftest ^:parallel expression-leaves-with-constant-test
+ (testing "arithmetic with constant returns only the metric leaf"
+ (let [leaf [:metric {:lib/uuid "a"} 1]]
+ (is (= [leaf] (lib-metric.definition/expression-leaves [:* {} leaf 100])))))
+ (testing "bare number returns empty vector"
+ (is (= [] (lib-metric.definition/expression-leaves 42)))))
+
(deftest ^:parallel expression-leaves-invalid-input-test
(testing "nil returns empty vector"
(is (= [] (lib-metric.definition/expression-leaves nil))))
@@ -260,6 +267,106 @@
(lib-metric.definition/expression-leaves [op {} leaf1 leaf2]))
(str "operator " op " should be supported"))))))
+;;; -------------------------------------------------- projection-valid? --------------------------------------------------
+
+(deftest ^:parallel projection-valid?-single-leaf-no-projections-test
+ (testing "single leaf with no projections is not valid"
+ (let [definition (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)]
+ (is (not (lib-metric.definition/projection-valid? definition))))))
+
+(deftest ^:parallel projection-valid?-single-leaf-with-projection-test
+ (testing "single leaf with a projection is valid"
+ (let [definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)
+ (assoc :projections [{:type :metric :id 42
+ :projection [[:dimension {} uuid-1]]}]))]
+ (is (lib-metric.definition/projection-valid? definition)))))
+
+(deftest ^:parallel projection-valid?-single-leaf-empty-projection-vector-test
+ (testing "single leaf with empty projection vector is not valid"
+ (let [definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)
+ (assoc :projections [{:type :metric :id 42
+ :projection []}]))]
+ (is (not (lib-metric.definition/projection-valid? definition))))))
+
+(deftest ^:parallel projection-valid?-arithmetic-all-projected-test
+ (testing "arithmetic expression with all leaves projected is valid"
+ (let [definition {:lib/type :metric/definition
+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] [:measure {:lib/uuid "b"} 2]]
+ :filters []
+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}
+ {:type :measure :id 2 :projection [[:dimension {} uuid-2]]}]
+ :metadata-provider mock-provider}]
+ (is (lib-metric.definition/projection-valid? definition)))))
+
+(deftest ^:parallel projection-valid?-arithmetic-one-missing-test
+ (testing "arithmetic expression with one leaf missing projection is not valid"
+ (let [definition {:lib/type :metric/definition
+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] [:measure {:lib/uuid "b"} 2]]
+ :filters []
+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}]
+ :metadata-provider mock-provider}]
+ (is (not (lib-metric.definition/projection-valid? definition))))))
+
+(deftest ^:parallel projection-valid?-constant-in-arithmetic-test
+ (testing "only real leaves need projections when constants present"
+ (let [definition {:lib/type :metric/definition
+ :expression [:* {} [:metric {:lib/uuid "a"} 1] 100]
+ :filters []
+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}]
+ :metadata-provider mock-provider}]
+ (is (lib-metric.definition/projection-valid? definition)))))
+
+(deftest ^:parallel projection-valid?-wrong-type-match-test
+ (testing "projection with wrong type does not match"
+ (let [definition {:lib/type :metric/definition
+ :expression [:metric {:lib/uuid "a"} 1]
+ :filters []
+ :projections [{:type :measure :id 1 :projection [[:dimension {} uuid-1]]}]
+ :metadata-provider mock-provider}]
+ (is (not (lib-metric.definition/projection-valid? definition))))))
+
+;;; -------------------------------------------------- unprojected-sources --------------------------------------------------
+
+(deftest ^:parallel unprojected-sources-single-leaf-no-projections-test
+ (testing "single leaf with no projections returns the leaf"
+ (let [definition (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)
+ result (lib-metric.definition/unprojected-sources definition)]
+ (is (= 1 (count result)))
+ (is (= :metric (first (first result))))
+ (is (= 42 (nth (first result) 2))))))
+
+(deftest ^:parallel unprojected-sources-single-leaf-with-projection-test
+ (testing "single leaf with projection returns empty"
+ (let [definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)
+ (assoc :projections [{:type :metric :id 42
+ :projection [[:dimension {} uuid-1]]}]))
+ result (lib-metric.definition/unprojected-sources definition)]
+ (is (empty? result)))))
+
+(deftest ^:parallel unprojected-sources-arithmetic-one-missing-test
+ (testing "arithmetic with one missing returns that leaf"
+ (let [leaf-b [:measure {:lib/uuid "b"} 2]
+ definition {:lib/type :metric/definition
+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] leaf-b]
+ :filters []
+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}]
+ :metadata-provider mock-provider}
+ result (lib-metric.definition/unprojected-sources definition)]
+ (is (= 1 (count result)))
+ (is (= :measure (first (first result))))
+ (is (= 2 (nth (first result) 2))))))
+
+(deftest ^:parallel unprojected-sources-all-projected-test
+ (testing "all sources projected returns empty"
+ (let [definition {:lib/type :metric/definition
+ :expression [:+ {} [:metric {:lib/uuid "a"} 1] [:measure {:lib/uuid "b"} 2]]
+ :filters []
+ :projections [{:type :metric :id 1 :projection [[:dimension {} uuid-1]]}
+ {:type :measure :id 2 :projection [[:dimension {} uuid-2]]}]
+ :metadata-provider mock-provider}
+ result (lib-metric.definition/unprojected-sources definition)]
+ (is (empty? result)))))
+
;;; -------------------------------------------------- Schema Validation --------------------------------------------------
(deftest ^:parallel metric-definition-schema-test
diff --git a/test/metabase/metrics/api_arithmetic_test.clj b/test/metabase/metrics/api_arithmetic_test.clj
new file mode 100644
index 00000000000..3d3f72756e9
--- /dev/null
+++ b/test/metabase/metrics/api_arithmetic_test.clj
@@ -0,0 +1,320 @@
+(ns metabase.metrics.api-arithmetic-test
+ (:require
+ [clojure.test :refer :all]
+ [metabase.lib.core :as lib]
+ [metabase.lib.metadata :as lib.metadata]
+ [metabase.metrics.core :as metrics]
+ [metabase.test :as mt]
+ [metabase.test.fixtures :as fixtures]
+ [toucan2.core :as t2]))
+
+(use-fixtures :once (fixtures/initialize :db :web-server :test-users))
+
+(deftest arithmetic-metric-plus-metric-test
+ (testing "POST /api/metric/dataset with metric_A + metric_B returns correct sum"
+ (mt/with-temp [:model/Card metric-a {:name "Metric A"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}
+ :model/Card metric-b {:name "Metric B"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ ;; Trigger dimension sync for both metrics
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))
+ ;; Get dimension UUIDs from each metric separately
+ (let [metric-a-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))
+ metric-b-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))
+ dim-a-uuid (:id (first (:dimensions metric-a-response)))
+ dim-b-uuid (:id (first (:dimensions metric-b-response)))
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:+ {}
+ [:metric {:lib/uuid "a"} (:id metric-a)]
+ [:metric {:lib/uuid "b"} (:id metric-b)]]
+ :projections [{:type :metric :id (:id metric-a) :lib/uuid "a"
+ :projection [[:dimension {} dim-a-uuid]]}
+ {:type :metric :id (:id metric-b) :lib/uuid "b"
+ :projection [[:dimension {} dim-b-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (pos? (:row_count response)))
+ ;; Each row should have [dim-value, sum] where sum is a+b for that dimension value
+ (is (every? #(= 2 (count %)) (get-in response [:data :rows])))))))
+
+(deftest arithmetic-subtraction-test
+ (testing "POST /api/metric/dataset with metric_A - metric_B"
+ (mt/with-temp [:model/Card metric-a {:name "Metric A"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}
+ :model/Card metric-b {:name "Metric B"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))
+ (let [metric-a-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-a)))
+ metric-b-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric-b)))
+ dim-a-uuid (:id (first (:dimensions metric-a-response)))
+ dim-b-uuid (:id (first (:dimensions metric-b-response)))
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:- {}
+ [:metric {:lib/uuid "a"} (:id metric-a)]
+ [:metric {:lib/uuid "b"} (:id metric-b)]]
+ :projections [{:type :metric :id (:id metric-a) :lib/uuid "a"
+ :projection [[:dimension {} dim-a-uuid]]}
+ {:type :metric :id (:id metric-b) :lib/uuid "b"
+ :projection [[:dimension {} dim-b-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ ;; Same query minus itself: all values should be 0
+ (is (every? #(zero? (last %)) (get-in response [:data :rows])))))))
+
+(deftest arithmetic-with-instance-filters-test
+ (testing "POST /api/metric/dataset with instance filters on arithmetic"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim (first (:dimensions metric-response))
+ dim-uuid (:id dim)
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:- {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:metric {:lib/uuid "b"} (:id metric)]]
+ :filters [{:lib/uuid "a"
+ :filter [:= {} [:dimension {} dim-uuid] 1]}]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "b"
+ :projection [[:dimension {} dim-uuid]]}]}})]
+ (is (= "completed" (:status response)))))))
+
+(deftest arithmetic-missing-projections-test
+ (testing "POST /api/metric/dataset arithmetic without projections returns scalar result"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (let [response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:+ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:metric {:lib/uuid "b"} (:id metric)]]}})]
+ (is (= "completed" (:status response)))
+ (is (= 1 (:row_count response)))))))
+(deftest arithmetic-nested-expression-test
+ (testing "POST /api/metric/dataset with nested (A + B) * C"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim (first (:dimensions metric-response))
+ dim-uuid (:id dim)
+ _ (assert dim-uuid (str "No dimension found in metric response: " (pr-str (:dimensions metric-response))))
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:* {}
+ [:+ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:metric {:lib/uuid "b"} (:id metric)]]
+ [:metric {:lib/uuid "c"} (:id metric)]]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "b"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "c"
+ :projection [[:dimension {} dim-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (pos? (:row_count response)))))))
+
+(deftest arithmetic-metric-times-constant-test
+ (testing "POST /api/metric/dataset with [:* {} [:metric ...] 2] returns correct results"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim-uuid (:id (first (:dimensions metric-response)))
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:* {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ 2]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (pos? (:row_count response)))
+ ;; Each result should be exactly double the count
+ (let [single-response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:metric {:lib/uuid "x"} (:id metric)]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "x"
+ :projection [[:dimension {} dim-uuid]]}]}})
+ single-rows (into {} (map (fn [[k v]] [k v]) (get-in single-response [:data :rows])))
+ double-rows (into {} (map (fn [[k v]] [k v]) (get-in response [:data :rows])))]
+ (doseq [[dim-val single-val] single-rows]
+ (is (= (* 2 single-val) (get double-rows dim-val))
+ (str "Value for " dim-val " should be doubled"))))))))
+
+(deftest arithmetic-nested-values-test
+ (testing "POST /api/metric/dataset nested (A + A) * 2 returns 4N per row"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim-uuid (:id (first (:dimensions metric-response)))
+ baseline (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:metric {:lib/uuid "x"} (:id metric)]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "x"
+ :projection [[:dimension {} dim-uuid]]}]}})
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:* {}
+ [:+ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:metric {:lib/uuid "b"} (:id metric)]]
+ 2]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "b"
+ :projection [[:dimension {} dim-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (pos? (:row_count response)))
+ (let [base-rows (into {} (map (fn [[k v]] [k v]) (get-in baseline [:data :rows])))
+ nested-rows (into {} (map (fn [[k v]] [k v]) (get-in response [:data :rows])))]
+ (doseq [[dim-val base-val] base-rows]
+ (is (= (* 4 base-val) (get nested-rows dim-val))
+ (str "Value for " dim-val " should be 4N"))))))))
+
+(deftest arithmetic-associativity-test
+ (testing "POST /api/metric/dataset nesting position affects result"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim-uuid (:id (first (:dimensions metric-response)))
+ projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "b"
+ :projection [[:dimension {} dim-uuid]]}]
+ ;; A / (A / 2) = N / (N/2) = 2.0
+ response-a (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:/ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:/ {}
+ [:metric {:lib/uuid "b"} (:id metric)]
+ 2]]
+ :projections projections}})
+ ;; (A / A) / 2 = (N/N) / 2 = 0.5
+ response-b (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:/ {}
+ [:/ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:metric {:lib/uuid "b"} (:id metric)]]
+ 2]
+ :projections projections}})]
+ (is (= "completed" (:status response-a)))
+ (is (= "completed" (:status response-b)))
+ (let [rows-a (into {} (map (fn [[k v]] [k (double v)]) (get-in response-a [:data :rows])))
+ rows-b (into {} (map (fn [[k v]] [k (double v)]) (get-in response-b [:data :rows])))]
+ (doseq [[dim-val val-a] rows-a]
+ (is (= 2.0 val-a) (str "A/(A/2) should be 2.0 for " dim-val))
+ (is (= 0.5 (get rows-b dim-val)) (str "(A/A)/2 should be 0.5 for " dim-val))))))))
+
+(deftest arithmetic-deeply-nested-test
+ (testing "POST /api/metric/dataset with 3-level nesting ((A + A) * A) / 2 = N²"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim-uuid (:id (first (:dimensions metric-response)))
+ baseline (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:metric {:lib/uuid "x"} (:id metric)]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "x"
+ :projection [[:dimension {} dim-uuid]]}]}})
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:/ {}
+ [:* {}
+ [:+ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:metric {:lib/uuid "b"} (:id metric)]]
+ [:metric {:lib/uuid "c"} (:id metric)]]
+ 2]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "b"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "c"
+ :projection [[:dimension {} dim-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (pos? (:row_count response)))
+ (let [base-rows (into {} (map (fn [[k v]] [k (double v)]) (get-in baseline [:data :rows])))
+ deep-rows (into {} (map (fn [[k v]] [k (double v)]) (get-in response [:data :rows])))]
+ (doseq [[dim-val base-val] base-rows]
+ (is (= (* base-val base-val) (get deep-rows dim-val))
+ (str "((A+A)*A)/2 should be N² for " dim-val))))))))
+
+(deftest arithmetic-nested-division-by-zero-test
+ (testing "POST /api/metric/dataset A / (A - A) returns 0 rows (zero guard)"
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}]
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim-uuid (:id (first (:dimensions metric-response)))
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:/ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:- {}
+ [:metric {:lib/uuid "b"} (:id metric)]
+ [:metric {:lib/uuid "c"} (:id metric)]]]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "b"
+ :projection [[:dimension {} dim-uuid]]}
+ {:type :metric :id (:id metric) :lib/uuid "c"
+ :projection [[:dimension {} dim-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (zero? (:row_count response)))))))
+
+(deftest arithmetic-mixed-metric-measure-test
+ (testing "POST /api/metric/dataset with metric + measure arithmetic"
+ (let [mp (mt/metadata-provider)
+ table-metadata (lib.metadata/table mp (mt/id :venues))
+ pmbql-def (-> (lib/query mp table-metadata)
+ (lib/aggregate (lib/count)))]
+ (mt/with-temp [:model/Card metric {:name "Test Metric"
+ :type :metric
+ :dataset_query (mt/mbql-query venues {:aggregation [[:count]]})}
+ :model/Measure measure {:name "Test Measure"
+ :table_id (mt/id :venues)
+ :definition pmbql-def}]
+ (mt/with-full-data-perms-for-all-users!
+ ;; Sync dimensions for both metric and measure
+ (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ (metrics/sync-dimensions! :metadata/measure (:id measure))
+ ;; Get dimension UUIDs from each entity
+ (let [metric-response (mt/user-http-request :rasta :get 200 (str "metric/" (:id metric)))
+ dim-metric-uuid (:id (first (:dimensions metric-response)))
+ measure-entity (t2/select-one :model/Measure :id (:id measure))
+ dim-measure-uuid (:id (first (:dimensions measure-entity)))
+ response (mt/user-http-request :rasta :post 202 "metric/dataset"
+ {:definition
+ {:expression [:+ {}
+ [:metric {:lib/uuid "a"} (:id metric)]
+ [:measure {:lib/uuid "b"} (:id measure)]]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
+ :projection [[:dimension {} dim-metric-uuid]]}
+ {:type :measure :id (:id measure) :lib/uuid "b"
+ :projection [[:dimension {} dim-measure-uuid]]}]}})]
+ (is (= "completed" (:status response)))
+ (is (pos? (:row_count response)))))))))
diff --git a/test/metabase/metrics/api_math_test.clj b/test/metabase/metrics/api_math_test.clj
index e7c62b50036..e64bfabf47f 100644
--- a/test/metabase/metrics/api_math_test.clj
+++ b/test/metabase/metrics/api_math_test.clj
@@ -194,3 +194,39 @@
(is (= 42 (:id decoded)))
(is (= "abc" (:lib/uuid decoded)))
(is (= 1 (count (:projection decoded)))))))
+
+;;; +----------------------------------------------------------------------------------------------------------------+
+;;; | Numeric Constant Tests |
+;;; +----------------------------------------------------------------------------------------------------------------+
+
+(deftest bare-integer-constant-test
+ (testing "A bare integer is a valid expression"
+ (is (valid? ::lib-metric.schema/metric-math-expression 42))))
+
+(deftest bare-float-constant-test
+ (testing "A bare float is a valid expression"
+ (is (valid? ::lib-metric.schema/metric-math-expression 3.14))))
+
+(deftest constant-in-arithmetic-test
+ (testing "Constant as operand in arithmetic is valid"
+ (is (valid? ::lib-metric.schema/metric-math-expression
+ [:* {} [:metric {:lib/uuid "a"} 1] 100]))))
+
+(deftest nested-constant-in-arithmetic-test
+ (testing "Constant in nested arithmetic is valid"
+ (is (valid? ::lib-metric.schema/metric-math-expression
+ [:/ {} [:metric {:lib/uuid "a"} 1] [:- {} [:metric {:lib/uuid "b"} 2] 10]]))))
+
+(deftest valid-definition-with-constant-test
+ (testing "Valid definition with constant in arithmetic (no projection needed for constant)"
+ (is (valid-definition?
+ {:expression [:* {} [:metric {:lib/uuid "a"} 42] 100]
+ :projections [{:type :metric
+ :id 42
+ :lib/uuid "a"
+ :projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440001"]]}]}))))
+
+(deftest normalize-json-number-passthrough-test
+ (testing "JSON number passes through normalization unchanged"
+ (let [decoded (decode ::lib-metric.schema/metric-math-expression 42)]
+ (is (= 42 decoded)))))