Skip to content

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

Change `:template-tags` from a map to a list (#77133)

Cam Saule3791b88e874
diff --git a/enterprise/backend/src/metabase_enterprise/checker/semantic.clj b/enterprise/backend/src/metabase_enterprise/checker/semantic.clj
index 37017f7cb1e..9842d8f000f 100644
--- a/enterprise/backend/src/metabase_enterprise/checker/semantic.clj
+++ b/enterprise/backend/src/metabase_enterprise/checker/semantic.clj
@@ -441,8 +441,19 @@
(let [stages (get-in data [:dataset_query :stages])]
(reduce
(fn [acc stage]
- (let [;; Snippets from template-tags
- snippets (->> (vals (:template-tags stage))
+ (let [template-tags (:template-tags stage)
+ ;; TODO (Cam 2026-07-07) MEGA ICK - we have to copy the usual template tag normalization stuff (map =>
+ ;; list) done IN LIB here because this code is DOING ⚠⚠⚠ RAW MBQL INTROSPECTION OUTSIDE OF LIB ⚠⚠⚠ which
+ ;; means it has to handle both old and new shapes instead of letting Lib take care of that for us... who
+ ;; know what other shape variations this code doesn't handle correctly? (See GHY-4080)
+ template-tags (if (map? template-tags)
+ (into []
+ (map (fn [[tag-name tag]]
+ (assoc tag :name tag-name)))
+ template-tags)
+ template-tags)
+ ;; Snippets from template-tags
+ snippets (->> template-tags
(filter #(= "snippet" (get % :type)))
(keep :snippet-name))
;; Measures and metrics from aggregation clauses
diff --git a/enterprise/backend/src/metabase_enterprise/dependencies/native_validation.clj b/enterprise/backend/src/metabase_enterprise/dependencies/native_validation.clj
index a7cda391d65..65f7419305d 100644
--- a/enterprise/backend/src/metabase_enterprise/dependencies/native_validation.clj
+++ b/enterprise/backend/src/metabase_enterprise/dependencies/native_validation.clj
@@ -63,13 +63,13 @@
(let [stage (first (:stages query))
sql (:native stage)
ttags (:template-tags stage)
- card-tags (into {} (filter #(= (:type (val %)) :card)) ttags)
- table-tags (into {} (filter #(= (:type (val %)) :table)) ttags)]
+ card-tags (filter #(= (:type %) :card) ttags)
+ table-tags (filter #(= (:type %) :table) ttags)]
(when-not (or (str/includes? sql card-placeholder-prefix)
(str/includes? sql table-placeholder-prefix))
(let [;; Replace card tags
sql-after-cards
- (reduce (fn [s [tag-name tag]]
+ (reduce (fn [s {tag-name :name, :as tag}]
(str/replace s
(str "{{" tag-name "}}")
(str card-placeholder-prefix (:card-id tag))))
@@ -78,7 +78,7 @@
;; Replace table tags
modified-sql
- (reduce (fn [s [tag-name tag]]
+ (reduce (fn [s {tag-name :name, :as tag}]
(str/replace s
(str "{{" tag-name "}}")
(str table-placeholder-prefix (:table-id tag))))
@@ -86,7 +86,7 @@
table-tags)
remaining-tags
- (into {} (remove #(#{:card :table} (:type (val %)))) ttags)
+ (into [] (remove #(#{:card :table} (:type %))) ttags)
modified-query
(-> query
diff --git a/enterprise/backend/test/metabase_enterprise/serialization/v2/load_test.clj b/enterprise/backend/test/metabase_enterprise/serialization/v2/load_test.clj
index e64a8bb9e96..2c5db7237fb 100644
--- a/enterprise/backend/test/metabase_enterprise/serialization/v2/load_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/serialization/v2/load_test.clj
@@ -1326,7 +1326,7 @@
(testing "on extraction"
(reset! extracted (serdes/extract-one "Card" {} @card1s))
(is (=? {:stages [{:lib/type :mbql.stage/native
- :template-tags {"snippet: things" {:snippet-id (:entity_id @snippet1s)}}}]}
+ :template-tags [{:name "snippet: things", :snippet-id (:entity_id @snippet1s)}]}]}
(:dataset_query @extracted))))
(testing "when loading"
(let [new-eid (u/generate-nano-id)
diff --git a/src/metabase/legacy_mbql/schema.cljc b/src/metabase/legacy_mbql/schema.cljc
index 48f23b8ae6d..0e40bccd2de 100644
--- a/src/metabase/legacy_mbql/schema.cljc
+++ b/src/metabase/legacy_mbql/schema.cljc
@@ -1692,7 +1692,10 @@
Map of template tag name -> template tag definition"
[:and
- [:map-of ::lib.schema.common/non-blank-string [:ref ::TemplateTag]]
+ [:map-of
+ {:decode/normalize #'lib.schema.template-tag/normalize-template-tag-map}
+ ::lib.schema.common/non-blank-string
+ [:ref ::TemplateTag]]
[:ref ::lib.schema.template-tag/template-tag-map.validate-names]])
(defn- remove-empty-keys [m {:keys [non-empty-keys non-nil-keys]}]
diff --git a/src/metabase/lib/convert.cljc b/src/metabase/lib/convert.cljc
index 4eecd03060a..3e7beb48d25 100644
--- a/src/metabase/lib/convert.cljc
+++ b/src/metabase/lib/convert.cljc
@@ -763,10 +763,11 @@
query-type (if (-> query :stages last :lib/type (= :mbql.stage/native))
:native
:query)]
- (merge (dissoc base :stages :parameters :lib.convert/converted?)
- (cond-> {:type query-type}
- (seq inner-query) (assoc query-type inner-query)
- (seq parameters) (assoc :parameters parameters))))
+ (->> (merge (dissoc base :stages :parameters :lib.convert/converted?)
+ (cond-> {:type query-type}
+ (seq inner-query) (assoc query-type inner-query)
+ (seq parameters) (assoc :parameters parameters)))
+ (lib.normalize/normalize ::mbql.s/Query)))
(catch #?(:clj Throwable :cljs :default) e
(throw (ex-info (lib.util/format "Error converting MBQL 5 query to legacy MBQL query: %s" (ex-message e))
{:query query}
diff --git a/src/metabase/lib/fe_util.cljc b/src/metabase/lib/fe_util.cljc
index 6eccb57b92d..58837a15531 100644
--- a/src/metabase/lib/fe_util.cljc
+++ b/src/metabase/lib/fe_util.cljc
@@ -856,7 +856,7 @@
(when (= (:lib/type base-stage) :mbql.stage/native)
(concat
;; Extract field dependencies from dimension template tags
- (for [{tag-type :type, [dim-tag _opts id] :dimension} (vals (:template-tags base-stage))
+ (for [{tag-type :type, [dim-tag _opts id] :dimension} (:template-tags base-stage)
:when (and (= tag-type :dimension)
(= dim-tag :field)
(integer? id))]
@@ -872,7 +872,7 @@
(query-dependents-snippets metadata-providerable snippet-id #{})
;; If we don't have a real metadata provider, just return the direct dependency
[{:type :native-query-snippet, :id snippet-id}])))
- (vals (:template-tags base-stage)))))
+ (:template-tags base-stage))))
(when-let [card-id (:source-card base-stage)]
(let [card (lib.metadata/card metadata-providerable card-id)
definition (:dataset-query card)]
diff --git a/src/metabase/lib/js.cljs b/src/metabase/lib/js.cljs
index f1c3bfc2408..931bc038a9c 100644
--- a/src/metabase/lib/js.cljs
+++ b/src/metabase/lib/js.cljs
@@ -2000,37 +2000,48 @@
(defn- remove-undefined-properties
[obj]
(cond-> obj
- (object? obj) (gobject/filter (fn [e _ _] (not (undefined? e))))))
+ (object? obj) (gobject/filter (fn [v _k _object] (not (undefined? v))))))
(defn- template-tags-js->cljs
- [tags]
- (-> tags
- (gobject/map (fn [e _ _]
- (remove-undefined-properties e)))
- js->clj
- (update-vals (fn [tag]
- (-> tag
- (perf/update-keys keyword)
- (update :type keyword)
- (m/update-existing :widget-type #(some-> % keyword))
- (m/update-existing :dimension #(some-> % legacy-ref->mbql5)))))))
+ "Convert a JavaScript Object containing template `tags` to a ClojureScript sequence."
+ [tags-object]
+ (perf/mapv (fn [tag-name]
+ (let [tag-object (gobject/get tags-object tag-name)]
+ (-> tag-object
+ remove-undefined-properties
+ js->clj
+ ;; TODO (Cam 2026-07-09) why not just normalize template tags the same way we do everything else?
+ ;; Not changing this now in case there's some sort of good reason for doing it manually
+ (perf/update-keys keyword)
+ (assoc :name tag-name) ; prefer the tag name used as a map key in case it's unset in the tag itself or differs
+ (update :type keyword)
+ (m/update-existing :widget-type #(some-> % keyword))
+ (m/update-existing :dimension #(some-> % legacy-ref->mbql5)))))
+ (gobject/getKeys tags-object)))
+
+(defn- template-tag-cljs->js [tag]
+ (-> tag
+ (update :type name)
+ (m/update-existing :widget-type #(some-> % u/qualified-name))
+ (m/update-existing :dimension #(some-> % ref->legacy-ref))
+ (clj->js :keyword-fn u/qualified-name)))
(defn- template-tags-cljs->js
+ "Convert a sequence of template `tags` to a JavaScript Object."
[tags]
- (-> tags
- (update-vals (fn [tag]
- (-> tag
- (update :type name)
- (m/update-existing :widget-type #(some-> % u/qualified-name))
- (m/update-existing :dimension #(some-> % ref->legacy-ref)))))
- (clj->js :keyword-fn u/qualified-name)))
+ (reduce
+ (fn [obj {tag-name :name, :as tag}]
+ (doto obj
+ (gobject/set (u/qualified-name tag-name) (template-tag-cljs->js tag))))
+ #js {}
+ tags))
(defn ^:export with-template-tags
"Updates the native first stage of `a-query`'s template tags to the provided `tags`.
> **Code health:** Healthy"
- [a-query tags]
- (lib.core/with-template-tags a-query (template-tags-js->cljs tags)))
+ [a-query tags-object]
+ (lib.core/with-template-tags a-query (template-tags-js->cljs tags-object)))
(defn ^:export raw-native-query
"Returns the native query string for the native first stage of `a-query`.
diff --git a/src/metabase/lib/js/metadata.cljc b/src/metabase/lib/js/metadata.cljc
index 09126a00bd2..db36d433a5e 100644
--- a/src/metabase/lib/js/metadata.cljc
+++ b/src/metabase/lib/js/metadata.cljc
@@ -523,6 +523,8 @@
[_object-type]
(fn [k v]
(case k
+ ;; TODO (Cam 2026-07-06) not sure this is needed since this should be done automatically as part of normalizing
+ ;; a `:metabase.lib.schema.metadata/native-query-snippet` these days
:template-tags (lib.normalize/normalize :metabase.lib.schema.template-tag/template-tag-map
#?(:cljs (js->clj v)
:clj v))
diff --git a/src/metabase/lib/native.cljc b/src/metabase/lib/native.cljc
index a5fc78c21e2..f1118799745 100644
--- a/src/metabase/lib/native.cljc
+++ b/src/metabase/lib/native.cljc
@@ -16,6 +16,7 @@
[metabase.lib.schema.common :as common]
[metabase.lib.schema.id :as lib.schema.id]
[metabase.lib.schema.metadata :as lib.schema.metadata]
+ [metabase.lib.schema.parameter :as lib.schema.parameter]
[metabase.lib.schema.template-tag :as lib.schema.template-tag]
[metabase.lib.template-tags :as lib.template-tags]
[metabase.lib.util :as lib.util]
@@ -27,7 +28,40 @@
[metabase.util.match :as match]
[metabase.util.performance :refer [empty? every? mapv not-empty select-keys some]]))
-(defn- finish-tag [{tag-name :name :as tag}]
+;; TODO (Cam 2026-07-06) -- a lot of this stuff is template-tag-specific rather than native-query-specific per se and
+;; should probably be moved into [[metabase.lib.template-tags]]
+
+(mr/def ::incomplete-template-tag
+ "An unfinished template tag; must be completed by [[finish-tag]]."
+ [:map
+ [:type ::lib.schema.template-tag/type]
+ [:name ::lib.schema.template-tag/name]])
+
+(mr/def ::incomplete-template-tags
+ [:sequential ::incomplete-template-tag])
+
+(mu/defn- merge-template-tags :- ::lib.schema.template-tag/template-tags
+ "Merge two sequences of template tags by `:name` as you would with map `merge`, e.g. with
+
+ (merge-template-tags x y)
+
+ tags from list `y` are preferred over tags from list `x`."
+ ([& template-tags-lists :- [:sequential [:maybe ::lib.schema.template-tag/template-tags]]]
+ (let [merged-tag-names (into []
+ (comp cat (map :name) (distinct))
+ template-tags-lists)]
+ (transduce
+ (map (fn tags-list->map [tags-list]
+ (into {} (map (juxt :name identity)) tags-list)))
+ (completing merge
+ (fn merged-map->list [merged-tags-map]
+ (mapv (partial get merged-tags-map)
+ merged-tag-names)))
+ {}
+ template-tags-lists))))
+
+(mu/defn- finish-tag :- ::lib.schema.template-tag/template-tag
+ [{tag-name :name :as tag} :- ::incomplete-template-tag]
(merge tag
(when-let [card-id (lib.params.parse/tag-name->card-id tag-name)]
{:type :card
@@ -38,17 +72,18 @@
(when-not (:display-name tag)
{:display-name (u.humanization/name->human-readable-name :simple tag-name)})))
-(defn- fresh-tag [tag-name]
+(mu/defn- fresh-tag :- ::lib.schema.template-tag/template-tag
+ [tag-name :- ::lib.schema.template-tag/name]
(finish-tag
{:type :text
:name tag-name
:id (str (random-uuid))}))
-(defn recognize-template-tags
+(mu/defn recognize-template-tags :- ::lib.schema.template-tag/template-tags
"Finds and returns all template tags in query-text."
- [query-text]
+ [query-text :- :string]
(let [parsed (lib.parse/parse {} query-text)]
- (loop [found {}
+ (loop [found []
[current & more] parsed]
(let [[found more] (match/match-one current
(_ :guard string?) [found more]
@@ -56,8 +91,8 @@
{:type ::lib.parse/param, :name tag-name}
(let [normalized-name (lib.params.parse/match-and-normalize-tag-name tag-name)]
[(cond-> found
- (and normalized-name (not (found normalized-name)))
- (assoc normalized-name (fresh-tag normalized-name)))
+ (and normalized-name (not (some #(= (:name %) normalized-name) found)))
+ (conj (fresh-tag normalized-name)))
more])
{:type ::lib.parse/optional, :contents contents}
@@ -68,61 +103,79 @@
(recur found more)
found)))))
-(defn- rename-template-tag
- [existing-tags old-name new-name]
- (let [old-tag (get existing-tags old-name)
- display-name (if (= (:display-name old-tag)
- (u.humanization/name->human-readable-name :simple old-name))
- ;; Replace the display name if it was the default; keep it if customized.
- (u.humanization/name->human-readable-name :simple new-name)
- (:display-name old-tag))
- new-tag (-> old-tag
- (dissoc :snippet-name :card-id :snippet-id)
- (assoc :display-name display-name
- :name new-name))]
- (-> existing-tags
- (dissoc old-name)
- (assoc new-name new-tag))))
-
-(defn- unify-template-tags
- [query-tags query-tag-names existing-tags existing-tag-names]
- (let [new-tags (set/difference query-tag-names existing-tag-names)
- old-tags (set/difference existing-tag-names query-tag-names)
- tags (if (= 1 (count new-tags) (count old-tags))
- ;; With exactly one change, we treat it as a rename.
- (rename-template-tag existing-tags (first old-tags) (first new-tags))
- ;; With more than one change, just drop the old ones and add the new.
- (merge (m/remove-keys old-tags existing-tags)
- (m/filter-keys new-tags query-tags)))]
- (update-vals tags finish-tag)))
-
-(defn- snippet-names [template-tags]
+(mu/defn- rename-template-tag :- ::incomplete-template-tags
+ [existing-tags :- ::lib.schema.template-tag/template-tags
+ old-name :- ::lib.schema.template-tag/name
+ new-name :- ::lib.schema.template-tag/name]
+ (letfn [(replace-tag [old-tag]
+ (let [new-display-name (if (= (:display-name old-tag)
+ (u.humanization/name->human-readable-name :simple old-name))
+ ;; Replace the display name if it was the default; keep it if customized.
+ (u.humanization/name->human-readable-name :simple new-name)
+ (:display-name old-tag))]
+ (-> old-tag
+ ;; these are dissoc'd because there is logic that derives these from the tag's name.
+ (dissoc :card-id :snippet-name :snippet-id)
+ (assoc :display-name new-display-name
+ :name new-name))))]
+ (mapv (fn [{tag-name :name, :as tag}]
+ (cond-> tag
+ (= tag-name old-name) replace-tag))
+ existing-tags)))
+
+(mu/defn- unify-template-tags :- ::lib.schema.template-tag/template-tags
+ [query-tags :- [:maybe ::lib.schema.template-tag/template-tags]
+ existing-tags :- [:maybe ::lib.schema.template-tag/template-tags]]
+ (let [query-tag-names (not-empty (into #{} (map :name) query-tags))
+ existing-tag-names (not-empty (into #{} (map :name) existing-tags))
+ new-tag-names (set/difference query-tag-names existing-tag-names)
+ old-tag-names (set/difference existing-tag-names query-tag-names)
+ tags (if (= 1 (count new-tag-names) (count old-tag-names))
+ ;; With exactly one change, we treat it as a rename.
+ (rename-template-tag existing-tags (first old-tag-names) (first new-tag-names))
+ ;; With more than one change, just drop the old ones and add the new.
+ (merge-template-tags
+ (remove #(contains? old-tag-names (:name %))
+ existing-tags)
+ (filter #(contains? new-tag-names (:name %))
+ query-tags)))]
+ (mapv finish-tag tags)))
+
+(mu/defn- snippet-names :- [:sequential ::lib.schema.template-tag/name]
+ [template-tags :- [:maybe ::lib.schema.template-tag/template-tags]]
(keep #(when (= (:type %) :snippet)
(:snippet-name %))
- (vals template-tags)))
+ template-tags))
-(defn- extract-snippet-tags [metadata-providerable template-tags]
+(mu/defn- extract-snippet-tags :- ::lib.schema.template-tag/template-tags
+ [metadata-providerable :- ::lib.schema.metadata/metadata-providerable
+ template-tags :- ::lib.schema.template-tag/template-tags]
(loop [[snippet-name & more-snippet-names] (snippet-names template-tags)
- seen #{}
- tags {}]
+ seen #{}
+ tags []]
(cond
(nil? snippet-name) tags
(seen snippet-name) (recur more-snippet-names seen tags)
- :else (let [snippet-tags (->> (lib.metadata/native-query-snippet-by-name metadata-providerable snippet-name)
- :template-tags)]
- (recur (into more-snippet-names (snippet-names snippet-tags))
- (conj seen snippet-name)
- (merge tags snippet-tags))))))
-
-(defn- add-snippet-ids [metadata-providerable template-tags]
- (update-vals template-tags
- (fn [{tag-type :type, :keys [snippet-name], :as tag}]
- (cond-> tag
- ;; A snippet can be referenced by a previous name. If it cannot be found, preserve the previous `snippet-id`.
- (= tag-type :snippet) (m/assoc-some :snippet-id
- (:id (lib.metadata/native-query-snippet-by-name metadata-providerable snippet-name)))))))
-
-(mu/defn extract-template-tags :- ::lib.schema.template-tag/template-tag-map
+ :else (let [snippet-tags-map (->> (lib.metadata/native-query-snippet-by-name metadata-providerable snippet-name)
+ :template-tags)
+ snippet-tags (some->> snippet-tags-map
+ (lib.normalize/normalize ::lib.schema.template-tag/template-tags))]
+ (recur (into more-snippet-names (snippet-names snippet-tags))
+ (conj seen snippet-name)
+ (merge-template-tags tags snippet-tags))))))
+
+(mu/defn- add-snippet-ids :- ::lib.schema.template-tag/template-tags
+ [metadata-providerable :- ::lib.schema.metadata/metadata-providerable
+ template-tags :- ::lib.schema.template-tag/template-tags]
+ (letfn [(update-tag [{tag-type :type, :keys [snippet-name], :as tag}]
+ (cond-> tag
+ ;; A snippet can be referenced by a previous name. If it cannot be found, preserve the previous
+ ;; `snippet-id`.
+ (= tag-type :snippet) (m/assoc-some :snippet-id
+ (:id (lib.metadata/native-query-snippet-by-name metadata-providerable snippet-name)))))]
+ (mapv update-tag template-tags)))
+
+(mu/defn extract-template-tags :- ::lib.schema.template-tag/template-tags
"Extract the template tags from a native query's text.
If the optional map of existing tags previously parsed is given, this will reuse the existing tags where
@@ -142,17 +195,17 @@
(extract-template-tags metadata-providerable query-text nil))
([metadata-providerable :- ::lib.schema.metadata/metadata-providerable
query-text :- ::common/non-blank-string
- existing-tags :- [:maybe ::lib.schema.template-tag/template-tag-map]]
+ existing-tags :- [:maybe ::lib.schema.template-tag/template-tags]]
(let [direct-tags (recognize-template-tags query-text)
- query-tags (merge direct-tags (extract-snippet-tags metadata-providerable direct-tags))
- query-tag-names (not-empty (set (keys query-tags)))
- existing-tag-names (not-empty (set (keys existing-tags)))]
- (if (or query-tag-names existing-tag-names)
+ tags-from-snippets (extract-snippet-tags metadata-providerable direct-tags)
+ query-tags (merge-template-tags direct-tags tags-from-snippets)]
+ (if (or (seq query-tags)
+ (seq existing-tags))
;; If there's at least some tags, unify them.
- (->> (unify-template-tags query-tags query-tag-names existing-tags existing-tag-names)
+ (->> (unify-template-tags query-tags existing-tags)
(add-snippet-ids metadata-providerable))
- ;; Otherwise just an empty map, no tags.
- {}))))
+ ;; Otherwise just an empty vector, no tags.
+ []))))
(defn- assert-native-stage [stage]
(assert (= (:lib/type stage) :mbql.stage/native) (i18n/tru "Must be a native query")))
@@ -230,15 +283,15 @@
(mu/defn with-native-query :- ::lib.schema/query
"Update the raw native query, the first stage must already be a native type.
Replaces templates tags"
- [query :- ::lib.schema/query
- inner-query :- ::common/non-blank-string]
+ [query :- ::lib.schema/query
+ query-text :- ::common/non-blank-string]
(lib.util/update-query-stage
query 0
(fn [{existing-tags :template-tags :as stage}]
(assert-native-stage stage)
(assoc stage
- :native inner-query
- :template-tags (extract-template-tags query inner-query existing-tags)))))
+ :native query-text
+ :template-tags (extract-template-tags query query-text existing-tags)))))
;;; TODO (Cam 7/16/25) -- this really doesn't seem to do what I'd expect, maybe we should rename it something like
;;; `with-replaced-template-tags`. It only replaces tags you specify rather then completely setting a new list
@@ -248,33 +301,31 @@
Note that this only updates existing tags, and will not blindly set them to `template-tags`; however, initializing a
query with [[native-query]] should populate them automatically by way of [[extract-template-tags]]."
[query :- ::lib.schema/query
- updated-tags :- ::lib.schema.template-tag/template-tag-map]
- (letfn [(update-template-tags [existing-tags]
- ;; the way we do this is really weird, but it's important that we use the order of the keys in
- ;; `updated-tags` See
- ;; https://metaboat.slack.com/archives/C0645JP1W81/p1759975007383889?thread_ts=1759289751.539169&cid=C0645JP1W81
- ;;
- ;; first, filter out the tags in `updated-tags` not in existing tags, preserving the original order.
- (let [updates (reduce-kv
- (fn [m updated-k updated-v]
- (let [updated-k (lib.params.parse/match-and-normalize-tag-name updated-k)]
- (cond-> m
- (contains? existing-tags updated-k) (assoc updated-k updated-v))))
- {}
- updated-tags)]
- ;; merge in old values that weren't in the `updated-tags` map
- (reduce-kv
- (fn [updates existing-k existing-v]
- (cond-> updates
- (not (contains? updates existing-k)) (assoc existing-k existing-v)))
- updates
- existing-tags)))
- (update-stage [stage]
- (assert-native-stage stage)
- (-> stage
- (update :template-tags update-template-tags)
- (->> (lib.normalize/normalize ::lib.schema/stage.native))))]
- (lib.util/update-query-stage query 0 update-stage)))
+ ;; TODO (Cam 2026-07-09) this function still supports a template tag map as input FOR NOW so I don't need to update
+ ;; a million tests, however it would be good at some point to just make this take a list and fix the tests in
+ ;; question.
+ updated-tags :- ::lib.schema.template-tag/template-tag-map-or-sequence]
+ (let [updated-tags (->> (lib.normalize/normalize ::lib.schema.template-tag/template-tags updated-tags)
+ ;; TODO (Cam 2026-07-08) -- do name normalization automatically as part of normalizing
+ ;; template tags. See #77314
+ (mapv (fn [tag]
+ (update tag :name (some-fn lib.params.parse/match-and-normalize-tag-name identity)))))]
+ (letfn [(update-template-tags [existing-tags]
+ ;; prefer order from `updated-tags`, but only update tags that are present in `existing-tags`; keep any
+ ;; `existing-tags` that don't have updates.
+ (let [existing-tag-names (into #{} (map :name) existing-tags)
+ updated-tags (filter #(contains? existing-tag-names (:name %))
+ updated-tags)
+ updated-tag-names (into #{} (map :name) updated-tags)
+ untouched-tags (remove #(contains? updated-tag-names (:name %))
+ existing-tags)]
+ (into (vec updated-tags) untouched-tags)))
+ (update-stage [stage]
+ (assert-native-stage stage)
+ (-> stage
+ (update :template-tags update-template-tags)
+ (->> (lib.normalize/normalize ::lib.schema/stage.native))))]
+ (lib.util/update-query-stage query 0 update-stage))))
(mu/defn raw-native-query :- some?
"Returns the native query. This is a SQL string for SQL-based drivers; for other drivers like MongoDB it might be a
@@ -282,7 +333,7 @@
[query :- ::lib.schema/query]
(:native (lib.util/query-stage query 0)))
-(mu/defn template-tags :- [:maybe ::lib.schema.template-tag/template-tag-map]
+(mu/defn template-tags :- [:maybe ::lib.schema.template-tag/template-tags]
"Returns the native query's template tags"
[query :- ::lib.schema/query]
(:template-tags (lib.util/query-stage query 0)))
@@ -312,7 +363,7 @@
[query :- ::lib.schema/query]
(letfn [(variable-tag? [{tag-type :type}]
(not (#{:snippet :card} tag-type)))]
- (boolean (some variable-tag? (vals (template-tags query))))))
+ (boolean (some variable-tag? (template-tags query)))))
(mu/defn has-write-permission :- :boolean
"Returns whether the database has native write permissions.
@@ -400,19 +451,20 @@
:target ["dimension" ["template-tag" tag-name]]}
nil))
-(defn add-parameters-for-template-tags
+(mu/defn add-parameters-for-template-tags :- ::lib.schema/query
"Adds dummy values for parameters that don't have one.
This is so that the resulting native query can be parsed. It's not expected to be executable."
- [query]
- (let [ttags (-> (lib.util/query-stage query 0)
- :template-tags)
- parameters (:parameters query)
- params-by-id (m/index-by :id parameters)
- new-parameters (into []
- (keep (fn [[tag-name {:keys [id] :as tag}]]
- (or (params-by-id id)
- (get-parameter-value query tag-name tag))))
- ttags)]
+ [query :- ::lib.schema/query]
+ (let [tags (-> (lib.util/query-stage query 0)
+ :template-tags)
+ parameters (:parameters query)
+ params-by-id (m/index-by :id parameters)
+ new-parameters (->> (into []
+ (keep (fn [{:keys [id], tag-name :name, :as tag}]
+ (or (params-by-id id)
+ (get-parameter-value query tag-name tag))))
+ tags)
+ (lib.normalize/normalize ::lib.schema.parameter/parameters))]
(cond-> query
(seq new-parameters) (assoc :parameters new-parameters))))
diff --git a/src/metabase/lib/parameters/parse.cljc b/src/metabase/lib/parameters/parse.cljc
index 8bd3c2caed8..0f09d2f1fa0 100644
--- a/src/metabase/lib/parameters/parse.cljc
+++ b/src/metabase/lib/parameters/parse.cljc
@@ -21,10 +21,10 @@
(def ^:private variable-tag-regex
#"\s*([A-Za-z0-9_\.]+)\s*")
-(defn- normalize-variable-tag
+(mu/defn- normalize-variable-tag :- [:maybe :string]
"Matches and normalizes a variable tag like {{my_var}}.
Returns normalized-name or nil if not a variable tag."
- [tag-name]
+ [tag-name :- :string]
(when-let [[_ content] (re-matches variable-tag-regex tag-name)]
content))
@@ -40,10 +40,10 @@
(when (str/starts-with? tag-name "snippet:")
(str/trim (subs tag-name (count "snippet:")))))
-(defn- normalize-snippet-tag
+(mu/defn- normalize-snippet-tag :- [:maybe :string]
"Normalizes a snippet tag like {{snippet: foo}}. E.g., 'snippet: foo ' -> 'snippet: foo'.
Returns normalized string or nil if not a snippet tag."
- [tag-name]
+ [tag-name :- :string]
(when-let [[_ content] (re-matches snippet-tag-regex tag-name)]
(let [snippet-name (tag-name->snippet-name content)]
(str "snippet: " snippet-name))))
@@ -59,15 +59,16 @@
(when-let [[_ id-str] (re-matches #"^#(\d+)(-[a-z0-9-]*)?$" tag-name)]
(parse-long id-str)))
-(defn- normalize-card-tag
+(mu/defn- normalize-card-tag :- [:maybe :string]
"Matches and normalizes a card tag like {{#123}} or {{#123-slug}}.
Normalizes '#123-slug' -> '#123'.
Returns normalized-name or nil if not a card tag."
- [tag-name]
+ [tag-name :- :string]
(when-let [[_ content _card-id _slug] (re-matches card-tag-regex tag-name)]
;; TODO: see tech debt issue #39378 and `native-test/card-tag-test`
content))
+;; TODO (Cam 2026-07-08) do this as part of normalization `:metabase.lib.schema.template-tag/name`. See #77314
(def ^{:arglists '([tag-name])} match-and-normalize-tag-name
"Matches a full tag string against tag normalizer functions and returns
normalized-name or nil if no match."
diff --git a/src/metabase/lib/query.cljc b/src/metabase/lib/query.cljc
index d6f0af2effd..77727276af6 100644
--- a/src/metabase/lib/query.cljc
+++ b/src/metabase/lib/query.cljc
@@ -19,6 +19,7 @@
[metabase.lib.schema.expression :as lib.schema.expression]
[metabase.lib.schema.id :as lib.schema.id]
[metabase.lib.schema.metadata :as lib.schema.metadata]
+ [metabase.lib.schema.template-tag :as lib.schema.template-tag]
[metabase.lib.temporal-bucket :as lib.temporal-bucket]
[metabase.lib.types.isa :as lib.types.isa]
[metabase.lib.util :as lib.util]
@@ -451,13 +452,16 @@
(let [{q :query, n :stage-number} (wrap-native-query-with-mbql a-query stage-number card-id)]
(apply f q n args)))
-(defn- template-tag-stages
- [template-tags]
- (for [{:keys [card-id snippet-id] tag-type :type} (vals template-tags)
- :when (#{:card :snippet} tag-type)]
- (case tag-type
- :card {:source-card card-id}
- :snippet {:source-snippet-id snippet-id})))
+(mu/defn- template-tag-stages
+ ;; works with either map or sequence of template tags because Native Query Snippets still store them as a map at the
+ ;; time of this writing
+ [template-tags :- [:maybe ::lib.schema.template-tag/template-tag-map-or-sequence]]
+ (let [template-tags (lib.normalize/normalize ::lib.schema.template-tag/template-tags template-tags)]
+ (for [{:keys [card-id snippet-id] tag-type :type} template-tags
+ :when (#{:card :snippet} tag-type)]
+ (case tag-type
+ :card {:source-card card-id}
+ :snippet {:source-snippet-id snippet-id}))))
(defn- stage-seq* [query-fragment]
(cond
diff --git a/src/metabase/lib/query/test_spec.cljc b/src/metabase/lib/query/test_spec.cljc
index 769fefe6595..1d80cbe3373 100644
--- a/src/metabase/lib/query/test_spec.cljc
+++ b/src/metabase/lib/query/test_spec.cljc
@@ -352,29 +352,42 @@
spec :- ::lib.schema.test-spec/test-template-tag-spec]
(u/update-if-exists spec :dimension #(field-id->field-ref query %)))
-(mu/defn- adjust-template-tags :- ::lib.schema.template-tag/template-tag-map
+(mu/defn- adjust-template-tags :- ::lib.schema.template-tag/template-tags
[query :- ::lib.schema/query
- inferred-template-tags :- ::lib.schema.template-tag/template-tag-map
+ inferred-template-tags :- ::lib.schema.template-tag/template-tags
template-tags-spec :- [:maybe ::lib.schema.test-spec/test-template-tags-spec]]
- (merge-with merge
- inferred-template-tags
- (update-vals template-tags-spec #(adjust-template-tag query %))))
+ (let [spec-tags (for [spec template-tags-spec]
+ (adjust-template-tag query spec))
+ inferred-tag-name->tag (into {} (map (juxt :name identity)) inferred-template-tags)
+ spec-tag-name->tag (into {} (map (juxt :name identity)) spec-tags)
+ tag-names (into []
+ (comp cat
+ (map :name)
+ (distinct))
+ [inferred-template-tags
+ spec-tags])]
+ (into []
+ (map (fn [tag-name]
+ (merge (inferred-tag-name->tag tag-name)
+ (spec-tag-name->tag tag-name))))
+ tag-names)))
(mu/defn- add-template-tags :- ::lib.schema/query
[query :- ::lib.schema/query
template-tags-spec :- [:maybe ::lib.schema.test-spec/test-template-tags-spec]]
- (let [inferred-template-tags (or (lib.native/template-tags query) {})]
+ (let [inferred-template-tags (or (lib.native/template-tags query) [])]
(->> template-tags-spec
(adjust-template-tags query inferred-template-tags)
(lib.native/with-template-tags query))))
-(def parse-native-query-spec
+(def ^:private parse-native-query-spec
"Parser for native-query-spec."
(mc/coercer [:ref ::lib.schema.test-spec/test-native-query-spec]
(mtx/transformer
mtx/json-transformer
(mtx/key-transformer {:decode #(-> % u/->kebab-case-en keyword)})
- mtx/default-value-transformer)))
+ mtx/default-value-transformer
+ {:name :normalize})))
(mu/defn test-native-query :- ::lib.schema/query
"Creates a native query from a test native query spec."
diff --git a/src/metabase/lib/schema.cljc b/src/metabase/lib/schema.cljc
index 5ce41f32426..48a3ba93b1c 100644
--- a/src/metabase/lib/schema.cljc
+++ b/src/metabase/lib/schema.cljc
@@ -101,7 +101,9 @@
[:collection {:optional true} ::common/non-blank-string]
;; optional template tag declarations. Template tags are things like `{{x}}` in the query (the value of the
;; `:native` key), but their definition lives under this key.
- [:template-tags {:optional true} [:ref ::template-tag/template-tag-map]]
+ ;;
+ ;; Prior to 63, this was a map, but was changed to a list to preserve order with more than 8 template tags.
+ [:template-tags {:optional true} [:ref ::template-tag/template-tags]]
;; optional, set of Card IDs referenced by this query in `:card` template tags like `{{card}}`. This is added
;; automatically during parameter expansion. To run a native query you must have native query permissions as well
;; as permissions for any Cards' parent Collections used in `:card` template tag parameters.
diff --git a/src/metabase/lib/schema/metadata.cljc b/src/metabase/lib/schema/metadata.cljc
index 2c6a8ace06d..b00e761a256 100644
--- a/src/metabase/lib/schema/metadata.cljc
+++ b/src/metabase/lib/schema/metadata.cljc
@@ -10,6 +10,7 @@
[metabase.lib.schema.id :as lib.schema.id]
[metabase.lib.schema.join :as lib.schema.join]
[metabase.lib.schema.metadata.fingerprint :as lib.schema.metadata.fingerprint]
+ [metabase.lib.schema.template-tag :as lib.schema.template-tag]
[metabase.lib.schema.temporal-bucketing :as lib.schema.temporal-bucketing]
[metabase.util.malli.registry :as mr]
[metabase.util.performance :refer [get-in]]))
@@ -754,10 +755,9 @@
(mr/def ::native-query-snippet
[:map
- [:lib/type [:= :metadata/native-query-snippet]]
- [:id ::lib.schema.id/native-query-snippet]])
-;;; TODO (Cam 8/8/25) -- description, content, archived, collection-id
-
+ [:lib/type [:= :metadata/native-query-snippet]]
+ [:id ::lib.schema.id/native-query-snippet]
+ [:template-tags {:optional true} [:maybe [:ref ::lib.schema.template-tag/template-tag-map]]]])
;;; TODO (Cam 8/8/25) -- description, content, archived, collection-id
(mr/def ::table
diff --git a/src/metabase/lib/schema/template_tag.cljc b/src/metabase/lib/schema/template_tag.cljc
index b562fec0c96..c36552bb873 100644
--- a/src/metabase/lib/schema/template_tag.cljc
+++ b/src/metabase/lib/schema/template_tag.cljc
@@ -1,12 +1,13 @@
(ns metabase.lib.schema.template-tag
- (:refer-clojure :exclude [every?])
+ (:refer-clojure :exclude [empty? every? mapv])
(:require
[malli.core :as mc]
+ [medley.core :as m]
[metabase.lib.schema.common :as common]
[metabase.lib.schema.id :as id]
[metabase.lib.schema.parameter :as lib.schema.parameter]
[metabase.util.malli.registry :as mr]
- [metabase.util.performance :refer [every?]]))
+ [metabase.util.performance :refer [empty? every? mapv]]))
(mr/def ::widget-type
"Schema for valid values of `:widget-type` for a `:metabase.lib.schema.template-tag/field-filter` template tag."
@@ -216,7 +217,70 @@
(= tag-name (:name tag-definition)))
m))])
+(defn normalize-template-tag-map
+ "If `template-tags` is a sequence, convert it to a map. This map should only be used for lookup purposes as it loses
+ the order the tags were saved in."
+ [template-tags]
+ (letfn [(normalize-template-tag-sequence [tags]
+ (into {}
+ (map (juxt :name identity))
+ tags))]
+ (cond
+ (sequential? template-tags) (normalize-template-tag-sequence template-tags)
+ :else template-tags)))
+
(mr/def ::template-tag-map
+ "Legacy way to store template tags... storing them as a map is problematic because having more than 8 template tags
+ causes the map to switch to a hash map (in Clojure < 1.13) and order gets lost (see #5136). For the sake of keeping
+ things simple for the FE (which does not have this issue with JS Objects).
+
+ This is still used by a handful of functions to support easy lookup by tag name, so we'll leave the schema around
+ FOR NOW, but it would probably be better to remove this entirely and just introduce helper functions for looking
+ things up."
[:and
- [:map-of ::name ::template-tag]
+ [:map-of
+ {:decode/normalize normalize-template-tag-map}
+ [:ref ::name]
+ [:ref ::template-tag]]
[:ref ::template-tag-map.validate-names]])
+
+(defn normalize-template-tags
+ "Normalize `template-tags` to a sequence (converting a map if needed)."
+ [template-tags]
+ (letfn [(normalize-map [tags-map]
+ (mapv (fn [[tag-name template-tag]]
+ ;; prefer the tag name that was used as a map key over the `:name` in the tag itself; they should
+ ;; agree but just in case they don't use the map key as the source of truth.
+ (assoc template-tag :name tag-name))
+ tags-map))]
+ (cond-> template-tags
+ (map? template-tags) normalize-map)))
+
+(mr/def ::distinct-template-tags
+ [:fn
+ {:error/message "Template tags must have distinct :names"
+ :decode/normalize (fn [tags]
+ (when (sequential? tags)
+ (into [] (m/distinct-by :name) tags)))}
+ (fn [template-tags]
+ (and (sequential? template-tags)
+ (or (empty? template-tags)
+ (apply distinct? (map :name template-tags)))))])
+
+(mr/def ::template-tags
+ "Prior to 63, this was a map, but was changed to a list to preserve order with more than 8 template tags.
+
+ Each tag must have a distinct `:name`."
+ [:and
+ [:sequential
+ {:decode/normalize normalize-template-tags}
+ [:ref ::template-tag]]
+ [:ref ::distinct-template-tags]])
+
+(mr/def ::template-tag-map-or-sequence
+ "Either a map of template tags (name => tag) or sequence of template tags. This schema is meant for functions that
+ accept either type as input as a convenience, since Native Query Snippet template tags are currently still stored as
+ a map."
+ [:or
+ [:ref ::template-tag-map]
+ [:ref ::template-tags]])
diff --git a/src/metabase/lib/schema/test_spec.cljc b/src/metabase/lib/schema/test_spec.cljc
index 33064255dc2..35101d55558 100644
--- a/src/metabase/lib/schema/test_spec.cljc
+++ b/src/metabase/lib/schema/test_spec.cljc
@@ -182,11 +182,11 @@
[::mc/default [:ref ::test-raw-value-spec]]])
(mr/def ::test-template-tags-spec
- [:map-of
- ::lib.schema.template-tag/name
+ [:sequential
+ {:decode/normalize #'lib.schema.template-tag/normalize-template-tags}
::test-template-tag-spec])
(mr/def ::test-native-query-spec
[:map
[:query string?]
- [:template-tags {:optional true :default {}} [:maybe [:ref ::test-template-tags-spec]]]])
+ [:template-tags {:optional true :default []} [:maybe [:ref ::test-template-tags-spec]]]])
diff --git a/src/metabase/lib/template_tags.cljc b/src/metabase/lib/template_tags.cljc
index 65b4456429d..1f0bd305e3a 100644
--- a/src/metabase/lib/template_tags.cljc
+++ b/src/metabase/lib/template_tags.cljc
@@ -8,14 +8,14 @@
(mu/defn template-tags->card-ids :- [:maybe [:set {:min 1} ::lib.schema.id/card]]
"Returns the card IDs from the template tags map."
- [template-tags :- [:maybe ::lib.schema.template-tag/template-tag-map]]
- (->> (vals template-tags)
+ [template-tags :- [:maybe ::lib.schema.template-tag/template-tags]]
+ (->> template-tags
(into #{} (keep :card-id))
not-empty))
(mu/defn template-tags->snippet-ids :- [:maybe [:set {:min 1} ::lib.schema.id/native-query-snippet]]
"Returns the snippet IDs from the template tags map."
- [template-tags :- [:maybe ::lib.schema.template-tag/template-tag-map]]
- (->> (vals template-tags)
+ [template-tags :- [:maybe ::lib.schema.template-tag/template-tags]]
+ (->> template-tags
(into #{} (keep :snippet-id))
not-empty))
diff --git a/src/metabase/lib/walk/util.cljc b/src/metabase/lib/walk/util.cljc
index 4827f2c1c91..0b5973eff8f 100644
--- a/src/metabase/lib/walk/util.cljc
+++ b/src/metabase/lib/walk/util.cljc
@@ -51,7 +51,8 @@
(transduce-stages
(comp (filter (fn [stage]
(= (:lib/type stage) :mbql.stage/native)))
- (mapcat :template-tags))
+ (mapcat :template-tags)
+ (map (juxt :name identity)))
(fn rf
([m]
(not-empty (persistent! m)))
diff --git a/src/metabase/metabot/query_analyzer/parameter_substitution.clj b/src/metabase/metabot/query_analyzer/parameter_substitution.clj
index 50422ca8bee..8877ff9f137 100644
--- a/src/metabase/metabot/query_analyzer/parameter_substitution.clj
+++ b/src/metabase/metabot/query_analyzer/parameter_substitution.clj
@@ -57,8 +57,8 @@
"Given a native dataset_query, return a `{:query \"<SQL string>\"}` where the SQL no longer has Metabase-specific
template tags."
[query]
- (if-let [name->tag (seq (lib/template-tags query))]
+ (if-let [tags (not-empty (lib/template-tags query))]
(-> query
- (lib/with-template-tags (update-vals name->tag tag-default))
+ (lib/with-template-tags (mapv tag-default tags))
qp.compile/compile)
{:query (lib/raw-native-query query)}))
diff --git a/src/metabase/native_query_snippets/models/native_query_snippet.clj b/src/metabase/native_query_snippets/models/native_query_snippet.clj
index b58d84b428b..03256bdcb37 100644
--- a/src/metabase/native_query_snippets/models/native_query_snippet.clj
+++ b/src/metabase/native_query_snippets/models/native_query_snippet.clj
@@ -25,6 +25,7 @@
(derive :hook/timestamped?)
(derive :hook/entity-id))
+;; TODO (Cam 2026-07-08) Change Native Query Snippets to store template tags as a list like we do in MBQL as of 63.
(t2/deftransforms :model/NativeQuerySnippet
{:template_tags {:in mi/json-in
:out (comp (mi/catch-normalization-exceptions
@@ -60,7 +61,9 @@
(filter snippet-tag?)
(map (juxt :snippet-name identity)))
old-tags)
- new-tags (lib/recognize-template-tags (:content snippet))
+ new-tags (into {}
+ (map (juxt :name identity))
+ (lib/recognize-template-tags (:content snippet)))
set-snippet-id (fn [{:keys [snippet-name] :as tag}]
;; Check for exact match in database:
(if-let [snippet-id (t2/select-one-fn :id :model/NativeQuerySnippet
diff --git a/src/metabase/native_query_snippets/schema.clj b/src/metabase/native_query_snippets/schema.clj
index fd688b3c362..ecf3da70479 100644
--- a/src/metabase/native_query_snippets/schema.clj
+++ b/src/metabase/native_query_snippets/schema.clj
@@ -12,4 +12,5 @@
[:content :string]
[:description {:optional true} [:maybe :string]]
[:collection_id {:optional true} [:maybe ::lib.schema.id/collection]]
+ ;; TODO (Cam 2026-07-08) Change Native Query Snippets to store template tags as a list like we do in MBQL as of 63.
[:template_tags [:ref ::lib.schema.template-tag/template-tag-map]]])
diff --git a/src/metabase/query_processor/middleware/parameters.clj b/src/metabase/query_processor/middleware/parameters.clj
index d127a2bef7c..3aadbda54d2 100644
--- a/src/metabase/query_processor/middleware/parameters.clj
+++ b/src/metabase/query_processor/middleware/parameters.clj
@@ -1,9 +1,10 @@
(ns metabase.query-processor.middleware.parameters
"Middleware for substituting parameters in queries."
- (:refer-clojure :exclude [some])
+ (:refer-clojure :exclude [mapv some])
(:require
[clojure.data :as data]
[clojure.set :as set]
+ [medley.core :as m]
[metabase.lib.core :as lib]
[metabase.lib.parameters :as lib.parameters]
[metabase.lib.schema :as lib.schema]
@@ -16,7 +17,7 @@
[metabase.util :as u]
[metabase.util.log :as log]
[metabase.util.malli :as mu]
- [metabase.util.performance :refer [some]]))
+ [metabase.util.performance :refer [mapv some]]))
(mu/defn- expand-stage :- ::lib.schema/stage
"Expand `:parameters` in one stage map that contains them."
@@ -88,8 +89,9 @@
"Find the template tag in `template-tags` that matches `param`'s target."
[template-tags param]
(when-let [name-or-id (lib.parameters/parameter-target-template-tag-name (:target param))]
- (or (get template-tags name-or-id) ; handle name
- (some (fn [[_ tag]] ; handle id (defensive, may be unnecessary)
+ (or (m/find-first #(= (:name %) name-or-id) ; handle name
+ template-tags)
+ (some (fn [tag] ; handle id (defensive, may be unnecessary)
(when (= (:id tag) name-or-id)
tag))
template-tags))))
@@ -152,14 +154,13 @@
(when-let [diff (second (data/diff query <>))]
(log/tracef "\n\nSubstituted params:\n%s\n" (u/pprint-to-str 'cyan diff))))))
-(mu/defn- assoc-database-id-in-snippet-tag :- ::lib.schema.template-tag/template-tag-map
- [template-tags :- ::lib.schema.template-tag/template-tag-map
+(mu/defn- assoc-database-id-in-snippet-tag :- ::lib.schema.template-tag/template-tags
+ [template-tags :- ::lib.schema.template-tag/template-tags
database-id :- ::lib.schema.id/database]
- (update-vals
- template-tags
- (fn [v]
- (cond-> v
- (= (:type v) :snippet) (assoc :database database-id)))))
+ (mapv (fn [tag]
+ (cond-> tag
+ (= (:type tag) :snippet) (assoc :database database-id)))
+ template-tags))
(mu/defn- hoist-database-for-snippet-tags :- ::lib.schema/query
"Assocs the `:database` ID from `query` in all snippet template tags."
diff --git a/src/metabase/query_processor/middleware/resolve_referenced.clj b/src/metabase/query_processor/middleware/resolve_referenced.clj
index bc28273fc93..59ec64a815d 100644
--- a/src/metabase/query_processor/middleware/resolve_referenced.clj
+++ b/src/metabase/query_processor/middleware/resolve_referenced.clj
@@ -6,6 +6,7 @@
[metabase.lib.schema.common :as lib.schema.common]
[metabase.lib.schema.id :as lib.schema.id]
[metabase.lib.schema.metadata :as lib.schema.metadata]
+ [metabase.lib.schema.template-tag :as lib.schema.template-tag]
[metabase.query-processor.error-type :as qp.error-type]
[metabase.query-processor.middleware.fetch-source-query :as qp.fetch-source-query]
[metabase.query-processor.middleware.resolve-fields :as qp.resolve-fields]
@@ -48,16 +49,17 @@
graph :- :map
init-query :- ::lib.schema/query]
(letfn [(card-subquery-graph [mp graph card-id]
- (let [card-query (fetch-card-query mp card-id)
- card-ids (concat (lib/native-query-card-ids card-query)
- (lib/all-source-card-ids card-query))
+ (let [card-query (fetch-card-query mp card-id)
+ card-ids (concat (lib/native-query-card-ids card-query)
+ (lib/all-source-card-ids card-query))
snippet-ids (lib/native-query-snippet-ids card-query)]
(subquery-graph* mp graph ::card card-id card-ids snippet-ids)))
(snippet-subquery-graph [mp graph snippet-id]
- (let [snippet (fetch-snippet mp snippet-id)
- snippet-template-tags (:template-tags snippet)
- card-ids (lib/template-tags->card-ids snippet-template-tags)
- snippet-ids (lib/template-tags->snippet-ids snippet-template-tags)]
+ (let [snippet (fetch-snippet mp snippet-id)
+ ;; convert snippet template tags (still stored as a map at the time of this writing) to list
+ snippet-template-tags (lib/normalize ::lib.schema.template-tag/template-tags (:template-tags snippet))
+ card-ids (lib/template-tags->card-ids snippet-template-tags)
+ snippet-ids (lib/template-tags->snippet-ids snippet-template-tags)]
(subquery-graph* mp graph ::snippet snippet-id card-ids snippet-ids)))
(subquery-graph* [mp graph node-type node-id card-ids snippet-ids]
(as-> graph <>
@@ -73,7 +75,7 @@
(snippet-subquery-graph mp
(dep/depend graph [node-type id] [::snippet nested-snippet-id])
nested-snippet-id)))]
- (let [card-ids (lib/native-query-card-ids init-query)
+ (let [card-ids (lib/native-query-card-ids init-query)
snippet-ids (lib/native-query-snippet-ids init-query)]
(subquery-graph* metadata-providerable
graph
diff --git a/src/metabase/query_processor/parameters/values.clj b/src/metabase/query_processor/parameters/values.clj
index 1ebc7aa444c..cfa910c338a 100644
--- a/src/metabase/query_processor/parameters/values.clj
+++ b/src/metabase/query_processor/parameters/values.clj
@@ -477,11 +477,12 @@
{tags :template-tags, params :parameters, :as _stage} :- ::lib.schema/stage]
(log/tracef "Building params map out of tags\n%s\nand params\n%s\n" (u/pprint-to-str tags) (u/pprint-to-str params))
(try
- (into {} (for [[k tag] tags
- :let [v (value-for-tag metadata-providerable tag params)]]
+ (into {} (for [{tag-name :name, :as tag} tags
+ :let [v (value-for-tag metadata-providerable tag params)]]
(do
- (log/tracef "Value for tag %s\n%s\n->\n%s" (pr-str k) (u/pprint-to-str tag) (u/pprint-to-str v))
- [(or (lib/match-and-normalize-tag-name k) k) v])))
+ (log/tracef "Value for tag %s\n%s\n->\n%s" (pr-str tag-name) (u/pprint-to-str tag) (u/pprint-to-str v))
+ (let [k' (or (lib/match-and-normalize-tag-name tag-name) tag-name)]
+ [k' v]))))
(catch Throwable e
(throw (ex-info (tru "Error building query parameter map: {0}" (ex-message e))
{:type (or (:type (ex-data e)) qp.error-type/invalid-parameter)
diff --git a/src/metabase/source_swap/native.clj b/src/metabase/source_swap/native.clj
index 08ea6bcd1cf..9a08c015e78 100644
--- a/src/metabase/source_swap/native.clj
+++ b/src/metabase/source_swap/native.clj
@@ -6,10 +6,14 @@
[metabase.lib.metadata :as lib.metadata]
[metabase.lib.parameters.parse :as lib.params.parse]
[metabase.lib.parameters.parse.types :as lib.params.parse.types]
+ [metabase.lib.schema :as lib.schema]
+ [metabase.lib.schema.id :as lib.schema.id]
+ [metabase.lib.schema.template-tag :as lib.schema.template-tag]
[metabase.sql-tools.core :as sql-tools]
;; sql-tools.init registers multimethod implementations for :macaw parser backend
[metabase.sql-tools.init]
[metabase.util :as u]
+ [metabase.util.malli :as mu]
[metabase.util.performance :as perf]))
(set! *warn-on-reflection* true)
@@ -109,13 +113,13 @@
;;; the SQL uses a stable variable name and the tag has a `:table-id`.
;;; Unlike card tags ({{#123}}), the SQL doesn't embed the ID directly.
-(defn- find-table-tags
- "Find all template tags of :type :table that reference the given table-id.
- Returns a seq of [tag-key tag-map] pairs."
- [template-tags table-id]
- (filter (fn [[_k v]]
- (and (= (:type v) :table)
- (= (:table-id v) table-id)))
+(mu/defn- find-table-tags :- ::lib.schema.template-tag/template-tags
+ "Find all template tags of :type :table that reference the given `table-id`."
+ [template-tags :- [:maybe ::lib.schema.template-tag/template-tags]
+ table-id :- ::lib.schema.id/table]
+ (filter (fn [tag]
+ (and (= (:type tag) :table)
+ (= (:table-id tag) table-id)))
template-tags))
(defn- replace-tag-in-sql
@@ -137,18 +141,18 @@
:else
(str token)))))
-(defn- update-table-tags-for-table-swap
+(mu/defn- update-table-tags-for-table-swap :- ::lib.schema.template-tag/template-tags
"Update :type :table template tags when swapping table→table.
Just updates the :table-id field."
- [template-tags old-table-id new-table-id]
- (reduce-kv
- (fn [acc k tag]
- (if (and (= (:type tag) :table)
- (= (:table-id tag) old-table-id))
- (assoc acc k (assoc tag :table-id new-table-id))
- (assoc acc k tag)))
- {}
- template-tags))
+ [template-tags :- [:maybe ::lib.schema.template-tag/template-tags]
+ old-table-id :- ::lib.schema.id/table
+ new-table-id :- ::lib.schema.id/table]
+ (mapv (fn [tag]
+ (cond-> tag
+ (and (= (:type tag) :table)
+ (= (:table-id tag) old-table-id))
+ (assoc :table-id new-table-id)))
+ template-tags))
;;; ====================== Dimension Tag Helpers ======================
;;;
@@ -156,54 +160,64 @@
;;; `:dimension [:field <opts> <id>]`. When swapping tables, we need
;;; to remap field IDs to the equivalent fields on the new table.
-(defn- update-dimension-tags
+(mu/defn- update-dimension-tags :- ::lib.schema.template-tag/template-tags
"Update :type :dimension and :type :temporal-unit template tags, remapping field IDs from old table to new table.
Finds matching fields by name."
- [query template-tags old-table-id new-table-id]
+ [query :- ::lib.schema/query
+ template-tags :- [:maybe ::lib.schema.template-tag/template-tags]
+ old-table-id :- ::lib.schema.id/table
+ new-table-id :- ::lib.schema.id/table]
(let [old-fields (lib.metadata/fields query old-table-id)
new-fields (lib.metadata/fields query new-table-id)]
- (reduce-kv
- (fn [acc k tag]
- (assoc acc k
- (or (when (#{:dimension :temporal-unit} (:type tag))
- (when-some [field (lib/find-matching-column (:dimension tag) old-fields)]
- (when-some [new-field (perf/some #(when (= (:name %) (:name field)) %) new-fields)]
- (assoc tag :dimension (lib/ref new-field)))))
- tag)))
- {}
- template-tags)))
-
-(defn- update-table-tags-for-card-swap
+ (mapv (fn [tag]
+ (or (when (#{:dimension :temporal-unit} (:type tag))
+ (when-some [field (lib/find-matching-column (:dimension tag) old-fields)]
+ (when-some [new-field (perf/some #(when (= (:name %) (:name field)) %) new-fields)]
+ (assoc tag :dimension (lib/ref new-field)))))
+ tag))
+ template-tags)))
+
+(mu/defn- update-table-tags-for-card-swap :- [:map
+ [:sql :string]
+ [:template-tags [:maybe ::lib.schema.template-tag/template-tags]]]
"Update :type :table template tags when swapping table→card.
Changes tag type from :table to :card, updates SQL to use {{#id-slug}} syntax.
Preserves optional fields like :required and :default from the original tag.
Returns {:sql new-sql :template-tags new-tags}."
- [sql template-tags old-table-id new-card-id new-card-name]
+ [sql :- :string
+ template-tags :- [:maybe ::lib.schema.template-tag/template-tags]
+ old-table-id :- ::lib.schema.id/table
+ new-card-id :- ::lib.schema.id/card
+ new-card-name :- :string]
(let [table-tags (find-table-tags template-tags old-table-id)
slug (card-slug new-card-name)
card-tag-key (str "#" new-card-id "-" slug)]
(if (perf/empty? table-tags)
{:sql sql :template-tags template-tags}
;; Replace each table tag with a card tag
- (let [;; Replace all matching tag names in SQL
- new-sql (reduce (fn [s [old-tag-name _]]
+ (let [ ;; Replace all matching tag names in SQL
+ new-sql (reduce (fn [s {old-tag-name :name, :as _table-tag}]
(replace-tag-in-sql (lib.params.parse/parse s) old-tag-name card-tag-key))
sql
table-tags)
;; Get first old tag to preserve its optional fields (:required, :default)
;; Note: :id is NOT preserved - new tag gets a new UUID
- [_ first-old-tag] (first table-tags)
+ first-old-tag (first table-tags)
preserved-fields (perf/select-keys first-old-tag [:required :default])
;; Update template-tags: remove old table tags, add new card tag
new-tags (as-> template-tags tags
;; Remove old table tags
- (reduce (fn [t [k _]] (dissoc t k)) tags table-tags)
+ (reduce (fn [tags {table-tag-name :name, :as _table-tag}]
+ (remove #(= (:name %) table-tag-name)
+ tags))
+ tags
+ table-tags)
;; Add new card tag with preserved fields
- (assoc tags card-tag-key (merge preserved-fields
- {:type :card
- :card-id new-card-id
- :name card-tag-key
- :display-name card-tag-key})))]
+ (conj (vec tags) (merge preserved-fields
+ {:type :card
+ :card-id new-card-id
+ :name card-tag-key
+ :display-name card-tag-key})))]
{:sql new-sql :template-tags new-tags}))))
(defn- unquote-template-refs
@@ -306,31 +320,33 @@
- old-table-id: ID of table to replace
- new-card-id: ID of card to reference"
[query old-table-id new-card-id]
- (or (when-let [database (lib.metadata/database query)]
+ (or (when-let [database (lib.metadata/database query)]
(when-let [old-table (lib.metadata/table query old-table-id)]
- (when-let [new-card (lib.metadata/card query new-card-id)]
- (let [driver (:engine database)
- sql (lib/raw-native-query query)
- template-tags (lib/template-tags query)
- slug (card-slug (:name new-card))
- card-tag (str "#" new-card-id "-" slug)
- card-ref (str "{{" card-tag "}}")
- old-spec (cond-> {:table (:name old-table)}
- (:schema old-table) (assoc :schema (:schema old-table)))
- sql-after-raw (replace-table-in-native-sql driver sql old-spec card-ref)
+ (when-let [new-card (lib.metadata/card query new-card-id)]
+ (let [driver (:engine database)
+ sql (lib/raw-native-query query)
+ template-tags (lib/template-tags query)
+ slug (card-slug (:name new-card))
+ card-tag-name (str "#" new-card-id "-" slug)
+ card-ref (str "{{" card-tag-name "}}")
+ old-spec (cond-> {:table (:name old-table)}
+ (:schema old-table) (assoc :schema (:schema old-table)))
+ sql-after-raw (replace-table-in-native-sql driver sql old-spec card-ref)
{:keys [sql template-tags]} (update-table-tags-for-card-swap
sql-after-raw
template-tags
old-table-id
new-card-id
(:name new-card))
- new-tag {:type :card
- :card-id new-card-id
- :name card-tag
- :display-name card-tag}
- template-tags (if (contains? template-tags card-tag)
- template-tags
- (assoc template-tags card-tag new-tag))]
+ new-tag {:type :card
+ :card-id new-card-id
+ :name card-tag-name
+ :display-name card-tag-name}
+ template-tags (mapv (fn [{tag-name :name, :as tag}]
+ (if (= tag-name card-tag-name)
+ new-tag
+ tag))
+ template-tags)]
(-> query
(lib/with-native-query sql)
(lib/with-template-tags template-tags))))))
@@ -385,29 +401,29 @@
(lib/with-native-query query new-sql))))
query))
-(defn- replace-template-tags
+(mu/defn- replace-template-tags :- ::lib.schema.template-tag/template-tags
"Replaces references to `old-card-id` with `new-card-id` in a template-tags map.
Preserves slug format: if old key was `#42-my-query`, new key will be `#99-new-query-name`."
- [tags old-card-id new-card-id new-card-name]
- (let [old-tag (str "#" old-card-id)
+ [tags :- [:maybe ::lib.schema.template-tag/template-tags]
+ old-card-id :- ::lib.schema.id/card
+ new-card-id :- ::lib.schema.id/card
+ new-card-name :- :string]
+ (let [old-tag (str "#" old-card-id)
new-slug (when new-card-name
(card-slug new-card-name))]
- (reduce-kv
- (fn [acc k v]
- (if (= (:card-id v) old-card-id)
- (let [;; Check if old key had a slug (e.g., "#42-my-query" vs "#42")
- had-slug? (str/starts-with? k (str old-tag "-"))
- new-key (if (and had-slug? new-slug)
- (str "#" new-card-id "-" new-slug)
- (str "#" new-card-id))]
- (assoc acc new-key
- (assoc v
- :card-id new-card-id
- :name new-key
- :display-name new-key)))
- (assoc acc k v)))
- {}
- tags)))
+ (mapv (fn [{tag-name :name, :as tag}]
+ (if (= (:card-id tag) old-card-id)
+ (let [ ;; Check if old key had a slug (e.g., "#42-my-query" vs "#42")
+ had-slug? (str/starts-with? tag-name (str old-tag "-"))
+ new-key (if (and had-slug? new-slug)
+ (str "#" new-card-id "-" new-slug)
+ (str "#" new-card-id))]
+ (assoc tag
+ :card-id new-card-id
+ :name new-key
+ :display-name new-key))
+ tag))
+ tags)))
(defn- replace-card-refs-in-parsed
"Walk parsed SQL tokens, replacing card references to old-card-id with new-card-id.
diff --git a/src/metabase/transforms_base/util.clj b/src/metabase/transforms_base/util.clj
index 11aa87ea29f..c771aac10ff 100644
--- a/src/metabase/transforms_base/util.clj
+++ b/src/metabase/transforms_base/util.clj
@@ -129,10 +129,10 @@
This is the table variable the incremental range filter is injected into (see
`inject-filters-into-table-tag`). When `table-id` is nil, any table template tag qualifies."
[query table-id]
- (some (fn [[k v]]
- (when (and (#{:table "table"} (:type v))
- (or (nil? table-id) (= table-id (:table-id v))))
- k))
+ (some (fn [{tag-name :name, :as tag}]
+ (when (and (#{:table "table"} (:type tag))
+ (or (nil? table-id) (= table-id (:table-id tag))))
+ tag-name))
(lib/template-tags query)))
(defn incremental-table-tag-name
@@ -335,7 +335,13 @@
hi (conj {:field-id checkpoint-filter-field-id :op :<= :value (:value hi)}))]
(lib.util/update-query-stage
query 0
- #(assoc-in % [:template-tags tag-name :source-filters] filters))))
+ update :template-tags
+ (fn [template-tags]
+ (mapv (fn [tag]
+ (cond-> tag
+ (= (:name tag) tag-name)
+ (assoc :source-filters filters)))
+ template-tags)))))
(mu/defn get-source-range-params :- [:maybe ::transforms-base.schema/source-range-params]
"Returns information on the incremental range filters that ought to be applied to a source query.
@@ -352,7 +358,7 @@
{:keys [checkpoint-filter-field-id]} source-incremental-strategy]
(when (and (incremental-target? transform)
(native-query-transform? transform)
- (not (some (fn [[_k v]] (#{:table "table"} (:type v)))
+ (not (some (fn [tag] (#{:table "table"} (:type tag)))
(lib/template-tags (:query source)))))
(let [msg (i18n/tru (str "Incremental transform with a native query requires a table variable. "
"Please add a table variable to the query and update the checkpoint field."))]
diff --git a/test/metabase/driver/native_parsing_test.clj b/test/metabase/driver/native_parsing_test.clj
index 53d24a2b621..3f3386ff279 100644
--- a/test/metabase/driver/native_parsing_test.clj
+++ b/test/metabase/driver/native_parsing_test.clj
@@ -1,6 +1,7 @@
(ns ^:mb/driver-tests metabase.driver.native-parsing-test
(:require
[clojure.test :refer :all]
+ [medley.core :as m]
[metabase.driver :as driver]
[metabase.lib.core :as lib]
[metabase.test :as mt]))
@@ -11,11 +12,12 @@
(let [mp (mt/metadata-provider)
sql (mt/native-query-with-card-template-tag driver/*driver* "table")
base-query (lib/native-query mp sql)
- template-tag (get (lib/template-tags base-query) "table")
+ template-tag (m/find-first #(= (:name %) "table")
+ (lib/template-tags base-query))
query (lib/with-template-tags base-query
- {"table" (merge template-tag
- {:type :table
- :table-id (mt/id :orders)})})]
+ [(merge template-tag
+ {:type :table
+ :table-id (mt/id :orders)})])]
;; by not preprocessing the query, the query itself is unparseable and we need to rely on the table tag
(is (= #{{:table (mt/id :orders)}}
(driver/native-query-deps driver/*driver* query)))))))
diff --git a/test/metabase/lib/convert_test.cljc b/test/metabase/lib/convert_test.cljc
index 1206d14185a..b6aef19c6cf 100644
--- a/test/metabase/lib/convert_test.cljc
+++ b/test/metabase/lib/convert_test.cljc
@@ -114,23 +114,46 @@
(deftest ^:parallel ->mbql5-native-query-test
(testing "template tag dimensions are converted"
- (let [original {:type :native
- :native
- {:query "SELECT count(*) AS count FROM PUBLIC.PEOPLE WHERE true [[AND {{NAME}}]]"
- :template-tags
- {"NAME"
- {:name "NAME"
- :display-name "Name"
- :type :dimension
- :dimension [:field 866 nil]
- :widget-type :string/=
- :default nil}}}
- :database 76}
+ (let [original {:type :native
+ :native
+ {:query "SELECT count(*) AS count FROM PUBLIC.PEOPLE WHERE true [[AND {{NAME}}]]"
+ :template-tags
+ {"NAME"
+ {:name "NAME"
+ :display-name "Name"
+ :type :dimension
+ :dimension [:field 866 nil]
+ :widget-type :string/=
+ :default nil}}}
+ :database 76}
converted (lib.convert/->mbql5 original)]
- (is (=? {:stages [{:template-tags {"NAME" {:dimension [:field {:lib/uuid string?} 866]}}}]}
+ (is (=? {:stages [{:template-tags [{:dimension [:field {:lib/uuid string?} 866]}]}]}
converted))
(is (mr/validate :metabase.lib.schema/query converted)))))
+(deftest ^:parallel native-query->legacy-test
+ (is (= {:database 76
+ :native {:query "SELECT count(*) AS count FROM PUBLIC.PEOPLE WHERE true [[AND {{NAME}}]]"
+ :template-tags {"NAME" {:default nil
+ :dimension [:field 866 nil]
+ :display-name "Name"
+ :name "NAME"
+ :type :dimension
+ :widget-type :string/=}}}
+ :type :native}
+ (lib.convert/->legacy-MBQL
+ {:database 76
+ :stages [{:native "SELECT count(*) AS count FROM PUBLIC.PEOPLE WHERE true [[AND {{NAME}}]]"
+ :template-tags
+ [{:default nil
+ :dimension [:field {:lib/uuid "7ba4c681-b39e-418b-8b77-b98ad974eeb1"} 866]
+ :display-name "Name"
+ :name "NAME"
+ :type :dimension
+ :widget-type :string/=}]
+ :lib/type :mbql.stage/native}]
+ :lib/type :mbql/query}))))
+
(deftest ^:parallel ->mbql5-joins-default-alias-test
(let [original {:database (meta/id)
:type :query
@@ -536,7 +559,7 @@
{"false" [:value false nil]}
[:expression "false"]
- {"eq" [:= 1 2]}
+ {"eq" [:= "a" "b"]}
[:expression "eq"]
{"and" [:and [:field 1 nil] [:field 2 nil]]}
@@ -1512,7 +1535,7 @@
:fields [[:field {:lib/uuid "00000000-0000-0000-0000-000000000001"} 1]
[:field {:lib/uuid "00000000-0000-0000-0000-000000000002"} 2]]}]
:fields [[:field {:lib/uuid "00000000-0000-0000-0000-000000000003", :join-alias "J"} 1]]
- :conditions [[:= {:lib/uuid "00000000-0000-0000-0000-000000000004"} 1 2]]}]}]}]
+ :conditions [[:= {:lib/uuid "00000000-0000-0000-0000-000000000004"} "a" "b"]]}]}]}]
(is (= {:type :query
:query {:source-table 1
:joins [{:alias "J"
@@ -1520,7 +1543,7 @@
:fields [[:field 1 nil]
[:field 2 nil]]}
:fields [[:field 1 {:join-alias "J"}]]
- :condition [:= 1 2]}]}}
+ :condition [:= "a" "b"]}]}}
(lib.convert/->legacy-MBQL query)
;; make sure roundtripping doesn't introduce extra stages.
(-> query
@@ -1539,14 +1562,14 @@
:source-table 2
:fields [[:field {:lib/uuid "00000000-0000-0000-0000-000000000001"} 1]
[:field {:lib/uuid "00000000-0000-0000-0000-000000000002"} 2]]}]
- :conditions [[:= {:lib/uuid "00000000-0000-0000-0000-000000000003"} 1 2]]}]}]}]
+ :conditions [[:= {:lib/uuid "00000000-0000-0000-0000-000000000003"} "a" "b"]]}]}]}]
(is (= {:type :query
:query {:source-table 1
:joins [{:alias "J"
:source-query {:source-table 2
:fields [[:field 1 nil]
[:field 2 nil]]}
- :condition [:= 1 2]}]}}
+ :condition [:= "a" "b"]}]}}
(lib.convert/->legacy-MBQL query)
;; make sure roundtripping doesn't introduce extra stages.
(-> query
@@ -1595,7 +1618,7 @@
[:relative-datetime -15 :day]
[:relative-datetime 0 :day]]
(lib.convert/->legacy-MBQL [:between
- {:include-current true,
+ {:include-current true
:lib/uuid "b8991b40-d452-4922-8768-b07f6f2b1918"}
[:field
{:base-type :type/Text
diff --git a/test/metabase/lib/fe_util_test.cljc b/test/metabase/lib/fe_util_test.cljc
index c5cb0e5b213..5ac8eb461f7 100644
--- a/test/metabase/lib/fe_util_test.cljc
+++ b/test/metabase/lib/fe_util_test.cljc
@@ -1080,23 +1080,23 @@
(deftest ^:parallel dependent-metadata-test-10
(testing "Native query snippets should be included in dependent metadata"
- (let [;; lib/native-query would try to look up the snippets:
+ (let [ ;; lib/native-query would try to look up the snippets:
query {:lib/type :mbql/query
:database 1
- :stages [{:lib/type :mbql.stage/native
- :native "SELECT * WHERE {{snippet: filter1}} AND {{snippet: filter2}}"
- :template-tags {"snippet: filter1" {:type :snippet
- :snippet-id 10
- :snippet-name "filter1"
- :name "snippet: filter1"
- :display-name "Filter 1"
- :id "def456"}
- "snippet: filter2" {:type :snippet
- :snippet-id 20
- :snippet-name "filter2"
- :name "snippet: filter2"
- :display-name "Filter 2"
- :id "ghi789"}}}]}]
+ :stages [{:lib/type :mbql.stage/native
+ :native "SELECT * WHERE {{snippet: filter1}} AND {{snippet: filter2}}"
+ :template-tags [{:type :snippet
+ :snippet-id 10
+ :snippet-name "filter1"
+ :name "snippet: filter1"
+ :display-name "Filter 1"
+ :id "def456"}
+ {:type :snippet
+ :snippet-id 20
+ :snippet-name "filter2"
+ :name "snippet: filter2"
+ :display-name "Filter 2"
+ :id "ghi789"}]}]}]
(is (=? [{:type :database}
{:type :schema}
{:type :native-query-snippet :id 10}
diff --git a/test/metabase/lib/js_test.cljs b/test/metabase/lib/js_test.cljs
index 796480dd617..70e7d20141e 100644
--- a/test/metabase/lib/js_test.cljs
+++ b/test/metabase/lib/js_test.cljs
@@ -163,11 +163,41 @@
query (lib.js/with-template-tags
(lib.js/native-query (:id db) meta/metadata-provider "select * from foo {{snippet: my snippet}}")
(add-undefined-params (clj->js snippets) snippet-name))]
- (is (= snippets
+ (is (= (vals snippets)
(get-in query [:stages 0 :template-tags])))
(is (test.js/= (clj->js snippets)
(lib.js/template-tags query))))))
+(deftest ^:parallel template-tags-preserve-order-test
+ (let [tags (mapv (fn [i]
+ {:name (str "template_tag_" i)
+ :display-name (str "Template Tag " i)
+ :type :number})
+ (range 10))
+ expected-order ["template_tag_0"
+ "template_tag_1"
+ "template_tag_2"
+ "template_tag_3"
+ "template_tag_4"
+ "template_tag_5"
+ "template_tag_6"
+ "template_tag_7"
+ "template_tag_8"
+ "template_tag_9"]]
+ (is (= expected-order
+ (mapv :name tags)))
+ (let [roundtripped-tags (-> tags
+ (#'lib.js/template-tags-cljs->js)
+ (#'lib.js/template-tags-js->cljs))]
+ (is (= expected-order
+ (mapv :name roundtripped-tags))))))
+
+(deftest ^:parallel template-tags-js->cljs-test
+ (testing "Should use map key as :name"
+ (is (= [{:name "tag", :display-name "Tag", :type :number}]
+ (#'lib.js/template-tags-js->cljs
+ #js {"tag" #js {"display-name" "Tag", "type" "number"}})))))
+
(deftest ^:parallel column-metadata?-test
(is (true? (lib.js/column-metadata? (meta/field-metadata :venues :id))))
(is (false? (lib.js/column-metadata? 1))))
diff --git a/test/metabase/lib/native_test.cljc b/test/metabase/lib/native_test.cljc
index d030740efe7..57bc8f492ec 100644
--- a/test/metabase/lib/native_test.cljc
+++ b/test/metabase/lib/native_test.cljc
@@ -2,6 +2,7 @@
(:require
#?@(:cljs ([metabase.test-runner.assert-exprs.approximately-equal]))
[clojure.test :refer [are deftest is testing]]
+ [medley.core :as m]
[metabase.lib.core :as lib]
[metabase.lib.metadata :as lib.metadata]
[metabase.lib.native :as lib.native]
@@ -12,8 +13,26 @@
#?(:cljs (comment metabase.test-runner.assert-exprs.approximately-equal/keep-me))
+(deftest ^:parallel merge-template-tags-test
+ (let [t1 {:id "ac8a19f0-e125-418a-81dc-aa7f4f2c3e76"
+ :name "var"
+ :display-name "Var"
+ :type :text}
+ t2 {:type :snippet
+ :name "snippet: snippet1"
+ :id "0e6dbc02-e9f4-4bdf-bf6e-9995afd108e0"
+ :snippet-name "snippet1"
+ :display-name "Snippet: Snippet1"}]
+ (testing "should preserve order"
+ (is (= [t1 t2]
+ (#'lib.native/merge-template-tags [t1] [t2]))))
+ (testing "should prefer changes from second collection like clojure.core/merge"
+ (let [t1' (assoc t1 :type :number)]
+ (is (= [t1' t2]
+ (#'lib.native/merge-template-tags [t1] [t2 t1'])))))))
+
(deftest ^:parallel variable-tag-test
- (are [exp input] (= exp (set (keys (lib.native/extract-template-tags meta/metadata-provider input))))
+ (are [exp input] (= exp (into #{} (map :name) (lib.native/extract-template-tags meta/metadata-provider input)))
#{"foo"} "SELECT * FROM table WHERE {{foo}} AND some_field IS NOT NULL"
#{"foo" "bar"} "SELECT * FROM table WHERE {{foo}} AND some_field = {{bar}}"
;; Duplicates are flattened.
@@ -22,13 +41,13 @@
#{} "SELECT * FROM table WHERE {{&foo}}"))
(deftest ^:parallel snippet-tag-test
- (are [exp input] (= exp (set (keys (lib.native/extract-template-tags meta/metadata-provider input))))
+ (are [exp input] (= exp (into #{} (map :name) (lib.native/extract-template-tags meta/metadata-provider input)))
#{"snippet: foo"} "SELECT * FROM table WHERE {{snippet: foo }} AND some_field IS NOT NULL"
#{"snippet: foo *#&@"} "SELECT * FROM table WHERE {{snippet: foo *#&@}}"
#{"snippet: foo"} "SELECT * FROM table WHERE {{snippet: foo}} AND {{snippet:foo}}"))
(deftest ^:parallel card-tag-test
- (are [exp input] (= exp (set (keys (lib.native/extract-template-tags meta/metadata-provider input))))
+ (are [exp input] (= exp (into #{} (map :name) (lib.native/extract-template-tags meta/metadata-provider input)))
#{"#123"} "SELECT * FROM table WHERE {{ #123 }} AND some_field IS NOT NULL"
;; TODO: This logic should trim the whitespace and unify these two card tags.
;; I think this is a bug in the original code but am aiming to reproduce it exactly for now.
@@ -44,17 +63,17 @@
:id 1}
metadata-provider (lib.tu/mock-metadata-provider
{:native-query-snippets [snippet]})]
- (is (=? {"snippet: foo" {:type :snippet
- :name "snippet: foo"
- :snippet-name "foo"
- :snippet-id 1
- :id string?}}
+ (is (=? [{:type :snippet
+ :name "snippet: foo"
+ :snippet-name "foo"
+ :snippet-id 1
+ :id string?}]
(lib.native/extract-template-tags metadata-provider "SELECT * FROM table WHERE {{snippet:foo}}")))
- (is (=? {"snippet: foo" {:type :snippet
- :name "snippet: foo"
- :snippet-name "foo"
- :snippet-id 1
- :id string?}}
+ (is (=? [{:type :snippet
+ :name "snippet: foo"
+ :snippet-name "foo"
+ :snippet-id 1
+ :id string?}]
(lib.native/extract-template-tags metadata-provider "SELECT * FROM {{snippet: foo}} WHERE {{snippet:foo}}"))))))
(deftest ^:parallel template-tags-test-2
@@ -64,32 +83,31 @@
:display-name "Foo"
:id (str (random-uuid))}]
(testing "changes display-name if the original is not customized"
- (is (=? {"bar" {:type :text
- :name "bar"
- :display-name "Bar"
- :id (:id old-tag)}}
+ (is (=? [{:type :text
+ :name "bar"
+ :display-name "Bar"
+ :id (:id old-tag)}]
(lib.native/extract-template-tags meta/metadata-provider "SELECT * FROM {{bar}}"
- {"foo" old-tag}))))
+ [old-tag]))))
(testing "keeps display-name if it's customized"
- (is (=? {"bar" {:type :text
- :name "bar"
- :display-name "Custom Name"
- :id (:id old-tag)}}
+ (is (=? [{:type :text
+ :name "bar"
+ :display-name "Custom Name"
+ :id (:id old-tag)}]
(lib.native/extract-template-tags meta/metadata-provider "SELECT * FROM {{bar}}"
- {"foo" (assoc old-tag :display-name "Custom Name")}))))
+ [(assoc old-tag :display-name "Custom Name")]))))
(testing "works with other variables present, if they don't change"
(let [other {:type :text
:name "other"
:display-name "Some Var"
:id (str (random-uuid))}]
- (is (=? {"other" other
- "bar" {:type :text
- :name "bar"
- :display-name "Bar"
- :id (:id old-tag)}}
+ (is (=? [{:type :text
+ :name "bar"
+ :display-name "Bar"
+ :id (:id old-tag)}
+ other]
(lib.native/extract-template-tags meta/metadata-provider "SELECT * FROM {{bar}} AND field = {{other}}"
- {"foo" old-tag
- "other" other}))))))))
+ [old-tag other]))))))))
(deftest ^:parallel template-tags-test-3
(testing "general case, add and remove"
@@ -109,7 +127,6 @@
:snippet-name "another snippet"
:snippet-id 124
:type :snippet})
-
c1 (mktag {:name "#123-card-1"
:type :card
:card-id 123})
@@ -117,36 +134,34 @@
:type :card
:card-id 321})
metadata-provider (lib.tu/mock-metadata-provider
- {:native-query-snippets [{:name "first snippet"
- :id 123}
- {:name "another snippet"
- :id 124}]})]
- (is (=? {"foo" v1
- "#123-card-1" c1
- "snippet: first snippet" s1}
+ {:native-query-snippets [{:name "first snippet"
+ :id 123
+ :snippet-name "first snippet"}
+ {:name "another snippet"
+ :id 124
+ :snippet-name "another snippet"}]})]
+ (is (=? [c1 v1 s1]
(lib.native/extract-template-tags
metadata-provider
"SELECT * FROM {{#123-card-1}} WHERE {{foo}} AND {{ snippet:first snippet}}")))
- (is (=? {"bar" v2
- "baz" v3
- "snippet: another snippet" s2
- "#321" c2}
+ (is (=? [c2 v3 v2 s2]
(lib.native/extract-template-tags
metadata-provider
"SELECT * FROM {{#321}} WHERE {{baz}} AND {{bar}} AND {{snippet:another snippet}}"
- {"foo" (assoc v1 :id (str (random-uuid)))
- "#123-card-1" (assoc c1 :id (str (random-uuid)))
- "snippet: first snippet" (assoc s1 :id (str (random-uuid)))})))
+ [(assoc v1 :id (str (random-uuid)))
+ (assoc c1 :id (str (random-uuid)))
+ (assoc s1 :id (str (random-uuid)))])))
(let [s1-uuid (str (random-uuid))]
- (is (= {"snippet: another snippet" (assoc s2 :id s1-uuid)}
+ (is (= [(assoc s2 :id s1-uuid)]
(lib.native/extract-template-tags
metadata-provider
"SELECT * FROM {{snippet:another snippet}}"
- {"snippet: first snippet" (assoc s1 :id s1-uuid)})))))))
+ [(assoc s1 :id s1-uuid)])))))))
(deftest ^:parallel variable-tag-with-dots-and-underscores-test
(testing "dots and underscores are legal in variable names (metabase#15029)"
- (are [exp input] (= exp (set (keys (lib.native/extract-template-tags meta/metadata-provider input))))
+ (are [exp input] (= exp
+ (into #{} (map :name) (lib.native/extract-template-tags meta/metadata-provider input)))
#{"number.of.stars"} "select * from products where rating = {{number.of.stars}}"
#{"a_b" "c.d"} "select {{a_b}}, {{c.d}}")))
@@ -202,7 +217,8 @@
(let [mp (lib.tu/mock-metadata-provider
meta/metadata-provider
{:native-query-snippets snippets})]
- (is (contains? (lib.native/extract-template-tags mp query) expected)))))))
+ (is (contains? (into #{} (map :name) (lib.native/extract-template-tags mp query))
+ expected)))))))
(deftest ^:parallel snippet-inner-tag-dedup-test
(doseq [[description snippets query expected]
@@ -235,7 +251,7 @@
meta/metadata-provider
{:native-query-snippets snippets})
tags (lib.native/extract-template-tags mp query)]
- (is (= 1 (count (filter #(= expected %) (keys tags)))))))))
+ (is (= 1 (count (filter #(= expected %) (map :name tags)))))))))
(def ^:private qp-results-metadata
"Capture of the `data.results_metadata` that would come back when running `SELECT * FROM VENUES;` with the Query
@@ -267,18 +283,18 @@
(let [query (lib/native-query meta/metadata-provider "select * from venues where id = {{myid}}")]
(testing "Updating query keeps template tags in sync"
(is (=? ["select * from venues where id = {{myid}}"
- {"myid" {:type :text
- :name "myid"
- :id string?
- :display-name "Myid"}}]
+ [{:type :text
+ :name "myid"
+ :id string?
+ :display-name "Myid"}]]
((juxt lib/raw-native-query lib/template-tags) query)))
(is (=? ["select * from venues where id = {{myid}} and x = {{y}}"
- {"myid" {} "y" {}}]
+ [{:name "myid"} {:name "y"}]]
(-> query
(lib/with-native-query "select * from venues where id = {{myid}} and x = {{y}}")
((juxt lib/raw-native-query lib/template-tags)))))
(is (=? ["select * from venues where id = {{myrenamedid}}"
- {"myrenamedid" {}}]
+ [{:name "myrenamedid"}]]
(-> query
(lib/with-native-query "select * from venues where id = {{myrenamedid}}")
((juxt lib/raw-native-query lib/template-tags)))))
@@ -292,62 +308,135 @@
(-> (lib.tu/venues-query)
(lib/with-native-query "foobar"))))))
+(deftest ^:parallel with-native-query-snippet-with-template-tags-test
+ (testing "with-native-query should pull in template tags from referenced snippets"
+ (let [mp (lib.tu/mock-metadata-provider
+ meta/metadata-provider
+ {:native-query-snippets [{:id 1
+ :name "snippet1"
+ :type :snippet
+ :content "{{var}}"
+ :template-tags {"var" {:id "ac8a19f0-e125-418a-81dc-aa7f4f2c3e76"
+ :name "var"
+ :display-name "Var"
+ :type :text}}}]})
+ initial-tags [{:snippet-name "snippet1"
+ :display-name "Snippet: Snippet1"
+ :type :snippet
+ :name "snippet: snippet1"
+ :id "e0616322-eadc-430b-a15b-d26d1615076d"
+ :snippet-id 1}]
+ expected [{:snippet-name "snippet1"
+ :display-name "Snippet: Snippet1"
+ :type :snippet
+ :name "snippet: snippet1"
+ :id "e0616322-eadc-430b-a15b-d26d1615076d"
+ :snippet-id 1}
+ {:id "ac8a19f0-e125-418a-81dc-aa7f4f2c3e76"
+ :name "var"
+ :display-name "Var"
+ :type :text}]]
+ (testing "Query created with `with-template-tags` should get snippet tags pulled in"
+ (let [query (-> (lib/native-query mp "{{snippet: snippet1}}")
+ (lib/with-template-tags initial-tags))]
+ (is (= expected
+ (lib/template-tags query)))))
+ (testing (str "lib.native/with-native-query should update template tags to the same was they'd be if we used"
+ " `with-template-tags` in the first place")
+ (let [query (-> (lib/native-query mp "{{snippet: snippet1}}")
+ ;; if we don't manually splice in tags here then `with-native-query` has nothing to update
+ (lib/update-query-stage 0 assoc :template-tags initial-tags))]
+ (is (= expected
+ (lib/template-tags (lib.native/with-native-query query "{{snippet: snippet1}}")))))))))
+
+(deftest ^:parallel with-native-query-update-snippet-with-template-tags-test
+ (testing "with-native-query should update template tags when a {{snippet: ...}} tag changes"
+ (let [mp (lib.tu/mock-metadata-provider
+ meta/metadata-provider
+ {:native-query-snippets [{:id 1
+ :name "snippet1"
+ :type :snippet
+ :content "SELECT"}
+ {:id 2
+ :name "snippet2"
+ :type :snippet
+ :content "{{var}}"
+ :template-tags {"var" {:id "ac8a19f0-e125-418a-81dc-aa7f4f2c3e76"
+ :name "var"
+ :display-name "Var"
+ :type :text}}}]})
+ initial-tags [{:snippet-name "snippet1"
+ :display-name "Snippet: Snippet1"
+ :type :snippet
+ :name "snippet: snippet1"
+ :id "e0616322-eadc-430b-a15b-d26d1615076d"
+ :snippet-id 1}]
+ query (-> (lib/native-query mp "{{snippet: snippet1}}")
+ (lib/with-template-tags initial-tags))]
+ (testing "Initial query (references snippet 1)"
+ (is (=? [{:name "snippet: snippet1"}]
+ (lib/template-tags query))))
+ (testing "updated query (references snippet 2) should update template tags and pull in tags from updated snippet"
+ (let [query' (lib.native/with-native-query query "{{snippet: snippet2}}")]
+ (is (=? [{:name "snippet: snippet2"}
+ {:name "var"}]
+ (lib/template-tags query'))))))))
+
(deftest ^:parallel with-template-tags-test
- (let [query (lib/native-query meta/metadata-provider "select * from venues where id = {{myid}}")
+ (let [query (lib/native-query meta/metadata-provider "select * from venues where id = {{myid}}")
original-tags (lib/template-tags query)]
- (is (= (assoc-in original-tags ["myid" :display-name] "My ID")
+ (is (= (assoc-in original-tags [0 :display-name] "My ID")
(-> query
- (lib/with-template-tags {"myid" (assoc (get original-tags "myid") :display-name "My ID")})
+ (lib/with-template-tags {"myid" (assoc (first original-tags) :display-name "My ID")})
lib/template-tags)))
(testing "Changing query keeps updated template tags"
- (is (= (assoc-in original-tags ["myid" :display-name] "My ID")
+ (is (= (assoc-in original-tags [0 :display-name] "My ID")
(-> query
- (lib/with-template-tags {"myid" (assoc (get original-tags "myid") :display-name "My ID")})
+ (lib/with-template-tags {"myid" (assoc (first original-tags) :display-name "My ID")})
(lib/with-native-query "select * from venues where category_id = {{myid}}")
lib/template-tags))))
(testing "Doesn't introduce garbage"
(is (= original-tags
(-> query
- (lib/with-template-tags {"garbage" (assoc (get original-tags "myid") :name "garbage" :display-name "Foobar")})
+ (lib/with-template-tags {"garbage" (assoc (first original-tags) :name "garbage" :display-name "Foobar")})
lib/template-tags))))
(testing "Allows to remove template tag properties"
- (let [template-tags {"tag"
- {:default nil
- :dimension [:field {:lib/uuid (str (random-uuid))} 1]
+ (let [template-tags [{:default nil
+ :dimension [:field {:lib/uuid (str (random-uuid))} 1]
:display-name "Tag"
- :id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
- :name "tag"
- :type :dimension
- :widget-type :date/range}}
+ :id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
+ :name "tag"
+ :type :dimension
+ :widget-type :date/range}]
query (-> (lib/native-query meta/metadata-provider "select * from venues where {{tag}}")
(lib/with-template-tags template-tags))
- new-template-tags {"tag"
- {:display-name "Tag"
- :id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
- :name "tag"
- :type :text}}]
+ new-template-tags [{:display-name "Tag"
+ :id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
+ :name "tag"
+ :type :text}]]
(is (= new-template-tags (lib/template-tags (lib/with-template-tags query new-template-tags))))))
(is (thrown-with-msg?
#?(:clj Throwable :cljs :default)
#"Must be a native query"
(-> (lib.tu/venues-query)
- (lib/with-template-tags {"myid" (assoc (get original-tags "myid") :display-name "My ID")}))))))
+ (lib/with-template-tags [(assoc (first original-tags) :display-name "My ID")]))))))
(deftest ^:parallel with-template-tags-update-map-order-test
- ;; yes, I know template tags are sorted as a map, but for small maps we should preserve the order passed in by the
- ;; FE. See
- ;; https://metaboat.slack.com/archives/C0645JP1W81/p1759974826834279?thread_ts=1759289751.539169&cid=C0645JP1W81
+ ;; preserve updated order as passed in by the FE.
(testing "it should be possible to reorder template tags with with-template-tags"
- (let [query (lib/native-query meta/metadata-provider "{{x}} {{y}} {{z}}")
- original-tags (lib/template-tags query)]
- (is (=? {"x" {}, "y" {}, "z" {}}
+ (let [query (lib/native-query meta/metadata-provider "{{x}} {{y}} {{z}}")
+ [x y :as original-tags] (lib/template-tags query)]
+ (is (=? [{:name "x"} {:name "y"} {:name "z"}]
original-tags))
- (is (= ["x" "y" "z"]
- (keys original-tags)))
- (let [updated-tags {"y" (get original-tags "y"), "x" (get original-tags "x")}
- query' (lib/with-template-tags query updated-tags)]
- (is (= ["y" "x" "z"]
- (keys (lib/template-tags query'))))))))
+ (doseq [[message updated-tags] {"updated tags is a map"
+ {"y" y, "x" x}
+
+ "updated tags is a list"
+ [y x]}]
+ (testing message
+ (let [query' (lib/with-template-tags query updated-tags)]
+ (is (=? [{:name "y"} {:name "x"} {:name "z"}]
+ (lib/template-tags query')))))))))
(defn ^:private metadata-provider-requiring-collection []
(meta/updated-metadata-provider update :features conj :native-requires-specified-collection))
@@ -532,7 +621,6 @@
(lib/with-different-database
(meta/updated-metadata-provider assoc :id 9999))
lib/template-tags
- vals
(->> (filter :dimension))))))))
(deftest ^:parallel native-query-idents-test
@@ -563,7 +651,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :string/=
:value ["foo"]
- :target ["variable" ["template-tag" "mytag"]]}]
+ :target [:variable [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag" {:type :text
:name "mytag"
@@ -576,7 +664,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :number/=
:value ["0"]
- :target ["variable" ["template-tag" "mytag"]]}]
+ :target [:variable [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:display-name "My Tag"
@@ -590,7 +678,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :date/single
:value "1970-01-01"
- :target ["variable" ["template-tag" "mytag"]]}]
+ :target [:variable [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:display-name "My Tag"
@@ -604,7 +692,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :boolean/=
:value [false]
- :target ["variable" ["template-tag" "mytag"]]}]
+ :target [:variable [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:display-name "My Tag"
@@ -618,7 +706,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :string/=
:value ["foo"]
- :target ["dimension" ["template-tag" "mytag"]]}]
+ :target [:dimension [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:dimension [:field
@@ -636,7 +724,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :number/=
:value ["0"]
- :target ["dimension" ["template-tag" "mytag"]]}]
+ :target [:dimension [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:dimension [:field
@@ -654,7 +742,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :date/single
:value "2025-01-01"
- :target ["dimension" ["template-tag" "mytag"]]}]
+ :target [:dimension [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:dimension [:field
@@ -672,7 +760,7 @@
(is (= [{:id "9ae1ea5e-ac33-4574-bc95-ff595b0ac1a7"
:type :temporal-unit
:value "week"
- :target ["dimension" ["template-tag" "mytag"]]}]
+ :target [:dimension [:template-tag "mytag"]]}]
(-> (lib/native-query meta/metadata-provider "select * from venues where {{mytag}}")
(lib/with-template-tags {"mytag"
{:dimension [:field
@@ -741,7 +829,7 @@
(defn- table-tag-query [mp template-tag-overrides]
(let [base-query (lib.native/native-query mp "select * from {{table}}")
- template-tag (get (lib.native/template-tags base-query) "table")]
+ template-tag (m/find-first #(= (:name %) "table") (lib.native/template-tags base-query))]
(lib.native/with-template-tags base-query
{"table" (merge template-tag {:type :table} template-tag-overrides)})))
@@ -754,11 +842,11 @@
:name "expensive_venues"
:content "venues WHERE price = 4"}]})]
(is (=? {:stages [{:native "SELECT * FROM {{snippet:expensive_venues}}"
- :template-tags {"snippet: expensive_venues" {:name "snippet: expensive_venues"
- :snippet-id 1
- :snippet-name "expensive_venues"
- :type :snippet
- :display-name "(New display name)"}}}]}
+ :template-tags [{:name "snippet: expensive_venues"
+ :snippet-id 1
+ :snippet-name "expensive_venues"
+ :type :snippet
+ :display-name "(New display name)"}]}]}
(-> (lib/native-query mp "SELECT * FROM {{snippet:expensive_venues}}")
(lib/with-template-tags {"snippet:expensive_venues" {:type :snippet
:name "snippet:expensive_venues"
diff --git a/test/metabase/lib/query/test_spec_test.cljc b/test/metabase/lib/query/test_spec_test.cljc
index 879a04bbffc..1dad67447ca 100644
--- a/test/metabase/lib/query/test_spec_test.cljc
+++ b/test/metabase/lib/query/test_spec_test.cljc
@@ -984,9 +984,9 @@
:display-name "Venue Name"}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues WHERE name = {{venue_name}}"))
- (is (=? {"venue_name" {:type :text
- :name "venue_name"
- :display-name "Venue Name"}}
+ (is (=? [{:type :text
+ :name "venue_name"
+ :display-name "Venue Name"}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-number-tag-test
@@ -1000,9 +1000,9 @@
:display-name "Price"}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues WHERE price = {{price}}"))
- (is (=? {"price" {:type :number
- :name "price"
- :display-name "Price"}}
+ (is (=? [{:type :number
+ :name "price"
+ :display-name "Price"}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-date-tag-test
@@ -1016,9 +1016,9 @@
:display-name "Date"}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM orders WHERE created_at = {{date}}"))
- (is (=? {"date" {:type :date
- :name "date"
- :display-name "Date"}}
+ (is (=? [{:type :date
+ :name "date"
+ :display-name "Date"}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-boolean-tag-test
@@ -1032,9 +1032,9 @@
:display-name "Is Active"}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM users WHERE active = {{is_active}}"))
- (is (=? {"is_active" {:type :boolean
- :name "is_active"
- :display-name "Is Active"}}
+ (is (=? [{:type :boolean
+ :name "is_active"
+ :display-name "Is Active"}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-dimension-tag-test
@@ -1050,11 +1050,11 @@
:widget-type :text}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues WHERE {{category_filter}}"))
- (is (=? {"category_filter" {:type :dimension
- :name "category_filter"
- :display-name "Category Filter"
- :dimension [:field {} (meta/id :venues :category-id)]
- :widget-type :text}}
+ (is (=? [{:type :dimension
+ :name "category_filter"
+ :display-name "Category Filter"
+ :dimension [:field {} (meta/id :venues :category-id)]
+ :widget-type :text}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-temporal-unit-tag-test
@@ -1069,10 +1069,10 @@
:dimension (meta/id :orders :created-at)}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM orders WHERE {{date_unit}}"))
- (is (=? {"date_unit" {:type :temporal-unit
- :name "date_unit"
- :display-name "Date Unit"
- :dimension [:field {} (meta/id :orders :created-at)]}}
+ (is (=? [{:type :temporal-unit
+ :name "date_unit"
+ :display-name "Date Unit"
+ :dimension [:field {} (meta/id :orders :created-at)]}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-snippet-tag-test
@@ -1087,10 +1087,10 @@
:snippet-name "my-snippet"}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM {{snippet: my-snippet}}"))
- (is (=? {"snippet: my-snippet" {:type :snippet
- :name "snippet: my-snippet"
- :display-name "My Snippet"
- :snippet-name "my-snippet"}}
+ (is (=? [{:type :snippet
+ :name "snippet: my-snippet"
+ :display-name "My Snippet"
+ :snippet-name "my-snippet"}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-card-tag-test
@@ -1105,10 +1105,10 @@
:card-id 1}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM {{#123}}"))
- (is (=? {"#123" {:type :card
- :name "#123"
- :display-name "Card 123"
- :card-id 1}}
+ (is (=? [{:type :card
+ :name "#123"
+ :display-name "Card 123"
+ :card-id 1}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-with-multiple-tags-test
@@ -1130,39 +1130,40 @@
:widget-type :text}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues WHERE name = {{name}} AND price > {{min_price}} AND {{category_filter}}"))
- (is (=? {"name" {:type :text
- :name "name"
- :display-name "Name"}
- "min_price" {:type :number
- :name "min_price"
- :display-name "Min Price"}
- "category_filter" {:type :dimension
- :name "category_filter"
- :display-name "Category Filter"
- :dimension [:field {} (meta/id :venues :category-id)]
- :widget-type :text}}
+ (is (=? [{:type :text
+ :name "name"
+ :display-name "Name"}
+ {:type :number
+ :name "min_price"
+ :display-name "Min Price"}
+ {:type :dimension
+ :name "category_filter"
+ :display-name "Category Filter"
+ :dimension [:field {} (meta/id :venues :category-id)]
+ :widget-type :text}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-inferred-tags-test
(testing "test-native-query infers template tags from query text"
(let [query (lib.query.test-spec/test-native-query
meta/metadata-provider
- {:database-id (meta/id)
- :query "SELECT * FROM venues WHERE name = {{venue_name}}"
- :template-tags {"venue_name" {:type :text
- :display-name "Custom Name"
- :default "Foo"
- :widget-type "string/contains"
- :required true}}})]
+ {:database-id (meta/id)
+ :query "SELECT * FROM venues WHERE name = {{venue_name}}"
+ :template-tags {"venue_name" {:type :text
+ :name "venue_name"
+ :display-name "Custom Name"
+ :default "Foo"
+ :widget-type "string/contains"
+ :required true}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues WHERE name = {{venue_name}}"))
- (is (=? {"venue_name" {:type :text
- :name "venue_name"
- :display-name "Custom Name"
- :default "Foo"
- :required true
- :widget-type "string/contains"
- :id string?}}
+ (is (=? [{:type :text
+ :name "venue_name"
+ :display-name "Custom Name"
+ :default "Foo"
+ :required true
+ :widget-type "string/contains"
+ :id string?}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-empty-template-tags-test
@@ -1180,42 +1181,44 @@
(testing "test-native-query infers template tags from query text, when passing spec from JS"
(let [query (lib.query.test-spec/test-native-query
meta/metadata-provider
- {:database-id (meta/id)
- "query" "SELECT * FROM venues WHERE name = {{venue_name}}"
- "templateTags" {"venue_name" {:type :text
- :displayName "Custom Name"
- :default "Foo"
- :widgetType "string/contains"
- :required true}}})]
+ {:database-id (meta/id)
+ "query" "SELECT * FROM venues WHERE name = {{venue_name}}"
+ "templateTags" {"venue_name" {:type :text
+ :displayName "Custom Name"
+ :default "Foo"
+ :name "venue_name"
+ :widgetType "string/contains"
+ :required true}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues WHERE name = {{venue_name}}"))
- (is (=? {"venue_name" {:type :text
- :name "venue_name"
- :display-name "Custom Name"
- :default "Foo"
- :required true
- :widget-type "string/contains"
- :id string?}}
+ (is (=? [{:type :text
+ :name "venue_name"
+ :display-name "Custom Name"
+ :default "Foo"
+ :required true
+ :widget-type "string/contains"
+ :id string?}]
(lib/template-tags query))))))
(deftest ^:parallel test-native-query-inferred-optional-tags-test
(testing "test-native-query infers optional template tags from query text"
(let [query (lib.query.test-spec/test-native-query
meta/metadata-provider
- {:database-id (meta/id)
- :query "SELECT * FROM venues [WHERE name = {{venue_name}}]"
- :template-tags {"venue_name" {:type :text
- :display-name "Custom Name"
- :default "Foo"
- :widget-type "string/contains"
- :required true}}})]
+ {:database-id (meta/id)
+ :query "SELECT * FROM venues [WHERE name = {{venue_name}}]"
+ :template-tags {"venue_name" {:type :text
+ :display-name "Custom Name"
+ :default "Foo"
+ :name "venue_name"
+ :widget-type "string/contains"
+ :required true}}})]
(is (=? (lib/raw-native-query query)
"SELECT * FROM venues [WHERE name = {{venue_name}}]"))
- (is (=? {"venue_name" {:type :text
- :name "venue_name"
- :display-name "Custom Name"
- :default "Foo"
- :required true
- :widget-type "string/contains"
- :id string?}}
+ (is (=? [{:type :text
+ :name "venue_name"
+ :display-name "Custom Name"
+ :default "Foo"
+ :required true
+ :widget-type "string/contains"
+ :id string?}]
(lib/template-tags query))))))
diff --git a/test/metabase/lib/query_test.cljc b/test/metabase/lib/query_test.cljc
index 08747f17790..a5d519f0de5 100644
--- a/test/metabase/lib/query_test.cljc
+++ b/test/metabase/lib/query_test.cljc
@@ -616,12 +616,11 @@
:database 1
:stages [{:lib/type :mbql.stage/native
:native "SELECT * FROM table WHERE {{checkin_date}};"
- :template-tags {"checkin_date"
- {:dimension [:field {} 2]
+ :template-tags [{:dimension [:field {} 2]
:display-name "Checkin Date"
:name "checkin_date"
:type :dimension
- :widget-type :date/all-options}}}]}
+ :widget-type :date/all-options}]}]}
(lib.query/query-from-legacy-inner-query
meta/metadata-provider
1
diff --git a/test/metabase/lib/schema/template_tag_test.cljc b/test/metabase/lib/schema/template_tag_test.cljc
index 1a1d3af2817..8da21c1ad56 100644
--- a/test/metabase/lib/schema/template_tag_test.cljc
+++ b/test/metabase/lib/schema/template_tag_test.cljc
@@ -60,3 +60,15 @@
{:base-type :type/Text, :lib/uuid "15f3559e-5c7a-4684-9a7a-d906da2eaf61", :effective-type :type/Text}
1]
:widget-type :string/contains}))))
+
+(deftest ^:parallel normalize-template-tags-map-to-list-test
+ (testing "names in the map values need to match keys in the map"
+ (is (=? [{:name "time-unit"
+ :display-name "id"
+ :type :temporal-unit
+ :dimension [:field {:lib/uuid string?} 1]}]
+ (lib/normalize ::lib.schema.template-tag/template-tags
+ {"time-unit" {:name "id"
+ :display-name "id"
+ :type :temporal-unit
+ :dimension [:field 1]}})))))
diff --git a/test/metabase/lib/schema_test.cljc b/test/metabase/lib/schema_test.cljc
index f081a689113..bce9e1e7126 100644
--- a/test/metabase/lib/schema_test.cljc
+++ b/test/metabase/lib/schema_test.cljc
@@ -348,7 +348,7 @@
(deftest ^:parallel remove-empty-stage-metadata-test
(is (= {:lib/type :mbql/query
:database 1493
- :stages [{:template-tags {"x" {:id "6c3d5730-6f9b-4bd6-ae25-3496e8b95011", :type :text, :name "x", :display-name "X"}}
+ :stages [{:template-tags [{:id "6c3d5730-6f9b-4bd6-ae25-3496e8b95011", :type :text, :name "x", :display-name "X"}]
:lib/type :mbql.stage/native
:native "update users set name = 'foo' where id = {{x}}"}]}
(lib/normalize
@@ -384,30 +384,30 @@
AND CREATED_AT > {{after_date}}
AND USER_ID = {{user_id}}
AND {{is_active}}"
- :template-tags {"min_total" {:type :number
- :name "min_total"
- :id "aa000001-0000-0000-0000-000000000001"
- :display-name "Minimum Total"
- :default 50
- :required true
- :sectionid "number"}
- "after_date" {:type :date
- :name "after_date"
- :id "aa000002-0000-0000-0000-000000000002"
- :display-name "After Date"
- :default "2024-01-01"
- :sectionid "date"}
- "user_id" {:type :text
- :name "user_id"
- :id "aa000003-0000-0000-0000-000000000003"
- :display-name "User ID"
- :default "1"}
- "is_active" {:type :boolean
- :name "is_active"
- :id "aa000004-0000-0000-0000-000000000004"
- :display-name "Is Active"
- :default true
- :sectionid "boolean"}}}]})
+ :template-tags [{:type :number
+ :name "min_total"
+ :id "aa000001-0000-0000-0000-000000000001"
+ :display-name "Minimum Total"
+ :default 50
+ :required true
+ :sectionid "number"}
+ {:type :date
+ :name "after_date"
+ :id "aa000002-0000-0000-0000-000000000002"
+ :display-name "After Date"
+ :default "2024-01-01"
+ :sectionid "date"}
+ {:type :text
+ :name "user_id"
+ :id "aa000003-0000-0000-0000-000000000003"
+ :display-name "User ID"
+ :default "1"}
+ {:type :boolean
+ :name "is_active"
+ :id "aa000004-0000-0000-0000-000000000004"
+ :display-name "Is Active"
+ :default true
+ :sectionid "boolean"}]}]})
(deftest ^:parallel external-test
;; this one is not valid according to the internal schema because it
@@ -429,3 +429,30 @@
(is (=? {:page {:page 1, :items 15}
:limit (symbol "nil #_\"key is not present.\"")}
(lib/normalize ::lib.schema/stage stage))))))
+
+(deftest ^:parallel normalize-template-tags-map-to-vector-test
+ (testing "Template tags should get transformed from a map to a vector; preserve `:name` from map keys"
+ (let [query {:lib/type :mbql/query
+ :stages [{:lib/type :mbql.stage/native
+ :template-tags {"parameter_0" {:widget-type :category
+ :id "00000000-0000-0000-0000-000000000000"
+ :name "<WRONG NAME>"
+ :display-name "Parameter 0"
+ :type :dimension
+ :dimension [:field {} 1]
+ :default nil}
+ "parameter_1" {:widget-type :category
+ :id "00000000-0000-0000-0000-000000000001"
+ ;; (`:name` is missing)
+ :display-name "Parameter 1"
+ :type :dimension
+ :dimension [:field {} 1]
+ :default nil}}
+ :native "<<NATIVE QUERY>>"}]
+ :database 2}
+ normalized (lib/normalize ::lib.schema/query query)]
+ (is (=? {:stages [{:template-tags [{:name "parameter_0"}
+ {:name "parameter_1"}]
+ :lib/type :mbql.stage/native}]
+ :lib/type :mbql/query}
+ normalized)))))
diff --git a/test/metabase/lib_be/json_schema_test.clj b/test/metabase/lib_be/json_schema_test.clj
index f7427b1fa25..c6b956697bc 100644
--- a/test/metabase/lib_be/json_schema_test.clj
+++ b/test/metabase/lib_be/json_schema_test.clj
@@ -8,15 +8,12 @@
[metabase.lib.core :as lib]
[metabase.lib.test-metadata :as meta]
[metabase.util.json :as json-util])
- (:import (com.github.erosb.jsonsKema FormatValidationPolicy
- JsonParser
- SchemaLoader
- Validator
- ValidatorConfig)))
+ (:import
+ (com.github.erosb.jsonsKema FormatValidationPolicy JsonParser SchemaLoader Validator ValidatorConfig)))
(set! *warn-on-reflection* true)
-(defn check-node [node]
+(defn- check-node [node]
(when (map? node)
(when (contains? node "type")
(is (not= nil (node "type"))))
@@ -31,7 +28,7 @@
(is (not (some empty? all-of)) (pr-str :empty-all-of all-of))))
node)
-(def simple-query
+(def ^:private simple-query
(-> (lib/query meta/metadata-provider
(meta/table-metadata :orders))
(lib/aggregate (lib/count))
@@ -39,7 +36,7 @@
(assoc-in [:stages 0 :source-table] ["hello" "schema" "tbl"])
(assoc :database "my-db")))
-(deftest fix-json-schema-test
+(deftest ^:parallel fix-json-schema-test
(let [schema-map (js/make-schema)
schema (.load (SchemaLoader. (json-util/encode schema-map)))
validator (Validator/create schema (ValidatorConfig. FormatValidationPolicy/ALWAYS))]
diff --git a/test/metabase/lib_be/models/transforms_test.clj b/test/metabase/lib_be/models/transforms_test.clj
index b0c3dd99826..f2501259d60 100644
--- a/test/metabase/lib_be/models/transforms_test.clj
+++ b/test/metabase/lib_be/models/transforms_test.clj
@@ -62,14 +62,13 @@
(is (=? {:lib/type :mbql/query
:stages [{:lib/type :mbql.stage/native
:template-tags
- {"device_category"
- {:widget-type :category
+ [{:widget-type :category
:id "e8b0b767-0f02-b640-5de3-128e7f7fd71e"
:name "device_category"
:display-name "Device category"
:type :dimension
:dimension [:field {} 298221]
- :default nil}}
+ :default nil}]
:native "<<NATIVE QUERY>>"}]
:database 26}
(mu/disable-enforcement
diff --git a/test/metabase/metabot/query_analyzer/parameter_substitution_test.clj b/test/metabase/metabot/query_analyzer/parameter_substitution_test.clj
index 4d74fa00fea..491533c8675 100644
--- a/test/metabase/metabot/query_analyzer/parameter_substitution_test.clj
+++ b/test/metabase/metabot/query_analyzer/parameter_substitution_test.clj
@@ -8,47 +8,50 @@
(use-fixtures :once (fixtures/initialize :db))
-(deftest replace-tags-without-template-tags-test
+(deftest ^:parallel replace-tags-without-template-tags-test
(testing "Query without template tags returns raw SQL"
(let [query (lib/native-query meta/metadata-provider "SELECT * FROM venues")]
(is (= {:query "SELECT * FROM venues"}
(nqa.sub/replace-tags query))))))
-(deftest replace-tags-with-text-tag-test
+(deftest ^:parallel replace-tags-with-text-tag-test
(testing "Query with :text template tag gets default value substituted"
(let [query (lib/native-query meta/metadata-provider "SELECT * FROM venues WHERE name = {{name}}")]
(is (=? {:query "SELECT * FROM venues WHERE name = ?"
:params ["sample text"]}
(nqa.sub/replace-tags query))))))
-(deftest replace-tags-with-number-tag-test
+(deftest ^:parallel replace-tags-with-number-tag-test
(testing "Query with :number template tag gets default value substituted"
(let [query (lib/native-query meta/metadata-provider "SELECT * FROM venues WHERE id = {{id}}")
- tags (-> (lib/template-tags query)
- (update-vals #(assoc % :type :number)))
+ tags (for [tag (lib/template-tags query)]
+ (assoc tag :type :number))
query-with-tags (lib/with-template-tags query tags)]
(is (=? {:query "SELECT * FROM venues WHERE id = 1"
:params []}
(nqa.sub/replace-tags query-with-tags))))))
-(deftest replace-tags-with-date-tag-test
+(deftest ^:parallel replace-tags-with-date-tag-test
(testing "Query with :date template tag gets default value substituted"
(let [query (lib/native-query meta/metadata-provider "SELECT * FROM venues WHERE created_at = {{date}}")
- tags (-> (lib/template-tags query)
- (update-vals #(assoc % :type :date)))
+ tags (for [tag (lib/template-tags query)]
+ (assoc tag :type :date))
query-with-tags (lib/with-template-tags query tags)]
(is (=? {:query "SELECT * FROM venues WHERE created_at = ?"
:params [#t "2024-01-09"]}
(nqa.sub/replace-tags query-with-tags))))))
-(deftest replace-tags-with-multiple-tags-test
+(deftest ^:parallel replace-tags-with-multiple-tags-test
(testing "Query with multiple template tags get default values substituted"
(let [query (lib/native-query meta/metadata-provider
"SELECT * FROM venues WHERE id = {{id}} AND name = {{name}}")
- tags (-> (lib/template-tags query)
- (update "id" #(assoc % :type :number))
- (update "name" #(assoc % :type :text)))
+ tags (lib/template-tags query)
+ tags (for [{tag-name :name, :as tag} tags]
+ (case tag-name
+ "id" (assoc tag :type :number)
+ "name" (assoc tag :type :text)
+ tag))
query-with-tags (lib/with-template-tags query tags)]
- (is (=? {:query "SELECT * FROM venues WHERE id = 1 AND name = ?"
+ (is (=? {:query "SELECT * FROM venues WHERE id = 1 AND name = ?"
:params ["sample text"]}
(nqa.sub/replace-tags query-with-tags))))))
diff --git a/test/metabase/metabot/used_tables_test.clj b/test/metabase/metabot/used_tables_test.clj
index b9efb8dafce..c32a45e523e 100644
--- a/test/metabase/metabot/used_tables_test.clj
+++ b/test/metabase/metabot/used_tables_test.clj
@@ -447,7 +447,7 @@
;;; tests run the real parser end-to-end against the H2 test-data DB so we catch integration issues. They need the
;;; real application DB metadata provider, so they cannot be `^:parallel`.
-(deftest sql-real-tables-for-native-join-with-where-test
+(deftest ^:parallel sql-real-tables-for-native-join-with-where-test
(testing "real tables-for-native against a plain JOIN + WHERE: both tables come through end-to-end"
(let [sql "SELECT o.id FROM orders o JOIN products p ON o.product_id = p.id WHERE p.category = 'Widget'"
mp (mt/metadata-provider)
diff --git a/test/metabase/pulse/api/pulse_test.clj b/test/metabase/pulse/api/pulse_test.clj
index 43f4c4942fd..827b0ff426e 100644
--- a/test/metabase/pulse/api/pulse_test.clj
+++ b/test/metabase/pulse/api/pulse_test.clj
@@ -5,6 +5,7 @@
[clojure.string :as str]
[clojure.test :refer :all]
[java-time.api :as t]
+ [medley.core :as m]
[metabase.api.response :as api.response]
[metabase.channel.api.channel-test :as api.channel-test]
[metabase.channel.impl.http-test :as channel.http-test]
@@ -1387,7 +1388,7 @@
(mt/with-premium-features #{:dashboard-subscription-filters}
(let [mp (mt/metadata-provider)
query (lib/native-query mp "SELECT {{p}} AS val, 1 AS n")
- p-tag (get (lib/template-tags query) "p")
+ p-tag (m/find-first #(= (:name %) "p") (lib/template-tags query))
query (lib/with-template-tags query {"p" (assoc p-tag :required true)})]
(mt/with-temp [:model/Card {card-id :id} {:dataset_query query
:display "table"}
@@ -1421,6 +1422,10 @@
:recipients [(mt/fetch-user :rasta)]}]
:skip_if_empty false}))))
content (-> channel-messages :channel/email first :message first :content)]
+ (is (=? {:channel/email [{:message [{:content string?}
+ {:content java.net.URL}]}]}
+ channel-messages)
+ "Pro tip: if channel-messages is empty check and make sure you've built static viz with `bun run build-static-viz`")
(is (str/includes? content "override-val"))
(is (not (str/includes? content "default-val")))))))))))
diff --git a/test/metabase/pulse/test_util.clj b/test/metabase/pulse/test_util.clj
index 5318ea11541..d2e9a556e98 100644
--- a/test/metabase/pulse/test_util.clj
+++ b/test/metabase/pulse/test_util.clj
@@ -41,7 +41,7 @@
(defmacro slack-test-setup!
"Macro that ensures test-data is present and disables sending of all notifications"
[& body]
- `(with-redefs [channel/send! (constantly :noop)]
+ `(with-redefs [channel/send! (constantly :noop)]
(do-with-site-url! (fn [] ~@body))))
(defmacro with-captured-channel-send-messages!
diff --git a/test/metabase/query_processor/middleware/optimize_temporal_filters_test.clj b/test/metabase/query_processor/middleware/optimize_temporal_filters_test.clj
index 406c8288089..45508aced69 100644
--- a/test/metabase/query_processor/middleware/optimize_temporal_filters_test.clj
+++ b/test/metabase/query_processor/middleware/optimize_temporal_filters_test.clj
@@ -535,14 +535,13 @@
(lib/interval 2 :day))
(lib/relative-datetime -1 :week)
(lib/relative-datetime 0 :week))))]
- (is (=? {:query {:filter [:between
- [:+ [:field (meta/id :orders :created-at) {}]
- [:interval 2 :day]]
- [:relative-datetime -1 :week]
- [:relative-datetime 0 :week]]}}
- (-> query
- optimize-temporal-clauses/optimize-temporal-clauses
- lib/->legacy-MBQL))))))
+ (is (=? {:stages [{:filters [[:between {}
+ [:+ {}
+ [:field {} (meta/id :orders :created-at)]
+ [:interval {} 2 :day]]
+ [:relative-datetime {} -1 :week]
+ [:relative-datetime {} 0 :week]]]}]}
+ (optimize-temporal-clauses/optimize-temporal-clauses query))))))
(deftest ^:parallel optimize-date-equals-date-filters-test
(doseq [unit [:day :default]
diff --git a/test/metabase/query_processor/parameters/temporal_units_test.clj b/test/metabase/query_processor/parameters/temporal_units_test.clj
index 06d2936bb23..9aff537a829 100644
--- a/test/metabase/query_processor/parameters/temporal_units_test.clj
+++ b/test/metabase/query_processor/parameters/temporal_units_test.clj
@@ -4,6 +4,7 @@
[clojure.string :as str]
[clojure.test :refer :all]
[java-time.api :as t]
+ [medley.core :as m]
[metabase.driver :as driver]
[metabase.lib.core :as lib]
[metabase.lib.metadata :as lib.metadata]
@@ -138,7 +139,7 @@
(let [mp (mt/metadata-provider)
make (fn [default]
(let [q0 (lib/native-query mp "SELECT ID [[, {{unit}} AS unit]] FROM PEOPLE ORDER BY ID LIMIT 2")
- existing (get (lib/template-tags q0) "unit")]
+ existing (m/find-first #(= (:name %) "unit") (lib/template-tags q0))]
(lib/with-template-tags
q0 {"unit" (merge existing
{:display-name "Unit"
diff --git a/test/metabase/query_processor/parameters/values_test.clj b/test/metabase/query_processor/parameters/values_test.clj
index 538409c8e13..42f2a835733 100644
--- a/test/metabase/query_processor/parameters/values_test.clj
+++ b/test/metabase/query_processor/parameters/values_test.clj
@@ -619,13 +619,13 @@
:content "venues WHERE price = 4"}]})
query (-> (lib/native-query mp "SELECT * FROM {{snippet:expensive_venues}}")
;; force unnormalized snippet names
- (lib/update-query-stage 0 assoc :template-tags {"snippet:expensive_venues" {:type :snippet
- :name "snippet:expensive_venues"
- :display-name "Expensive Venues"
- :snippet-name "expensive_venues"
- :snippet-id 1}}))]
- (is (= {"snippet: expensive_venues" (lib/parsed-referenced-query-snippet-param 1 "venues WHERE price = 4")}
- (params.values/stage->params-map query (lib/query-stage query -1)))))))
+ (lib/update-query-stage 0 assoc :template-tags [{:type :snippet
+ :name "snippet:expensive_venues"
+ :display-name "Expensive Venues"
+ :snippet-name "expensive_venues"
+ :snippet-id 1}]))]
+ (is (= {"snippet: expensive_venues" (lib/parsed-referenced-query-snippet-param 1 "venues WHERE price = 4")}
+ (params.values/stage->params-map query (lib/query-stage query -1)))))))
(deftest ^:parallel table-tag-test
(testing "Table template tag produces a ReferencedTableQuery"
diff --git a/test/metabase/query_processor/parameters_test.clj b/test/metabase/query_processor/parameters_test.clj
index b480e979176..1d5ad86d28a 100644
--- a/test/metabase/query_processor/parameters_test.clj
+++ b/test/metabase/query_processor/parameters_test.clj
@@ -787,7 +787,8 @@
[mp ids template-tag-overrides]
(let [sql (mt/native-query-with-card-template-tag driver/*driver* "table")
base-query (lib/native-query mp sql)
- template-tag (get (lib/template-tags base-query) "table")
+ template-tag (m/find-first #(= (:name %) "table")
+ (lib/template-tags base-query))
query (lib/with-template-tags base-query
{"table" (merge template-tag {:type :table} template-tag-overrides)})]
(is (= (set ids) (query-result-ids query)))))
diff --git a/test/metabase/source_swap/native_test.clj b/test/metabase/source_swap/native_test.clj
index bd86cbb337b..4b9a0c4ed69 100644
--- a/test/metabase/source_swap/native_test.clj
+++ b/test/metabase/source_swap/native_test.clj
@@ -12,7 +12,7 @@
[mp field-id]
(lib/ref (lib.metadata/field mp field-id)))
-(defn- metadata-provider-with-cards []
+(def ^:private metadata-provider-with-cards
(lib.tu/mock-metadata-provider meta/metadata-provider
{:cards [{:id 1 :name "Card 1" :database-id (meta/id)}
{:id 2 :name "Card 2" :database-id (meta/id)}
@@ -21,14 +21,15 @@
;;; ----------------------------------------- swap-card-in-native-query (pure) ------------------------------------------
(deftest ^:parallel swap-card-in-native-query-basic-test
- (let [mp (metadata-provider-with-cards)]
+ (let [mp metadata-provider-with-cards]
(testing "Simple card tag replacement"
(let [query (-> (lib/native-query mp "SELECT * FROM {{#1}}")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}}))
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= "SELECT * FROM {{#2}}"
(lib/raw-native-query result)))
- (is (= 2 (get-in (lib/template-tags result) ["#2" :card-id])))))
+ (is (=? [{:name "#2", :card-id 2}]
+ (lib/template-tags result)))))
(testing "Multiple card tags, only matching one is replaced"
(let [query (-> (lib/native-query mp "SELECT * FROM {{#1}} JOIN {{#3}} ON 1=1")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}
@@ -36,24 +37,25 @@
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= "SELECT * FROM {{#2}} JOIN {{#3}} ON 1=1"
(lib/raw-native-query result)))
- (is (= 2 (get-in (lib/template-tags result) ["#2" :card-id])))
- (is (= 3 (get-in (lib/template-tags result) ["#3" :card-id])))))))
+ (is (=? [{:name "#2", :card-id 2}
+ {:name "#3", :card-id 3}]
+ (lib/template-tags result)))))))
(deftest ^:parallel swap-card-in-native-query-with-field-filters-test
(testing "Card tag with field filter tags present"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (-> (lib/native-query mp "SELECT * FROM {{#1}} WHERE {{created_at}}")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}
"created_at" {:type :dimension :name "created_at" :display-name "Created At" :widget-type :date/single}}))
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= "SELECT * FROM {{#2}} WHERE {{created_at}}"
(lib/raw-native-query result)))
- (is (= 2 (get-in (lib/template-tags result) ["#2" :card-id])))
- (is (= "created_at"
- (get-in (lib/template-tags result) ["created_at" :name]))))))
+ (is (=? [{:name "#2", :card-id 2}
+ {:name "created_at"}]
+ (lib/template-tags result))))))
(deftest ^:parallel swap-card-in-native-query-with-optional-clauses-test
- (let [mp (metadata-provider-with-cards)]
+ (let [mp metadata-provider-with-cards]
(testing "Card tag with optional clause containing field filter"
(let [query (-> (lib/native-query mp "SELECT * FROM {{#1}} [[WHERE {{created_at}}]]")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}
@@ -61,17 +63,20 @@
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= "SELECT * FROM {{#2}} [[WHERE {{created_at}}]]"
(lib/raw-native-query result)))
- (is (= 2 (get-in (lib/template-tags result) ["#2" :card-id])))))
+ (is (=? [{:name "#2", :card-id 2}
+ {:name "created_at"}]
+ (lib/template-tags result)))))
(testing "Card tag inside optional clause"
(let [query (-> (lib/native-query mp "SELECT * FROM foo [[JOIN {{#1}} ON 1=1]]")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}}))
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= "SELECT * FROM foo [[JOIN {{#2}} ON 1=1]]"
(lib/raw-native-query result)))
- (is (= 2 (get-in (lib/template-tags result) ["#2" :card-id])))))))
+ (is (=? [{:name "#2", :card-id 2}]
+ (lib/template-tags result)))))))
(deftest ^:parallel swap-card-in-native-query-comment-test
- (let [mp (metadata-provider-with-cards)]
+ (let [mp metadata-provider-with-cards]
(testing "Card tag inside a line comment should NOT be replaced"
(let [query (-> (lib/native-query mp "SELECT * FROM {{#1}}\n-- old: {{#1}}")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}}))
@@ -89,7 +94,7 @@
(deftest ^:parallel swap-card-in-native-query-string-literal-test
(testing "Card tag inside a SQL string literal is also replaced (parser does not distinguish string literals)"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (-> (lib/native-query mp "SELECT * FROM {{#1}} WHERE col = '{{#1}}'")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}}))
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
@@ -99,22 +104,23 @@
(deftest ^:parallel swap-card-in-native-query-multiple-cards-test
(testing "Multiple different card tags, replace only the target"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (-> (lib/native-query mp "SELECT a.* FROM {{#1}} a JOIN {{#3}} b ON a.id = b.id JOIN {{#1}} c ON a.id = c.id")
(lib/with-template-tags {"#1" {:type :card :card-id 1 :name "#1" :display-name "#1"}
"#3" {:type :card :card-id 3 :name "#3" :display-name "#3"}}))
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= "SELECT a.* FROM {{#2}} a JOIN {{#3}} b ON a.id = b.id JOIN {{#2}} c ON a.id = c.id"
(lib/raw-native-query result)))
- (is (= 2 (get-in (lib/template-tags result) ["#2" :card-id])))
- (is (= 3 (get-in (lib/template-tags result) ["#3" :card-id]))))))
+ (is (=? [{:name "#2", :card-id 2}
+ {:name "#3", :card-id 3}]
+ (lib/template-tags result))))))
;;; ------------------------------------------------ Native Query Card Reference Tests ------------------------------------------------
;;; These tests cover card→card replacement specifically in native SQL queries using {{#id}} syntax
(deftest ^:parallel swap-native-card-ref-with-whitespace-test
(testing "Card reference with whitespace ({{ #1 }}) is replaced correctly"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT * FROM {{ #1 }} WHERE x > 1")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "{{#2}}"))
@@ -122,7 +128,7 @@
(deftest ^:parallel swap-native-card-ref-multiple-test
(testing "Multiple card references to the same card are all replaced"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT * FROM {{#1}} a JOIN {{#1}} b ON a.id = b.id")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (= 2 (count (re-seq #"\{\{#2\}\}" (lib/raw-native-query result)))))
@@ -130,7 +136,7 @@
(deftest ^:parallel swap-native-card-ref-in-cte-test
(testing "Card reference in CTE is replaced correctly"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "WITH base AS {{#1}} SELECT * FROM base WHERE x > 1")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "WITH base AS {{#2}}"))
@@ -138,7 +144,7 @@
(deftest ^:parallel swap-native-card-ref-with-alias-test
(testing "Card reference with alias ({{#1}} AS t) is replaced correctly"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT t.* FROM {{#1}} AS t WHERE t.x > 1")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "{{#2}} AS t"))
@@ -146,18 +152,19 @@
(deftest ^:parallel swap-native-card-ref-preserves-other-params-test
(testing "Other template params are preserved when replacing card reference"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT * FROM {{#1}} WHERE status = {{status}} AND total > {{min_total}}")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "{{#2}}"))
(is (str/includes? (lib/raw-native-query result) "{{status}}"))
(is (str/includes? (lib/raw-native-query result) "{{min_total}}"))
- (is (contains? (lib/template-tags result) "status"))
- (is (contains? (lib/template-tags result) "min_total")))))
+ (let [tag-names (into #{} (map :name) (lib/template-tags result))]
+ (is (contains? tag-names "status"))
+ (is (contains? tag-names "min_total"))))))
(deftest ^:parallel swap-native-card-ref-different-cards-test
(testing "Only the specified card reference is replaced, others are preserved"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT * FROM {{#1}} a JOIN {{#3}} b ON a.id = b.id")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "{{#2}}"))
@@ -166,7 +173,7 @@
(deftest ^:parallel swap-native-card-ref-in-subquery-test
(testing "Card reference in subquery is replaced correctly"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT * FROM orders WHERE product_id IN (SELECT id FROM {{#1}})")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "FROM {{#2}}"))
@@ -174,7 +181,7 @@
(deftest ^:parallel swap-native-card-ref-in-optional-clause-test
(testing "Card reference inside optional clause [[...{{#1}}...]] is replaced correctly"
- (let [mp (metadata-provider-with-cards)
+ (let [mp metadata-provider-with-cards
query (lib/native-query mp "SELECT * FROM orders WHERE 1=1 [[AND product_id IN (SELECT id FROM {{#1}})]]\n")
result (source-swap.native/swap-source-in-native-stages query [:card 1] [:card 2])]
(is (str/includes? (lib/raw-native-query result) "{{#2}}"))
@@ -313,7 +320,9 @@
[:table (meta/id :products)]
[:table (meta/id :orders)])]
(is (str/includes? (lib/raw-native-query result) "ORDERS"))
- (is (not (str/includes? (lib/raw-native-query result) "PRODUCTS")))))
+ (is (not (str/includes? (lib/raw-native-query result) "PRODUCTS"))))))
+
+(deftest ^:parallel replace-table-in-native-query-test-2
(testing "table→table: template tags are preserved"
(let [query (lib/native-query meta/metadata-provider "SELECT * FROM PRODUCTS WHERE category = {{category}}")
result (source-swap.native/swap-source-in-native-stages query
@@ -321,7 +330,9 @@
[:table (meta/id :orders)])]
(is (str/includes? (lib/raw-native-query result) "ORDERS"))
(is (not (str/includes? (lib/raw-native-query result) "PRODUCTS")))
- (is (str/includes? (lib/raw-native-query result) "{{category}}"))))
+ (is (str/includes? (lib/raw-native-query result) "{{category}}")))))
+
+(deftest ^:parallel replace-table-in-native-query-test-3
(testing "table→table: only the target table is renamed in a JOIN"
(let [query (lib/native-query meta/metadata-provider "SELECT o.*, p.title FROM ORDERS o JOIN PRODUCTS p ON o.product_id = p.id")
result (source-swap.native/swap-source-in-native-stages query
@@ -329,7 +340,9 @@
[:table (meta/id :reviews)])]
(is (str/includes? (lib/raw-native-query result) "REVIEWS"))
(is (str/includes? (lib/raw-native-query result) "PRODUCTS"))
- (is (not (str/includes? (lib/raw-native-query result) "ORDERS")))))
+ (is (not (str/includes? (lib/raw-native-query result) "ORDERS"))))))
+
+(deftest ^:parallel replace-table-in-native-query-test-4
(testing "table→table: schema-qualified SQL reference is replaced"
(let [query (lib/native-query meta/metadata-provider "SELECT * FROM PUBLIC.PRODUCTS")
result (source-swap.native/swap-source-in-native-stages query
@@ -341,32 +354,37 @@
;;; ------------------------------------------------ table→card for native queries ------------------------------------------------
(deftest ^:parallel replace-table-with-card-in-native-test
- (let [mp (metadata-provider-with-cards)]
- (testing "table→card: SQL gets card template tag"
- (let [query (lib/native-query mp "SELECT * FROM PRODUCTS")
- result (source-swap.native/swap-source-in-native-stages query
- [:table (meta/id :products)]
- [:card 1])]
- (is (str/includes? (lib/raw-native-query result) "{{#1-card-1}}"))
- (is (not (str/includes? (lib/raw-native-query result) "PRODUCTS")))
- (is (= 1 (get-in (lib/template-tags result) ["#1-card-1" :card-id])))))
- (testing "table→card: existing template tags are preserved"
- (let [query (lib/native-query mp "SELECT * FROM PRODUCTS WHERE category = {{category}}")
- result (source-swap.native/swap-source-in-native-stages query
- [:table (meta/id :products)]
- [:card 1])]
- (is (str/includes? (lib/raw-native-query result) "{{#1-card-1}}"))
- (is (str/includes? (lib/raw-native-query result) "{{category}}"))
- (is (contains? (lib/template-tags result) "category"))
- (is (= 1 (get-in (lib/template-tags result) ["#1-card-1" :card-id])))))
- (testing "table→card: schema-qualified SQL gets card ref without schema prefix"
- (let [query (lib/native-query mp "SELECT * FROM PUBLIC.PRODUCTS")
- result (source-swap.native/swap-source-in-native-stages query
- [:table (meta/id :products)]
- [:card 1])]
- (is (str/includes? (lib/raw-native-query result) "{{#1-card-1}}"))
- (is (not (str/includes? (lib/raw-native-query result) "PUBLIC.{{")))
- (is (not (str/includes? (lib/raw-native-query result) "PRODUCTS")))))))
+ (testing "table→card: SQL gets card template tag"
+ (let [query (lib/native-query metadata-provider-with-cards "SELECT * FROM PRODUCTS")
+ result (source-swap.native/swap-source-in-native-stages query
+ [:table (meta/id :products)]
+ [:card 1])]
+ (is (str/includes? (lib/raw-native-query result) "{{#1-card-1}}"))
+ (is (not (str/includes? (lib/raw-native-query result) "PRODUCTS")))
+ (is (=? [{:name "#1-card-1", :card-id 1}]
+ (lib/template-tags result))))))
+
+(deftest ^:parallel replace-table-with-card-in-native-test-2
+ (testing "table→card: existing template tags are preserved"
+ (let [query (lib/native-query metadata-provider-with-cards "SELECT * FROM PRODUCTS WHERE category = {{category}}")
+ result (source-swap.native/swap-source-in-native-stages query
+ [:table (meta/id :products)]
+ [:card 1])]
+ (is (str/includes? (lib/raw-native-query result) "{{#1-card-1}}"))
+ (is (str/includes? (lib/raw-native-query result) "{{category}}"))
+ (is (=? [{:name "category"}
+ {:name "#1-card-1", :card-id 1}]
+ (lib/template-tags result))))))
+
+(deftest ^:parallel replace-table-with-card-in-native-test-3
+ (testing "table→card: schema-qualified SQL gets card ref without schema prefix"
+ (let [query (lib/native-query metadata-provider-with-cards "SELECT * FROM PUBLIC.PRODUCTS")
+ result (source-swap.native/swap-source-in-native-stages query
+ [:table (meta/id :products)]
+ [:card 1])]
+ (is (str/includes? (lib/raw-native-query result) "{{#1-card-1}}"))
+ (is (not (str/includes? (lib/raw-native-query result) "PUBLIC.{{")))
+ (is (not (str/includes? (lib/raw-native-query result) "PRODUCTS"))))))
;;; ------------------------------------------------ card→table for native queries ------------------------------------------------
@@ -379,7 +397,9 @@
[:table (meta/id :orders)])]
(is (str/includes? (lib/raw-native-query result) "ORDERS"))
(is (not (str/includes? (lib/raw-native-query result) "{{#1")))
- (is (empty? (filter #(= (:card-id %) 1) (vals (lib/template-tags result)))))))
+ (is (empty? (filter #(= (:card-id %) 1) (vals (lib/template-tags result))))))))
+
+(deftest ^:parallel replace-card-with-table-in-native-test-2
(testing "card→table: other template tags are preserved"
(let [query (-> (lib/native-query meta/metadata-provider "SELECT * FROM {{#1-card-1}} WHERE status = {{status}}")
(lib/with-template-tags {"#1-card-1" {:type :card :card-id 1 :name "#1-card-1" :display-name "#1-card-1"}}))
@@ -388,8 +408,8 @@
[:table (meta/id :orders)])]
(is (str/includes? (lib/raw-native-query result) "ORDERS"))
(is (str/includes? (lib/raw-native-query result) "{{status}}"))
- (is (contains? (lib/template-tags result) "status"))
- (is (empty? (filter #(= (:card-id %) 1) (vals (lib/template-tags result))))))))
+ (is (=? [{:name "status", :type :text, :card-id (symbol "nil #_\"key is not present.\"")}]
+ (lib/template-tags result))))))
;;; ------------------------------------------------ Table Tag Tests ------------------------------------------------
@@ -400,57 +420,59 @@
result (#'source-swap.native/update-table-tags-for-table-swap
(lib/template-tags query)
1 2)]
- (is (= 2 (get-in result ["my_table" :table-id]))))))
+ (is (=? [{:name "my_table", :table-id 2}]
+ result)))))
(deftest ^:parallel swap-table-to-card-with-table-tag-test
(testing "swap-source table → card: {{my_table}} becomes {{#card-id-slug}}"
(let [sql "SELECT * FROM {{my_table}}"
- tags {"my_table" {:type :table :table-id 1 :name "my_table" :display-name "My Table"}}
+ tags [{:type :table :table-id 1 :name "my_table" :display-name "My Table"}]
{:keys [sql template-tags]} (#'source-swap.native/update-table-tags-for-card-swap sql tags 1 2 "New Card")]
;; SQL should have card reference
(is (str/includes? sql "{{#2-new-card}}"))
(is (not (str/includes? sql "{{my_table}}")))
- ;; Template tag should be :type :card now
- (is (= :card (get-in template-tags ["#2-new-card" :type])))
- (is (= 2 (get-in template-tags ["#2-new-card" :card-id])))
- ;; Old table tag should be gone
- (is (not (contains? template-tags "my_table"))))))
+ ;; Template tag should be :type :card now; old table tag should be gone
+ (is (=? [{:name "#2-new-card", :type :card, :card-id 2}]
+ template-tags)))))
(deftest ^:parallel swap-table-to-card-preserves-required-flag-test
(testing "swap-source table → card: :required flag is preserved"
- (let [sql "SELECT * FROM {{my_table}}"
- tags {"my_table" {:type :table
- :table-id 1
- :name "my_table"
- :display-name "My Table"
- :required true
- :default "fallback"}}
- {:keys [template-tags]} (#'source-swap.native/update-table-tags-for-card-swap sql tags 1 2 "New Card")]
+ (let [sql "SELECT * FROM {{my_table}}"
+ tags [{:type :table
+ :table-id 1
+ :name "my_table"
+ :display-name "My Table"
+ :required true
+ :default "fallback"}]]
;; :required and :default should be preserved
- (is (true? (get-in template-tags ["#2-new-card" :required])))
- (is (= "fallback" (get-in template-tags ["#2-new-card" :default]))))))
+ (is (=? [{:name "#2-new-card", :required true, :default "fallback"}]
+ (:template-tags (#'source-swap.native/update-table-tags-for-card-swap sql tags 1 2 "New Card")))))))
;;; ------------------------------------------------ Dimension Tag Tests ------------------------------------------------
(deftest ^:parallel update-dimension-tags-test
(testing "dimension tag field ref is remapped to new table's field"
(let [query (lib/native-query meta/metadata-provider "SELECT 1")
- tags {"filter" {:type :dimension
- :name "filter"
- :dimension (field-id-ref meta/metadata-provider (meta/id :products :id))}}
+ tags [{:type :dimension
+ :name "filter"
+ :display-name "Filter"
+ :widget-type :number/=
+ :dimension (field-id-ref meta/metadata-provider (meta/id :products :id))}]
result (#'source-swap.native/update-dimension-tags query tags (meta/id :products) (meta/id :orders))]
- (is (=? {"filter" {:dimension [:field {} (meta/id :orders :id)]}}
+ (is (=? [{:name "filter", :dimension [:field {} (meta/id :orders :id)]}]
result)))))
(deftest ^:parallel update-dimension-tags-no-match-test
(testing "dimension tag left unchanged when no matching field on new table"
(let [query (lib/native-query meta/metadata-provider "SELECT 1")
dimension (field-id-ref meta/metadata-provider (meta/id :products :ean))
- tags {"filter" {:type :dimension
- :name "filter"
- :dimension dimension}}
+ tags [{:type :dimension
+ :name "filter"
+ :display-name "Filter"
+ :widget-type :number/=
+ :dimension dimension}]
;; Orders table doesn't have an EAN field
- result (#'source-swap.native/update-dimension-tags query tags (meta/id :products) (meta/id :orders))]
+ result (#'source-swap.native/update-dimension-tags query tags (meta/id :products) (meta/id :orders))]
;; Should be unchanged since no matching field
- (is (= dimension
- (get-in result ["filter" :dimension]))))))
+ (is (=? [{:name "filter", :dimension dimension}]
+ result)))))
diff --git a/test/metabase/transforms_rest/api/transform_test.clj b/test/metabase/transforms_rest/api/transform_test.clj
index 6926a9887ff..0c750becb74 100644
--- a/test/metabase/transforms_rest/api/transform_test.clj
+++ b/test/metabase/transforms_rest/api/transform_test.clj
@@ -182,7 +182,8 @@
(with-transform-cleanup! [table-name "gadget_products"]
(testing "Cannot create a transform with a required param"
(let [base-query (lib/native-query (mt/metadata-provider) "select * from foo where {{id}} = id")
- tag (get (lib/template-tags base-query) "id")
+ tag (m/find-first #(= (:name %) "id")
+ (lib/template-tags base-query))
query (lib/with-template-tags base-query
{"id" (assoc tag :required true)})
schema (get-test-schema)
@@ -349,7 +350,8 @@
:name table-name}})
transform-id (:id created)
base-query (lib/native-query (mt/metadata-provider) "select * from foo where {{id}} = id")
- tag (get (lib/template-tags base-query) "id")
+ tag (m/find-first #(= (:name %) "id")
+ (lib/template-tags base-query))
new-query (lib/with-template-tags base-query
{"id" (assoc tag :required true)})
response (mt/user-http-request :crowberto :put 400
diff --git a/test_resources/serialization_baseline/collections/main/dashboards/series_and_parameter_mappings/native_orders_query.yaml b/test_resources/serialization_baseline/collections/main/dashboards/series_and_parameter_mappings/native_orders_query.yaml
index 8832ce35b48..9f9d9ef290f 100644
--- a/test_resources/serialization_baseline/collections/main/dashboards/series_and_parameter_mappings/native_orders_query.yaml
+++ b/test_resources/serialization_baseline/collections/main/dashboards/series_and_parameter_mappings/native_orders_query.yaml
@@ -11,8 +11,7 @@ dataset_query:
stages:
- native: SELECT * FROM ORDERS WHERE TOTAL > {{min_total}}
template-tags:
- min_total:
- default: 50
+ - default: 50
display-name: Minimum Total
id: ee000001-0000-0000-0000-000000000001
name: min_total
diff --git a/test_resources/serialization_baseline/collections/main/minimal/marketing_analytics/top_products_by_revenue.yaml b/test_resources/serialization_baseline/collections/main/minimal/marketing_analytics/top_products_by_revenue.yaml
index cd51609c679..ca981c66a00 100644
--- a/test_resources/serialization_baseline/collections/main/minimal/marketing_analytics/top_products_by_revenue.yaml
+++ b/test_resources/serialization_baseline/collections/main/minimal/marketing_analytics/top_products_by_revenue.yaml
@@ -21,8 +21,7 @@ dataset_query:
ORDER BY revenue DESC
LIMIT 10
template-tags:
- category:
- default: Widget
+ - default: Widget
display-name: Category
id: b2c3d4e5-f678-90ab-cdef-1234567890ab
name: category
diff --git a/test_resources/serialization_baseline/collections/main/queries/native_query___card_and_snippet_references.yaml b/test_resources/serialization_baseline/collections/main/queries/native_query___card_and_snippet_references.yaml
index 7f7d18e2442..da8caef479f 100644
--- a/test_resources/serialization_baseline/collections/main/queries/native_query___card_and_snippet_references.yaml
+++ b/test_resources/serialization_baseline/collections/main/queries/native_query___card_and_snippet_references.yaml
@@ -16,14 +16,12 @@ dataset_query:
ORDER BY "count" DESC
LIMIT 10
template-tags:
- '#1-basic_aggregations':
- card-id: h5F2EjHsRd73Dqqh8sAtd
+ - card-id: h5F2EjHsRd73Dqqh8sAtd
display-name: Basic Aggregations
id: cc000001-0000-0000-0000-000000000001
name: '#1-basic_aggregations'
type: card
- 'snippet: Active Product Filter':
- display-name: 'Snippet: Active Product Filter'
+ - display-name: 'Snippet: Active Product Filter'
id: cc000002-0000-0000-0000-000000000002
name: 'snippet: Active Product Filter'
snippet-id: WyQWnT23PF-SfbYLROllJ
diff --git a/test_resources/serialization_baseline/collections/main/queries/native_query___field_filter_and_temporal_unit.yaml b/test_resources/serialization_baseline/collections/main/queries/native_query___field_filter_and_temporal_unit.yaml
index 2efd61d6b59..0c3635c0319 100644
--- a/test_resources/serialization_baseline/collections/main/queries/native_query___field_filter_and_temporal_unit.yaml
+++ b/test_resources/serialization_baseline/collections/main/queries/native_query___field_filter_and_temporal_unit.yaml
@@ -17,8 +17,7 @@ dataset_query:
AND {{date_filter}}
GROUP BY {{created_at}}, PRODUCTS.CATEGORY
template-tags:
- category_filter:
- dimension:
+ - dimension:
- field
- {}
- - Sample Database
@@ -30,8 +29,7 @@ dataset_query:
name: category_filter
type: dimension
widget-type: string/=
- created_at:
- default: month
+ - default: month
dimension:
- field
- {}
@@ -44,8 +42,7 @@ dataset_query:
name: created_at
sectionid: date
type: temporal-unit
- date_filter:
- dimension:
+ - dimension:
- field
- {}
- - Sample Database
diff --git a/test_resources/serialization_baseline/collections/main/queries/native_query___variables.yaml b/test_resources/serialization_baseline/collections/main/queries/native_query___variables.yaml
index 09201f93c4d..9ab0889e11b 100644
--- a/test_resources/serialization_baseline/collections/main/queries/native_query___variables.yaml
+++ b/test_resources/serialization_baseline/collections/main/queries/native_query___variables.yaml
@@ -17,30 +17,26 @@ dataset_query:
AND USER_ID = {{user_id}}
AND {{is_active}}
template-tags:
- after_date:
- default: '2024-01-01'
+ - default: '2024-01-01'
display-name: After Date
id: aa000002-0000-0000-0000-000000000002
name: after_date
sectionid: date
type: date
- is_active:
- default: true
+ - default: true
display-name: Is Active
id: aa000004-0000-0000-0000-000000000004
name: is_active
sectionid: boolean
type: boolean
- min_total:
- default: 50
+ - default: 50
display-name: Minimum Total
id: aa000001-0000-0000-0000-000000000001
name: min_total
required: true
sectionid: number
type: number
- user_id:
- default: '1'
+ - default: '1'
display-name: User ID
id: aa000003-0000-0000-0000-000000000003
name: user_id