The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
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.cljindex 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 clausesdiff --git a/enterprise/backend/src/metabase_enterprise/dependencies/native_validation.clj b/enterprise/backend/src/metabase_enterprise/dependencies/native_validation.cljindex 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 tagssql-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 tagsmodified-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(-> querydiff --git a/enterprise/backend/test/metabase_enterprise/serialization/v2/load_test.clj b/enterprise/backend/test/metabase_enterprise/serialization/v2/load_test.cljindex 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.cljcindex 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.cljcindex 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.cljcindex 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.cljsindex 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.cljcindex 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.cljcindex 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-providerablequery-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-stagequery 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 aquery 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.cljcindex 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 returnsnormalized-name or nil if no match."diff --git a/src/metabase/lib/query.cljc b/src/metabase/lib/query.cljcindex 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](conddiff --git a/src/metabase/lib/query/test_spec.cljc b/src/metabase/lib/query/test_spec.cljcindex 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-tagstemplate-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/querytemplate-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/transformermtx/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.cljcindex 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.cljcindex 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 ::tablediff --git a/src/metabase/lib/schema/template_tag.cljc b/src/metabase/lib/schema/template_tag.cljcindex 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.cljcindex 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.cljcindex 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.cljcindex 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.cljindex 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-specifictemplate 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.cljindex 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/NativeQuerySnippetdiff --git a/src/metabase/native_query_snippets/schema.clj b/src/metabase/native_query_snippets/schema.cljindex 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.cljindex 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-tagsdatabase-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.cljindex 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 :- :mapinit-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-providerablegraphdiff --git a/src/metabase/query_processor/parameters/values.clj b/src/metabase/query_processor/parameters/values.cljindex 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.cljindex 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))sqltable-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 tagnew-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-swapsql-after-rawtemplate-tagsold-table-idnew-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.cljindex 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-stagequery 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.cljindex 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.cljcindex 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/Textdiff --git a/test/metabase/lib/fe_util_test.cljc b/test/metabase/lib/fe_util_test.cljcindex 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.cljsindex 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.cljcindex 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-tagsmetadata-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-tagsmetadata-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-tagsmetadata-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-providermeta/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.cljcindex 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-querymeta/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-querymeta/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-querymeta/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.cljcindex 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-querymeta/metadata-provider1diff --git a/test/metabase/lib/schema/template_tag_test.cljc b/test/metabase/lib/schema/template_tag_test.cljcindex 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.cljcindex 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.cljindex 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.cljindex 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-enforcementdiff --git a/test/metabase/metabot/query_analyzer/parameter_substitution_test.clj b/test/metabase/metabot/query_analyzer/parameter_substitution_test.cljindex 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.cljindex 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.cljindex 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.cljindex 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.cljindex 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.cljindex 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-tagsq0 {"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.cljindex 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.cljindex 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.cljindex 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-cardsquery (-> (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-cardsquery (-> (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-cardsquery (-> (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-cardsquery (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-cardsquery (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-cardsquery (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-cardsquery (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-cardsquery (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-cardsquery (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-cardsquery (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-cardsquery (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.cljindex 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 400diff --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.yamlindex 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: 50display-name: Minimum Totalid: ee000001-0000-0000-0000-000000000001name: min_totaldiff --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.yamlindex 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 DESCLIMIT 10template-tags:- category:- default: Widget+ - default: Widgetdisplay-name: Categoryid: b2c3d4e5-f678-90ab-cdef-1234567890abname: categorydiff --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.yamlindex 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" DESCLIMIT 10template-tags:- '#1-basic_aggregations':- card-id: h5F2EjHsRd73Dqqh8sAtd+ - card-id: h5F2EjHsRd73Dqqh8sAtddisplay-name: Basic Aggregationsid: cc000001-0000-0000-0000-000000000001name: '#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-000000000002name: 'snippet: Active Product Filter'snippet-id: WyQWnT23PF-SfbYLROllJdiff --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.yamlindex 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.CATEGORYtemplate-tags:- category_filter:- dimension:+ - dimension:- field- {}- - Sample Database@@ -30,8 +29,7 @@ dataset_query:name: category_filtertype: dimensionwidget-type: string/=- created_at:- default: month+ - default: monthdimension:- field- {}@@ -44,8 +42,7 @@ dataset_query:name: created_atsectionid: datetype: temporal-unit- date_filter:- dimension:+ - dimension:- field- {}- - Sample Databasediff --git a/test_resources/serialization_baseline/collections/main/queries/native_query___variables.yaml b/test_resources/serialization_baseline/collections/main/queries/native_query___variables.yamlindex 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 Dateid: aa000002-0000-0000-0000-000000000002name: after_datesectionid: datetype: date- is_active:- default: true+ - default: truedisplay-name: Is Activeid: aa000004-0000-0000-0000-000000000004name: is_activesectionid: booleantype: boolean- min_total:- default: 50+ - default: 50display-name: Minimum Totalid: aa000001-0000-0000-0000-000000000001name: min_totalrequired: truesectionid: numbertype: number- user_id:- default: '1'+ - default: '1'display-name: User IDid: aa000003-0000-0000-0000-000000000003name: user_id