Skip to content

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

Look up long display-name from previous stages (#77230)

metamben911c0ef81626
diff --git a/src/metabase/lib/fe_util.cljc b/src/metabase/lib/fe_util.cljc
index 58837a15531..0ddae3e91d9 100644
--- a/src/metabase/lib/fe_util.cljc
+++ b/src/metabase/lib/fe_util.cljc
@@ -140,10 +140,43 @@
query stage-number (cond-> clause
(expandable-temporal-expression? clause) expand-temporal-expression)))
+(defn- composite-clause-in-stages-0-to?
+ "True when any stage 0..`max-stage` contains an `:aggregation` or `:expressions` clause with
+ `:lib/uuid = target-uuid`. Searched latest-first since the originating aggregation is usually close to the
+ current stage."
+ [query max-stage target-uuid]
+ (loop [stage-number max-stage]
+ (cond
+ (neg? stage-number) false
+ (let [stage (lib.util/query-stage query stage-number)]
+ (some (fn [clause] (= (lib.options/uuid clause) target-uuid))
+ (concat (:aggregation stage) (:expressions stage)))) true
+ :else (recur (dec stage-number)))))
+
+(defn- restore-previous-stage-source-uuid
+ "Nominal `:field` refs into a previous stage lose the connection to their originating aggregation/expression
+ clause because `resolve-field-ref` overwrites `:lib/source-uuid` with the ref's own uuid. That breaks the
+ `:long` display-name traceback in [[metabase.lib.field]] (source-uuid → source clause), so two same-named
+ aggregations from different joins render identically (#76986). For expression-parts consumers we recover the
+ link: look up the previous-stage returned column by `:lib/deduplicated-name` and copy its `:lib/source-uuid`
+ onto the resolved col — but only when that uuid points at a composite (aggregation/expression) clause
+ somewhere upstream. Scoped to expression-parts; a broader display-name-level fix has a wider blast radius and
+ is deferred to the Column Heritage effort."
+ [query stage-number col]
+ (or (when-let [previous-stage-number (lib.util/previous-stage-number query stage-number)]
+ (when-let [dedup-name (:lib/deduplicated-name col)]
+ (when-let [prev-col (m/find-first #(= (:lib/deduplicated-name %) dedup-name)
+ (lib.metadata.calculation/returned-columns query previous-stage-number))]
+ (when-let [prev-source-uuid (:lib/source-uuid prev-col)]
+ (when (composite-clause-in-stages-0-to? query previous-stage-number prev-source-uuid)
+ (assoc col :lib/source-uuid prev-source-uuid))))))
+ col))
+
(defmethod expression-parts-method :field
[query stage-number field-ref]
(let [stripped-ref (lib.options/update-options field-ref #(dissoc % :lib/expression-name))]
- (column-metadata-from-ref query stage-number stripped-ref)))
+ (->> (column-metadata-from-ref query stage-number stripped-ref)
+ (restore-previous-stage-source-uuid query stage-number))))
(defmethod expression-parts-method :segment
[query _stage-number segment-ref]
diff --git a/test/metabase/lib/fe_util_test.cljc b/test/metabase/lib/fe_util_test.cljc
index 5ac8eb461f7..c9df628a706 100644
--- a/test/metabase/lib/fe_util_test.cljc
+++ b/test/metabase/lib/fe_util_test.cljc
@@ -13,6 +13,7 @@
[metabase.lib.ref :as lib.ref]
[metabase.lib.test-metadata :as meta]
[metabase.lib.test-util :as lib.tu]
+ [metabase.lib.test-util.notebook-helpers :as lib.tu.notebook]
[metabase.util.malli :as mu]
[metabase.util.number :as u.number]
[metabase.util.time :as u.time]))
@@ -882,6 +883,34 @@
:lib/source-uuid string?}]}
(lib.fe-util/expression-parts query (second (lib/aggregations query)))))))
+(deftest ^:parallel expression-parts-preserves-join-disambiguation-test
+ (testing (str "same-named aggregations from different joins keep their disambiguated long display names "
+ "when their :field refs are read back via expression-parts (#76986)")
+ (let [q0 (-> (lib/query meta/metadata-provider (meta/table-metadata :orders))
+ (lib/join (lib/join-clause (meta/table-metadata :products)
+ [(lib/= (meta/field-metadata :orders :product-id)
+ (meta/field-metadata :products :id))])))
+ orders-id (lib.tu.notebook/find-col-with-spec
+ q0 (lib/orderable-columns q0) {:is-main-group true} {:display-name "ID"})
+ products-id (lib.tu.notebook/find-col-with-spec
+ q0 (lib/orderable-columns q0) {:display-name "Products"} {:display-name "ID"})
+ q1 (-> q0
+ (lib/aggregate (lib/distinct orders-id))
+ (lib/aggregate (lib/distinct products-id))
+ lib/append-stage)
+ agg1 (lib.tu.notebook/find-col-with-spec
+ q1 (lib/expressionable-columns q1 1 nil)
+ {:is-main-group true} {:long-display-name "Distinct values of ID"})
+ agg2 (lib.tu.notebook/find-col-with-spec
+ q1 (lib/expressionable-columns q1 1 nil)
+ {:is-main-group true} {:long-display-name "Distinct values of Products → ID"})
+ q2 (lib/expression q1 1 "diff" (lib/- agg2 agg1))
+ expr (first (lib/expressions q2 1))
+ parts (lib.fe-util/expression-parts q2 1 expr)]
+ (is (= ["Distinct values of Products → ID" "Distinct values of ID"]
+ (mapv #(:long-display-name (lib/display-info q2 1 %))
+ (:args parts)))))))
+
(deftest ^:parallel join-condition-clause-test
(let [lhs (lib/ref (meta/field-metadata :orders :product-id))
rhs (lib/ref (meta/field-metadata :products :id))]