Skip to content

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

Fix transform self cycle (#81676)

Nicola Mometto1dfc2d1c903c
diff --git a/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts b/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
index ab10a6a3777..a3532b85b1c 100644
--- a/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
@@ -1388,20 +1388,48 @@ LIMIT
});
it("should not allow to overwrite an existing table when changing the target", () => {
+ cy.log("run a transform so its target table exists");
createMbqlTransform({ visitTransform: true });
+ H.DataStudio.Transforms.runTab().click();
+ runTransformAndWaitForSuccess();
- cy.log("change the target to an existing table");
+ cy.log("change another transform's target to that table");
+ createMbqlTransform({
+ name: "Other transform",
+ targetTable: TARGET_TABLE_2,
+ visitTransform: true,
+ });
H.DataStudio.Transforms.settingsTab().click();
getTransformsTargetContent().button("Change target").click();
H.modal().within(() => {
- cy.findByLabelText("New table name").clear().type(SOURCE_TABLE);
+ cy.findByLabelText("New table name").clear().type(TARGET_TABLE);
cy.button("Change target").click();
- cy.wait("@updateTransform");
+ cy.wait("@updateTransform")
+ .its("response.statusCode")
+ .should("eq", 403);
cy.findByText("A table with that name already exists.").should(
"be.visible",
);
});
});
+
+ it("should not allow to change the target to one of the source tables", () => {
+ createMbqlTransform({ visitTransform: true });
+
+ cy.log("change the target to the source table");
+ H.DataStudio.Transforms.settingsTab().click();
+ getTransformsTargetContent().button("Change target").click();
+ H.modal().within(() => {
+ cy.findByLabelText("New table name").clear().type(SOURCE_TABLE);
+ cy.button("Change target").click();
+ cy.wait("@updateTransform")
+ .its("response.statusCode")
+ .should("eq", 400);
+ cy.findByText(/Cyclic transform definitions detected/).should(
+ "be.visible",
+ );
+ });
+ });
});
describe("metadata", () => {
diff --git a/src/metabase/transforms_base/db.clj b/src/metabase/transforms_base/db.clj
index be3017f682c..16a301a882b 100644
--- a/src/metabase/transforms_base/db.clj
+++ b/src/metabase/transforms_base/db.clj
@@ -10,9 +10,11 @@
(t2/select-one-fn :source [:model/Transform :id :source] transform-id))
(defn transforms-for-ordering
- "The id, name, target, target Table id, source Database id, and table dependencies of every Transform."
- []
- (t2/select [:model/Transform :id :name :target :target_table_id :source_database_id :table_dependencies]))
+ "The id, name, target, target Table id, source Database id, and table dependencies of every Transform
+ excluding [[transform-id]]."
+ [transform-id]
+ (t2/select [:model/Transform :id :name :target :target_table_id :source_database_id :table_dependencies]
+ :id [:not= transform-id]))
(defn transform
"The Transform with `transform-id`, or nil."
diff --git a/src/metabase/transforms_base/ordering.clj b/src/metabase/transforms_base/ordering.clj
index 6d456263da8..63e36a302d9 100644
--- a/src/metabase/transforms_base/ordering.clj
+++ b/src/metabase/transforms_base/ordering.clj
@@ -247,14 +247,17 @@
"
[{transform-id :id :as to-check}]
(let [db-id (get-in to-check [:source :query :database])
- ;; Recompute the transform under test live — its source may have just changed, so any stored
- ;; deps are stale — and pin its source db. Every other transform uses its stored deps.
- to-check (-> to-check (assoc :source_database_id db-id) (dissoc :table_dependencies))
- transforms (map (fn [{:keys [id] :as transform}]
- (if (= id transform-id)
- to-check
- transform))
- (transforms-base.db/transforms-for-ordering))
+ ;; Recompute the transform under test live — its source or target may have just changed, so the
+ ;; stored deps and `target_table_id` are stale — and pin its source db. Every other transform
+ ;; uses its stored values.
+ to-check (-> to-check
+ (assoc :source_database_id db-id
+ :target_table_id (when-let [db-id (transforms-base.i/target-db-id to-check)]
+ (let [{:keys [schema name]} (:target to-check)]
+ (:id (transforms-base.db/target-table db-id schema name :active true)))))
+ (dissoc :table_dependencies))
+ transforms (conj (vec (transforms-base.db/transforms-for-ordering transform-id))
+ to-check)
transforms-by-id (into {}
(map (juxt :id identity))
transforms)
diff --git a/test/metabase/transforms_base/ordering_test.clj b/test/metabase/transforms_base/ordering_test.clj
index 714f80e19a8..08439cc8dd4 100644
--- a/test/metabase/transforms_base/ordering_test.clj
+++ b/test/metabase/transforms_base/ordering_test.clj
@@ -370,6 +370,53 @@
:cycle [t1 t3 t2]}
(ordering/get-transform-cycle (t2/select-one :model/Transform :id t1)))))))
+(deftest get-transform-cycle-live-target-test
+ (testing "the transform under test resolves its target live, not from a stale target_table_id"
+ (mt/with-temp [:model/Table {table1 :id} {:schema (default-schema-or-public), :name "table_1"}
+ :model/Field _ {:table_id table1
+ :name "foo"}
+ :model/Table {table2 :id} {:schema (default-schema-or-public), :name "table_2"}
+ :model/Transform {t1 :id} (-> (make-transform
+ {:database (mt/id),
+ :type "query",
+ :query {:source-table table1}}
+ "table_2")
+ (assoc :target_table_id table2))]
+ (let [transform (t2/select-one :model/Transform :id t1)]
+ (is (nil? (ordering/get-transform-cycle transform)))
+ (testing "retargeting onto its own source table is a self-cycle"
+ (is (= {:cycle-str "transform_table_2"
+ :cycle [t1]}
+ (ordering/get-transform-cycle (assoc-in transform [:target :name] "table_1")))))))))
+
+(deftest get-transform-cycle-target-collision-test
+ (testing "retargeting onto another transform's output table that we also read from is a self-cycle"
+ (mt/with-temp [:model/Table {table1 :id} {:schema (default-schema-or-public), :name "table_1"}
+ :model/Field _ {:table_id table1
+ :name "foo"}
+ :model/Table {table2 :id} {:schema (default-schema-or-public), :name "table_2"}
+ :model/Field _ {:table_id table2
+ :name "foo"}
+ :model/Table {table3 :id} {:schema (default-schema-or-public), :name "table_3"}
+ :model/Transform _ (-> (make-transform
+ {:database (mt/id),
+ :type "query",
+ :query {:source-table table1}}
+ "table_2")
+ (assoc :target_table_id table2))
+ :model/Transform {t2 :id} (-> (make-transform
+ {:database (mt/id),
+ :type "query",
+ :query {:source-table table2}}
+ "table_3")
+ (assoc :target_table_id table3))]
+ (let [transform (t2/select-one :model/Transform :id t2)]
+ (is (nil? (ordering/get-transform-cycle transform)))
+ ;; both transforms now resolve to table_2; the one under test must win regardless of select order
+ (is (= {:cycle-str "transform_table_3"
+ :cycle [t2]}
+ (ordering/get-transform-cycle (assoc-in transform [:target :name] "table_2"))))))))
+
;;; --------------------------------------- Precomputed table_dependencies ---------------------------------------
;;; These exercise the read side in isolation (no driver / SQL parser): transforms carry their deps in the
;;; `:table_dependencies` key the way the appdb column supplies them.