Skip to content

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

Fix pie chart Other slice drill-through (#75938)

Anderson4cc540400eb7
diff --git a/e2e/test/scenarios/visualizations-tabular/drillthroughs/chart_drill.cy.spec.js b/e2e/test/scenarios/visualizations-tabular/drillthroughs/chart_drill.cy.spec.js
index 872de69bb71..bb459331555 100644
--- a/e2e/test/scenarios/visualizations-tabular/drillthroughs/chart_drill.cy.spec.js
+++ b/e2e/test/scenarios/visualizations-tabular/drillthroughs/chart_drill.cy.spec.js
@@ -695,6 +695,48 @@ describe("scenarios > visualizations > drillthroughs > chart drill", () => {
cy.location("pathname").should("eq", "/question/42");
});
+ it("should only show the 'See these records' option for the 'Other' pie slice (metabase#5334)", () => {
+ H.visitQuestionAdhoc({
+ name: "5334",
+ dataset_query: {
+ database: SAMPLE_DB_ID,
+ query: {
+ "source-table": PRODUCTS_ID,
+ aggregation: [["count"]],
+ breakout: [
+ ["field", PRODUCTS.CATEGORY, { "base-type": "type/Text" }],
+ ],
+ },
+ type: "query",
+ },
+ display: "pie",
+ visualization_settings: {
+ "pie.dimension": "CATEGORY",
+ "pie.metric": "count",
+ "pie.slice_threshold": 26,
+ },
+ });
+
+ H.pieSlices()
+ .filter("[fill^='hsla']")
+ .then(($slice) => {
+ const { height } = $slice[0].getBoundingClientRect();
+
+ cy.wrap($slice).realClick({
+ x: 30,
+ y: height / 2,
+ scrollBehavior: false,
+ });
+ });
+
+ H.popover().within(() => {
+ cy.findByTestId("click-actions-view").within(() => {
+ cy.findByText("See these Products").should("be.visible");
+ cy.findAllByRole("button").should("have.length", 1);
+ });
+ });
+ });
+
describe("for an unsaved question", () => {
beforeEach(() => {
const questionDetails = {
diff --git a/frontend/src/metabase-lib/query/types.ts b/frontend/src/metabase-lib/query/types.ts
index e8261c7c00c..e0b66395539 100644
--- a/frontend/src/metabase-lib/query/types.ts
+++ b/frontend/src/metabase-lib/query/types.ts
@@ -457,6 +457,9 @@ export type DrillThruType =
export type BaseDrillThruInfo<Type extends DrillThruType> = { type: Type };
+export type AutomaticInsightsDrillThruInfo =
+ BaseDrillThruInfo<"drill-thru/automatic-insights">;
+
declare const ColumnExtractionSymbol: unique symbol;
export type ColumnExtraction = unknown & {
_opaque: typeof ColumnExtractionSymbol;
@@ -545,6 +548,7 @@ export type ZoomGeographicDrillThruInfo =
};
export type DrillThruDisplayInfo =
+ | AutomaticInsightsDrillThruInfo
| ColumnExtractDrillThruInfo
| CombineColumnsDrillThruInfo
| QuickFilterDrillThruInfo
diff --git a/frontend/src/metabase/querying/drills/utils/query-drill.ts b/frontend/src/metabase/querying/drills/utils/query-drill.ts
index 379eef403eb..54cd321e1ae 100644
--- a/frontend/src/metabase/querying/drills/utils/query-drill.ts
+++ b/frontend/src/metabase/querying/drills/utils/query-drill.ts
@@ -6,6 +6,22 @@ import type Question from "metabase-lib/v1/Question";
import { DRILLS } from "./constants";
+export function isGroupedDimensionClick(clicked: Lib.ClickObject) {
+ return (
+ clicked.dimensions?.some((dimension) => Array.isArray(dimension.value)) ??
+ false
+ );
+}
+
+export function shouldHideDrill(
+ drillInfo: DrillThruDisplayInfo,
+ clicked: Lib.ClickObject,
+) {
+ return isGroupedDimensionClick(clicked)
+ ? drillInfo.type !== "drill-thru/underlying-records"
+ : false;
+}
+
export function queryDrill(
question: Question,
clicked: Lib.ClickObject,
@@ -39,7 +55,11 @@ export function queryDrill(
const drillInfo = Lib.displayInfo(query, stageIndex, drill);
const drillHandler = DRILLS[drillInfo.type];
- if (!isDrillEnabled(drillInfo) || !drillHandler) {
+ if (
+ !isDrillEnabled(drillInfo) ||
+ !drillHandler ||
+ shouldHideDrill(drillInfo, clicked)
+ ) {
return null;
}
diff --git a/frontend/src/metabase/querying/drills/utils/query-drill.unit.spec.ts b/frontend/src/metabase/querying/drills/utils/query-drill.unit.spec.ts
new file mode 100644
index 00000000000..a80a6d0945e
--- /dev/null
+++ b/frontend/src/metabase/querying/drills/utils/query-drill.unit.spec.ts
@@ -0,0 +1,52 @@
+import type { ClickObject, DrillThruDisplayInfo } from "metabase-lib";
+import { createMockColumn } from "metabase-types/api/mocks";
+
+import { isGroupedDimensionClick, shouldHideDrill } from "./query-drill";
+
+const groupedDimensionClick: ClickObject = {
+ dimensions: [
+ {
+ column: createMockColumn(),
+ value: ["Gizmo", "Doohickey"],
+ },
+ ],
+};
+
+describe("isGroupedDimensionClick", () => {
+ it("detects clicks with grouped dimension values", () => {
+ expect(isGroupedDimensionClick(groupedDimensionClick)).toBe(true);
+ });
+
+ it("ignores clicks with regular dimension values", () => {
+ const clicked: ClickObject = {
+ dimensions: [
+ {
+ column: createMockColumn(),
+ value: "Gizmo",
+ },
+ ],
+ };
+
+ expect(isGroupedDimensionClick(clicked)).toBe(false);
+ });
+});
+
+describe("shouldHideDrill", () => {
+ it("keeps underlying records for grouped dimension clicks", () => {
+ const drillInfo: DrillThruDisplayInfo = {
+ type: "drill-thru/underlying-records",
+ rowCount: 2,
+ tableName: "Products",
+ };
+
+ expect(shouldHideDrill(drillInfo, groupedDimensionClick)).toBe(false);
+ });
+
+ it("hides other drills for grouped dimension clicks", () => {
+ const drillInfo: DrillThruDisplayInfo = {
+ type: "drill-thru/pivot",
+ };
+
+ expect(shouldHideDrill(drillInfo, groupedDimensionClick)).toBe(true);
+ });
+});
diff --git a/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.ts b/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.ts
index 21f95b19b0d..0c50c1ccf39 100644
--- a/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.ts
+++ b/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.ts
@@ -10,7 +10,10 @@ import type {
} from "metabase/visualizations/components/ChartTooltip/EChartsTooltip";
import { getTotalValue } from "metabase/visualizations/components/ChartTooltip/StackedDataTooltip/utils";
import type { PieChartFormatters } from "metabase/visualizations/echarts/pie/format";
-import type { PieChartModel } from "metabase/visualizations/echarts/pie/model/types";
+import type {
+ PieChartModel,
+ SliceTreeNode,
+} from "metabase/visualizations/echarts/pie/model/types";
import type { EChartsSunburstSeriesMouseEvent } from "metabase/visualizations/echarts/pie/types";
import {
getArrayFromMapValues,
@@ -27,6 +30,8 @@ import type {
VisualizationProps,
} from "metabase/visualizations/types";
import type { EChartsEventHandler } from "metabase/visualizations/types/echarts";
+import type { ClickObjectDimension } from "metabase-lib";
+import type { DatasetColumn, RowValue } from "metabase-types/api";
export const getTooltipModel = (
sliceKeyPath: string[],
@@ -113,6 +118,60 @@ function getHoverData(
};
}
+function getNodeColumnIndex(chartModel: PieChartModel, nodeIndex: number) {
+ return [
+ chartModel.colDescs.dimensionDesc.index,
+ chartModel.colDescs.middleDimensionDesc?.index,
+ chartModel.colDescs.outerDimensionDesc?.index,
+ ][nodeIndex];
+}
+
+function hasObjectDimensionValue(
+ node: SliceTreeNode,
+ nodeIndex: number,
+ row: VisualizationProps["data"]["rows"][number] | undefined,
+ dataProp: VisualizationProps["data"],
+ chartModel: PieChartModel,
+) {
+ const columnIndex = getNodeColumnIndex(chartModel, nodeIndex);
+
+ if (columnIndex == null) {
+ return false;
+ }
+
+ const values = node.isOther
+ ? getArrayFromMapValues(node.children)
+ .map((childNode) => childNode.rowIndex)
+ .filter((rowIndex) => rowIndex != null)
+ .map((rowIndex) => dataProp.rows[rowIndex]?.[columnIndex])
+ : [row?.[columnIndex]];
+
+ return values.some((value) => value != null && typeof value === "object");
+}
+
+function getOtherSliceDimensionValue(node: SliceTreeNode): RowValue {
+ return getArrayFromMapValues(node.children).map((childNode) =>
+ getValueFromDimensionKey(childNode.key),
+ );
+}
+
+function getDimensionColumn(node: SliceTreeNode): DatasetColumn {
+ return checkNotNull(
+ node.column ?? getArrayFromMapValues(node.children)[0]?.column,
+ );
+}
+
+function getClickObjectDimensions(
+ nodes: SliceTreeNode[],
+): ClickObjectDimension[] {
+ return nodes.map((node) => ({
+ value: node.isOther
+ ? getOtherSliceDimensionValue(node)
+ : getValueFromDimensionKey(node.key),
+ column: getDimensionColumn(node),
+ }));
+}
+
function handleClick(
event: EChartsSunburstSeriesMouseEvent,
dataProp: VisualizationProps["data"],
@@ -121,7 +180,7 @@ function handleClick(
onVisualizationClick: VisualizationProps["onVisualizationClick"],
chartModel: PieChartModel,
) {
- if (event.dataIndex == null) {
+ if (event.name == null) {
return;
}
@@ -130,24 +189,14 @@ function handleClick(
getSliceKeyPath(event),
);
- if (sliceTreeNode.isOther) {
- return;
- }
-
const rowIndex = sliceTreeNode.rowIndex;
const row = rowIndex != null ? dataProp.rows[rowIndex] : undefined;
// the underlying records filter doesn't support objects, so return early if any of the dimension values are objects
if (
- row &&
- [
- chartModel.colDescs.dimensionDesc.index,
- chartModel.colDescs.middleDimensionDesc?.index,
- chartModel.colDescs.outerDimensionDesc?.index,
- ]
- .filter((index) => index != null)
- .map((index) => row[index])
- .some((value) => value != null && typeof value === "object")
+ nodes.some((node, index) =>
+ hasObjectDimensionValue(node, index, row, dataProp, chartModel),
+ )
) {
return;
}
@@ -168,10 +217,7 @@ function handleClick(
value: sliceTreeNode.value,
column: chartModel.colDescs.metricDesc.column,
data,
- dimensions: nodes.map((node) => ({
- value: getValueFromDimensionKey(node.key),
- column: checkNotNull(node.column),
- })),
+ dimensions: getClickObjectDimensions(nodes),
settings,
event: event.event.event,
};
diff --git a/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.unit.spec.ts b/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.unit.spec.ts
new file mode 100644
index 00000000000..794f43fb1bb
--- /dev/null
+++ b/frontend/src/metabase/visualizations/visualizations/PieChart/use-chart-events.unit.spec.ts
@@ -0,0 +1,175 @@
+import { renderHook } from "@testing-library/react";
+import type { EChartsType } from "echarts/core";
+import type { MutableRefObject } from "react";
+
+import { OTHER_SLICE_KEY } from "metabase/visualizations/echarts/pie/constants";
+import type {
+ PieChartModel,
+ SliceTreeNode,
+} from "metabase/visualizations/echarts/pie/model/types";
+import type { VisualizationProps } from "metabase/visualizations/types";
+import type { ClickObject } from "metabase-lib";
+import {
+ createMockCard,
+ createMockColumn,
+ createMockDatasetData,
+ createMockSingleSeries,
+ createMockVisualizationSettings,
+} from "metabase-types/api/mocks";
+
+import { useChartEvents } from "./use-chart-events";
+
+const categoryColumn = createMockColumn({
+ name: "CATEGORY",
+ display_name: "Category",
+ base_type: "type/Text",
+});
+
+const countColumn = createMockColumn({
+ name: "count",
+ display_name: "Count",
+ base_type: "type/Integer",
+ semantic_type: "type/Quantity",
+});
+
+function createSliceNode(
+ key: string,
+ name: string,
+ rawValue: number,
+ rowIndex: number,
+): SliceTreeNode {
+ return {
+ key,
+ name,
+ value: rawValue,
+ rawValue,
+ normalizedPercentage: 0.5,
+ visible: true,
+ color: "",
+ startAngle: 0,
+ endAngle: 0,
+ children: new Map(),
+ column: categoryColumn,
+ rowIndex,
+ isOther: true,
+ };
+}
+
+function createChartModel(): PieChartModel {
+ const otherNode: SliceTreeNode = {
+ key: OTHER_SLICE_KEY,
+ name: "Other",
+ value: 93,
+ rawValue: 93,
+ normalizedPercentage: 0.465,
+ visible: true,
+ color: "",
+ startAngle: 0,
+ endAngle: 0,
+ children: new Map([
+ ["Gizmo", createSliceNode("Gizmo", "Gizmo", 51, 0)],
+ ["Doohickey", createSliceNode("Doohickey", "Doohickey", 42, 1)],
+ ]),
+ column: categoryColumn,
+ isOther: true,
+ includeInLegend: true,
+ legendHoverIndex: 2,
+ };
+
+ return {
+ sliceTree: new Map([[OTHER_SLICE_KEY, otherNode]]),
+ total: 200,
+ numRings: 1,
+ colDescs: {
+ metricDesc: { index: 1, column: countColumn },
+ dimensionDesc: { index: 0, column: categoryColumn },
+ },
+ };
+}
+
+function createVisualizationProps(
+ onVisualizationClick: (clickObject: ClickObject | null) => void,
+): VisualizationProps {
+ const card = createMockCard();
+ const data = createMockDatasetData({
+ rows: [
+ ["Gizmo", 51],
+ ["Doohickey", 42],
+ ],
+ cols: [categoryColumn, countColumn],
+ });
+ const series = createMockSingleSeries(card, { data });
+
+ return {
+ series: [series],
+ rawSeries: [series],
+ data,
+ card,
+ settings: createMockVisualizationSettings({
+ "pie.metric": "count",
+ "pie.dimension": ["CATEGORY"],
+ }),
+ fontFamily: "Lato",
+ isFullscreen: false,
+ isQueryBuilder: false,
+ isEmbeddingSdk: false,
+ showTitle: false,
+ isDashboard: false,
+ isDocument: false,
+ isVisualizer: false,
+ isVisualizerCard: false,
+ isEditing: false,
+ isMetricsViewer: false,
+ isMobile: false,
+ isSettings: false,
+ width: 500,
+ height: 300,
+ visualizationIsClickable: () => true,
+ onRender: () => undefined,
+ onRenderError: () => undefined,
+ onActionDismissal: () => undefined,
+ onHoverChange: () => undefined,
+ onVisualizationClick,
+ onUpdateVisualizationSettings: () => undefined,
+ dispatch: jest.fn(),
+ };
+}
+
+describe("useChartEvents", () => {
+ it("emits grouped dimensions when the Other slice is clicked (#5334)", () => {
+ const onVisualizationClick = jest.fn();
+ const chartRef: MutableRefObject<EChartsType | undefined> = {
+ current: undefined,
+ };
+
+ const { result } = renderHook(() =>
+ useChartEvents(
+ createVisualizationProps(onVisualizationClick),
+ chartRef,
+ createChartModel(),
+ ),
+ );
+
+ const clickHandler = result.current.find(
+ (handler) => handler.eventName === "click",
+ );
+
+ clickHandler?.handler({
+ name: OTHER_SLICE_KEY,
+ event: { event: new MouseEvent("click") },
+ });
+
+ expect(onVisualizationClick).toHaveBeenCalledWith(
+ expect.objectContaining({
+ value: 93,
+ column: countColumn,
+ dimensions: [
+ {
+ value: ["Gizmo", "Doohickey"],
+ column: categoryColumn,
+ },
+ ],
+ }),
+ );
+ });
+});
diff --git a/src/metabase/lib/drill_thru/underlying_records.cljc b/src/metabase/lib/drill_thru/underlying_records.cljc
index 3decd201a59..7e9c30db16f 100644
--- a/src/metabase/lib/drill_thru/underlying_records.cljc
+++ b/src/metabase/lib/drill_thru/underlying_records.cljc
@@ -28,7 +28,7 @@
Question transformation:
- Set display \"table\""
- (:refer-clojure :exclude [mapv empty? #?(:clj for)])
+ (:refer-clojure :exclude [mapv empty? not-empty #?(:clj for)])
(:require
[medley.core :as m]
[metabase.lib.aggregation :as lib.aggregation]
@@ -50,7 +50,7 @@
[metabase.lib.util :as lib.util]
[metabase.util :as u]
[metabase.util.malli :as mu]
- [metabase.util.performance :refer [mapv empty? #?(:clj for)]]))
+ [metabase.util.performance :refer [mapv empty? not-empty #?(:clj for)]]))
(mu/defn underlying-records-drill :- [:maybe ::lib.schema.drill-thru/drill-thru.underlying-records]
"When clicking on a particular broken-out group, offer a look at the details of all the rows that went into this
@@ -128,6 +128,13 @@
:row-count row-count
:table-name table-name})
+(defn- non-empty-seq [value]
+ #?(:clj (when (sequential? value)
+ (not-empty value))
+ :cljs (cond
+ (array? value) (not-empty (array-seq value))
+ (sequential? value) (not-empty value))))
+
(mu/defn- drill-filter :- ::lib.schema/query
[query :- ::lib.schema/query
stage-number :- :int
@@ -135,35 +142,43 @@
column-ref :- ::lib.schema.ref/ref
value :- :any]
(let [filter-column (lib.drill-thru.common/breakout->filterable-column query stage-number column-ref column)
- filter-clauses (or (when (lib.binning/binning column)
- (let [unbinned-column (-> filter-column
- (lib.binning/with-binning nil)
- (dissoc :lib/original-binning))]
- (if (some? value)
- (when-let [{:keys [min-value max-value]} (lib.binning/resolve-bin-width query column value)]
- [(lib.filter/>= unbinned-column min-value)
- (lib.filter/< unbinned-column max-value)])
- [(lib.filter/is-null unbinned-column)])))
- ;; if the column was temporally bucketed in the top level, make sure the `=` filter we
- ;; generate still has that bucket. Otherwise the filter will be something like
- ;;
- ;; col = March 2023
- ;;
- ;; instead of
- ;;
- ;; month(col) = March 2023
- (let [bucket (or (::lib.underlying/temporal-unit column)
- (lib.temporal-bucket/temporal-bucket column))
- unit (cond-> bucket
- (map? bucket) :unit)
- column (if unit
- (lib.temporal-bucket/with-temporal-bucket filter-column unit)
- filter-column)]
- (if (nil? value)
- [(lib.filter/is-null column)]
- [(cond-> (lib.filter/= column value)
- (and unit (lib.schema.temporal-bucketing/datetime-truncation-units unit))
- lib.fe-util/expand-temporal-expression)])))]
+ values (non-empty-seq value)
+ filter-clauses (or
+ (when (lib.binning/binning column)
+ (let [unbinned-column (-> filter-column
+ (lib.binning/with-binning nil)
+ (dissoc :lib/original-binning))]
+ (if (some? value)
+ (when-let [{:keys [min-value max-value]} (lib.binning/resolve-bin-width query column value)]
+ [(lib.filter/>= unbinned-column min-value)
+ (lib.filter/< unbinned-column max-value)])
+ [(lib.filter/is-null unbinned-column)])))
+ ;; if the column was temporally bucketed in the top level, make sure the `=` filter we
+ ;; generate still has that bucket. Otherwise the filter will be something like
+ ;;
+ ;; col = March 2023
+ ;;
+ ;; instead of
+ ;;
+ ;; month(col) = March 2023
+ (let [bucket (or (::lib.underlying/temporal-unit column)
+ (lib.temporal-bucket/temporal-bucket column))
+ unit (cond-> bucket
+ (map? bucket) :unit)
+ column (if unit
+ (lib.temporal-bucket/with-temporal-bucket filter-column unit)
+ filter-column)]
+ (cond
+ values
+ [(apply lib.filter/filter-clause :in column values)]
+
+ (nil? value)
+ [(lib.filter/is-null column)]
+
+ :else
+ [(cond-> (lib.filter/= column value)
+ (and unit (lib.schema.temporal-bucketing/datetime-truncation-units unit))
+ lib.fe-util/expand-temporal-expression)])))]
(reduce
(fn [query filter-clause]
(lib.filter/filter query stage-number filter-clause))
diff --git a/test/metabase/lib/drill_thru/underlying_records_test.cljc b/test/metabase/lib/drill_thru/underlying_records_test.cljc
index d79413ab61e..bea0c8ddc54 100644
--- a/test/metabase/lib/drill_thru/underlying_records_test.cljc
+++ b/test/metabase/lib/drill_thru/underlying_records_test.cljc
@@ -346,6 +346,28 @@
:fields (symbol "nil #_\"key is not present.\"")}]}
(lib.drill-thru/drill-thru query drill))))))
+(deftest ^:parallel chart-other-slice-click-test
+ (testing "chart clicks with grouped breakout values use an in filter (#5334)"
+ (let [query (-> (lib/query meta/metadata-provider (meta/table-metadata :orders))
+ (lib/aggregate (lib/count))
+ (lib/breakout (meta/field-metadata :products :category)))
+ cols (lib/returned-columns query)
+ category (lib.tu.notebook/find-col-with-spec query cols {} {:display-name "Category"})
+ context {:column nil
+ :column-ref nil
+ :value nil
+ :dimensions [{:column category
+ :column-ref (lib/ref category)
+ :value ["Gadget" "Doohickey"]}]}
+ drill (m/find-first #(= (:type %) :drill-thru/underlying-records)
+ (lib.drill-thru/available-drill-thrus query context))]
+ (is (=? {:lib/type :mbql/query
+ :stages [{:filters [[:in {} [:field {} (meta/id :products :category)] "Gadget" "Doohickey"]]
+ :aggregation (symbol "nil #_\"key is not present.\"")
+ :breakout (symbol "nil #_\"key is not present.\"")
+ :fields (symbol "nil #_\"key is not present.\"")}]}
+ (lib.drill-thru/drill-thru query drill))))))
+
(deftest ^:parallel preserve-temporal-bucket-test
(testing "preserve the temporal bucket on a breakout column in the previous stage (#13504 #36582)"
(let [base-query (-> (lib/query meta/metadata-provider (meta/table-metadata :orders))