Skip to content

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

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.ts
index 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.ts
index 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.ts
index 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 =
| StringFilterParts
diff --git a/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx b/frontend/src/metabase/metrics-viewer/components/FilterPopover/FilterPopoverContent.tsx
index 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
+ <MetricGroupFilterSectionList
sections={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 ? (
<UnstyledButton
className={cx(S.accordionControl, {
- [S.accordionControlExpanded]: showDimensions,
+ [S.accordionControlExpanded]: showItems,
})}
onClick={() => onToggleExpanded(group.id)}
w="100%"
@@ -246,7 +236,7 @@ function MetricGroupList({
) : (
<Box
className={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
+ <MetricGroupFilterSectionList
sections={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.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.css
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
new file mode 100644
index 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.css
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.cljc
index 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] args
diff --git a/src/metabase/lib_metric/display_info.cljc b/src/metabase/lib_metric/display_info.cljc
index 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-info
diff --git a/src/metabase/lib_metric/filter.cljc b/src/metabase/lib_metric/filter.cljc
index 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-ref
diff --git a/src/metabase/lib_metric/js.cljs b/src/metabase/lib_metric/js.cljs
index 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-key
diff --git a/src/metabase/lib_metric/metadata/js.cljs b/src/metabase/lib_metric/metadata/js.cljs
index 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.cljc
index 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 metrics
measure-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-id
db-provider-fn ;; (fn [db-id] ...) returns MetadataProvider for that database
setting-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]
(->MetricContextMetadataProvider
metric-fetcher-fn
measure-fetcher-fn
dimension-fetcher-fn
+ segment-fetcher-fn
table->db-fn
db-provider-fn
setting-fn
diff --git a/test/metabase/lib_metric/ast/build_test.cljc b/test/metabase/lib_metric/ast/build_test.cljc
index 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.cljc
index 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)))))))