The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
UXW-3754 add segments to Metric Viewer (#72820)
Denis Berezin32c8c2ade374
diff --git a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.tsindex e63576b276f..48128bd9a52 100644--- a/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts+++ b/e2e/test/scenarios/metrics/metrics-explorer.cy.spec.ts@@ -1915,6 +1915,67 @@ describe("scenarios > metrics > explorer", () => {});});+ describe("Segments", () => {+ beforeEach(() => {+ interceptDatasetQuery();+ H.MetricsViewer.goToViewer();+ });++ it("should apply a segment as a filter to a metric", () => {+ const SEGMENT_NAME = "Big orders";++ H.createSegment({+ name: SEGMENT_NAME,+ description: "Orders with a total over $100",+ table_id: ORDERS_ID,+ definition: {+ "source-table": ORDERS_ID,+ filter: [">", ["field", ORDERS.TOTAL, null], 100],+ },+ });++ addMetric("Count of orders");+ cy.wait("@dataset");++ H.MetricsViewer.getFilterButton().click();++ cy.log(+ "segment should appear alongside dimensions in the filter popover",+ );+ H.popover().findByText(SEGMENT_NAME).should("be.visible");++ cy.log("search should match segment names");+ H.popover().findByPlaceholderText("Search dimensions...").type("big");+ H.popover().findByText(SEGMENT_NAME).should("be.visible");+ H.popover().findByPlaceholderText("Search dimensions...").clear();++ cy.log("clicking a segment applies it directly as a filter");+ H.popover().findByText(SEGMENT_NAME).click();++ H.MetricsViewer.getAllFilterPills()+ .should("have.length", 1)+ .should("contain.text", SEGMENT_NAME);++ H.expectUnstructuredSnowplowEvent({+ event: "metrics_viewer_filter_added",+ triggered_from: "metric_filter",+ });++ cy.log("removing the segment pill removes the filter");+ H.MetricsViewer.getAllFilterPills()+ .eq(0)+ .findByLabelText("Remove")+ .click();++ H.MetricsViewer.getAllFilterPills().should("have.length", 0);++ H.expectUnstructuredSnowplowEvent({+ event: "metrics_viewer_filter_removed",+ triggered_from: "metric_filter",+ });+ });+ });+// ============================================================================// Drill Through// ============================================================================diff --git a/frontend/src/metabase-lib/metric/core.ts b/frontend/src/metabase-lib/metric/core.tsindex 7b7f470d28f..d59670dee72 100644--- a/frontend/src/metabase-lib/metric/core.ts+++ b/frontend/src/metabase-lib/metric/core.ts@@ -7,6 +7,7 @@ import type {JsMetricDefinition,MeasureId,MetricId,+ SegmentId,} from "metabase-types/api";import type {@@ -35,6 +36,8 @@ import type {NumberFilterParts,ProjectionClause,RelativeDateFilterParts,+ SegmentDisplayInfo,+ SegmentMetadata,SourceInstance,SpecificDateFilterParts,StringFilterParts,@@ -204,6 +207,37 @@ export function filter(return LibMetric.filter(definition, filterClause) as MetricDefinition;}+export function availableSegments(+ definition: MetricDefinition,+): SegmentMetadata[] {+ return LibMetric.availableSegments(definition) as SegmentMetadata[];+}++export function addSegmentFilter(+ definition: MetricDefinition,+ segment: SegmentMetadata,+): MetricDefinition {+ return LibMetric.addSegmentFilter(definition, segment) as MetricDefinition;+}++export function isSegmentFilter(filterClause: FilterClause): boolean {+ return Boolean(LibMetric.isSegmentFilter(filterClause));+}++export function segmentMetadataForFilter(+ definition: MetricDefinition,+ filterClause: FilterClause,+): SegmentMetadata | null {+ return LibMetric.segmentMetadataForFilter(+ definition,+ filterClause,+ ) as SegmentMetadata | null;+}++export function segmentMetadataId(segment: SegmentMetadata): SegmentId {+ return LibMetric.segmentMetadataId(segment) as SegmentId;+}+export function stringFilterClause(parts: StringFilterParts): FilterClause {return LibMetric.stringFilterClause(parts) as FilterClause;}@@ -686,6 +720,10 @@ export function displayInfo(definition: MetricDefinition,binningStrategy: BinningStrategy,): BinningStrategyDisplayInfo;+export function displayInfo(+ definition: MetricDefinition,+ segment: SegmentMetadata,+): SegmentDisplayInfo;export function displayInfo(definition: MetricDefinition,filterParts: Displayable,diff --git a/frontend/src/metabase-lib/metric/types.ts b/frontend/src/metabase-lib/metric/types.tsindex 03db4258168..46612f04c1c 100644--- a/frontend/src/metabase-lib/metric/types.ts+++ b/frontend/src/metabase-lib/metric/types.ts@@ -26,6 +26,7 @@ declare const _ProjectionClauseSymbol: unique symbol;declare const _TemporalBucketSymbol: unique symbol;declare const _BinningStrategySymbol: unique symbol;declare const _SourceInstanceSymbol: unique symbol;+declare const _SegmentMetadataSymbol: unique symbol;export type MetadataProvider = unknown & {_opaque: typeof _MetadataProviderSymbol;@@ -67,6 +68,19 @@ export type SourceInstance = unknown & {_opaque: typeof _SourceInstanceSymbol;};+export type SegmentMetadata = unknown & {+ _opaque: typeof _SegmentMetadataSymbol;+};++export type SegmentDisplayInfo = {+ name?: string;+ displayName: string;+ longDisplayName?: string;+ description?: string;+ filterPositions?: number[];+ group?: DimensionGroup;+};+export type MetadataProviderable = MetadataProvider | MetricDefinition;export type Clause = FilterClause | ProjectionClause;@@ -122,7 +136,8 @@ export type Displayable =| Clause| DimensionMetadata| TemporalBucket- | BinningStrategy;+ | BinningStrategy+ | SegmentMetadata;export type DisplayInfo =| MetricDisplayInfo@@ -130,7 +145,8 @@ export type DisplayInfo =| ClauseDisplayInfo| DimensionDisplayInfo| TemporalBucketDisplayInfo- | BinningStrategyDisplayInfo;+ | BinningStrategyDisplayInfo+ | SegmentDisplayInfo;export type FilterParts =| StringFilterPartsdiff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsxindex 865df51f85f..e505fdc6bbb 100644--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx@@ -2,16 +2,8 @@ import cx from "classnames";import { useCallback, useMemo, useState } from "react";import { t } from "ttag";-import { AccordionList } from "metabase/common/components/AccordionList";import { SourceColorIndicator } from "metabase/common/components/SourceColorIndicator";-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 {Badge,Box,@@ -32,7 +24,9 @@ import type { SourceColorMap } from "../../types/viewer-state";import type { DefinitionSource } from "../../utils/definition-sources";import S from "./FilterPopover.module.css";-import { filterDisplayGroupsBySearch } from "./utils";+import { MetricGroupFilterSectionList } from "./MetricGroupFilterSectionList";+import type { DimensionListItem, MetricGroup, SegmentListItem } from "./types";+import { filterDisplayGroupsBySearch, getMetricGroups } from "./utils";const LIST_WIDTH = "20rem";const FILTER_WIDTH = "24rem";@@ -96,6 +90,22 @@ export function FilterPopoverContent({[navState, definitionSources, onFilterApplied, onSourceDefinitionChange],);+ const handleSegmentSelect = useCallback(+ (item: SegmentListItem) => {+ const selected = definitionSources[item.definitionIndex];+ if (!selected) {+ return;+ }+ const newDefinition = LibMetric.addSegmentFilter(+ selected.definition,+ item.segment,+ );+ onSourceDefinitionChange(selected, newDefinition);+ onFilterApplied();+ },+ [definitionSources, onFilterApplied, onSourceDefinitionChange],+ );+const toggleExpanded = useCallback((id: number) => {setExpandedItems((prev) =>prev.includes(id) ? prev.filter((item) => item !== id) : [...prev, id],@@ -105,6 +115,7 @@ export function FilterPopoverContent({const isSearching = filteredDisplayGroups !== null;const visibleGroups = isSearching ? filteredDisplayGroups : displayGroups;const hasNoResults = isSearching && visibleGroups.length === 0;+ const hasAnySegments = displayGroups.some((group) => group.hasSegments);const showMetricHeaders = definitionSources.length > 1;if (navState.view === "filter") {@@ -142,7 +153,9 @@ export function FilterPopoverContent({{hasNoResults ? (<Box p="xl"><Text c="text-secondary" ta="center">- {t`No dimensions found`}+ {hasAnySegments+ ? t`No dimensions or segments found`+ : t`No dimensions found`}</Text></Box>) : showMetricHeaders ? (@@ -152,11 +165,13 @@ export function FilterPopoverContent({collapsible={!isSearching}onToggleExpanded={toggleExpanded}onDimensionSelect={handleDimensionSelect}+ onSegmentSelect={handleSegmentSelect}/>) : (- <DimensionList+ <MetricGroupFilterSectionListsections={visibleGroups[0]?.sections ?? []}- onSelect={handleDimensionSelect}+ onDimensionSelect={handleDimensionSelect}+ onSegmentSelect={handleSegmentSelect}/>)}</Box>@@ -164,61 +179,36 @@ export function FilterPopoverContent({);}-function DimensionList({- sections,- onSelect,-}: {- sections: DimensionSection[];- onSelect: (item: DimensionListItem) => void;-}) {- const renderItemIcon = useCallback((item: DimensionListItem) => {- const icon = getDimensionIcon(item.dimension);- return <Icon name={icon} size={16} />;- }, []);-- return (- <AccordionList<DimensionListItem, DimensionSection>- className={S.dimensionList}- sections={sections}- onChange={onSelect}- renderItemName={(item) => item.name}- renderItemIcon={renderItemIcon}- width="100%"- maxHeight={Infinity}- searchable={false}- alwaysExpanded- />- );-}-function MetricGroupList({groups,expandedItems,collapsible,onToggleExpanded,onDimensionSelect,+ onSegmentSelect,}: {groups: MetricGroup[];expandedItems: number[];collapsible: boolean;onToggleExpanded: (id: number) => void;onDimensionSelect: (item: DimensionListItem) => void;+ onSegmentSelect: (item: SegmentListItem) => void;}) {return (<Box>{groups.map((group) => {const isExpanded = !collapsible || expandedItems.includes(group.id);- const hasDimensions = group.sections.some(+ const hasItems = group.sections.some((section) => section.items && section.items.length > 0,);- const showDimensions = isExpanded && hasDimensions;+ const showItems = isExpanded && hasItems;return (<Box key={group.id} className={S.accordionItem}>{collapsible ? (<UnstyledButtonclassName={cx(S.accordionControl, {- [S.accordionControlExpanded]: showDimensions,+ [S.accordionControlExpanded]: showItems,})}onClick={() => onToggleExpanded(group.id)}w="100%"@@ -246,7 +236,7 @@ function MetricGroupList({) : (<BoxclassName={cx(S.accordionHeader, {- [S.accordionHeaderExpanded]: showDimensions,+ [S.accordionHeaderExpanded]: showItems,})}px="md">@@ -260,11 +250,12 @@ function MetricGroupList({</Flex></Box>)}- {showDimensions && (+ {showItems && (<Box pb="sm">- <DimensionList+ <MetricGroupFilterSectionListsections={group.sections}- onSelect={onDimensionSelect}+ onDimensionSelect={onDimensionSelect}+ onSegmentSelect={onSegmentSelect}/></Box>)}diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/MetricGroupFilterSectionList.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/MetricGroupFilterSectionList.tsxnew file mode 100644index 00000000000..3f778a65a43--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/MetricGroupFilterSectionList.tsx@@ -0,0 +1,56 @@+import { useCallback } from "react";++import { AccordionList } from "metabase/common/components/AccordionList";+import { getDimensionIcon } from "metabase/metrics/utils/dimensions";+import type {+ DimensionListItem,+ FilterItem,+ MetricGroupFilterSection,+ SegmentListItem,+} from "metabase/metrics-viewer/components/FilterPopover/types";+import { isSegmentListItem } from "metabase/metrics-viewer/components/FilterPopover/types";+import { Icon } from "metabase/ui";++import S from "./FilterPopover.module.css";++export function MetricGroupFilterSectionList({+ sections,+ onDimensionSelect,+ onSegmentSelect,+}: {+ sections: MetricGroupFilterSection[];+ onDimensionSelect: (item: DimensionListItem) => void;+ onSegmentSelect: (item: SegmentListItem) => void;+}) {+ const handleChange = useCallback(+ (item: FilterItem) => {+ if (isSegmentListItem(item)) {+ onSegmentSelect(item);+ } else {+ onDimensionSelect(item);+ }+ },+ [onDimensionSelect, onSegmentSelect],+ );++ const renderItemIcon = useCallback((item: FilterItem) => {+ if (isSegmentListItem(item)) {+ return <Icon name="segment" size={16} />;+ }+ return <Icon name={getDimensionIcon(item.dimension)} size={16} />;+ }, []);++ return (+ <AccordionList<FilterItem, MetricGroupFilterSection>+ className={S.dimensionList}+ sections={sections}+ onChange={handleChange}+ renderItemName={(item) => item.name}+ renderItemIcon={renderItemIcon}+ width="100%"+ maxHeight={Infinity}+ searchable={false}+ alwaysExpanded+ />+ );+}diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/types.ts b/frontend/src/metabase/metrics-viewer/components/FilterPopover/types.tsnew file mode 100644index 00000000000..0876f9e4997--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/types.ts@@ -0,0 +1,37 @@+import type { Section as BaseSection } from "metabase/common/components/AccordionList";+import type * as LibMetric from "metabase-lib/metric";++export type DimensionListItem = {+ name: string;+ definition: LibMetric.MetricDefinition;+ definitionIndex: number;+ dimension: LibMetric.DimensionMetadata;+};++export type SegmentListItem = {+ name: string;+ definitionIndex: number;+ definition: LibMetric.MetricDefinition;+ segment: LibMetric.SegmentMetadata;+};++export type FilterItem = DimensionListItem | SegmentListItem;++export type MetricGroupFilterSection = BaseSection<FilterItem> & {+ /** True only for the metric's "main" (source-table) group. */+ isSourceTable?: boolean;+};++export type MetricGroup = {+ id: number;+ metricName: string;+ metricCount?: number;+ icon?: "metric" | "ruler";+ colors: string[] | undefined;+ sections: MetricGroupFilterSection[];+ /** Only used for empty-state copy selection. */+ hasSegments: boolean;+};++export const isSegmentListItem = (item: FilterItem): item is SegmentListItem =>+ (item as SegmentListItem).segment != null;diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.ts b/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.tsindex 0561d5eb441..67b42cf8061 100644--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.ts+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.ts@@ -1,3 +1,18 @@+import type {+ DimensionListItem,+ MetricGroup,+ MetricGroupFilterSection,+ SegmentListItem,+} from "metabase/metrics-viewer/components/FilterPopover/types";+import type { SourceColorMap } from "metabase/metrics-viewer/types";+import {+ type DefinitionSource,+ getDefinitionSourceIcon,+ getDefinitionSourceName,+} from "metabase/metrics-viewer/utils/definition-sources";+import type { MetricDefinition } from "metabase-lib/metric";+import * as LibMetric from "metabase-lib/metric";+type NamedItem = { name: string };type SectionWithItems<TItem extends NamedItem> = {@@ -36,3 +51,128 @@ export function filterDisplayGroupsBySearch<}).filter((group) => group.sections.length > 0);}++type DimensionBucket = {+ groupName: string;+ groupType: "main" | "connection" | undefined;+ items: DimensionListItem[];+};++export function getMetricGroups(+ definitionSources: DefinitionSource[],+ metricColors: SourceColorMap,+): MetricGroup[] {+ return definitionSources.map((definitionSource, definitionIndex) => {+ const definition = definitionSource.definition;+ const segmentItems = buildSegmentItems(definition, definitionIndex);+ const dimensions = LibMetric.filterableDimensions(definition);++ const byGroupId = new Map<string, DimensionBucket>();++ for (const dimension of dimensions) {+ const info = LibMetric.displayInfo(definition, dimension);+ const groupId = info.group?.id ?? "";+ const groupName = info.group?.displayName ?? "";+ const groupType = info.group?.type;+ const item: DimensionListItem = {+ name: info.displayName,+ definition,+ definitionIndex,+ dimension,+ };++ const entry = byGroupId.get(groupId);+ if (entry) {+ entry.items.push(item);+ } else {+ byGroupId.set(groupId, { groupName, groupType, items: [item] });+ }+ }++ const hasSegments = segmentItems.length > 0;+ const sections = buildSections(byGroupId, segmentItems);++ return {+ id: definitionSource.index,+ metricName: getDefinitionSourceName(definitionSource),+ metricCount: definitionSource.token?.count,+ icon: getDefinitionSourceIcon(definitionSource),+ colors: metricColors[definitionSource.entityIndex],+ sections,+ hasSegments,+ };+ });+}++function buildSections(+ byGroupId: Map<string, DimensionBucket>,+ segmentItems: SegmentListItem[],+): MetricGroupFilterSection[] {+ // No dimensions at all — if there are segments, still surface them+ // inside a single source-table section so they don't disappear.+ if (byGroupId.size === 0) {+ if (segmentItems.length > 0) {+ return [{ isSourceTable: true, items: segmentItems }];+ }+ return [];+ }++ // Single-group fallback: merge every dimension + every segment+ // into one unnamed section and treat it as the source table.+ if (byGroupId.size === 1) {+ const [{ items }] = [...byGroupId.values()];+ return [+ {+ isSourceTable: true,+ items: [...segmentItems, ...items],+ },+ ];+ }++ // Multiple groups: segments live on the metric's source table, so+ // attach them to the source-table section. Joined-table segments are+ // out of scope for this milestone and are not surfaced by+ // `available-segments` on the backend.+ const sections: MetricGroupFilterSection[] = [];+ let mainAttached = false;+ for (const [, { groupName, groupType, items }] of byGroupId) {+ const isSourceTable = groupType === "main";+ sections.push({+ name: groupName,+ isSourceTable,+ items:+ isSourceTable && segmentItems.length > 0+ ? [...segmentItems, ...items]+ : items,+ });+ if (isSourceTable) {+ mainAttached = true;+ }+ }++ // Defensive: if no section was flagged as the source table but we+ // still have segments, surface them in a synthesized source-table+ // section so they don't disappear.+ if (!mainAttached && segmentItems.length > 0) {+ sections.unshift({ isSourceTable: true, items: segmentItems });+ }++ return sections;+}++function buildSegmentItems(+ definition: MetricDefinition,+ definitionIndex: number,+): SegmentListItem[] {+ const items: SegmentListItem[] = [];+ for (const segment of LibMetric.availableSegments(definition)) {+ const info = LibMetric.displayInfo(definition, segment);+ items.push({+ name: info.displayName,+ definition,+ definitionIndex,+ segment,+ });+ }+ return items;+}diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.unit.spec.ts b/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.unit.spec.tsindex ca5175a0d61..e1595d100eb 100644--- a/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.unit.spec.ts+++ b/frontend/src/metabase/metrics-viewer/components/FilterPopover/utils.unit.spec.ts@@ -1,4 +1,27 @@-import { filterDisplayGroupsBySearch } from "./utils";+import type { DefinitionSource } from "metabase/metrics-viewer/utils/definition-sources";+import type * as LibMetric from "metabase-lib/metric";+import type {+ DimensionDisplayInfo,+ SegmentDisplayInfo,+} from "metabase-lib/metric";+import * as LibMetricModule from "metabase-lib/metric";++import { filterDisplayGroupsBySearch, getMetricGroups } from "./utils";++jest.mock("metabase-lib/metric", () => ({+ __esModule: true,+ filterableDimensions: jest.fn(),+ availableSegments: jest.fn(),+ displayInfo: jest.fn(),+}));++jest.mock("metabase/metrics-viewer/utils/definition-sources", () => ({+ __esModule: true,+ getDefinitionSourceIcon: jest.fn(() => "metric" as const),+ getDefinitionSourceName: jest.fn(() => "Revenue"),+}));++const mockLibMetric = LibMetricModule as jest.Mocked<typeof LibMetric>;type TestItem = { name: string };@@ -17,6 +40,51 @@ function makeGroup(id: string, items: { name: string }[][]): TestGroup {};}+function makeDefinitionSource(+ index: number,+ overrides: Partial<DefinitionSource> = {},+): DefinitionSource {+ return {+ index,+ id: `src-${index}` as DefinitionSource["id"],+ definition: {+ __fakeDefinition: index,+ } as unknown as LibMetric.MetricDefinition,+ entity: {} as DefinitionSource["entity"],+ entityIndex: index,+ token: undefined,+ ...overrides,+ };+}++function getSourceTableDimensionInfo(+ displayName: string,+ id = "main",+): DimensionDisplayInfo {+ return {+ displayName,+ group: { id, displayName: "Orders", type: "main" },+ } as DimensionDisplayInfo;+}++function getJoinedTabledDimensionInfo(+ displayName: string,+ id = "conn",+): DimensionDisplayInfo {+ return {+ displayName,+ group: { id, displayName: "Products", type: "connection" },+ } as DimensionDisplayInfo;+}++function getSegmentInfo(displayName: string): SegmentDisplayInfo {+ return { displayName } as SegmentDisplayInfo;+}++beforeEach(() => {+ jest.clearAllMocks();+});+describe("filterDisplayGroupsBySearch", () => {const groups: TestGroup[] = [makeGroup("revenue", [@@ -92,4 +160,228 @@ describe("filterDisplayGroupsBySearch", () => {},]);});++ it("matches segment-like items that live inside a section", () => {+ // With segments merged into section.items, a section can contain both+ // dimensions and segments — search should treat them uniformly.+ const groupsWithMergedSegments: TestGroup[] = [+ {+ id: "revenue",+ sections: [+ {+ name: "Source",+ items: [{ name: "Active customers" }, { name: "Created At" }],+ },+ ],+ },+ ];+ expect(+ filterDisplayGroupsBySearch(groupsWithMergedSegments, "active"),+ ).toEqual([+ {+ id: "revenue",+ sections: [{ name: "Source", items: [{ name: "Active customers" }] }],+ },+ ]);+ });+});++describe("getMetricGroups", () => {+ it("places segments above dimensions in the single source-table section", () => {+ const source = makeDefinitionSource(0);+ const dim = {+ __dim: "createdAt",+ } as unknown as LibMetric.DimensionMetadata;+ const seg = {+ __seg: "active",+ } as unknown as LibMetric.SegmentMetadata;++ mockLibMetric.filterableDimensions.mockReturnValue([dim]);+ mockLibMetric.availableSegments.mockReturnValue([seg]);+ mockLibMetric.displayInfo.mockImplementation(+ (_def: unknown, target: unknown) => {+ if (target === dim) {+ return getSourceTableDimensionInfo("Created At");+ }+ if (target === seg) {+ return getSegmentInfo("Active customers");+ }+ throw new Error("unexpected displayInfo target");+ },+ );++ const [group] = getMetricGroups([source], {});++ expect(group.hasSegments).toBe(true);+ expect(group.sections).toHaveLength(1);+ expect(group.sections[0].isSourceTable).toBe(true);+ expect(group.sections[0].items).toEqual([+ expect.objectContaining({ name: "Active customers", segment: seg }),+ expect.objectContaining({ name: "Created At", definitionIndex: 0 }),+ ]);+ });++ it("emits empty sections when neither dimensions nor segments exist", () => {+ const source = makeDefinitionSource(0);+ mockLibMetric.filterableDimensions.mockReturnValue([]);+ mockLibMetric.availableSegments.mockReturnValue([]);++ const [group] = getMetricGroups([source], {});+ expect(group.hasSegments).toBe(false);+ expect(group.sections).toEqual([]);+ });++ it("synthesizes a source-table section when there are segments but no filterable dimensions", () => {+ const source = makeDefinitionSource(0);+ const seg = { __seg: "big" } as unknown as LibMetric.SegmentMetadata;++ mockLibMetric.filterableDimensions.mockReturnValue([]);+ mockLibMetric.availableSegments.mockReturnValue([seg]);+ mockLibMetric.displayInfo.mockReturnValue(getSegmentInfo("Big orders"));++ const [group] = getMetricGroups([source], {});+ expect(group.hasSegments).toBe(true);+ expect(group.sections).toHaveLength(1);+ expect(group.sections[0].isSourceTable).toBe(true);+ expect(group.sections[0].items).toEqual([+ expect.objectContaining({ name: "Big orders", segment: seg }),+ ]);+ });++ it("only attaches segments to the main section when joined groups exist", () => {+ const source = makeDefinitionSource(0);+ const mainDimMeta = {+ __dim: "createdAt",+ } as unknown as LibMetric.DimensionMetadata;+ const connDimMeta = {+ __dim: "productCategory",+ } as unknown as LibMetric.DimensionMetadata;+ const seg = {+ __seg: "active",+ } as unknown as LibMetric.SegmentMetadata;++ mockLibMetric.filterableDimensions.mockReturnValue([+ mainDimMeta,+ connDimMeta,+ ]);+ mockLibMetric.availableSegments.mockReturnValue([seg]);+ mockLibMetric.displayInfo.mockImplementation(+ (_def: unknown, target: unknown) => {+ if (target === mainDimMeta) {+ return getSourceTableDimensionInfo("Created At");+ }+ if (target === connDimMeta) {+ return getJoinedTabledDimensionInfo("Category");+ }+ if (target === seg) {+ return getSegmentInfo("Active customers");+ }+ throw new Error("unexpected displayInfo target");+ },+ );++ const [group] = getMetricGroups([source], {});+ expect(group.sections).toHaveLength(2);++ const mainSection = group.sections.find((s) => s.isSourceTable);+ const connSection = group.sections.find((s) => !s.isSourceTable);++ expect(mainSection?.items).toEqual([+ expect.objectContaining({ name: "Active customers", segment: seg }),+ expect.objectContaining({ name: "Created At" }),+ ]);+ expect(connSection?.items).toEqual([+ expect.objectContaining({ name: "Category" }),+ ]);+ // Segments MUST NOT leak into the joined-table section.+ expect(+ connSection?.items?.some(+ (item) => (item as { segment?: unknown }).segment != null,+ ),+ ).toBe(false);+ });++ it("falls back to a synthesized source-table section if no group reports as main", () => {+ const source = makeDefinitionSource(0);+ const connDimMeta = {+ __dim: "productCategory",+ } as unknown as LibMetric.DimensionMetadata;+ const otherDimMeta = {+ __dim: "other",+ } as unknown as LibMetric.DimensionMetadata;+ const seg = { __seg: "x" } as unknown as LibMetric.SegmentMetadata;++ mockLibMetric.filterableDimensions.mockReturnValue([+ connDimMeta,+ otherDimMeta,+ ]);+ mockLibMetric.availableSegments.mockReturnValue([seg]);+ mockLibMetric.displayInfo.mockImplementation(+ (_def: unknown, target: unknown) => {+ if (target === connDimMeta) {+ return getJoinedTabledDimensionInfo("Category", "conn1");+ }+ if (target === otherDimMeta) {+ return getJoinedTabledDimensionInfo("Other", "conn2");+ }+ if (target === seg) {+ return getSegmentInfo("Seg A");+ }+ throw new Error("unexpected displayInfo target");+ },+ );++ const [group] = getMetricGroups([source], {});+ // Two connection sections + one synthesized source-table section at top.+ expect(group.sections).toHaveLength(3);+ expect(group.sections[0].isSourceTable).toBe(true);+ expect(group.sections[0].items).toEqual([+ expect.objectContaining({ name: "Seg A", segment: seg }),+ ]);+ expect(group.sections.slice(1).every((s) => s.isSourceTable !== true)).toBe(+ true,+ );+ });++ it("scopes segments per definition source index", () => {+ const source0 = makeDefinitionSource(0);+ const source1 = makeDefinitionSource(1);+ const segA = { __seg: "a" } as unknown as LibMetric.SegmentMetadata;+ const segB = { __seg: "b" } as unknown as LibMetric.SegmentMetadata;++ mockLibMetric.filterableDimensions.mockReturnValue([]);+ mockLibMetric.availableSegments.mockImplementation((def: unknown) => {+ if ((def as { __fakeDefinition: number }).__fakeDefinition === 0) {+ return [segA];+ }+ return [segB];+ });+ mockLibMetric.displayInfo.mockImplementation(+ (_def: unknown, target: unknown) => {+ if (target === segA) {+ return getSegmentInfo("Seg A");+ }+ if (target === segB) {+ return getSegmentInfo("Seg B");+ }+ throw new Error("unexpected displayInfo target");+ },+ );++ const groups = getMetricGroups([source0, source1], {});+ expect(groups[0].sections[0].items).toEqual([+ expect.objectContaining({+ name: "Seg A",+ definitionIndex: 0,+ segment: segA,+ }),+ ]);+ expect(groups[1].sections[0].items).toEqual([+ expect.objectContaining({+ name: "Seg B",+ definitionIndex: 1,+ segment: segB,+ }),+ ]);+ });});diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.cssindex 9d0aa7903b2..d477a8cb0c6 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.module.css@@ -1,5 +1,4 @@.root {- cursor: pointer;background-color: var(--mb-color-background-primary);border: 1px solid var(--mb-color-border-filter);border-radius: 0.75rem;@@ -8,3 +7,7 @@.root:hover {background-color: var(--mb-color-background-secondary);}++.clickable {+ cursor: pointer;+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsxindex 9ea8c3deaef..802a4719e18 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPill.tsx@@ -1,10 +1,11 @@-import type { HTMLAttributes, MouseEvent, Ref } from "react";+import cx from "classnames";+import type { HTMLAttributes, Ref } from "react";import { forwardRef } from "react";import { t } from "ttag";import { SourceColorIndicator } from "metabase/common/components/SourceColorIndicator";import type { IconName } from "metabase/ui";-import { Flex, Icon, Text } from "metabase/ui";+import { Flex, Pill, Text } from "metabase/ui";import S from "./MetricsFilterPill.module.css";@@ -19,45 +20,42 @@ export const MetricsFilterPill = forwardRef(function MetricsFilterPill(children,colors,fallbackIcon,+ onClick,onRemoveClick,...props}: MetricsFilterPillProps,ref: Ref<HTMLDivElement>,) {- const handleRemoveClick = (event: MouseEvent) => {- event.stopPropagation();- onRemoveClick?.();- };-return (- <Flex+ <Pill{...props}ref={ref}- className={S.root}- align="center"- gap="xs"- px="sm"+ className={cx(S.root, !!onClick && S.clickable)}+ size="xs"h="lg"+ px="sm"+ fw="normal"data-testid="metrics-viewer-filter-pill"+ withRemoveButton={!!onRemoveClick}+ onRemove={onRemoveClick}+ onClick={onClick}+ removeButtonProps={{+ mr: 0,+ "aria-label": t`Remove`,+ "aria-hidden": false,+ c: "text-filter",+ }}>- <SourceColorIndicator- colors={colors}- fallbackIcon={fallbackIcon}- size={12}- />- <Text c="text-filter" fz="sm">- {children}- </Text>- {onRemoveClick && (- <Icon- c="text-filter"- name="close"+ <Flex align="center" gap="xs" h="1.25rem">+ <SourceColorIndicator+ colors={colors}+ fallbackIcon={fallbackIcon}size={12}- role="button"- aria-label={t`Remove`}- onClick={handleRemoveClick}/>- )}- </Flex>+ <Text c="text-filter" fz="sm">+ {children}+ </Text>+ </Flex>+ </Pill>);});diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsxindex 6cf22878eb5..cacf1639cf2 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPillPopover.tsx@@ -68,19 +68,25 @@ export function MetricsFilterPillPopover({><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>+ <Flex align="center">+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {metricName}+ </Text>+ {(metricCount ?? 0) > 1 && (+ <Badge+ circle+ color="filter"+ // override background from Badge.config.tsx+ styles={{ root: { background: "var(--badge-bg)" } }}+ ml="xs"+ >+ {metricCount}+ </Badge>+ )}+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {", "}+ </Text>+ </Flex>)}{displayParts.label}{displayParts.value && (diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsxindex 76f001fdf57..5dda9923f09 100644--- a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.tsx@@ -14,6 +14,7 @@ import {} from "../../utils/definition-sources";import { MetricsFilterPillPopover } from "./MetricsFilterPillPopover";+import { MetricsSegmentFilterPillPopover } from "./MetricsSegmentFilterPillPopover";interface MetricsFilterPillsProps {definitionSources: DefinitionSource[];@@ -32,6 +33,8 @@ type FlattenedFilter = {key: string;metricName?: string;metricCount?: number;+ isSegment: boolean;+ segmentName?: string;};export function MetricsFilterPills({@@ -74,21 +77,36 @@ export function MetricsFilterPills({return (<Group gap="sm">- {flatFilters.map((item) => (- <MetricsFilterPillPopover- key={item.key}- definition={item.source.definition}- filter={item.filter}- colors={item.colors}- icon={item.icon}- metricName={item.metricName}- metricCount={item.metricCount}- onUpdate={(newFilter) =>- handleUpdate(item.source, item.filter, newFilter)- }- onRemove={() => handleRemove(item.source, item.filter)}- />- ))}+ {flatFilters.map((item) =>+ item.isSegment ? (+ <MetricsSegmentFilterPillPopover+ key={item.key}+ definitionSource={item.source}+ oldFilter={item.filter}+ colors={item.colors}+ metricColors={sourceColors}+ metricName={item.metricName}+ metricCount={item.metricCount}+ segmentName={item.segmentName}+ onSourceDefinitionChange={onSourceDefinitionChange}+ onRemove={() => handleRemove(item.source, item.filter)}+ />+ ) : (+ <MetricsFilterPillPopover+ key={item.key}+ definition={item.source.definition}+ filter={item.filter}+ colors={item.colors}+ icon={item.icon}+ metricName={item.metricName}+ metricCount={item.metricCount}+ onUpdate={(newFilter) =>+ handleUpdate(item.source, item.filter, newFilter)+ }+ onRemove={() => handleRemove(item.source, item.filter)}+ />+ ),+ )}</Group>);}@@ -106,16 +124,34 @@ function getFlatFilters(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: `${source.index}-${filterIndex}`,- metricName: shouldDisplayMetricName- ? getDefinitionSourceName(source)- : undefined,- metricCount: source.token?.count,- }));+ return LibMetric.filters(source.definition).map((filter, filterIndex) => {+ const isSegment = LibMetric.isSegmentFilter(filter);+ let segmentName: string | undefined;+ if (isSegment) {+ const segmentMetadata = LibMetric.segmentMetadataForFilter(+ source.definition,+ filter,+ );+ if (segmentMetadata) {+ segmentName = LibMetric.displayInfo(+ source.definition,+ segmentMetadata,+ ).displayName;+ }+ }+ return {+ source,+ filter,+ colors,+ icon,+ key: `${source.index}-${filterIndex}`,+ metricName: shouldDisplayMetricName+ ? getDefinitionSourceName(source)+ : undefined,+ metricCount: source.token?.count,+ isSegment,+ segmentName,+ };+ });});}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.unit.spec.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.unit.spec.tsxnew file mode 100644index 00000000000..dd06120a847--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsFilterPills.unit.spec.tsx@@ -0,0 +1,189 @@+import userEvent from "@testing-library/user-event";++import { renderWithProviders, screen } from "__support__/ui";+import type { DefinitionSource } from "metabase/metrics-viewer/utils/definition-sources";+import type * as LibMetric from "metabase-lib/metric";+import * as LibMetricModule from "metabase-lib/metric";++import { MetricsFilterPills } from "./MetricsFilterPills";++jest.mock("metabase-lib/metric", () => ({+ __esModule: true,+ filters: jest.fn(),+ isSegmentFilter: jest.fn(),+ segmentMetadataForFilter: jest.fn(),+ displayInfo: jest.fn(),+ replaceClause: jest.fn(),+ removeClause: jest.fn(),+}));++jest.mock("metabase/metrics-viewer/analytics", () => ({+ __esModule: true,+ trackMetricsViewerFilterRemoved: jest.fn(),+ trackMetricsViewerFilterEdited: jest.fn(),+}));++jest.mock("metabase/metrics-viewer/utils/definition-sources", () => ({+ __esModule: true,+ getDefinitionSourceIcon: jest.fn(() => "metric" as const),+ getDefinitionSourceName: jest.fn(() => "Revenue"),+}));++jest.mock("metabase/metrics-viewer/types/viewer-state", () => ({+ __esModule: true,+ isExpressionEntry: jest.fn(() => false),+}));++// Avoid pulling the FilterPicker dependency tree into the unit test.+jest.mock("./MetricsFilterPillPopover", () => ({+ __esModule: true,+ MetricsFilterPillPopover: ({+ metricName,+ onRemove,+ }: {+ metricName?: string;+ onRemove: () => void;+ }) => (+ <button data-testid="non-segment-pill" onClick={onRemove}>+ {metricName ?? "filter-pill"}+ </button>+ ),+}));++// Same: avoid pulling FilterPopoverContent into the unit test —+// behavior of the segment popover is covered by its own spec.+jest.mock("./MetricsSegmentFilterPillPopover", () => ({+ __esModule: true,+ MetricsSegmentFilterPillPopover: ({+ segmentName,+ onRemove,+ }: {+ segmentName?: string;+ onRemove: () => void;+ }) => (+ <button+ data-testid="segment-pill"+ aria-label={`Segment filter: ${segmentName ?? ""}`}+ onClick={onRemove}+ >+ {segmentName}+ </button>+ ),+}));++const mockLibMetric = LibMetricModule as jest.Mocked<typeof LibMetric>;++function makeDefinitionSource(+ index: number,+ overrides: Partial<DefinitionSource> = {},+): DefinitionSource {+ return {+ index,+ id: `src-${index}` as DefinitionSource["id"],+ definition: { __fakeDef: index } as unknown as LibMetric.MetricDefinition,+ entity: {+ type: "metric",+ id: index,+ } as unknown as DefinitionSource["entity"],+ entityIndex: index,+ token: undefined,+ ...overrides,+ };+}++beforeEach(() => {+ jest.clearAllMocks();+});++describe("MetricsFilterPills", () => {+ it("renders a segment-iconed pill for a segment filter with its display name", () => {+ const source = makeDefinitionSource(0);+ const segmentClause = {+ __clause: "segment",+ } as unknown as LibMetric.FilterClause;+ const segmentMetadata = {+ __seg: "active",+ } as unknown as LibMetric.SegmentMetadata;++ mockLibMetric.filters.mockReturnValue([segmentClause]);+ mockLibMetric.isSegmentFilter.mockReturnValue(true);+ mockLibMetric.segmentMetadataForFilter.mockReturnValue(segmentMetadata);+ mockLibMetric.displayInfo.mockReturnValue({+ displayName: "Active customers",+ } as ReturnType<typeof LibMetric.displayInfo>);++ renderWithProviders(+ <MetricsFilterPills+ definitionSources={[source]}+ sourceColors={{ 0: ["#ff0000"] }}+ onSourceDefinitionChange={jest.fn()}+ />,+ );++ expect(screen.getByText("Active customers")).toBeInTheDocument();+ expect(+ screen.getByLabelText("Segment filter: Active customers"),+ ).toBeInTheDocument();+ expect(screen.getByTestId("segment-pill")).toBeInTheDocument();+ // Non-segment popover pill should NOT render for a segment filter.+ expect(screen.queryByTestId("non-segment-pill")).not.toBeInTheDocument();+ });++ it("calls removeClause when segment pill remove is invoked", async () => {+ const source = makeDefinitionSource(0);+ const segmentClause = {+ __clause: "segment",+ } as unknown as LibMetric.FilterClause;+ const segmentMetadata = {+ __seg: "active",+ } as unknown as LibMetric.SegmentMetadata;+ const newDefinition = {+ __fakeDef: "after-remove",+ } as unknown as LibMetric.MetricDefinition;++ mockLibMetric.filters.mockReturnValue([segmentClause]);+ mockLibMetric.isSegmentFilter.mockReturnValue(true);+ mockLibMetric.segmentMetadataForFilter.mockReturnValue(segmentMetadata);+ mockLibMetric.displayInfo.mockReturnValue({+ displayName: "Active customers",+ } as ReturnType<typeof LibMetric.displayInfo>);+ mockLibMetric.removeClause.mockReturnValue(newDefinition);++ const handleChange = jest.fn();+ renderWithProviders(+ <MetricsFilterPills+ definitionSources={[source]}+ sourceColors={{ 0: ["#ff0000"] }}+ onSourceDefinitionChange={handleChange}+ />,+ );++ await userEvent.click(screen.getByTestId("segment-pill"));++ expect(mockLibMetric.removeClause).toHaveBeenCalledWith(+ source.definition,+ segmentClause,+ );+ expect(handleChange).toHaveBeenCalledWith(source, newDefinition);+ });++ it("uses the popover pill for regular (non-segment) filter clauses", () => {+ const source = makeDefinitionSource(0);+ const normalClause = {+ __clause: "normal",+ } as unknown as LibMetric.FilterClause;++ mockLibMetric.filters.mockReturnValue([normalClause]);+ mockLibMetric.isSegmentFilter.mockReturnValue(false);++ renderWithProviders(+ <MetricsFilterPills+ definitionSources={[source]}+ sourceColors={{ 0: ["#ff0000"] }}+ onSourceDefinitionChange={jest.fn()}+ />,+ );++ expect(screen.getByTestId("non-segment-pill")).toBeInTheDocument();+ });+});diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.module.css b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.module.cssnew file mode 100644index 00000000000..d655d3444ea--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.module.css@@ -0,0 +1,5 @@+.dropdown {+ display: flex;+ flex-direction: column;+ overflow: hidden;+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.tsxnew file mode 100644index 00000000000..a9929eb7906--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.tsx@@ -0,0 +1,124 @@+import { useCallback, useState } from "react";+import { t } from "ttag";++import {+ trackMetricsViewerFilterEdited,+ trackMetricsViewerFilterRemoved,+} from "metabase/metrics-viewer/analytics";+import { Badge, Flex, Popover, Text } from "metabase/ui";+import type { MetricDefinition } from "metabase-lib/metric";+import * as LibMetric from "metabase-lib/metric";++import type { SourceColorMap } from "../../types/viewer-state";+import type { DefinitionSource } from "../../utils/definition-sources";+import { FilterPopoverContent } from "../FilterPopover/FilterPopoverContent";++import { MetricsFilterPill } from "./MetricsFilterPill";+import S from "./MetricsSegmentFilterPillPopover.module.css";++const POPOVER_MAX_HEIGHT = "37.5rem";++interface MetricsSegmentFilterPillPopoverProps {+ definitionSource: DefinitionSource;+ oldFilter: LibMetric.FilterClause;+ colors: string[];+ metricColors: SourceColorMap;+ metricName?: string;+ metricCount?: number;+ segmentName?: string;+ onSourceDefinitionChange: (+ source: DefinitionSource,+ newDefinition: MetricDefinition,+ ) => void;+ onRemove: () => void;+}++export function MetricsSegmentFilterPillPopover({+ definitionSource,+ oldFilter,+ colors,+ metricColors,+ metricName,+ metricCount,+ segmentName,+ onSourceDefinitionChange,+ onRemove,+}: MetricsSegmentFilterPillPopoverProps) {+ const [isOpened, setIsOpened] = useState(false);+ const [contentKey, setContentKey] = useState(0);++ const handleScopedDefinitionChange = useCallback(+ (source: DefinitionSource, newDefinition: MetricDefinition) => {+ const replaced = LibMetric.removeClause(newDefinition, oldFilter);+ onSourceDefinitionChange(source, replaced);+ },+ [oldFilter, onSourceDefinitionChange],+ );++ const handleFilterApplied = useCallback(() => {+ setIsOpened(false);+ setContentKey((key) => key + 1);+ trackMetricsViewerFilterEdited("metric_filter");+ }, []);++ const handleRemove = useCallback(() => {+ onRemove();+ trackMetricsViewerFilterRemoved("metric_filter");+ setIsOpened(false);+ }, [onRemove]);++ return (+ <Popover+ opened={isOpened}+ position="bottom-start"+ transitionProps={{ duration: 0 }}+ onChange={setIsOpened}+ >+ <Popover.Target>+ <MetricsFilterPill+ colors={colors}+ fallbackIcon="segment"+ onClick={() => setIsOpened((prev) => !prev)}+ onRemoveClick={handleRemove}+ aria-label={t`Segment filter: ${segmentName ?? ""}`}+ >+ <Flex align="center" gap="xs">+ {metricName && (+ <Flex align="center">+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {metricName}+ </Text>+ {(metricCount ?? 0) > 1 && (+ <Badge+ circle+ color="filter"+ // override background from Badge.config.tsx+ styles={{ root: { background: "var(--badge-bg)" } }}+ ml="xs"+ >+ {metricCount}+ </Badge>+ )}+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {", "}+ </Text>+ </Flex>+ )}+ <Text component="span" fw={700} c="inherit" fz="inherit">+ {segmentName}+ </Text>+ </Flex>+ </MetricsFilterPill>+ </Popover.Target>+ <Popover.Dropdown p={0} mah={POPOVER_MAX_HEIGHT} className={S.dropdown}>+ <FilterPopoverContent+ key={contentKey}+ definitionSources={[definitionSource]}+ metricColors={metricColors}+ onSourceDefinitionChange={handleScopedDefinitionChange}+ onFilterApplied={handleFilterApplied}+ />+ </Popover.Dropdown>+ </Popover>+ );+}diff --git a/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.unit.spec.tsx b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.unit.spec.tsxnew file mode 100644index 00000000000..b1468f1cbc4--- /dev/null+++ b/frontend/src/metabase/metrics-viewer/components/MetricsFilterPills/MetricsSegmentFilterPillPopover.unit.spec.tsx@@ -0,0 +1,179 @@+import userEvent from "@testing-library/user-event";++import { renderWithProviders, screen } from "__support__/ui";+import {+ trackMetricsViewerFilterEdited,+ trackMetricsViewerFilterRemoved,+} from "metabase/metrics-viewer/analytics";+import type { DefinitionSource } from "metabase/metrics-viewer/utils/definition-sources";+import type * as LibMetric from "metabase-lib/metric";+import * as LibMetricModule from "metabase-lib/metric";++import { MetricsSegmentFilterPillPopover } from "./MetricsSegmentFilterPillPopover";++jest.mock("metabase-lib/metric", () => ({+ __esModule: true,+ removeClause: jest.fn(),+}));++jest.mock("metabase/metrics-viewer/analytics", () => ({+ __esModule: true,+ trackMetricsViewerFilterEdited: jest.fn(),+ trackMetricsViewerFilterRemoved: jest.fn(),+}));++jest.mock("../FilterPopover/FilterPopoverContent", () => ({+ __esModule: true,+ FilterPopoverContent: ({+ definitionSources,+ onSourceDefinitionChange,+ onFilterApplied,+ }: {+ definitionSources: { definition: unknown }[];+ onSourceDefinitionChange: (source: unknown, def: unknown) => void;+ onFilterApplied: () => void;+ }) => (+ <div data-testid="filter-popover-content">+ <button+ data-testid="apply-stub"+ onClick={() => {+ onSourceDefinitionChange(definitionSources[0], {+ __after: "filter-popover-apply",+ } as unknown);+ onFilterApplied();+ }}+ >+ Apply+ </button>+ </div>+ ),+}));++const mockLibMetric = LibMetricModule as jest.Mocked<typeof LibMetric>;+const mockTrackEdited = trackMetricsViewerFilterEdited as jest.MockedFunction<+ typeof trackMetricsViewerFilterEdited+>;+const mockTrackRemoved = trackMetricsViewerFilterRemoved as jest.MockedFunction<+ typeof trackMetricsViewerFilterRemoved+>;++function makeDefinitionSource(): DefinitionSource {+ return {+ index: 0,+ id: "src-0" as DefinitionSource["id"],+ definition: { __fakeDef: 0 } as unknown as LibMetric.MetricDefinition,+ entity: {} as DefinitionSource["entity"],+ entityIndex: 0,+ token: undefined,+ };+}++const oldFilter = {+ __clause: "old-segment",+} as unknown as LibMetric.FilterClause;++beforeEach(() => {+ jest.clearAllMocks();+});++describe("MetricsSegmentFilterPillPopover", () => {+ it("renders the segment name on the pill", () => {+ renderWithProviders(+ <MetricsSegmentFilterPillPopover+ definitionSource={makeDefinitionSource()}+ oldFilter={oldFilter}+ colors={["#ff0000"]}+ metricColors={{ 0: ["#ff0000"] }}+ segmentName="Active customers"+ onSourceDefinitionChange={jest.fn()}+ onRemove={jest.fn()}+ />,+ );++ expect(screen.getByText("Active customers")).toBeInTheDocument();+ expect(+ screen.getByLabelText("Segment filter: Active customers"),+ ).toBeInTheDocument();+ });++ it("opens the popover with FilterPopoverContent when the pill is clicked", async () => {+ renderWithProviders(+ <MetricsSegmentFilterPillPopover+ definitionSource={makeDefinitionSource()}+ oldFilter={oldFilter}+ colors={["#ff0000"]}+ metricColors={{ 0: ["#ff0000"] }}+ segmentName="Active customers"+ onSourceDefinitionChange={jest.fn()}+ onRemove={jest.fn()}+ />,+ );++ expect(+ screen.queryByTestId("filter-popover-content"),+ ).not.toBeInTheDocument();++ await userEvent.click(+ screen.getByLabelText("Segment filter: Active customers"),+ );++ expect(screen.getByTestId("filter-popover-content")).toBeInTheDocument();+ });++ it("removes the original segment from the picked definition before propagating up", async () => {+ const source = makeDefinitionSource();+ const replaced = {+ __after: "old-segment-removed",+ } as unknown as LibMetric.MetricDefinition;+ mockLibMetric.removeClause.mockReturnValue(replaced);+ const handleChange = jest.fn();++ renderWithProviders(+ <MetricsSegmentFilterPillPopover+ definitionSource={source}+ oldFilter={oldFilter}+ colors={["#ff0000"]}+ metricColors={{ 0: ["#ff0000"] }}+ segmentName="Active customers"+ onSourceDefinitionChange={handleChange}+ onRemove={jest.fn()}+ />,+ );++ await userEvent.click(+ screen.getByLabelText("Segment filter: Active customers"),+ );+ await userEvent.click(screen.getByTestId("apply-stub"));++ // The popover content's "applied" definition is piped through+ // removeClause(_, oldFilter) so the new selection effectively+ // replaces the original segment.+ expect(mockLibMetric.removeClause).toHaveBeenCalledWith(+ { __after: "filter-popover-apply" },+ oldFilter,+ );+ expect(handleChange).toHaveBeenCalledTimes(1);+ expect(handleChange).toHaveBeenCalledWith(source, replaced);+ expect(mockTrackEdited).toHaveBeenCalledWith("metric_filter");+ });++ it("invokes onRemove and tracks analytics when the X is clicked", async () => {+ const handleRemove = jest.fn();+ renderWithProviders(+ <MetricsSegmentFilterPillPopover+ definitionSource={makeDefinitionSource()}+ oldFilter={oldFilter}+ colors={["#ff0000"]}+ metricColors={{ 0: ["#ff0000"] }}+ segmentName="Active customers"+ onSourceDefinitionChange={jest.fn()}+ onRemove={handleRemove}+ />,+ );++ await userEvent.click(screen.getByLabelText("Remove"));++ expect(handleRemove).toHaveBeenCalledTimes(1);+ expect(mockTrackRemoved).toHaveBeenCalledWith("metric_filter");+ });+});diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts b/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.tsindex a42bbdcc0e4..649d5349a55 100644--- a/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts+++ b/frontend/src/metabase/metrics-viewer/hooks/use-definition-queries.ts@@ -1,7 +1,7 @@import { useEffect, useMemo } from "react";import { t } from "ttag";-import { metricApi } from "metabase/api";+import { metricApi, useListSegmentsQuery } from "metabase/api";import { getErrorMessage } from "metabase/api/utils/errors";import { useDispatch, useSelector } from "metabase/redux";import type { State } from "metabase/redux/store";@@ -273,6 +273,8 @@ export function useDefinitionQueries(});}, [formulaEntities, definitions]);+ useListSegmentsQuery(); // FIXME segments don't have any filters yet. We should load only segments that are related to the formula+useEffect(() => {const requestsToMake = [...datasetRequestsByEntityIndex.values()];diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.tsindex ddae4ff17b1..2b23a93ecfa 100644--- a/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts+++ b/frontend/src/metabase/metrics-viewer/hooks/use-viewer-state.ts@@ -1,6 +1,6 @@import { useCallback, useEffect, useRef, useState } from "react";-import { measureApi, metricApi } from "metabase/api";+import { measureApi, metricApi, segmentApi } from "metabase/api";import { useDispatch, useStore } from "metabase/redux";import { getMetadata } from "metabase/selectors/metadata";import { getObjectEntries, objectFromEntries } from "metabase/utils/objects";@@ -45,9 +45,10 @@ async function loadMetricDefinition(getState: ReturnType<typeof useStore>["getState"],metricId: MetricId,): Promise<MetricDefinition> {- const result = await dispatch(- metricApi.endpoints.getMetric.initiate(metricId),- );+ const [result] = await Promise.all([+ dispatch(metricApi.endpoints.getMetric.initiate(metricId)),+ dispatch(segmentApi.endpoints.listSegments.initiate()), // Ensure segments are present in Redux before building the metadata provider+ ]);if (!result.data) {throw new Error(`Failed to load metric ${metricId}`);}@@ -64,9 +65,10 @@ async function loadMeasureDefinition(getState: ReturnType<typeof useStore>["getState"],measureId: MeasureId,): Promise<MetricDefinition> {- const result = await dispatch(- measureApi.endpoints.getMeasure.initiate(measureId),- );+ const [result] = await Promise.all([+ dispatch(measureApi.endpoints.getMeasure.initiate(measureId)),+ dispatch(segmentApi.endpoints.listSegments.initiate()), // Ensure segments are present in Redux before building the metadata provider+ ]);if (!result.data) {throw new Error(`Failed to load measure ${measureId}`);}diff --git a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts b/frontend/src/metabase/metrics-viewer/utils/url-serialization.tsindex 70e3c8a918b..f8ce81e28c8 100644--- a/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts+++ b/frontend/src/metabase/metrics-viewer/utils/url-serialization.ts@@ -4,6 +4,7 @@ import type { MetricDefinition } from "metabase-lib/metric";import * as LibMetric from "metabase-lib/metric";import type {MathOperator,+ SegmentId,TemporalUnit,VisualizationSettings,} from "metabase-types/api";@@ -72,6 +73,7 @@ export interface SerializedDefinitionInfo {breakoutTemporalUnit?: TemporalUnit;breakoutBinning?: string;filters?: SerializedUrlFilter[];+ segments?: SegmentId[];}export function applySerializedDefinitionInfo(@@ -81,6 +83,7 @@ export function applySerializedDefinitionInfo(breakoutTemporalUnit,breakoutBinning,filters,+ segments,}: SerializedDefinitionInfo,): MetricDefinition {let result = definition;@@ -127,6 +130,21 @@ export function applySerializedDefinitionInfo(}}+ if (segments?.length) {+ const availableById = new Map(+ LibMetric.availableSegments(result).map((segment) => [+ LibMetric.segmentMetadataId(segment),+ segment,+ ]),+ );+ for (const segmentId of segments) {+ const segment = availableById.get(segmentId);+ if (segment) {+ result = LibMetric.addSegmentFilter(result, segment);+ }+ }+ }+return result;}@@ -138,6 +156,7 @@ interface SerializedExpressionSubToken {op?: MathOperator;value?: number;filters?: SerializedUrlFilter[];+ segments?: SegmentId[];}interface SerializedExpressionEntry {@@ -159,6 +178,7 @@ interface SerializedSource {breakoutTemporalUnit?: TemporalUnit;breakoutBinning?: string;filters?: SerializedUrlFilter[];+ segments?: SegmentId[];}type SerializedFormulaEntity = SerializedExpressionEntry | SerializedSource;@@ -210,6 +230,7 @@ function serializeSubToken(type: "metric",sourceId: token.sourceId,filters: annotatedSource.filters,+ segments: annotatedSource.segments,};}if (token.type === "constant") {@@ -225,13 +246,15 @@ function deserializeSubToken(token: SerializedExpressionSubToken,): ExpressionSubToken | null {if (token.type === "metric" && token.sourceId) {+ const hasInfo = token.filters || token.segments;return {type: "metric",sourceId: token.sourceId as MetricSourceId,count: 0,- serializedDefinitionInfo: token.filters+ serializedDefinitionInfo: hasInfo? {filters: token.filters,+ segments: token.segments,}: undefined,};@@ -258,6 +281,7 @@ export function deserializeFormulaEntities(for (const entity of serializedState.formulaEntities) {if (entity.type === "metric" || entity.type === "measure") {+ const hasInfo = entity.breakout || entity.filters || entity.segments;entities.push({id:entity.type === "metric"@@ -265,15 +289,15 @@ export function deserializeFormulaEntities(: `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,+ serializedDefinitionInfo: hasInfo+ ? {+ breakout: entity.breakout,+ breakoutTemporalUnit: entity.breakoutTemporalUnit,+ breakoutBinning: entity.breakoutBinning,+ filters: entity.filters,+ segments: entity.segments,+ }+ : undefined,});}if (entity.type === "expression") {@@ -420,6 +444,23 @@ function annotateSource(}));}+ const segmentIds: SegmentId[] = [];+ for (const filterClause of LibMetric.filters(entry.definition)) {+ if (!LibMetric.isSegmentFilter(filterClause)) {+ continue;+ }+ const metadata = LibMetric.segmentMetadataForFilter(+ entry.definition,+ filterClause,+ );+ if (metadata) {+ segmentIds.push(LibMetric.segmentMetadataId(metadata));+ }+ }+ if (segmentIds.length > 0) {+ source.segments = segmentIds;+ }+return source;}@@ -475,6 +516,7 @@ const expressionSubTokenSchema =op: { key: "o", optional: true },value: { key: "v", optional: true },filters: { key: "F", schema: sourceFilterSchema, optional: true },+ segments: { key: "S", optional: true },});const formulaEntitySchema = defineCompactSchema<SerializedFormulaEntity>({@@ -484,6 +526,7 @@ const formulaEntitySchema = defineCompactSchema<SerializedFormulaEntity>({breakoutTemporalUnit: { key: "u", optional: true },breakoutBinning: { key: "B", optional: true },filters: { key: "F", schema: sourceFilterSchema, optional: true },+ segments: { key: "s", optional: true },name: { key: "n", optional: true },tokens: { key: "T", schema: expressionSubTokenSchema, optional: true },});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.tsindex 12deaec9b99..c89b115fed3 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@@ -140,6 +140,136 @@ describe("url-serialization", () => {expect(decoded).toEqual(state);});+ it("round-trips a metric with a single segment", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "metric",+ id: 5,+ segments: [42],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("round-trips a metric with multiple segments preserving order", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "metric",+ id: 5,+ segments: [11, 7, 23],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ const entity = decoded.formulaEntities[0];+ if (entity.type === "expression") {+ throw new Error("Expected metric entity");+ }+ expect(entity.segments).toEqual([11, 7, 23]);+ });++ it("round-trips a metric with both dimension filters and segments", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "metric",+ id: 5,+ filters: [+ {+ dimensionId: "category",+ value: {+ type: "string",+ operator: "=",+ values: ["Gadget"],+ options: {},+ },+ },+ ],+ segments: [42],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("round-trips expression tokens with segments", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [+ {+ type: "expression",+ id: "expression:test",+ name: "test",+ tokens: [+ {+ type: "metric",+ sourceId: "metric:1",+ segments: [99],+ },+ { type: "operator", op: "+" },+ { type: "metric", sourceId: "metric:2" },+ ],+ },+ ],+ tabs: [],+ selectedTabId: null,+ };++ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ expect(decoded).toEqual(state);+ });++ it("decodes a legacy URL without `segments` to undefined (backward compat)", () => {+ // Encode an older-shape state (no segments field) and confirm+ // round-trip still works and leaves segments undefined.+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [{ type: "metric", id: 1, breakout: "dim-1" }],+ tabs: [],+ selectedTabId: null,+ };+ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ const entity = decoded.formulaEntities[0];+ if (entity.type === "expression") {+ throw new Error("Expected metric entity");+ }+ expect(entity.segments).toBeUndefined();+ });++ it("propagates decoded segments into serializedDefinitionInfo on the entity", () => {+ const state: SerializedMetricsViewerPageState = {+ formulaEntities: [{ type: "metric", id: 5, segments: [42] }],+ tabs: [],+ selectedTabId: null,+ };+ const hash = encodeStateOrThrow(state);+ const decoded = decodeState(hash);+ const entities = deserializeFormulaEntities(decoded);+ expect(entities).toHaveLength(1);+ const entity = entities[0];+ if (entity.type !== "metric") {+ throw new Error("Expected metric entity");+ }+ expect(entity.serializedDefinitionInfo?.segments).toEqual([42]);+ });+it("round-trips expressions in formula entities", () => {const state: SerializedMetricsViewerPageState = {formulaEntities: [diff --git a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts b/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.tsdeleted file mode 100644index b1eded004de..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/types.ts+++ /dev/null@@ -1,20 +0,0 @@-import type { Section as BaseSection } from "metabase/common/components/AccordionList";-import type * as LibMetric from "metabase-lib/metric";--export type DimensionListItem = {- name: string;- definition: LibMetric.MetricDefinition;- definitionIndex: number;- dimension: LibMetric.DimensionMetadata;-};--export type DimensionSection = BaseSection<DimensionListItem>;--export type MetricGroup = {- id: number;- metricName: string;- 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.tsdeleted file mode 100644index e97877737c6..00000000000--- a/frontend/src/metabase/metrics/components/FilterPicker/FilterDimensionPicker/utils.ts+++ /dev/null@@ -1,62 +0,0 @@-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(- definitionSources: DefinitionSource[],- metricColors: SourceColorMap,-): MetricGroup[] {- return definitionSources.map((definitionSource, definitionIndex) => {- const definition = definitionSource.definition;- const dimensions = LibMetric.filterableDimensions(definition);-- const byGroupId = new Map<- string,- { groupName: string; items: DimensionListItem[] }- >();-- for (const dimension of dimensions) {- const info = LibMetric.displayInfo(definition, dimension);- const groupId = info.group?.id ?? "";- const groupName = info.group?.displayName ?? "";- const item: DimensionListItem = {- name: info.displayName,- definition,- definitionIndex,- dimension,- };-- const entry = byGroupId.get(groupId);- if (entry) {- entry.items.push(item);- } else {- byGroupId.set(groupId, { groupName, items: [item] });- }- }-- const sections: DimensionSection[] = [];- if (byGroupId.size <= 1) {- const allItems = [...byGroupId.values()].flatMap((g) => g.items);- sections.push({ items: allItems });- } else {- for (const [, { groupName, items }] of byGroupId) {- sections.push({ name: groupName, items });- }- }-- return {- id: definitionSource.index,- metricName: getDefinitionSourceName(definitionSource),- metricCount: definitionSource.token?.count,- icon: getDefinitionSourceIcon(definitionSource),- colors: metricColors[definitionSource.entityIndex],- sections,- };- });-}diff --git a/src/metabase/lib_metric/ast/build.cljc b/src/metabase/lib_metric/ast/build.cljcindex d046ca5e934..2fc9ad8a670 100644--- a/src/metabase/lib_metric/ast/build.cljc+++ b/src/metabase/lib_metric/ast/build.cljc@@ -192,6 +192,11 @@:dimension (dimension-ref-or-expression dimension-ref):values (vec values)})+ ;; Segment filters — passthrough, resolved by the query processor.+ (= :segment operator)+ {:node/type :filter/mbql+ :clause mbql-clause}+;; Temporal filters(operators/temporal? operator)(let [[dimension-ref value unit pos-offset-value pos-offset-unit] argsdiff --git a/src/metabase/lib_metric/display_info.cljc b/src/metabase/lib_metric/display_info.cljcindex cc685863e1a..ad315874694 100644--- a/src/metabase/lib_metric/display_info.cljc+++ b/src/metabase/lib_metric/display_info.cljc@@ -104,6 +104,13 @@:is-calculated (= source :source/expressions):is-implicitly-joinable (= source :source/implicitly-joinable)}))))+;;; -------------------------------------------------- Segment --------------------------------------------------++(defmethod display-info-method :metadata/segment+ [definition segment]+ (cond-> (default-display-info definition segment)+ (:filter-positions segment) (assoc :filter-positions (:filter-positions segment))))+;;; -------------------------------------------------- Temporal Bucket --------------------------------------------------(defn- temporal-bucket-display-infodiff --git a/src/metabase/lib_metric/filter.cljc b/src/metabase/lib_metric/filter.cljcindex 4ade8523ae5..1fa9873a144 100644--- a/src/metabase/lib_metric/filter.cljc+++ b/src/metabase/lib_metric/filter.cljc@@ -6,6 +6,7 @@[metabase.lib-metric.operators :as operators][metabase.lib-metric.types.isa :as types.isa][metabase.lib.core :as lib]+ [metabase.lib.metadata.protocols :as lib.metadata.protocols][metabase.util.performance :as perf][metabase.util.time :as u.time]))@@ -133,6 +134,81 @@(let [inst-filter {:lib/uuid instance-uuid :filter filter-clause}](update definition :filters (fnil conj []) inst-filter))))+;;; -------------------------------------------------- Segments --------------------------------------------------++(defn- leaf-table-id+ "Resolve the source table-id for an expression leaf ([:metric _ id] or [:measure _ id])."+ [provider leaf]+ (let [leaf-type (definition/expression-leaf-type leaf)+ leaf-id (definition/expression-leaf-id leaf)+ md-type (case leaf-type+ :metric :metadata/metric+ :measure :metadata/measure+ nil)]+ (when md-type+ (some-> (first (lib.metadata.protocols/metadatas+ provider+ {:lib/type md-type :id #{leaf-id}}))+ :table-id))))++(defn available-segments+ "Return available Segments for a metric definition, scoped to each expression leaf's+ source table. Returns a sequence of Segment metadata maps (de-duplicated by :id),+ each annotated with:++ - `:lib-metric/instance-uuid` — the expression leaf's uuid (so callers can+ attach the segment to the correct instance filter)."+ [definition]+ (let [provider (:metadata-provider definition)+ leaves (definition/expression-leaves (:expression definition))]+ (->> leaves+ (mapcat (fn [leaf]+ (let [uuid (definition/expression-leaf-uuid leaf)+ table-id (leaf-table-id provider leaf)]+ (when table-id+ (map (fn [segment]+ (assoc segment :lib-metric/instance-uuid uuid))+ (lib.metadata.protocols/segments provider table-id))))))+ (reduce (fn [{:keys [seen acc]} segment]+ (if (contains? seen (:id segment))+ {:seen seen :acc acc}+ {:seen (conj seen (:id segment))+ :acc (conj acc segment)}))+ {:seen #{} :acc []})+ :acc)))++(defn segment-clause?+ "True if `filter-clause` is a segment reference, i.e. `[:segment _opts id]`."+ [filter-clause]+ (and (vector? filter-clause)+ (= :segment (first filter-clause))))++(defn segment-id-from-clause+ "Return the segment id from a `[:segment _opts id]` clause, or nil."+ [filter-clause]+ (when (segment-clause? filter-clause)+ (nth filter-clause 2 nil)))++(defn segment-metadata-for-clause+ "Return the segment metadata referenced by a `[:segment _opts id]` filter-clause, or nil."+ [definition filter-clause]+ (when-let [segment-id (segment-id-from-clause filter-clause)]+ (first (lib.metadata.protocols/metadatas+ (:metadata-provider definition)+ {:lib/type :metadata/segment :id #{segment-id}}))))++(defn add-segment-filter+ "Add a segment as a filter on a metric definition. `segment-metadata` is a segment+ metadata map (must have `:id`). If the metadata carries a `:lib-metric/instance-uuid`+ the filter is attached to that instance; otherwise the definition's sole leaf uuid is+ used. The resulting filter clause is `[:segment {:lib/uuid ...} id]`."+ [definition segment-metadata]+ (let [segment-id (:id segment-metadata)+ instance-uuid (or (:lib-metric/instance-uuid segment-metadata)+ (definition/expression-leaf-uuid (:expression definition)))+ filter-clause (lib/ensure-uuid [:segment {} segment-id])]+ (add-filter definition filter-clause instance-uuid)))+;;; -------------------------------------------------- Filter Clause Helpers --------------------------------------------------(defn- dimension-refdiff --git a/src/metabase/lib_metric/js.cljs b/src/metabase/lib_metric/js.cljsindex 7bd568de8b9..ca717290eae 100644--- a/src/metabase/lib_metric/js.cljs+++ b/src/metabase/lib_metric/js.cljs@@ -390,6 +390,37 @@[dimension](to-array (map name (lib-metric.filter/filterable-dimension-operators dimension))))+(defn ^:export availableSegments+ "Return segments that can be applied as filters on this metric definition.+ Segments are scoped to the source table(s) of the definition's expression leaves.+ Each segment metadata is annotated with `:lib-metric/instance-uuid` so the FE+ can pass the same opaque value back to `addSegmentFilter` / `filter`.+ Returns a JS array of (opaque) CLJS segment metadata maps."+ [definition]+ (to-array (lib-metric.filter/available-segments definition)))++(defn ^:export isSegmentFilter+ "Return true if the filter-clause is a segment reference."+ [filter-clause]+ (lib-metric.filter/segment-clause? filter-clause))++(defn ^:export segmentMetadataForFilter+ "Return the segment metadata referenced by a segment filter-clause, or nil."+ [definition filter-clause]+ (lib-metric.filter/segment-metadata-for-clause definition filter-clause))++(defn ^:export addSegmentFilter+ "Add a segment as a filter on this metric definition. `segment-metadata` is an+ opaque CLJS segment metadata map returned by `availableSegments`."+ [definition segment-metadata]+ (lib-metric.filter/add-segment-filter definition segment-metadata))++(defn ^:export segmentMetadataId+ "Return the numeric id of a segment metadata map returned by `availableSegments`+ or `segmentMetadataForFilter`."+ [segment-metadata]+ (:id segment-metadata))+;;; -------------------------------------------------- Filter Parts JS Conversion --------------------------------------------------(defn- js-key->cljs-keydiff --git a/src/metabase/lib_metric/metadata/js.cljs b/src/metabase/lib_metric/metadata/js.cljsindex bb8df742100..d3447757216 100644--- a/src/metabase/lib_metric/metadata/js.cljs+++ b/src/metabase/lib_metric/metadata/js.cljs@@ -9,6 +9,7 @@[metabase.lib-metric.dimension :as lib-metric.dimension][metabase.lib-metric.metadata.provider :as provider][metabase.lib.js.metadata :as js-metadata]+ [metabase.lib.metadata.protocols :as lib.metadata.protocols][metabase.util :as u]))(defn- object-get [obj k]@@ -183,6 +184,15 @@(let [provider (js-metadata/metadata-provider db-id metadata)](swap! db-provider-cache assoc db-id provider)provider)))+ ;; Segments live globally under `metadata.segments`, not per-database.+ ;; Looking them up via `table->db-fn` + `db-provider-fn` means a user+ ;; who hasn't loaded the metric's source table metadata sees no+ ;; segments (because `table->db-fn` returns nil and routing short-+ ;; circuits). Route segment requests through a db-agnostic provider+ ;; so they always resolve against the full metadata snapshot.+ segment-provider (delay (js-metadata/metadata-provider nil metadata))+ segment-fetcher-fn (fn [spec]+ (lib.metadata.protocols/metadatas @segment-provider spec))setting-fn (fn [setting-key](some-> settings (object-get (name setting-key))))](provider/metric-context-metadata-provider@@ -190,6 +200,8 @@(when parsed-measures(fn [spec] (filter-measures parsed-measures spec)))(fn [spec] (filter-dimensions all-dimensions spec))+ segment-fetcher-fn(fn [table-id] (get table->db-id table-id))db-provider-fn- setting-fn)))+ setting-fn+ nil)))diff --git a/src/metabase/lib_metric/metadata/provider.cljc b/src/metabase/lib_metric/metadata/provider.cljcindex 99b57b99a24..c0dd3ef9e75 100644--- a/src/metabase/lib_metric/metadata/provider.cljc+++ b/src/metabase/lib_metric/metadata/provider.cljc@@ -56,6 +56,7 @@[metric-fetcher-fn ;; (fn [metadata-spec] ...) returns metricsmeasure-fetcher-fn ;; (fn [metadata-spec] ...) returns measures (optional, can be nil)dimension-fetcher-fn ;; (fn [metadata-spec] ...) returns dimensions (optional, can be nil)+ segment-fetcher-fn ;; (fn [metadata-spec] ...) returns segments (optional, can be nil)table->db-fn ;; (fn [table-id] ...) returns database-iddb-provider-fn ;; (fn [db-id] ...) returns MetadataProvider for that databasesetting-fn ;; (fn [setting-key] ...) returns setting value@@ -92,7 +93,9 @@[]):metadata/segment- (or (route-metadata-by-table table->db-fn db-provider-fn metadata-spec) [])+ (if segment-fetcher-fn+ (segment-fetcher-fn metadata-spec)+ (or (route-metadata-by-table table->db-fn db-provider-fn metadata-spec) [])):metadata/card(route-card-metadata table->db-fn db-provider-fn metadata-spec)@@ -142,6 +145,7 @@(= metric-fetcher-fn (.-metric-fetcher-fn ^MetricContextMetadataProvider another))(= measure-fetcher-fn (.-measure-fetcher-fn ^MetricContextMetadataProvider another))(= dimension-fetcher-fn (.-dimension-fetcher-fn ^MetricContextMetadataProvider another))+ (= segment-fetcher-fn (.-segment-fetcher-fn ^MetricContextMetadataProvider another))(= table->db-fn (.-table->db-fn ^MetricContextMetadataProvider another))(= db-provider-fn (.-db-provider-fn ^MetricContextMetadataProvider another))(= setting-fn (.-setting-fn ^MetricContextMetadataProvider another))@@ -166,16 +170,20 @@- Routes table/column/segment requests to the appropriate database provider- Caches metric, measure, and dimension metadata internally"([metric-fetcher-fn table->db-fn db-provider-fn setting-fn]- (metric-context-metadata-provider metric-fetcher-fn nil nil table->db-fn db-provider-fn setting-fn nil))+ (metric-context-metadata-provider metric-fetcher-fn nil nil nil table->db-fn db-provider-fn setting-fn nil))([metric-fetcher-fn measure-fetcher-fn table->db-fn db-provider-fn setting-fn]- (metric-context-metadata-provider metric-fetcher-fn measure-fetcher-fn nil table->db-fn db-provider-fn setting-fn nil))+ (metric-context-metadata-provider metric-fetcher-fn measure-fetcher-fn nil nil table->db-fn db-provider-fn setting-fn nil))([metric-fetcher-fn measure-fetcher-fn dimension-fetcher-fn table->db-fn db-provider-fn setting-fn]- (metric-context-metadata-provider metric-fetcher-fn measure-fetcher-fn dimension-fetcher-fn table->db-fn db-provider-fn setting-fn nil))+ (metric-context-metadata-provider metric-fetcher-fn measure-fetcher-fn dimension-fetcher-fn nil table->db-fn db-provider-fn setting-fn nil))([metric-fetcher-fn measure-fetcher-fn dimension-fetcher-fn table->db-fn db-provider-fn setting-fn column-post-process-fn]+ (metric-context-metadata-provider metric-fetcher-fn measure-fetcher-fn dimension-fetcher-fn nil table->db-fn db-provider-fn setting-fn column-post-process-fn))+ ([metric-fetcher-fn measure-fetcher-fn dimension-fetcher-fn segment-fetcher-fn+ table->db-fn db-provider-fn setting-fn column-post-process-fn](->MetricContextMetadataProvidermetric-fetcher-fnmeasure-fetcher-fndimension-fetcher-fn+ segment-fetcher-fntable->db-fndb-provider-fnsetting-fndiff --git a/test/metabase/lib_metric/ast/build_test.cljc b/test/metabase/lib_metric/ast/build_test.cljcindex fd1b89b02c4..94fa9a9140a 100644--- a/test/metabase/lib_metric/ast/build_test.cljc+++ b/test/metabase/lib_metric/ast/build_test.cljc@@ -321,6 +321,13 @@(is (= :filter/not (:node/type result)))(is (= :filter/comparison (get-in result [:child :node/type]))))))+(deftest ^:parallel mbql-filter->ast-filter-segment-test+ (testing "segment filters are preserved as raw MBQL passthrough"+ (let [clause [:segment {:lib/uuid "46acdc23-a272-414a-b8eb-f93ead6b98ec"} 2]+ result (ast.build/mbql-filter->ast-filter clause)]+ (is (= :filter/mbql (:node/type result)))+ (is (= clause (:clause result))))))+(deftest ^:parallel mbql-filter->ast-filter-exclude-day-of-week-test(let [;; Exclude Monday (1) and Sunday (7) using ISO day-of-week;; This is the MBQL 5 shape produced by lib/fe_util/exclude-date-filter-clause@@ -551,3 +558,72 @@(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]))))))))++;;; -------------------------------------------------- Segment filter passthrough --------------------------------------------------++;; A `[:segment _ id]` filter clause is wrapped as a `:filter/mbql` passthrough+;; AST node and compiled verbatim. The QP's `expand-macros` middleware then+;; replaces it with the segment's own filter clauses at run time.+;;+;; Joined-table segment support (pre-expanding the segment clause at build+;; time and annotating field refs with `:source-field`) lives in the follow-up+;; branch `den/UXW-3754-segments-joined-tables`.++(defn- source-table-segment []+ ;; A segment authored on the metric's own source table (venues).+ {:lib/type :metadata/segment+ :id 600+ :name "expensive"+ :table-id (meta/id :venues)+ :definition {:lib/type :mbql/query+ :database (meta/id)+ :stages [{:lib/type :mbql.stage/mbql+ :source-table (meta/id :venues)+ :filters [[:> {:lib/uuid "ffffffff-0000-0000-0000-000000000001"}+ [:field {:lib/uuid "ffffffff-0000-0000-0000-000000000002"}+ (meta/id :venues :price)]+ 50]]}]}})++(defn- make-test-provider-with-segments+ "Test provider that additionally serves the listed segments."+ [metric-metadata measure-metadata segments]+ (let [seg-by-id (into {} (map (juxt :id identity)) segments)]+ (reify lib.metadata.protocols/MetadataProvider+ (metadatas [_this metadata-spec]+ (case (:lib/type metadata-spec)+ :metadata/metric+ (if (contains? (:id metadata-spec) (:id metric-metadata))+ [metric-metadata]+ [])+ :metadata/measure+ (if (and measure-metadata (contains? (:id metadata-spec) (:id measure-metadata)))+ [measure-metadata]+ [])+ :metadata/segment+ (into [] (keep seg-by-id) (:id metadata-spec))+ (lib.metadata.protocols/metadatas meta/metadata-provider metadata-spec)))+ (database [_this]+ (lib.metadata.protocols/database meta/metadata-provider))+ (setting [_this setting-key]+ (lib.metadata.protocols/setting meta/metadata-provider setting-key)))))++(deftest ^:parallel from-definition-preserves-source-table-segment-test+ (testing "segment on the metric's source table is passed through as a raw :segment clause"+ (let [provider (make-test-provider-with-segments+ (sample-metric-metadata)+ (sample-measure-metadata)+ [(source-table-segment)])+ definition {:lib/type :metric/definition+ :expression [:metric {:lib/uuid expr-uuid} 42]+ :filters [{:lib/uuid expr-uuid+ :filter [:segment {:lib/uuid "22222222-0000-0000-0000-000000000001"} 600]}]+ :projections []+ :metadata-provider provider}+ ast (ast.build/from-definition definition)+ filter-node (get-in ast [:expression :ast :filter])]+ (testing "valid AST"+ (is (nil? (me/humanize (mr/explain ::ast.schema/ast ast)))))+ (testing "segment clause is passed through unchanged"+ (is (= :filter/mbql (:node/type filter-node)))+ (is (= :segment (first (:clause filter-node))))+ (is (= 600 (nth (:clause filter-node) 2)))))))diff --git a/test/metabase/lib_metric/filter_test.cljc b/test/metabase/lib_metric/filter_test.cljcindex 43b4dfe973e..1cacea0cbc4 100644--- a/test/metabase/lib_metric/filter_test.cljc+++ b/test/metabase/lib_metric/filter_test.cljc@@ -799,3 +799,88 @@;; All dimensions should have empty filter-positions(doseq [dim dims](is (= [] (:filter-positions dim)))))))++;;; -------------------------------------------------- available-segments --------------------------------------------------+;;; These tests cover the source-table-only behavior. Joined-table segment+;;; support lives in a follow-up PR (den/UXW-3754-segments-joined-tables).++(def ^:private seg-source-metric-1+ {:lib/type :metadata/metric, :id 1, :name "revenue", :display-name "Revenue", :table-id 10})++(def ^:private seg-source-metric-2+ {:lib/type :metadata/metric, :id 2, :name "orders", :display-name "Orders", :table-id 30})++(def ^:private seg-source-segment+ {:lib/type :metadata/segment, :id 100, :name "Big Orders", :table-id 10, :definition {}})++(def ^:private seg-joined-segment+ {:lib/type :metadata/segment, :id 200, :name "Active Users", :table-id 20, :definition {}})++(def ^:private seg-second-source-segment+ {:lib/type :metadata/segment, :id 300, :name "Live Widgets", :table-id 30, :definition {}})++(defn- seg-metric-fetcher [{:keys [id]}]+ (let [wanted (or id #{1 2})]+ (filterv #(contains? wanted (:id %)) [seg-source-metric-1 seg-source-metric-2])))++(defn- seg-segment-fetcher [{:keys [table-id]}]+ (case table-id+ 10 [seg-source-segment]+ 20 [seg-joined-segment]+ 30 [seg-second-source-segment]+ []))++(def ^:private seg-mock-provider+ (lib-metric.metadata.provider/metric-context-metadata-provider+ seg-metric-fetcher+ (constantly []) ; measure-fetcher-fn+ (constantly []) ; dimension-fetcher-fn+ seg-segment-fetcher ; segment-fetcher-fn+ (constantly nil) ; table->db-fn+ (constantly nil) ; db-provider-fn+ (constantly nil) ; setting-fn+ nil)) ; column-post-process-fn++(def ^:private seg-leaf-uuid-1 "550e8400-e29b-41d4-a716-446655440001")+(def ^:private seg-leaf-uuid-2 "550e8400-e29b-41d4-a716-446655440002")++(def ^:private seg-definition+ {:lib/type :metric/definition+ :expression [:metric {:lib/uuid seg-leaf-uuid-1} 1]+ :filters []+ :projections []+ :metadata-provider seg-mock-provider})++(deftest ^:parallel available-segments-returns-source-table-segments-test+ (testing "available-segments returns only segments on the metric's source table"+ (let [segments (lib-metric.filter/available-segments seg-definition)+ by-id (into {} (map (juxt :id identity)) segments)]+ (is (= #{100} (set (keys by-id)))+ "Only the source-table segment (100) is returned; joined-table segment (200) is not")+ (is (every? #(= seg-leaf-uuid-1 (:lib-metric/instance-uuid %)) segments)+ "All segments carry the expression leaf's instance-uuid"))))++(deftest ^:parallel available-segments-dedupes-by-id-test+ (testing "available-segments de-duplicates by :id when a segment surfaces for multiple leaves"+ (let [definition (assoc seg-definition+ :expression+ [:+ {:lib/uuid "cccccccc-0000-0000-0000-000000000001"}+ [:metric {:lib/uuid seg-leaf-uuid-1} 1]+ [:metric {:lib/uuid seg-leaf-uuid-2} 1]])+ segments (lib-metric.filter/available-segments definition)]+ (is (= 1 (count segments)))+ (is (= 100 (:id (first segments)))))))++(deftest ^:parallel available-segments-multi-leaf-expression-test+ (testing "available-segments over a multi-leaf expression returns each leaf's source-table segments"+ (let [definition (assoc seg-definition+ :expression+ [:+ {:lib/uuid "cccccccc-0000-0000-0000-000000000001"}+ [:metric {:lib/uuid seg-leaf-uuid-1} 1]+ [:metric {:lib/uuid seg-leaf-uuid-2} 2]])+ segments (lib-metric.filter/available-segments definition)+ by-id (into {} (map (juxt :id identity)) segments)]+ (is (= #{100 300} (set (keys by-id)))+ "Segments from each leaf's own source table are returned")+ (is (= seg-leaf-uuid-1 (:lib-metric/instance-uuid (by-id 100))))+ (is (= seg-leaf-uuid-2 (:lib-metric/instance-uuid (by-id 300)))))))