Skip to content

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

[dashboards] Handle parallel FKs with dashboard filter values (#66287)

Braden Shepherdson478607669248
diff --git a/src/metabase/parameters/chain_filter.clj b/src/metabase/parameters/chain_filter.clj
index 5aae77763c5..d1673bdeac0 100644
--- a/src/metabase/parameters/chain_filter.clj
+++ b/src/metabase/parameters/chain_filter.clj
@@ -223,17 +223,20 @@
[:not= :fk-field.fk_target_field_id nil]
:fk-field.active]
:order-by [[:fk-field.id :desc]
- [:pk-field.id :desc]]})]
- (reduce
- (partial merge-with merge)
- {}
- (for [{:keys [t1 f1 t2 f2]} rows]
- (merge
- {t1 {t2 [{:lhs {:table t1, :field f1}, :rhs {:table t2, :field f2}}]}}
- (let [reverse-join {:lhs {:table t2, :field f2}, :rhs {:table t1, :field f1}}]
- (if enable-reverse-joins?
- {t2 {t1 [reverse-join]}}
- (log/tracef "Not including reverse join (disabled) %s" (format-join-for-logging reverse-join)))))))))
+ [:pk-field.id :desc]]})
+ joins (for [{:keys [t1 f1 t2 f2]} rows]
+ {:lhs {:table t1, :field f1}
+ :rhs {:table t2, :field f2}})
+ reversed (map (fn [{:keys [lhs rhs]}]
+ {:lhs rhs, :rhs lhs})
+ joins)
+ joins (if enable-reverse-joins?
+ (concat joins reversed)
+ (do (doseq [rev-join reversed]
+ (log/tracef "Not including reverse join (disabled) %s" (format-join-for-logging rev-join)))
+ joins))]
+ (-> (group-by (comp :table :lhs) joins) ; Outer grouping: LHS table ID
+ (update-vals #(group-by (comp :table :rhs) %))))) ; Inner grouping: RHS table ID
(def ^:private ^{:arglists '([database-id enable-reverse-joins?])} database-fk-relationships
"Return a sequence of FK relationships that exist in a database, in the format
@@ -288,6 +291,8 @@
;;
;; the general idea here is to see if LHS can join directly against RHS, otherwise recursively try all of the
;; tables LHS can join against and see if we can find a path that way.
+ ;; TODO: (bshepherdson 2025/11/25) This bespoke graph construction and traversal would be better migrated to
+ ;; use `metabase.graph.core`.
(u/prog1 (traverse-graph fk-relationships source-table-id other-table-id max-traversal-depth)
(when (seq <>)
(log/tracef (format-joins-for-logging <>))))))
@@ -295,7 +300,10 @@
(def ^:private ^{:arglists '([database-id source-table-id other-table-id]
[database-id source-table-id other-table-id enable-reverse-joins?])} find-joins
"Find the joins that must be done to make fields in Table with `other-table-id` accessible in a query whose
- primary (source) Table is the Table with `source-table-id`. Information about joins is returned in the format
+ primary (source) Table is the Table with `source-table-id`. Note that if there are multiple FKs for a particular
+ link between two tables, both will be returned as possible joins.
+
+ Information about joins is returned in the format:
[{:lhs {:table <id>, :field <id>}, :rhs {table <id>, :field <id>}}
...]
@@ -330,11 +338,11 @@
(f database-id source-table-id other-table-id enable-reverse-joins?)))
(meta f))))
-(def ^:private ^{:arglists '([source-table other-table-ids enable-reverse-joins?])} find-all-joins*
+(def ^:private ^{:arglists '([source-table field-ids other-table-ids enable-reverse-joins?])} find-all-joins*
(memoize/ttl
- ^{::memoize/args-fn (fn [[source-table-id other-table-ids enable-reverse-joins?]]
- [(mdb/unique-identifier) source-table-id other-table-ids enable-reverse-joins?])}
- (fn [source-table-id other-table-ids enable-reverse-joins?]
+ ^{::memoize/args-fn (fn [[source-table-id field-ids other-table-ids enable-reverse-joins?]]
+ [(mdb/unique-identifier) source-table-id field-ids other-table-ids enable-reverse-joins?])}
+ (fn [source-table-id field-ids other-table-ids enable-reverse-joins?]
(let [db-id (database/table-id->database-id source-table-id)
all-joins (mapcat #(find-joins db-id source-table-id % enable-reverse-joins?)
other-table-ids)]
@@ -344,7 +352,7 @@
(str/join ", " (map (partial name-for-logging :model/Table)
other-table-ids))
(format-joins-for-logging all-joins))
- (u/prog1 (vec (dedupe/dedupe-joins source-table-id all-joins other-table-ids))
+ (u/prog1 (vec (dedupe/dedupe-joins source-table-id field-ids all-joins other-table-ids))
(when-not (= all-joins <>)
(log/tracef "Deduplicated:\n%s" (format-joins-for-logging <>)))))))
:ttl/threshold find-joins-cache-duration-ms))
@@ -355,7 +363,7 @@
field-ids :- [:set ::lib.schema.id/field]]
(when-let [other-table-ids (not-empty (disj (set (map field/field-id->table-id (set field-ids)))
source-table-id))]
- (find-all-joins* source-table-id other-table-ids *enable-reverse-joins*)))
+ (find-all-joins* source-table-id field-ids other-table-ids *enable-reverse-joins*)))
(mu/defn- add-joins :- ::lib.schema/query
"Add joins to the MBQL `query` we're generating. The Field for which we are returning values is the \"source Field\",
diff --git a/src/metabase/parameters/chain_filter/dedupe_joins.clj b/src/metabase/parameters/chain_filter/dedupe_joins.clj
index 6bd3f6f923e..767e1a51608 100644
--- a/src/metabase/parameters/chain_filter/dedupe_joins.clj
+++ b/src/metabase/parameters/chain_filter/dedupe_joins.clj
@@ -1,7 +1,7 @@
(ns metabase.parameters.chain-filter.dedupe-joins
(:require
[clojure.set :as set]
- [medley.core :as m]))
+ [metabase.util.log :as log]))
(def ^:private source-node (comp :table :lhs))
@@ -58,19 +58,46 @@
(let [next-node (node-fn edge)]
(recur (cons next-node nodes) (conj result next-node))))))))
+(defn- prefer-requested-fks
+ "Sometimes when trying to find a chain of joins between two requested tables, there are multiple FKs which point
+ between them. These create parallel edges in the graph of joins, and we need to choose one. This function groups
+ edges by their source and target, keeps any single edges, and tries to disambiguate using the input set of preferred
+ field IDs.
+
+ If they cannot be disambiguated (either because multiple FKs are preferred, or none are) then log quietly and choose
+ one arbitrarily."
+ [preferred-fk-ids edges]
+ (if (= (count edges) 1)
+ (first edges)
+ (let [preferred (filter (fn [{{lhs-field :field} :lhs
+ {rhs-field :field} :rhs}]
+ (or (preferred-fk-ids lhs-field)
+ (preferred-fk-ids rhs-field)))
+ edges)]
+ (case (count preferred)
+ 1 (first preferred)
+ (do (log/debugf "Could not choose between multiple FKs for a chain filters join. %d edges, %d preferred"
+ (count edges)
+ (count preferred))
+ (or (first preferred)
+ (first edges)))))))
+
(defn dedupe-joins
"Remove unnecessary joins from a collection of `in-joins`.
`keep-ids` = the IDs of Tables that we want to keep joins for. Joins that are not needed to keep these Tables may be
removed.
+ `field-ids` = FKs we prefer - where there are parallel edges, we expect exactly one of them to be in this set.
Note that this function implements a simple greedy algorithm, replacing the previous optimal, but exponential
implementation."
- [source-id in-joins keep-ids]
- (let [;; get rid of parallel edges, for our purposes they are equivalent
- edges (m/distinct-by edge-nodes in-joins)
+ [source-id field-ids in-joins keep-ids]
+ (let [;; Group up any parallel edges, and choose one from each group. Prefer the input `field-ids`.
+ edges (-> (group-by edge-nodes in-joins)
+ (update-vals #(prefer-requested-fks field-ids %))
+ vals)
out-edges (group-by source-node edges)
- in-edges (group-by target-node edges)
+ in-edges (group-by target-node edges)
;; Collect the IDs that must be included either way to prefer them
;; during the construction of the tree.
transitive-keep-ids (forced-nodes source-node keep-ids in-edges)
diff --git a/test/metabase/parameters/chain_filter/dedupe_joins_test.clj b/test/metabase/parameters/chain_filter/dedupe_joins_test.clj
index 8fa96580858..0f55db2ff1a 100644
--- a/test/metabase/parameters/chain_filter/dedupe_joins_test.clj
+++ b/test/metabase/parameters/chain_filter/dedupe_joins_test.clj
@@ -12,7 +12,7 @@
([joins start-id keep-ids]
(map (juxt (comp :table :lhs) (comp :table :rhs))
(dedupe/dedupe-joins
- start-id
+ start-id #{}
(for [[lhs rhs] joins]
{:lhs {:table lhs}, :rhs {:table rhs}})
keep-ids))))
@@ -75,8 +75,8 @@
(testing "Node 3 is omitted from the above graph."
(is (= [[0 1]
[1 2] [2 5] [5 6]
- [5 4] [4 8] [8 9]
- [4 7]]
+ [5 4] [4 8] [4 7]
+ [8 9]]
(dedupe-joins
[[0 1]
[1 3] [3 4] [4 7]
@@ -114,7 +114,7 @@
{:lhs {:table 30, :field 334}, :rhs {:table 38, :field 399}}
{:lhs {:table 30, :field 333}, :rhs {:table 37, :field 396}}]
result
- (dedupe/dedupe-joins 24 in-joins #{32 40 28 38 37})]
+ (dedupe/dedupe-joins 24 #{} in-joins #{32 40 28 38 37})]
(is (= (first expected)
(first result)))
(is (= (-> expected rest set)
diff --git a/test/metabase/parameters/chain_filter_test.clj b/test/metabase/parameters/chain_filter_test.clj
index d33a540ba49..6ab99d11f29 100644
--- a/test/metabase/parameters/chain_filter_test.clj
+++ b/test/metabase/parameters/chain_filter_test.clj
@@ -808,19 +808,32 @@
(#'chain-filter/find-joins* a b c false))
([a b c d]
(#'chain-filter/find-joins* a b c d)))]
- (testing "receiver_id is active and should be used for the join"
+ (testing "with both FKs active, both are returned"
(is (= [{:lhs {:table $$messages, :field %messages.receiver_id}
+ :rhs {:table $$users, :field %users.id}}
+ {:lhs {:table $$messages, :field %messages.sender_id}
:rhs {:table $$users, :field %users.id}}]
- (#'chain-filter/find-joins (mt/id) $$messages $$users))))
+ (->> (#'chain-filter/find-joins (mt/id) $$messages $$users)
+ (sort-by (comp :field :lhs))))))
(try
(t2/update! :model/Field {:id %messages.receiver_id} {:active false})
- (testing "check that it switches to sender once receiver is inactive"
+ (testing "check that it switches to sender only once receiver is inactive"
(is (= [{:lhs {:table $$messages, :field %messages.sender_id}
:rhs {:table $$users, :field %users.id}}]
(#'chain-filter/find-joins (mt/id) $$messages $$users))))
(finally
(t2/update! :model/Field {:id %messages.receiver_id} {:active true})))
+
+ (try
+ (t2/update! :model/Field {:id %messages.sender_id} {:active false})
+ (testing "check that it switches to receiver only once sender is inactive"
+ (is (= [{:lhs {:table $$messages, :field %messages.receiver_id}
+ :rhs {:table $$users, :field %users.id}}]
+ (#'chain-filter/find-joins (mt/id) $$messages $$users))))
+ (finally
+ (t2/update! :model/Field {:id %messages.sender_id} {:active true})))
+
;; mark field
(t2/update! :model/Field {:id %users.id} {:active false})
(testing "there are no connections when PK is inactive"
diff --git a/test/metabase/parameters/dashboard_test.clj b/test/metabase/parameters/dashboard_test.clj
index 8e2d2934d9b..a128c85e262 100644
--- a/test/metabase/parameters/dashboard_test.clj
+++ b/test/metabase/parameters/dashboard_test.clj
@@ -182,6 +182,47 @@
(parameters.dashboard/dashboard-param-remapped-value dashboard (:id parameter) 1))
"Querying fails due to insufficient permissions")))))))))))))))
+(deftest ^:sequential dashboard-remapping-parallel-fks-test
+ (testing "two FKs to the same table, same remap, but pointing to different rows (#65838)"
+ (testing "always shows parameter values using the correct FK"
+ ;; Before this bug was fixed, the logic chose a parallel edge at random, so one of the two parameter bindings
+ ;; below would fail.
+ (mt/dataset avian-singles
+ (let [sender-id (mt/id :messages :sender_id)
+ receiver-id (mt/id :messages :receiver_id)]
+ ;; Create dashboard with parameter mapped to *one* field.
+ ;; Alternate between this a few times to be sure none of the ad-hoc caching in `chain-filter`
+ ;; is reusing something it shouldn't!
+ (doseq [filter-fk [sender-id receiver-id sender-id receiver-id]]
+ (mt/with-temp [:model/Card {messages-card-id :id} {:dataset_query (mt/mbql-query messages)}
+ :model/Dashboard {dashboard-id :id} {:parameters [{:id "p1"
+ :name "Squawker"
+ :slug "p1"
+ :type "id"
+ :sectionId "id"
+ :default 1}]}
+ :model/DashboardCard {} {:dashboard_id dashboard-id
+ :card_id messages-card-id
+ :parameter_mappings
+ [{:card_id messages-card-id
+ :parameter_id "p1"
+ :target ["dimension" ["field" filter-fk nil]]}]}]
+ (mt/with-column-remappings [messages.sender_id users.name
+ messages.receiver_id users.name]
+ (binding [api/*current-user-id* (mt/user->id :rasta)]
+ (let [dashboard (t2/select-one :model/Dashboard :id dashboard-id)
+ parameter (first (:parameters dashboard))]
+ ;; Mimicks the API endpoint (required):
+ (binding [qp.perms/*param-values-query* true]
+ ;; Important to check all the mappings here because sometimes they match up by coincidence
+ ;; and pass even when the bug is still present.
+ (let [expected (into {} (mt/rows (mt/process-query (mt/mbql-query users))))
+ actual (into {} (map (fn [id]
+ (parameters.dashboard/dashboard-param-remapped-value
+ dashboard (:id parameter) id)))
+ (keys expected))]
+ (is (= expected actual))))))))))))))
+
(deftest ^:sequential dashboard-remapping-conflict-scenarios-test
;; Test various scenarios where FK1, FK2, and PK have different remapping configurations.
;; This tests the logic in find-common-remapping-target and documents that it was