The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
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.jsindex 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.tsindex 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| QuickFilterDrillThruInfodiff --git a/frontend/src/metabase/querying/drills/utils/query-drill.ts b/frontend/src/metabase/querying/drills/utils/query-drill.tsindex 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.tsnew file mode 100644index 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.tsindex 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 objectsif (- 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.tsnew file mode 100644index 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.cljcindex 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/querystage-number :- :int@@ -135,35 +142,43 @@column-ref :- ::lib.schema.ref/refvalue :- :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.cljcindex 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))