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
Finish migrating from deprecated `drivers.common.parameters` parsing code to Lib (#74236)
Cam Saul0a17a810ed8a
diff --git a/.clj-kondo/config.edn b/.clj-kondo/config.ednindex 29d3a236096..36635a5c413 100644--- a/.clj-kondo/config.edn+++ b/.clj-kondo/config.edn@@ -899,10 +899,8 @@:deprecated-namespace{:exclude- [metabase.driver.common.parameters- metabase.driver.common.parameters.dates+ [metabase.driver.common.parameters.datesmetabase.driver.common.parameters.operators- metabase.driver.common.parameters.parsemetabase.driver.common.parameters.valuesmetabase.legacy-mbql.jvm-utilmetabase.legacy-mbql.normalizediff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.ednindex d931429a6f2..c9115f3bc3b 100644--- a/.clj-kondo/config/modules/config.edn+++ b/.clj-kondo/config/modules/config.edn@@ -806,8 +806,6 @@{:team "Querying Platform":api #{metabase.drivermetabase.driver.common- metabase.driver.common.parameters- metabase.driver.common.parameters.parsemetabase.driver.connectionmetabase.driver.ddl.interfacemetabase.driver.h2@@ -2665,6 +2663,7 @@api-keysapp-dbdriver+ libpermissionspremium-featuressettingsdiff --git a/docs/developers-guide/driver-changelog.md b/docs/developers-guide/driver-changelog.mdindex 670a9f0e484..3e41713a805 100644--- a/docs/developers-guide/driver-changelog.md+++ b/docs/developers-guide/driver-changelog.md@@ -35,6 +35,14 @@ title: Driver interface changelog`metabase.driver.sql-jdbc/set-role-statement`, which takes an additional `java.sql.Connection` parameter, so you usethe connection to call `quote_ident()` or similar for identifier quoting/escaping purposes.+- The `metabase.driver.commmon.parameters` and `metabase.driver.commmon.parameters.parse` namespaces, deprecated in+ 0.57.0, have been removed. Please use the Lib implementations instead. Relevant functions are aliased in+ `metabase.lib.core`, for example `metabase.lib.core/parse-parameters`, `metabase.lib.core/parsed-parameter`, and+ `metabase.lib.core/parsed-parameter?`.++- `metabase.driver.sql.parameters.substitution/align-temporal-unit-with-param-type`, deprecated in 0.49.0, has been+ removed.+## Metabase 0.60.0- Added `validate-impersonated-query` multimethod. This is used for drivers to perform validation on impersonated native queries.diff --git a/enterprise/backend/src/metabase_enterprise/advanced_config/file.clj b/enterprise/backend/src/metabase_enterprise/advanced_config/file.cljindex f1107b00327..fa18a6d355e 100644--- a/enterprise/backend/src/metabase_enterprise/advanced_config/file.clj+++ b/enterprise/backend/src/metabase_enterprise/advanced_config/file.clj@@ -61,7 +61,7 @@### TemplatesAfter spec validation, the config map is walked and `{{template}}` forms are expanded. This uses the same code used- to parse template tags in SQL queries, i.e. [[metabase.driver.common.parameters.parse]], which means that+ to parse template tags in SQL queries, i.e. [[metabase.lib.parameters.parse]], which means that`[[optional {{templates}}]]` work as well, if there is some reason you might need them.A template form like `{{env MY_ENV_VAR}}` is wrapped in parens and parsed as EDN, and then the result is passed@@ -101,19 +101,16 @@[metabase-enterprise.advanced-config.file.interface :as advanced-config.file.i][metabase-enterprise.advanced-config.file.settings][metabase-enterprise.advanced-config.file.users]- ;; TODO (Cam 10/3/25) -- update this to use the Lib versions of these namespaces- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse]+ [metabase.lib.core :as lib][metabase.premium-features.core :as premium-features][metabase.util :as u][metabase.util.files :as u.files][metabase.util.i18n :refer [trs tru]][metabase.util.log :as log]+ [metabase.util.malli :as mu][metabase.util.yaml :as yaml]))(comment- ;; for parameter parsing- metabase.driver.common.parameters/keep-me;; for `settings:` section codemetabase-enterprise.advanced-config.file.settings/keep-me;; for `databases:` section code@@ -190,7 +187,7 @@(defmulti ^:private expand-template-str-part{:arglists '([part])}- type)+ (some-fn :lib/type type))(defmethod expand-template-str-part String[s]@@ -204,8 +201,8 @@(s/or :env (s/cat :template-type (s/and symbol? valid-template-type?):env-var-name symbol?)))-(defmethod expand-template-str-part metabase.driver.common.parameters.Param- [{s :k}]+(mu/defmethod expand-template-str-part :metabase.lib.parameters.parse.types/param+ [{s :k} :- :metabase.lib.parameters.parse.types/param]{:pre [(string? s)]}(when (seq s)(when-let [obj (try@@ -216,16 +213,16 @@(s/assert* ::template-form obj)(expand-parsed-template-form obj))))-(defmethod expand-template-str-part metabase.driver.common.parameters.Optional- [{:keys [args]}]+(mu/defmethod expand-template-str-part :metabase.lib.parameters.parse.types/optional+ [{:keys [args]} :- :metabase.lib.parameters.parse.types/optional](let [parts (map expand-template-str-part args)](when (every? seq parts)(str/join parts))))(defn- expand-templates-in-str [s]- (if-let [[_, raw-string] (re-matches #"\{\{\{(.+)\}\}\}" s)]+ (if-let [[_ raw-string] (re-matches #"\{\{\{(.+)\}\}\}" s)](str/trim raw-string)- (str/join (map expand-template-str-part (params.parse/parse s)))))+ (str/join (map expand-template-str-part (lib/parse-parameters s)))))(defn- expand-templates [m](walk/postwalkdiff --git a/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj b/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.cljindex b0bf2a578db..10677c7ce2e 100644--- a/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj+++ b/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj@@ -9,7 +9,6 @@[metabase.driver-api.core :as driver-api][metabase.driver.bigquery-cloud-sdk.common :as bigquery.common][metabase.driver.common :as driver.common]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters][metabase.driver.connection :as driver.conn][metabase.driver.sql.parameters.substitution :as sql.params.substitution][metabase.driver.sql.query-processor :as sql.qp]@@ -35,13 +34,10 @@LocalTimeOffsetDateTimeOffsetTime- ZonedDateTime)- (metabase.driver.common.parameters FieldFilter)))+ ZonedDateTime)))(set! *warn-on-reflection* true)-(comment metabase.driver.common.parameters/keep-me)-(defn- valid-project-identifier?"Is String `s` a valid BigQuery project identifier (a.k.a. project-id)? Identifiers are only allowed to containletters, numbers, and underscores, cannot start with a number, and for project-id, can be at most 30 characters long."@@ -1039,12 +1035,12 @@[_driver]:mysql)-(mu/defmethod sql.params.substitution/->replacement-snippet-info [:bigquery-cloud-sdk FieldFilter]+(mu/defmethod sql.params.substitution/->replacement-snippet-info [:bigquery-cloud-sdk :metabase.lib.parameters.parse.types/field-filter][driver :- :keyword{:keys [field], :as field-filter} :- [:map[:field driver-api/schema.metadata.column]]](let [field-temporal-type (temporal-type field)- parent-method (get-method sql.params.substitution/->replacement-snippet-info [:sql FieldFilter])+ parent-method (get-method sql.params.substitution/->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/field-filter])result (parent-method driver field-filter)](cond-> resultfield-temporal-type (update :prepared-statement-args (fn [args]diff --git a/modules/drivers/mongo/src/metabase/driver/mongo/parameters.clj b/modules/drivers/mongo/src/metabase/driver/mongo/parameters.cljindex da4e4a467e0..ac42aa54b84 100644--- a/modules/drivers/mongo/src/metabase/driver/mongo/parameters.clj+++ b/modules/drivers/mongo/src/metabase/driver/mongo/parameters.clj@@ -4,12 +4,11 @@[clojure.string :as str][java-time.api :as t][metabase.driver-api.core :as driver-api]- [metabase.driver.common.parameters :as params][metabase.driver.common.parameters.dates :as params.dates][metabase.driver.common.parameters.operators :as params.ops]- [metabase.driver.common.parameters.parse :as params.parse][metabase.driver.common.parameters.values :as params.values][metabase.driver.mongo.query-processor :as mongo.qp]+ [metabase.lib.core :as lib][metabase.util :as u][metabase.util.date-2 :as u.date][metabase.util.i18n :refer [tru]]@@ -19,8 +18,7 @@[metabase.util.performance :as perf :refer [get-in]])(:import(java.time ZoneOffset)- (java.time.temporal Temporal)- (metabase.driver.common.parameters Date)))+ (java.time.temporal Temporal)))(set! *warn-on-reflection* true)@@ -44,7 +42,7 @@;; Date = the Parameters Date type, not an java.util.Date or java.sql.Date type;; convert to a `Temporal` instance and recur- (instance? Date x)+ (lib/parsed-date-param? x)(recur field (u.date/parse (:s x)))(and (instance? Temporal x)@@ -86,9 +84,10 @@(or start-conditionend-condition))))-;; Field filter value is either params/no-value (handled in `substitute-param`, a map with `:type` and `:value`, or a+;; Field filter value is either lib/parsed-param-no-value-placeholder (handled in `substitute-param`, a map with `:type` and `:value`, or a;; sequence of those maps.-(defn- substitute-one-field-filter [{field :field, alias :alias, {param-type :type, value :value} :value, :as field-filter}]+(mu/defn- substitute-one-field-filter+ [{:keys [field alias], {param-type :type, value :value} :value, :as field-filter} :- :metabase.lib.parameters.parse.types/field-filter];; convert relative dates to appropriate date range representations(cond(params.dates/not-single-date-type? param-type)@@ -106,25 +105,28 @@(format "{%s: %s}" (field->name field alias) (param-value->str field value))))(mu/defn- substitute-field-filter- [{field :field, alias :alias, {:keys [value]} :value, :as field-filter} :- [:map- [:field driver-api/schema.metadata.column]- [:value [:map [:value :any]]]]]+ [{field :field, alias :alias, {:keys [value]} :value, :as field-filter} :- :metabase.lib.parameters.parse.types/field-filter](if (sequential? value)(format "{%s: %s}" (field->name field alias) (param-value->str field value))(substitute-one-field-filter field-filter)))-(defn- substitute-native-query-snippet [[acc missing] v]- (let [{:keys [content]} v]- [(conj acc content) missing]))+(mu/defn- substitute-native-query-snippet+ [[acc missing]+ {:keys [content]} :- :metabase.lib.parameters.parse.types/referenced-query-snippet]+ [(conj acc content) missing])-(defn- substitute-param [param->value [acc missing] in-optional? {:keys [k], :as _param}]+(mu/defn- substitute-param+ [param->value+ [acc missing]+ in-optional?+ {:keys [k], :as _param} :- :metabase.lib.parameters.parse.types/param](let [v (get param->value k)](cond(not (contains? param->value k))[acc (conj missing k)]- (params/FieldFilter? v)- (let [no-value? (= (:value v) params/no-value)]+ (lib/parsed-field-filter-param? v)+ (let [no-value? (= (:value v) lib/parsed-param-no-value-placeholder)](cond(params.ops/operator? (get-in v [:value :type]))#_{:clj-kondo/ignore [:deprecated-var]}@@ -153,14 +155,14 @@:else [(conj acc (substitute-field-filter v))missing]))- (params/ReferencedQuerySnippet? v)+ (lib/parsed-referenced-query-snippet-param? v)(substitute-native-query-snippet [acc missing] v)- (params/ReferencedCardQuery? v)+ (lib/parsed-referenced-card-query-param? v)(throw (ex-info (tru "Cannot run query: MongoDB doesn''t support saved questions reference: {0}" k){:type driver-api/qp.error-type.invalid-query}))- (= v params/no-value)+ (= v lib/parsed-param-no-value-placeholder)[acc (conj missing k)]:else@@ -168,7 +170,10 @@(declare substitute*)-(defn- substitute-optional [param->value [acc missing] {subclauses :args}]+(mu/defn- substitute-optional+ [param->value+ [acc missing]+ {subclauses :args} :- :metabase.lib.parameters.parse.types/optional](let [[opt-acc opt-missing] (substitute* param->value subclauses true)](if (seq opt-missing)[acc missing]@@ -183,10 +188,10 @@(string? x)[(conj acc x) missing]- (params/Param? x)+ (lib/parsed-param? x)(substitute-param param->value [acc missing] in-optional? x)- (params/Optional? x)+ (lib/parsed-optional-param? x)(substitute-optional param->value [acc missing] x):else@@ -195,7 +200,9 @@[[] nil]xs))-(defn- substitute [param->value xs]+(mu/defn- substitute+ [param->value :- [:maybe [:map-of :string :any]]+ xs](let [[replaced missing] (substitute* param->value xs false)](when (seq missing)(throw (ex-info (tru "Cannot run query: missing required parameters: {0}" (set missing))@@ -206,7 +213,7 @@(defn- parse-and-substitute [param->value x](if-not (string? x)x- (u/prog1 (substitute param->value (params.parse/parse x false))+ (u/prog1 (substitute param->value (lib/parse-parameters x false))(when-not (= x <>)(log/debugf "Substituted %s -> %s" (pr-str x) (pr-str <>))))))diff --git a/modules/drivers/mongo/test/metabase/driver/mongo/parameters_test.clj b/modules/drivers/mongo/test/metabase/driver/mongo/parameters_test.cljindex 62d6256f50e..de40e9bf5d6 100644--- a/modules/drivers/mongo/test/metabase/driver/mongo/parameters_test.clj+++ b/modules/drivers/mongo/test/metabase/driver/mongo/parameters_test.clj@@ -7,11 +7,12 @@[clojure.string :as str][clojure.test :refer :all][java-time.api :as t]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params][metabase.driver.mongo.parameters :as mongo.params]+ [metabase.lib.core :as lib][metabase.query-processor.test :as qp][metabase.test :as mt]- [metabase.util.json :as json]))+ [metabase.util.json :as json]+ [metabase.util.malli :as mu]))(set! *warn-on-reflection* true)@@ -24,98 +25,95 @@(is (= (t/instant "2020-03-14T00:00:00Z")(#'mongo.params/->utc-instant t))))))-(defn- substitute [param->value xs]- (#'mongo.params/substitute param->value xs))+(mu/defn- optional :- :metabase.lib.parameters.parse.types/optional+ [& args]+ (lib/parsed-optional-param args))-(defn- param [k]- (params/->Param k))--(defn- optional [& xs]- (params/->Optional xs))--(defn- field-filter+(mu/defn- field-filter :- :metabase.lib.parameters.parse.types/field-filter([field-name value-type value](field-filter field-name nil value-type value))([field-name base-type value-type value](field-filter field-name base-type value-type value nil))([field-name base-type value-type value options]- (params/->FieldFilter {:lib/type :metadata/column- :name (name field-name)- :base-type (or base-type :type/*)}- (cond-> {:type value-type, :value value}- (map? options) (assoc :options options))- nil)))+ (merge (lib/parsed-field-filter-param {:lib/type :metadata/column+ :name (name field-name)+ :base-type (or base-type :type/*)}+ (cond-> {:type value-type, :value value}+ (map? options) (assoc :options options)))+ options)))(deftest ^:parallel substitute-test(testing "non-parameterized strings should not be substituted"(is (= "wow"- (substitute nil ["wow"])))))+ (#'mongo.params/substitute nil ["wow"])))))(deftest ^:parallel substitute-test-2(testing "non-optional-params"(testing "single param with no string before or after"(is (= "100"- (substitute {:x 100} [(param :x)]))+ (#'mongo.params/substitute {"x" 100} [(lib/parsed-param "x")]))"\"{{x}}\" with x = 100 should be replaced with \"100\""))(testing "if a param is missing, an Exception should be thrown"(is (thrown-with-msg? clojure.lang.ExceptionInfo- #"missing required parameters: #\{:x\}"- (substitute nil [(param :x)]))))+ #"missing required parameters: #\{\"x\"\}"+ (#'mongo.params/substitute nil [(lib/parsed-param "x")]))))(testing "params preceded or followed by strings should get combined into a single string"(is (= "2100"- (substitute {:x 100} ["2" (param :x)]))+ (#'mongo.params/substitute {"x" 100} ["2" (lib/parsed-param "x")]))"\"2{{x}}\" with x = 100 should be replaced with string \"2100\""))(testing "temporal params"(is (= "ISODate(\"2019-12-06T17:01:00-08:00\")"- (substitute {:written-at #t "2019-12-06T17:01:00-08:00[America/Los_Angeles]"} [(param :written-at)]))))+ (#'mongo.params/substitute {"written-at" #t "2019-12-06T17:01:00-08:00[America/Los_Angeles]"}+ [(lib/parsed-param "written-at")]))))(testing "multiple params in one string"(is (= "2019-12-10"- (substitute {:year 2019, :month 12, :day 10} [(param :year) "-" (param :month) "-" (param :day)]))+ (#'mongo.params/substitute {"year" 2019, "month" 12, "day" 10} [(lib/parsed-param "year") "-" (lib/parsed-param "month") "-" (lib/parsed-param "day")]))"\"{{year}}-{{month}}-{{day}}\" should be replaced with \"2019-12-09\"")(testing "some params missing"(is (thrown-with-msg? clojure.lang.ExceptionInfo- #"missing required parameters: #\{:day\}"- (substitute {:year 2019, :month 12} [(param :year) "-" (param :month) "-" (param :day)])))))))+ #"missing required parameters: #\{\"day\"\}"+ (#'mongo.params/substitute {"year" 2019, "month" 12} [(lib/parsed-param "year") "-" (lib/parsed-param "month") "-" (lib/parsed-param "day")])))))))(deftest ^:parallel substitute-test-3(testing "optional params"(testing "single optional param"(is (= nil- (substitute nil [(optional (param :x))]))+ (#'mongo.params/substitute nil [(optional (lib/parsed-param "x"))]))"\"[[{{x}}]]\" with no value for x should be replaced with `nil`"))(testing "{{year}}[[-{{month}}[[-{{day}}]]]]"- (let [params [(param :year) (optional "-" (param :month) (optional "-" (param :day)))]]+ (let [params [(lib/parsed-param "year")+ (optional "-" (lib/parsed-param "month") (optional "-" (lib/parsed-param "day")))]](testing "with all params present"(is (= "2019-12-10"- (substitute {:year 2019, :month 12, :day 10} params))))+ (#'mongo.params/substitute {"year" 2019, "month" 12, "day" 10} params))))(testing "with :year & :month present but not :day"(is (= "2019-12"- (substitute {:year 2019, :month 12} params))))+ (#'mongo.params/substitute {"year" 2019, "month" 12} params))))(testing "with :year present but not :month or :day"(is (= "2019"- (substitute {:year 2019} params))))+ (#'mongo.params/substitute {"year" 2019} params))))(testing "with no params present"(is (thrown-with-msg? clojure.lang.ExceptionInfo#"missing required parameters"- (substitute nil params))))))))+ (#'mongo.params/substitute nil params))))))))(deftest ^:parallel substitute-test-4(testing "comma-separated numbers"(is (= "{$in: [1, 2, 3]}"- (substitute {:id [1 2 3]}- [(param :id)])))))+ (#'mongo.params/substitute {"id" [1 2 3]}+ [(lib/parsed-param "id")])))))(deftest ^:parallel substitute-test-5(testing "multiple-values single (#30136)"(is (= "\"33 Taps\""- (substitute {:id ["33 Taps"]}- [(param :id)])))))+ (#'mongo.params/substitute {"id" ["33 Taps"]}+ [(lib/parsed-param "id")])))))(deftest ^:parallel substitute-test-6(testing "multiple-values multi (#22486)"(is (= "{$in: [\"33 Taps\", \"Cha Cha Chicken\"]}"- (substitute {:id ["33 Taps" "Cha Cha Chicken"]}- [(param :id)])))))+ (#'mongo.params/substitute {"id" ["33 Taps" "Cha Cha Chicken"]}+ [(lib/parsed-param "id")])))))(defprotocol ^:private ToBSON(^:private to-bson [this]@@ -159,8 +157,8 @@(testing "Date ranges"(mt/with-clock #t "2019-12-13T12:00:00.000Z[UTC]"(letfn [(substitute-date-range [s]- (substitute {:date (field-filter "date" :date/range s)}- ["[{$match: " (param :date) "}]"]))]+ (#'mongo.params/substitute {"date" (field-filter "date" :date/range s)}+ ["[{$match: " (lib/parsed-param "date") "}]"]))](is (= (to-bson [{:$match {:$and [{"date" {:$gte (ISODate "2019-12-08T00:00:00Z")}}{"date" {:$lt (ISODate "2019-12-13T00:00:00Z")}}]}}])(substitute-date-range "past5days")))@@ -175,20 +173,23 @@(deftest ^:parallel field-filter-test-2(testing "multiple values (numbers)"(is (= (to-bson [{:$match {"id" {:$in [1 2 3]}}}])- (substitute {:id (field-filter "id" :number [1 2 3])}- ["[{$match: " (param :id) "}]"])))))+ (#'mongo.params/substitute {"id" (field-filter "id" :number [1 2 3])}+ ["[{$match: " (lib/parsed-param "id") "}]"])))))(deftest ^:parallel field-filter-test-3(testing "single date"(is (= (to-bson [{:$match {:$and [{"date" {:$gte (ISODate "2019-12-08")}}{"date" {:$lt (ISODate "2019-12-09")}}]}}])- (substitute {:date (field-filter "date" :date/single "2019-12-08")}- ["[{$match: " (param :date) "}]"])))))+ (#'mongo.params/substitute {"date" (field-filter "date" :date/single "2019-12-08")}+ ["[{$match: " (lib/parsed-param "date") "}]"])))))(deftest ^:parallel field-filter-test-4(testing "parameter not supplied"(is (= (to-bson [{:$match {}}])- (substitute {:date (params/->FieldFilter {:name "date"} params/no-value nil)} ["[{$match: " (param :date) "}]"])))))+ (#'mongo.params/substitute {"date" (lib/parsed-field-filter-param+ {:lib/type :metadata/column, :name "date", :base-type :type/Date}+ lib/parsed-param-no-value-placeholder)}+ ["[{$match: " (lib/parsed-param "date") "}]"])))))(deftest ^:parallel field-filter-test-5(testing "operators"@@ -220,8 +221,8 @@(testing operator(is (= (strip (to-bson [{:$match form}]))(strip- (substitute {:desc (field-filter "description" :type/Text operator input options)}- ["[{$match: " (param :desc) "}]"])))))))))+ (#'mongo.params/substitute {"desc" (field-filter "description" :type/Text operator input options)}+ ["[{$match: " (lib/parsed-param "desc") "}]"])))))))))(deftest ^:parallel field-filter-test-6(testing "operators"@@ -236,8 +237,8 @@(testing operator(is (= (strip (to-bson [{:$match form}]))(strip- (substitute {:price (field-filter "price" :type/Integer operator input)}- ["[{$match: " (param :price) "}]"])))))))))+ (#'mongo.params/substitute {"price" (field-filter "price" :type/Integer operator input)}+ ["[{$match: " (lib/parsed-param "price") "}]"])))))))))(deftest ^:parallel field-filter-test-7(testing "operators"@@ -247,8 +248,8 @@(is (= (strip (to-bson [{:$match {"$or" [{"description" "foo"}{"description" "bar"}]}}]))(strip- (substitute {:desc (field-filter "description" :type/Text :string/= ["foo" "bar"])}- ["[{$match: " (param :desc) "}]"])))))+ (#'mongo.params/substitute {"desc" (field-filter "description" :type/Text :string/= ["foo" "bar"])}+ ["[{$match: " (lib/parsed-param "desc") "}]"])))))(testing :string/!=;; this could be optimized to {:description {:in ["foo" "bar"}}? one thing is that we pass it through the;; desugar middleware that does this [:= 1 2] -> [:or [:= 1] [:= 2]] which makes for more complicated (or just@@ -257,26 +258,29 @@(is (= (strip (to-bson [{:$match {"$and" [{"description" {"$ne" "foo"}}{"description" {"$ne" "bar"}}]}}]))(strip- (substitute {:desc (field-filter "description" :type/Text :string/!= ["foo" "bar"])}- ["[{$match: " (param :desc) "}]"])))))+ (#'mongo.params/substitute {"desc" (field-filter "description" :type/Text :string/!= ["foo" "bar"])}+ ["[{$match: " (lib/parsed-param "desc") "}]"])))))(testing :number/=(is (= (strip (to-bson [{:$match {"$or" [{"price" 1}{"price" 2}]}}]))(strip- (substitute {:price (field-filter "price" :type/Integer :number/= [1 2])}- ["[{$match: " (param :price) "}]"])))))+ (#'mongo.params/substitute {"price" (field-filter "price" :type/Integer :number/= [1 2])}+ ["[{$match: " (lib/parsed-param "price") "}]"])))))(testing :number/!=(is (= (strip (to-bson [{:$match {"$and" [{"price" {"$ne" 1}}{"price" {"$ne" 2}}]}}]))(strip- (substitute {:price (field-filter "price" :type/Integer :number/!= [1 2])}- ["[{$match: " (param :price) "}]"]))))))))+ (#'mongo.params/substitute {"price" (field-filter "price" :type/Integer :number/!= [1 2])}+ ["[{$match: " (lib/parsed-param "price") "}]"]))))))))(deftest ^:parallel substitute-native-query-snippets-test(testing "Native query snippet substitution"(is (= (strip (to-bson [{:$match {"price" {:$gt 2}}}]))- (strip (substitute {"snippet: high price" (params/->ReferencedQuerySnippet 123 (to-bson {"price" {:$gt 2}}))}- ["[{$match: " (param "snippet: high price") "}]"]))))))+ (strip (#'mongo.params/substitute {"snippet: high price"+ {:lib/type :metabase.lib.parameters.parse.types/referenced-query-snippet+ :snippet-id 123+ :content (to-bson {"price" {:$gt 2}})}}+ ["[{$match: " (lib/parsed-param "snippet: high price") "}]"]))))))(deftest ^:parallel e2e-field-filter-test(mt/test-driver :mongodiff --git a/modules/drivers/snowflake/test/metabase/driver/snowflake_test.clj b/modules/drivers/snowflake/test/metabase/driver/snowflake_test.cljindex 10f2e0575f0..3db5a53b1c0 100644--- a/modules/drivers/snowflake/test/metabase/driver/snowflake_test.clj+++ b/modules/drivers/snowflake/test/metabase/driver/snowflake_test.clj@@ -11,7 +11,6 @@[java-time.api :as t][medley.core :as m][metabase.driver :as driver]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params][metabase.driver.snowflake :as driver.snowflake][metabase.driver.sql-jdbc :as driver.sql-jdbc][metabase.driver.sql-jdbc.connection :as sql-jdbc.conn]@@ -978,7 +977,7 @@(qp.store/with-metadata-provider meta/metadata-provider(is (= {:replacement-snippet "'2014-08-02'::date":prepared-statement-args nil}- (sql.params.substitution/->replacement-snippet-info :snowflake (params/->Date "2014-08-02")))))))+ (sql.params.substitution/->replacement-snippet-info :snowflake (lib/parsed-date-param "2014-08-02")))))))(deftest report-timezone-test(mt/test-driver :snowflakediff --git a/src/metabase/actions/http_action.clj b/src/metabase/actions/http_action.cljindex 97e0790e5d9..d359bd0992a 100644--- a/src/metabase/actions/http_action.clj+++ b/src/metabase/actions/http_action.clj@@ -2,13 +2,13 @@(:require[clj-http.client :as http][clojure.string :as str]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse]+ [metabase.lib.core :as lib][metabase.query-processor.error-type :as qp.error-type][metabase.util :as u][metabase.util.i18n :refer [tru]][metabase.util.json :as json]- [metabase.util.log :as log])+ [metabase.util.log :as log]+ [metabase.util.malli :as mu])(:import(com.fasterxml.jackson.databind ObjectMapper)(net.thisptr.jackson.jq BuiltinFunctionLoader JsonQuery Output Scope Versions)))@@ -27,18 +27,25 @@;; May go away if parameters substitution is taken out of query-processing/db dependency(declare substitute*)-(defn- substitute-param [param->value [sql missing] _in-optional? {:keys [k]}]+(mu/defn- substitute-param+ [param->value+ [sql missing]+ _in-optional?+ {:keys [k]} :- :metabase.lib.parameters.parse.types/param](if-not (contains? param->value k)[sql (conj missing k)](let [v (get param->value k)](cond- (= params/no-value v)+ (= v lib/parsed-param-no-value-placeholder)[sql (conj missing k)]:else[(str sql v) missing]))))-(defn- substitute-optional [param->value [sql missing] {subclauses :args}]+(mu/defn- substitute-optional+ [param->value+ [sql missing]+ {subclauses :args} :- :metabase.lib.parameters.parse.types/optional](let [[opt-sql opt-missing] (substitute* param->value subclauses true)](if (seq opt-missing)[sql missing]@@ -53,15 +60,15 @@(string? x)[(str sql x) missing]- (params/Param? x)+ (lib/parsed-param? x)(substitute-param param->value [sql missing] in-optional? x)- (params/Optional? x)+ (lib/parsed-optional-param? x)(substitute-optional param->value [sql missing] x)))nilparsed))-(defn substitute+(defn- substitute"Substitute `Optional` and `Param` objects in a `parsed-template`, a sequence of parsed string fragments and tokens, withthe values from the map `param->value` (using logic from `substitution` to decide what replacement SQL should begenerated).@@ -90,7 +97,7 @@(defn- parse-and-substitute [s params->value](when s(-> s- params.parse/parse+ lib/parse-parameters(substitute params->value))));;diff --git a/src/metabase/channel/params.clj b/src/metabase/channel/params.cljindex 305f7ba84c8..b7a9e6495be 100644--- a/src/metabase/channel/params.clj+++ b/src/metabase/channel/params.clj@@ -1,9 +1,7 @@(ns metabase.channel.params(:require[clojure.string :as str]- ;; TODO (Cam 10/3/25) -- migrate this namespace to the Lib version of these namespaces- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse]))+ [metabase.lib.core :as lib]))(defn- param-name->path[param-name]@@ -18,10 +16,10 @@:or {ignore-missing? false}:as _opts}];; NOTE: in case the syntax involves, consider using the handlebars syntax and use stencil for substitution- (let [components (params.parse/parse text)]+ (let [components (lib/parse-parameters text)](str/join ""(for [c components]- (if (params/Param? c)+ (if (lib/parsed-param? c)(or (get-in context (param-name->path (:k c)))(when-not ignore-missing?(throw (ex-info (str "Missing parameter: " (:k c)) {:param (:k c)}))))diff --git a/src/metabase/driver/common/parameters.clj b/src/metabase/driver/common/parameters.cljdeleted file mode 100644index a3d672107b2..00000000000--- a/src/metabase/driver/common/parameters.clj+++ /dev/null@@ -1,156 +0,0 @@-(ns metabase.driver.common.parameters- "Various record types below are used as a convenience for differentiating the different param types.-- DEPRECATED: `driver.common.parameters.*` namespaces deal with legacy MBQL queries. Migrate to MBQL-5-friendly- replacement namespaces. The replacement for this namespace is [[metabase.lib.parameters.parse.types]]."- {:deprecated "0.57.0"}- (:require- [potemkin.types :as p.types]- [pretty.core :as pretty]))--;; "FieldFilter" is something that expands to a clause like "some_field BETWEEN 1 AND 10"-;;-;; `field` is a Field Toucan instance-;;-;; `value`" is either:-;; * `no-value`-;; * A map containing the value and type info for the value, e.g.-;;-;; {:type :date/single-;; :value #t "2019-09-20T19:52:00.000-07:00"}-;;-;; * A vector of maps like the one above (for multiple values)-(p.types/defrecord+ FieldFilter [field value alias]- pretty/PrettyPrintable- (pretty [this]- (list (pretty/qualify-symbol-for-*ns* `map->FieldFilter) (into {} this))))--(defn FieldFilter?- "Is `x` an instance of the `FieldFilter` record type?"- [x]- (instance? FieldFilter x))--(p.types/defrecord+ TemporalUnit [field value alias]- pretty/PrettyPrintable- (pretty [this]- (list (pretty/qualify-symbol-for-*ns* `map->TemporalUnit) (into {} this))))--(defn TemporalUnit?- "Is `x` an instance of the `TemporalUnit` record type?"- [x]- (instance? TemporalUnit x))--;; A "ReferencedCardQuery" parameter expands to the native query of the referenced card.-;;-;; `card-id` is the ID of the Card instance whose query is the value for this parameter.-;;-;; `query` is the native query as stored in the Card-;;-;; `parameters` are positional parameters for a parameterized native query e.g. the JDBC parameters corresponding to-;; `?` placeholders-(p.types/defrecord+ ReferencedCardQuery [card-id query params]- pretty/PrettyPrintable- (pretty [this]- (list (pretty/qualify-symbol-for-*ns* `map->ReferencedCardQuery) (into {} this))))--(defn ReferencedCardQuery?- "Is `x` an instance of the `ReferencedCardQuery` record type?"- [x]- (instance? ReferencedCardQuery x))--;; A "ReferencedTableQuery" parameter expands to a query selecting from a specific table, potentially with a filter on a-;; specific column.-;;-;; `table-id` is the id of the table being referenced-;;-;; `source-filters` is an optional sequence of filter maps applied to the table reference. Each filter map has:-;; :field-id - the ID of the field to filter on-;; :op - the comparison operator, one of :>, :>=, :<, :<=, :=, :!=-;; :value - the value to compare against-;; When present, the table reference is rendered as a filtered subquery:-;; (SELECT * FROM "table" WHERE "col" > ? AND "col" <= ?)-;; source-filters was introduced to support incremental transforms, unused by the frontend.-;;-;; `alias` is an optional string alias for the table reference. When present, the expansion includes-;; an AS clause: "table" AS "alias" or (SELECT ...) AS "alias".-;; Resolved from the template tag's `:emit-alias` boolean and `:name` during parsing.-(p.types/defrecord+ ReferencedTableQuery [table-id source-filters alias]- pretty/PrettyPrintable- (pretty [this]- (list (pretty/qualify-symbol-for-*ns* `map->ReferencedTableQuery) (into {} this))))--(defn ReferencedTableQuery?- "Is `x` an instance of the `ReferencedTableQuery` record type?"- [x]- (instance? ReferencedTableQuery x))--;; A `ReferencedQuerySnippet` expands to the partial query snippet stored in the `NativeQuerySnippet` table in the-;; application DB.-;;-;; `snippet-id` is the integer ID of the row in the application DB from where the snippet content is loaded.-;;-;; `content` is the raw query snippet which will be replaced, verbatim, for this template tag.-(p.types/defrecord+ ReferencedQuerySnippet [snippet-id content]- pretty/PrettyPrintable- (pretty [this]- (list (pretty/qualify-symbol-for-*ns* `map->ReferencedQuerySnippet) (into {} this))))--(defn ReferencedQuerySnippet?- "Is `x` an instance of the `ReferencedQuerySnippet` record type?"- [x]- (instance? ReferencedQuerySnippet x))--;; as in a literal date, defined by date-string S-;;-;; TODO - why don't we just parse this into a Temporal type and let drivers handle it.-(p.types/defrecord+ Date [^String s]- pretty/PrettyPrintable- (pretty [_]- (list (pretty/qualify-symbol-for-*ns* `->Date) s)))--(p.types/defrecord+ DateRange [start end]- pretty/PrettyPrintable- (pretty [_]- (list (pretty/qualify-symbol-for-*ns* `->DateRange) start end)))--(p.types/defrecord+ DateTimeRange [start end]- pretty/PrettyPrintable- (pretty [_]- (list (pretty/qualify-symbol-for-*ns* `->DateRange) start end)))--(def no-value- "Convenience for representing an *optional* parameter present in a query but whose value is unspecified in the param- values."- ::no-value)--(p.types/defrecord+ Param [k]- pretty/PrettyPrintable- (pretty [_]- (list (pretty/qualify-symbol-for-*ns* `->Param) k)))--(p.types/defrecord+ FunctionParam [function-name args]- pretty/PrettyPrintable- (pretty [_]- (list (pretty/qualify-symbol-for-*ns* `->FunctionParam) function-name args)))--(p.types/defrecord+ Optional [args]- pretty/PrettyPrintable- (pretty [_]- (cons (pretty/qualify-symbol-for-*ns* `->Optional) args)))--;; `Param?`, `FunctionParam?`, and `Optional?` exist mostly so you don't have to try to import the classes from this-;; namespace which can cause problems if the ns isn't loaded first-(defn Param?- "Is `x` an instance of the `Param` record type?"- [x]- (instance? Param x))--(defn FunctionParam?- "Is `x` an instance of the `FunctionParam` record type?"- [x]- (instance? FunctionParam x))--(defn Optional?- "Is `x` an instance of the `Optional` record type?"- [x]- (instance? Optional x))diff --git a/src/metabase/driver/common/parameters/dates.clj b/src/metabase/driver/common/parameters/dates.cljindex 53002ec47a4..5ac77266363 100644--- a/src/metabase/driver/common/parameters/dates.clj+++ b/src/metabase/driver/common/parameters/dates.clj@@ -49,7 +49,7 @@[{:parser #(= % "today"):range (fn [_ dt](let [dt-res (t/local-date dt)]- {:start dt-res,+ {:start dt-res:end dt-res:unit :day})):filter (fn [_ field-clause]diff --git a/src/metabase/driver/common/parameters/parse.clj b/src/metabase/driver/common/parameters/parse.cljdeleted file mode 100644index ffab35e89ba..00000000000--- a/src/metabase/driver/common/parameters/parse.clj+++ /dev/null@@ -1,49 +0,0 @@-(ns metabase.driver.common.parameters.parse- "DEPRECATED: `driver.common.parameters.*` namespaces deal with legacy MBQL queries. Migrate to MBQL-5-friendly- replacement namespaces. The replacement for this namespace is [[metabase.lib.parameters.parse]]."- {:deprecated "0.57.0"}- (:require- [clojure.string :as str]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]- [metabase.lib.core :as lib]- [metabase.lib.schema.common :as lib.schema.common]- [metabase.query-processor.error-type :as qp.error-type]- [metabase.util.malli :as mu]- [metabase.util.match :as match])- (:import- (metabase.driver.common.parameters Optional FunctionParam Param)))--(set! *warn-on-reflection* true)--(def ^:private ParsedToken- [:or- :string- (lib.schema.common/instance-of-class Param)- (lib.schema.common/instance-of-class FunctionParam)- (lib.schema.common/instance-of-class Optional)])--(defn- ->param [value]- (match/match-one value- (s :guard string?)- s-- {:type :metabase.lib.parse/param, :name name}- (params/->Param (or (lib/match-and-normalize-tag-name name) (str/trim name)))-- {:type :metabase.lib.parse/optional, :contents contents}- (params/->Optional (map ->param contents))))--(mu/defn parse :- [:sequential ParsedToken]- "Attempts to parse parameters in string `s`. Parses any optional clauses or parameters found, and returns a sequence- of non-parameter string fragments (possibly) interposed with `Param` or `Optional` instances.-- If `handle-sql-comments` is true (default) then we make a best effort to ignore params in SQL comments."- ([s :- :string]- (parse s true))-- ([s :- :string- handle-sql-comments :- :boolean]- (->> (lib/parse {:parse-error-type qp.error-type/invalid-query}- s- handle-sql-comments)- (map ->param))))diff --git a/src/metabase/driver/common/parameters/values.clj b/src/metabase/driver/common/parameters/values.cljindex b4bc81871a8..22518c5af40 100644--- a/src/metabase/driver/common/parameters/values.clj+++ b/src/metabase/driver/common/parameters/values.clj@@ -20,7 +20,6 @@(:refer-clojure :exclude [every? some mapv not-empty get-in])(:require[clojure.string :as str]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params][metabase.legacy-mbql.schema :as mbql.s][metabase.lib.core :as lib][metabase.lib.metadata :as lib.metadata]@@ -38,19 +37,14 @@[metabase.util.i18n :refer [tru]][metabase.util.log :as log][metabase.util.malli :as mu]- [metabase.util.performance :refer [every? mapv some not-empty get-in]])+ [metabase.util.malli.registry :as mr]+ [metabase.util.performance :refer [every? get-in mapv not-empty some]])(:import(clojure.lang ExceptionInfo)(java.util UUID)))(set! *warn-on-reflection* true)-(def ^:private Date (lib.schema.common/instance-of-class metabase.driver.common.parameters.Date))-(def ^:private FieldFilter (lib.schema.common/instance-of-class metabase.driver.common.parameters.FieldFilter))-(def ^:private ReferencedQuerySnippet (lib.schema.common/instance-of-class metabase.driver.common.parameters.ReferencedQuerySnippet))-(def ^:private ReferencedCardQuery (lib.schema.common/instance-of-class metabase.driver.common.parameters.ReferencedCardQuery))-(def ^:private ReferencedTableQuery (lib.schema.common/instance-of-class metabase.driver.common.parameters.ReferencedTableQuery))-(defmulti ^:private parse-tag"Parse a tag by its `:type`, returning an appropriate record type such as`metabase.driver.common.parameters.FieldFilter`."@@ -72,18 +66,23 @@;; the type of a FieldFilter look at the key `:widget-type`. This applies to things like the default value for a;; FieldFilter as well.-(def ^:private SingleValue+(mr/def ::single-value"Schema for a valid *single* value for a param."- [:or FieldFilter Date number? :string :boolean])--(def ^:private ParsedParamValue+ [:or+ :metabase.lib.parameters.parse.types/field-filter+ :metabase.lib.parameters.parse.types/date+ number?+ :string+ :boolean])++(mr/def ::parsed-param-value"Schema for valid param value(s). Params can have one or more values."[:maybe[:or{:error/message "Valid param value(s)"}- [:= params/no-value]- SingleValue- [:sequential SingleValue]+ [:= lib/parsed-param-no-value-placeholder]+ ::single-value+ [:sequential ::single-value]:map]])(mu/defn- tag-targets@@ -187,10 +186,10 @@(some :value matching-params)(not nil-value?))(normalize-params (filter :value matching-params))- ;; If a FieldFilter has value=nil, return a [[params/no-value]]+ ;; If a FieldFilter has value=nil, return a [[lib/parsed-param-no-value-placeholder]];; so that this filter can be substituted with "1 = 1" regardless of whether or not this tag has default value(and (not (:required tag)) nil-value?)- params/no-value+ lib/parsed-param-no-value-placeholder;; When a FieldFilter has value=nil and is required, use the default value or throw an exception(and (:required tag) nil-value?)(if-let [tag-default (:default tag)]@@ -211,22 +210,22 @@;; otherwise there is no value for this Field filter ("dimension"), throw Exception if this param is required,(:required tag)(throw (missing-required-param-exception (:display-name tag)))- ;; otherwise return [[params/no-value]] to signify that this filter can be substituted with "1 = 1"+ ;; otherwise return [[lib/parsed-param-no-value-placeholder]] to signify that this filter can be substituted+ ;; with "1 = 1":else- params/no-value)))+ lib/parsed-param-no-value-placeholder)))-(mu/defmethod parse-tag :dimension :- [:maybe FieldFilter]+(mu/defmethod parse-tag :dimension :- [:maybe :metabase.lib.parameters.parse.types/field-filter][{:keys [dimension alias], :as tag} :- ::mbql.s/TemplateTagparams :- [:maybe [:sequential ::lib.schema.parameter/parameter]]]- (params/map->FieldFilter- {:field (let [field-id (dimension->field-id dimension)]- (or (lib.metadata/field (qp.store/metadata-provider) field-id)- (throw (ex-info (tru "Can''t find field with ID: {0}" field-id)- {:field-id field-id, :type qp.error-type/invalid-parameter}))))- :value (field-filter-value tag params)- :alias alias}))--(mu/defmethod parse-tag :card :- ReferencedCardQuery+ (let [field-id (dimension->field-id dimension)+ field (or (lib.metadata/field (qp.store/metadata-provider) field-id)+ (throw (ex-info (tru "Can''t find field with ID: {0}" field-id)+ {:field-id field-id, :type qp.error-type/invalid-parameter})))+ value (field-filter-value tag params)]+ (lib/parsed-field-filter-param field value alias)))++(mu/defmethod parse-tag :card :- :metabase.lib.parameters.parse.types/referenced-card-query[{:keys [card-id], :as tag} :- ::mbql.s/TemplateTag _params](when-not card-id(throw (ex-info (tru "Invalid :card parameter: missing `:card-id`")@@ -238,15 +237,14 @@(throw (ex-info (tru "Card {0} not found." card-id){:card-id card-id, :tag tag, :type qp.error-type/invalid-parameter})))](try- (params/map->ReferencedCardQuery- (let [query (assoc query :info {:card-id card-id})]- (log/tracef "Compiling referenced query for Card %d\n%s" card-id (u/pprint-to-str query))- (merge {:card-id card-id}- (or (when (qp.persistence/can-substitute? card persisted-info)- {:query (qp.persistence/persisted-info-native-query- (u/the-id (lib.metadata/database (qp.store/metadata-provider)))- persisted-info)})- (qp.compile/compile (qp/disable-max-results query))))))+ (log/tracef "Compiling referenced query for Card %d\n%s" card-id (u/pprint-to-str query))+ (let [query (assoc query :info {:card-id card-id})+ {:keys [query params]} (or (when (qp.persistence/can-substitute? card persisted-info)+ {:query (qp.persistence/persisted-info-native-query+ (u/the-id (lib.metadata/database (qp.store/metadata-provider)))+ persisted-info)})+ (qp.compile/compile (qp/disable-max-results query)))]+ (lib/parsed-referenced-card-query-param card-id query params))(catch ExceptionInfo e(throw (ex-info(tru "The sub-query from referenced question #{0} failed with the following error: {1}"@@ -257,16 +255,19 @@:type qp.error-type/invalid-parameter}e))))))-(mu/defmethod parse-tag :table :- ReferencedTableQuery+(mu/defmethod parse-tag :table :- :metabase.lib.parameters.parse.types/referenced-table-query[{:keys [table-id source-filters emit-alias name]} :- ::mbql.s/TemplateTag _params](when (seq source-filters)(when-let [op (some #(when-not (lib.schema.template-tag/allowed-source-filter-ops (:op %)) %) source-filters)](throw (ex-info (tru "Invalid source-filter operator: {0}. Allowed operators: {1}"(pr-str op) (pr-str lib.schema.template-tag/allowed-source-filter-ops)){:op op :allowed-ops lib.schema.template-tag/allowed-source-filter-ops}))))- (params/->ReferencedTableQuery table-id (not-empty source-filters) (when emit-alias name)))+ (lib/parsed-referenced-table-query-param+ table-id+ (not-empty source-filters)+ (when emit-alias name)))-(mu/defmethod parse-tag :snippet :- ReferencedQuerySnippet+(mu/defmethod parse-tag :snippet :- :metabase.lib.parameters.parse.types/referenced-query-snippet[{:keys [snippet-name snippet-id], :as tag} :- ::mbql.s/TemplateTag_params](let [snippet-id (or snippet-id@@ -278,9 +279,7 @@:snippet-name snippet-name:tag tag:type qp.error-type/invalid-parameter})))]- (params/map->ReferencedQuerySnippet- {:snippet-id (:id snippet)- :content (:content snippet)})))+ (lib/parsed-referenced-query-snippet-param (:id snippet) (:content snippet))))(defmethod parse-tag :temporal-unit[{:keys [required dimension alias] :as tag} params]@@ -302,19 +301,18 @@(throw (ex-info (tru "Error: invalid value specified for temporal-unit parameter."){:value param-value:expected valid-temporal-units})))- (params/map->TemporalUnit- {:field (let [field-id (dimension->field-id dimension)]- (or (lib.metadata/field (qp.store/metadata-provider) field-id)- (throw (ex-info (tru "Can''t find field with ID: {0}" field-id)- {:field-id field-id, :type qp.error-type/invalid-parameter}))))- :value (or (:value matching-param)- (when (and nil-value? (not required))- params/no-value)- (:default tag)- (if required- (throw (missing-required-param-exception (:display-name tag)))- params/no-value))- :alias alias})))+ (let [field (let [field-id (dimension->field-id dimension)]+ (or (lib.metadata/field (qp.store/metadata-provider) field-id)+ (throw (ex-info (tru "Can''t find field with ID: {0}" field-id)+ {:field-id field-id, :type qp.error-type/invalid-parameter}))))+ value (or (:value matching-param)+ (when (and nil-value? (not required))+ lib/parsed-param-no-value-placeholder)+ (:default tag)+ (if required+ (throw (missing-required-param-exception (:display-name tag)))+ lib/parsed-param-no-value-placeholder))]+ (lib/parsed-temporal-unit-param field value alias))));;; Non-FieldFilter Params (e.g. WHERE x = {{x}})@@ -334,7 +332,7 @@(= (count real-values) 1) (first real-values);; If some parameters matched, but none have values, AND this tag is not required, then return a blank value.(and (seq matching-params)- (not (:required tag))) params/no-value+ (not (:required tag))) lib/parsed-param-no-value-placeholder;; Prefer the default value of the tag over those of the parameters.(:default tag) (:default tag)@@ -346,7 +344,7 @@;; No value at all - throw if this tag was required.(:required tag) (throw (missing-required-param-exception (:display-name tag)));; Fall back to no value.- :else params/no-value)))+ :else lib/parsed-param-no-value-placeholder)))(defmethod parse-tag :number[tag params]@@ -410,10 +408,10 @@:elsevalue))-(mu/defn- update-filter-for-field-type :- ParsedParamValue+(mu/defn- update-filter-for-field-type :- ::parsed-param-value"Update a Field Filter with a textual, or sequence of textual, values. The base type and semantic type of the fieldare used to determine what 'semantic' type interpretation is required (e.g. for UUID fields)."- [{field :field, {value :value} :value, :as field-filter} :- FieldFilter]+ [{field :field, {value :value} :value, :as field-filter} :- :metabase.lib.parameters.parse.types/field-filter](let [effective-type ((some-fn :effective-type :base-type) field)new-value (cond(string? value)@@ -428,7 +426,7 @@(cond-> field-filternew-value (assoc-in [:value :value] new-value))))-(mu/defn- parse-value-for-type :- ParsedParamValue+(mu/defn- parse-value-for-type :- ::parsed-param-value"Parse a `value` based on the type chosen for the param, such as `text` or `number`. (Depending on the type of paramcreated, `value` here might be a raw value or a map including information about the Field it references as well as avalue.) For numbers, dates, and the like, this will parse the string appropriately; for `text` parameters, this will@@ -436,14 +434,14 @@base type Fields as UUIDs."[param-type :- ::lib.schema.template-tag/type value](cond- (= value params/no-value)+ (= value lib/parsed-param-no-value-placeholder)value(= param-type :number)(value->number value)(= param-type :date)- (params/map->Date {:s value})+ (lib/parsed-date-param value);; Field Filters(and (= param-type :dimension)@@ -461,7 +459,7 @@:elsevalue))-(mu/defn- value-for-tag :- ParsedParamValue+(mu/defn- value-for-tag :- ::parsed-param-value"Given a map `tag` (a value in the `:template-tags` dictionary) return the corresponding value from the `params`sequence. The `value` is something that can be compiled to SQL via `->replacement-snippet-info`."[tag :- ::mbql.s/TemplateTag@@ -477,7 +475,7 @@:params params}e)))))-(mu/defn query->params-map :- [:map-of ::lib.schema.common/non-blank-string ParsedParamValue]+(mu/defn query->params-map :- [:map-of ::lib.schema.common/non-blank-string ::parsed-param-value]"Extract parameters info from `query`. Return a map of parameter name -> value.(query->params-map some-inner-query)@@ -505,9 +503,9 @@(mu/defn referenced-card-ids :- [:set ::lib.schema.id/card]"Return a set of all Card IDs referenced in the parameters in `params-map`. This should be added to the (inner) queryunder the `:query-permissions/referenced-card-ids` key when doing parameter expansion."- [params-map :- [:map-of ::lib.schema.common/non-blank-string ParsedParamValue]]+ [params-map :- [:map-of ::lib.schema.common/non-blank-string ::parsed-param-value]](into #{}(keep (fn [param]- (when (params/ReferencedCardQuery? param)+ (when (lib/parsed-referenced-card-query-param? param)(:card-id param))))(vals params-map)))diff --git a/src/metabase/driver/sql.clj b/src/metabase/driver/sql.cljindex 0971d402e07..aa175bff62a 100644--- a/src/metabase/driver/sql.clj+++ b/src/metabase/driver/sql.clj@@ -5,7 +5,6 @@[clojure.set :as set][metabase.driver :as driver][metabase.driver-api.core :as driver-api]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse]^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.values :as params.values][metabase.driver.connection :as driver.conn][metabase.driver.sql.normalize :as sql.normalize]@@ -14,6 +13,7 @@[metabase.driver.sql.query-processor :as sql.qp][metabase.driver.sql.util :as sql.u][metabase.driver.util :as driver.u]+ [metabase.lib.core :as lib][metabase.lib.util :as lib.util][metabase.query-processor.error-type :as qp.error-type][metabase.sql-tools.core :as sql-tools]@@ -29,31 +29,31 @@(doseq [feature [:advanced-math-expressions:binning+ :database-routing+ :dependencies/native+ :distinct-where+ :distinct-where:expression-aggregations:expressions+ :expressions/date+ :expressions/datetime+ :expressions/text+ :expressions/today:full-join:inner-join:left-join+ :metadata/key-constraints:native-parameters+ :native-temporal-units:nested-queries:parameterized-sql+ :parameters/table-reference:percentile-aggregations:regex:right-join:standard-deviation-aggregations- :metadata/key-constraints:window-functions/cumulative- :window-functions/offset- :distinct-where- :native-temporal-units- :expressions/datetime- :expressions/date- :expressions/text- :expressions/today- :distinct-where- :database-routing- :dependencies/native- :parameters/table-reference]]+ :window-functions/offset]](defmethod driver/database-supports? [:sql feature] [_driver _feature _db] true))(defmethod driver/database-supports? [:sql :persist-models-enabled]@@ -75,7 +75,7 @@(let [params-map (params.values/query->params-map inner-query)referenced-card-ids (params.values/referenced-card-ids params-map)[query params] (-> query- params.parse/parse+ lib/parse-parameters(sql.params.substitute/substitute params-map))](cond-> (assoc inner-query:query querydiff --git a/src/metabase/driver/sql/parameters/substitute.clj b/src/metabase/driver/sql/parameters/substitute.cljindex 54736833556..d059998f5d5 100644--- a/src/metabase/driver/sql/parameters/substitute.clj+++ b/src/metabase/driver/sql/parameters/substitute.clj@@ -4,18 +4,32 @@[clojure.string :as str][metabase.driver :as driver][metabase.driver-api.core :as driver-api]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse][metabase.driver.sql.parameters.substitution :as sql.params.substitution]+ [metabase.lib.core :as lib][metabase.util :as u][metabase.util.i18n :refer [tru]][metabase.util.log :as log]+ [metabase.util.malli :as mu]+ [metabase.util.malli.registry :as mr][metabase.util.performance :refer [not-empty]]))+(set! *warn-on-reflection* true)+(declare #^:private substitute*)-(defn- substitute-field-param [[sql args missing] in-optional? k {:keys [_field value], :as v}]- (if (and (= params/no-value value) in-optional?)+(mr/def ::acc+ [:maybe+ [:tuple+ #_sql [:maybe string?]+ #_args [:maybe [:sequential any?]]+ #_missing [:maybe any?]]])++(mu/defn- substitute-field-param :- ::acc+ [[sql args missing] :- ::acc+ in-optional?+ k+ {:keys [_field value], :as v}]+ (if (and (= value lib/parsed-param-no-value-placeholder) in-optional?);; no-value field filters inside optional clauses are ignored, and eventually emitted entirely[sql args (conj missing k)];; otherwise no values get replaced with `1 = 1` and other values get replaced normally@@ -23,35 +37,42 @@(sql.params.substitution/->replacement-snippet-info driver/*driver* v)][(str sql replacement-snippet) (concat args prepared-statement-args) missing])))-(defn- substitute-simple-query [[sql args missing] v]+(mu/defn- substitute-simple-query :- ::acc+ [[sql args missing] :- ::acc+ v](let [{:keys [replacement-snippet prepared-statement-args]}(sql.params.substitution/->replacement-snippet-info driver/*driver* v)][(str sql replacement-snippet) (concat args prepared-statement-args) missing]))-(defn- substitute-native-query-snippet [param->value [sql args missing] in-optional? v]+(mu/defn- substitute-native-query-snippet :- ::acc+ [param->value [sql args missing] in-optional? v](let [{:keys [replacement-snippet]} (sql.params.substitution/->replacement-snippet-info driver/*driver* v)- [processed-snippet snippet-args snippet-missing] (substitute* param->value (params.parse/parse replacement-snippet) in-optional?)]+ [processed-snippet snippet-args snippet-missing] (substitute* param->value (lib/parse-parameters replacement-snippet) in-optional?)][(str sql processed-snippet)(not-empty (concat args snippet-args))(not-empty (concat missing snippet-missing))]))-(defn- substitute-param [param->value [sql args missing] in-optional? {:keys [k]}]+(mu/defn- substitute-param :- ::acc+ [param->value+ [sql args missing] :- ::acc+ in-optional?+ {:keys [k]} :- :metabase.lib.parameters.parse.types/param](if-not (contains? param->value k)[sql args (conj missing k)](let [v (get param->value k)](cond- (or (params/FieldFilter? v)- (params/TemporalUnit? v))+ (or (lib/parsed-field-filter-param? v)+ (lib/parsed-temporal-unit-param? v))(substitute-field-param [sql args missing] in-optional? k v)- (or (params/ReferencedCardQuery? v)- (params/ReferencedTableQuery? v))+ (or (lib/parsed-referenced-card-query-param? v)+ (lib/parsed-referenced-table-query-param? v))(substitute-simple-query [sql args missing] v)- (params/ReferencedQuerySnippet? v)+ (lib/parsed-referenced-query-snippet-param? v)(substitute-native-query-snippet param->value [sql args missing] in-optional? v)- (= params/no-value v)+ (= v lib/parsed-param-no-value-placeholder)[sql args (conj missing k)]:else@@ -59,26 +80,34 @@(sql.params.substitution/->replacement-snippet-info driver/*driver* v)][(str sql replacement-snippet) (concat args prepared-statement-args) missing])))))-(defn- substitute-optional [param->value [sql args missing] {subclauses :args}]+(mu/defn- substitute-optional :- ::acc+ [param->value+ [sql args missing] :- ::acc+ {subclauses :args}](let [[opt-sql opt-args opt-missing] (substitute* param->value subclauses true)](if (seq opt-missing)[sql args missing][(str sql opt-sql) (concat args opt-args) missing])))-(defn- substitute*+(mu/defn- substitute* :- ::acc"Returns a sequence of `[replaced-sql-string jdbc-args missing-parameters]`."- [param->value parsed in-optional?]+ [param->value :- [:maybe [:map-of string? any?]]+ parsed+ in-optional?](reduce(fn [[sql args missing] x](cond(string? x)[(str sql x) args missing]- (params/Param? x)+ (lib/parsed-param? x)(substitute-param param->value [sql args missing] in-optional? x)- (params/Optional? x)- (substitute-optional param->value [sql args missing] x)))+ (lib/parsed-optional-param? x)+ (substitute-optional param->value [sql args missing] x)++ :else+ (throw (ex-info (format "Unexpected parsed param ^%s %s" (some-> x class .getCanonicalName) (pr-str x)) {:x x}))))nilparsed))diff --git a/src/metabase/driver/sql/parameters/substitution.clj b/src/metabase/driver/sql/parameters/substitution.cljindex 30af4f42a00..e3a315ab042 100644--- a/src/metabase/driver/sql/parameters/substitution.clj+++ b/src/metabase/driver/sql/parameters/substitution.clj@@ -12,29 +12,21 @@[medley.core :as m][metabase.driver :as driver][metabase.driver-api.core :as driver-api]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.dates :as params.dates]^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.operators :as params.ops][metabase.driver.sql.query-processor :as sql.qp]+ [metabase.lib.core :as lib][metabase.util :as u][metabase.util.date-2 :as u.date][metabase.util.honey-sql-2 :as h2x][metabase.util.i18n :refer [tru]][metabase.util.malli :as mu]+ [metabase.util.malli.registry :as mr][metabase.util.performance :refer [mapv not-empty]])(:import(clojure.lang IPersistentVector Keyword)(java.time.temporal Temporal)- (java.util UUID)- (metabase.driver.common.parameters- Date- DateRange- DateTimeRange- FieldFilter- ReferencedCardQuery- ReferencedTableQuery- ReferencedQuerySnippet- TemporalUnit)))+ (java.util UUID)));;; ------------------------------------ ->prepared-substitution & default impls -------------------------------------@@ -43,7 +35,8 @@specific parameters and SQL replacement text (usually just ?). The param value is already prepared and ready forinclusion in the query, such as what's needed for SQLite and timestamps."{:added "0.34.0" :arglists '([driver x])}- (fn [driver x] [(driver/dispatch-on-initialized-driver driver) (class x)])+ (fn [driver x] [(driver/dispatch-on-initialized-driver driver)+ ((some-fn :lib/type class) x)]):hierarchy #'driver/hierarchy)(def PreparedStatementSubstitution@@ -85,24 +78,15 @@[driver kwd](honeysql->prepared-stmt-subs driver kwd))-(mu/defmethod ->prepared-substitution [:sql Date] :- PreparedStatementSubstitution- [_driver date]+(mu/defmethod ->prepared-substitution [:sql :metabase.lib.parameters.parse.types/date] :- PreparedStatementSubstitution+ [_driver :- :keyword+ date :- :metabase.lib.parameters.parse.types/date](make-stmt-subs "?" [date]))(mu/defmethod ->prepared-substitution [:sql Temporal] :- PreparedStatementSubstitution[driver t](honeysql->prepared-stmt-subs driver t))-(defmulti align-temporal-unit-with-param-type- "Returns a suitable temporal unit conversion keyword for `field`, `param-type` and the given driver.- The resulting keyword will be used to call the corresponding `metabase.driver.sql.query-processor/date`- implementation to convert the `field`.- Returns `nil` if the conversion is not necessary for this `field` and `param-type` combination.- Deprecated: use `align-temporal-unit-with-param-type-and-value` instead, as it has access to `value`."- {:added "0.48.0" :deprecated "0.49.0" :arglists '([driver field param-type])}- driver/dispatch-on-initialized-driver- :hierarchy #'driver/hierarchy)-(defmulti align-temporal-unit-with-param-type-and-value"Returns a suitable temporal unit conversion keyword for `field`, `param-type`, `value` and the given driver.The resulting keyword will be used to call the corresponding `metabase.driver.sql.query-processor/date`@@ -112,12 +96,6 @@driver/dispatch-on-initialized-driver:hierarchy #'driver/hierarchy)-#_{:clj-kondo/ignore [:deprecated-var]}-(defmethod align-temporal-unit-with-param-type :default- [_driver _field param-type]- (when (params.dates/date-type? param-type)- :day))-(defmethod align-temporal-unit-with-param-type-and-value :default[_driver _field param-type value](when (params.dates/date-type? param-type)@@ -127,7 +105,7 @@;;; ------------------------------------------- ->replacement-snippet-info --------------------------------------------(def ^:private ParamSnippetInfo+(mr/def ::param-snippet-info[:map[:replacement-snippet {:optional true} :string] ; allowed to be blank if this is an optional param[:prepared-statement-args {:optional true} [:maybe [:sequential :any]]]])@@ -138,7 +116,8 @@(->replacement-snippet-info :h2 \"ABC\") -> {:replacement-snippet \"?\", :prepared-statement-args \"ABC\"}"{:added "0.33.4" :arglists '([driver value])}- (fn [driver v & _args] [(driver/the-initialized-driver driver) (class v)])+ (fn [driver v & _args] [(driver/the-initialized-driver driver)+ ((some-fn :lib/type class) v)]):hierarchy #'driver/hierarchy)(defn- create-replacement-snippet@@ -165,7 +144,7 @@(defmethod ->replacement-snippet-info [:sql Keyword][driver this]- (if (= this params/no-value)+ (if (= this lib/parsed-param-no-value-placeholder){:replacement-snippet ""}(create-replacement-snippet driver this)))@@ -188,8 +167,9 @@{:type driver-api/qp.error-type.invalid-parameter:parameter x}))))-(defmethod ->replacement-snippet-info [:sql Date]- [driver {:keys [s]}]+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/date]+ [driver :- :keyword+ {:keys [s]} :- :metabase.lib.parameters.parse.types/date](create-replacement-snippet driver (maybe-parse-temporal-literal s)))(defn- prepared-ts-subs [driver operator date-str]@@ -197,8 +177,9 @@{:replacement-snippet (str operator " " sql-string):prepared-statement-args param-values}))-(defmethod ->replacement-snippet-info [:sql DateRange]- [driver {:keys [start end]}]+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/date-range]+ [driver :- :keyword+ {:keys [start end]} :- :metabase.lib.parameters.parse.types/date-range](cond(= start end)(prepared-ts-subs driver \= start)@@ -218,8 +199,10 @@{:replacement-snippet (format "BETWEEN %s AND %s" (:sql-string start) (:sql-string end)):prepared-statement-args (concat (:param-values start) (:param-values end))})))-(defmethod ->replacement-snippet-info [:sql DateTimeRange]- [driver {:keys [start end]} & [field-identifier]]+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/date-time-range]+ [driver :- :keyword+ {:keys [start end]} :- :metabase.lib.parameters.parse.types/date-time-range+ & [field-identifier]](let [[start end] (map (fn [s](when s(->prepared-substitution driver (maybe-parse-temporal-literal s))))@@ -236,30 +219,30 @@;;; ------------------------------------- Field Filter replacement snippet info ---------------------------------------(mu/defn- combine-replacement-snippet-maps :- ParamSnippetInfo+(mu/defn- combine-replacement-snippet-maps :- ::param-snippet-info"Combine multiple `replacement-snippet-maps` into a single map using a SQL `AND` clause."- [replacement-snippet-maps :- [:maybe [:sequential ParamSnippetInfo]]]+ [replacement-snippet-maps :- [:maybe [:sequential ::param-snippet-info]]]{:replacement-snippet (str \( (str/join " AND " (map :replacement-snippet replacement-snippet-maps)) \)):prepared-statement-args (mapcat :prepared-statement-args replacement-snippet-maps)});; for relative dates convert the param to a `DateRange` record type and call `->replacement-snippet-info` on it-(mu/defn- date-range-field-filter->replacement-snippet-info :- ParamSnippetInfo+(mu/defn- date-range-field-filter->replacement-snippet-info :- ::param-snippet-info[driver value]- (->> (params.dates/date-string->range value)- params/map->DateRange- (->replacement-snippet-info driver)))+ (let [{:keys [start end]} (params.dates/date-string->range value)]+ (->> (lib/parsed-date-range-param start end)+ (->replacement-snippet-info driver))))-(mu/defn- field-filter->equals-clause-sql :- ParamSnippetInfo+(mu/defn- field-filter->equals-clause-sql :- ::param-snippet-info[driver value](-> (->replacement-snippet-info driver value)(update :replacement-snippet (partial str "= "))))-(mu/defn- field-filter-multiple-values->in-clause-sql :- ParamSnippetInfo+(mu/defn- field-filter-multiple-values->in-clause-sql :- ::param-snippet-info[driver values](-> (->replacement-snippet-info driver (vec values))(update :replacement-snippet (partial format "IN (%s)"))))-(mu/defn- honeysql->replacement-snippet-info :- ParamSnippetInfo+(mu/defn- honeysql->replacement-snippet-info :- ::param-snippet-info"Convert `hsql-form` to a replacement snippet info map by passing it to HoneySQL's `format` function."[driver hsql-form](let [[snippet & args] (sql.qp/format-honeysql driver hsql-form)]@@ -313,9 +296,9 @@(letfn [(->datetime-replacement-snippet-info[range](->replacement-snippet-info driver range (field->identifier driver field type value)))]- (-> (params.dates/date-str->datetime-range value ((some-fn :effective-type :base-type) field))- params/map->DateTimeRange- ->datetime-replacement-snippet-info)))+ (let [{:keys [start end]} (params.dates/date-str->datetime-range value ((some-fn :effective-type :base-type) field))]+ (-> (lib/parsed-date-time-range-param start end)+ ->datetime-replacement-snippet-info))))(defmulti to-clause"Helper to dispatch to `params.ops/to-clause` for `:sql` or `qp.params.ops/to-clause` for `:sql-mbql5`."@@ -356,7 +339,7 @@(defmethod date-string->filter :default [_driver date-string field] (params.dates/date-string->filter date-string field))-(mu/defn- field-filter->replacement-snippet-info :- ParamSnippetInfo+(mu/defn- field-filter->replacement-snippet-info :- ::param-snippet-info"Return `[replacement-snippet & prepared-statement-args]` appropriate for a field filter parameter."[driver {{param-type :type, value :value, :as params} :value, field :field, :as field-filter}](assert (:id field) (format "Why doesn't Field have an ID?\n%s" (u/pprint-to-str field)))@@ -395,7 +378,7 @@;; convert all other dates to `= <date>`(params.dates/date-type? param-type) (prepend-field- (field-filter->equals-clause-sql driver (params/map->Date {:s value})))+ (field-filter->equals-clause-sql driver (lib/parsed-date-param value)));; for sequences of multiple values we want to generate an `IN (...)` clause(sequential? value) (prepend-field(field-filter-multiple-values->in-clause-sql driver value))@@ -412,16 +395,14 @@(sql.qp/format-honeysql driver))](update replacement-snippet-info :replacement-snippet str/replace old-name alias))))-(mu/defmethod ->replacement-snippet-info [:sql FieldFilter]- [driver :- :keyword- {:keys [value alias field], :as field-filter} :- [:map- [:field driver-api/schema.metadata.column]- [:value :any]]]+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/field-filter]+ [driver :- :keyword+ {:keys [value alias field], :as field-filter} :- :metabase.lib.parameters.parse.types/field-filter](let [replacement-snippet-info(cond;; otherwise if the value isn't present just put in something that will always be true, such as `1` (e.g. `WHERE 1;; = 1`). This is only used for field filters outside of optional clauses- (= value params/no-value) {:replacement-snippet "1 = 1"}+ (= value lib/parsed-param-no-value-placeholder) {:replacement-snippet "1 = 1"};; if we have a vector of multiple values recursively convert them to SQL and combine into an `AND` clause;; (This is multiple values in the sense that the frontend provided multiple maps with value values for the same;; FieldFilter, not in the sense that we have a single map with multiple values for `:value`.)@@ -433,30 +414,30 @@(field-filter->replacement-snippet-info driver field-filter))](replace-alias driver field alias replacement-snippet-info)))-;;; ------------------------------------ Referenced Card replacement snippet info --------------------------------------(defmethod ->replacement-snippet-info [:sql ReferencedCardQuery]- [_ {:keys [query params]}]- {:prepared-statement-args (not-empty params)+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/referenced-card-query]+ [_driver :- :keyword+ {:keys [query parameters]} :- :metabase.lib.parameters.parse.types/referenced-card-query]+ {:prepared-statement-args (not-empty parameters):replacement-snippet (sql.qp/make-nestable-sql query)})-;;; ---------------------------------- Native Query Snippet replacement snippet info -----------------------------------(defmethod ->replacement-snippet-info [:sql ReferencedQuerySnippet]- [_ {:keys [content]}]+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/referenced-query-snippet]+ [_driver :- :keyword+ {:keys [content]} :- :metabase.lib.parameters.parse.types/referenced-query-snippet]{:prepared-statement-args nil:replacement-snippet content})-(defmethod ->replacement-snippet-info [:sql TemporalUnit]- [driver {:keys [value field alias]}]- (let [replacement-snippet-info (->> (field->clause driver field (when (not= value params/no-value)+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/temporal-unit]+ [driver :- :keyword+ {:keys [value field alias]} :- :metabase.lib.parameters.parse.types/temporal-unit]+ (let [replacement-snippet-info (->> (field->clause driver field (when (not= value lib/parsed-param-no-value-placeholder){:temporal-unit (keyword value)}))(sql.qp/->honeysql driver)(honeysql->replacement-snippet-info driver))](replace-alias driver field alias replacement-snippet-info)))-(defmethod ->replacement-snippet-info [:sql ReferencedTableQuery]- [driver {:keys [table-id source-filters alias]}]+(mu/defmethod ->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/referenced-table-query]+ [driver :- :keyword+ {:keys [table-id source-filters alias]} :- :metabase.lib.parameters.parse.types/referenced-table-query](let [mp (driver-api/metadata-provider)table-hsql (sql.qp/->honeysql driver (driver-api/table mp table-id))add-alias (fn [result]diff --git a/src/metabase/lib/core.cljc b/src/metabase/lib/core.cljcindex d6965d4a889..27e28dd0875 100644--- a/src/metabase/lib/core.cljc+++ b/src/metabase/lib/core.cljc@@ -94,7 +94,8 @@[metabase.lib.order-by :as lib.order-by][metabase.lib.page][metabase.lib.parameters]- [metabase.lib.parameters.parse :as lib.parameters.parse]+ [metabase.lib.parameters.parse]+ [metabase.lib.parameters.parse.types][metabase.lib.parse :as lib.parse][metabase.lib.query :as lib.query][metabase.lib.query.test-spec :as lib.query.test-spec]@@ -203,6 +204,8 @@lib.options/keep-melib.order-by/keep-memetabase.lib.parameters/keep-me+ metabase.lib.parameters.parse/keep-me+ metabase.lib.parameters.parse.types/keep-melib.parse/keep-melib.query/keep-melib.query.test-spec/keep-me@@ -1514,7 +1517,7 @@parameter-target-template-tag-nameupdate-parameter-target-dimension-optionsupdate-parameter-target-field-ref]- [lib.parameters.parse+ [metabase.lib.parameters.parsematch-and-normalize-tag-name][lib.parseparse]@@ -1674,3 +1677,37 @@Prefer this over setting the `:case-sensitive false` option directly."[boolean-expression :- ::lib.schema.expression/boolean](lib.options/update-options boolean-expression assoc :case-sensitive false))++;;; Parameter Parsing+;;;+;;; **Code Health:** Healthy.++(shared.ns/import-fn metabase.lib.parameters.parse/parse parse-parameters)+(shared.ns/import-fn metabase.lib.parameters.parse.types/field-filter parsed-field-filter-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/field-filter? parsed-field-filter-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/temporal-unit parsed-temporal-unit-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/temporal-unit? parsed-temporal-unit-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/referenced-card-query parsed-referenced-card-query-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/referenced-card-query? parsed-referenced-card-query-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/referenced-table-query parsed-referenced-table-query-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/referenced-table-query? parsed-referenced-table-query-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/referenced-query-snippet parsed-referenced-query-snippet-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/referenced-query-snippet? parsed-referenced-query-snippet-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/date parsed-date-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/date? parsed-date-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/date-range parsed-date-range-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/date-range? parsed-date-range-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/date-time-range parsed-date-time-range-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/date-time-range? parsed-date-time-range-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/param parsed-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/param? parsed-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/function-param? parsed-function-param?)+(shared.ns/import-fn metabase.lib.parameters.parse.types/optional parsed-optional-param)+(shared.ns/import-fn metabase.lib.parameters.parse.types/optional? parsed-optional-param?)++(def parsed-param-no-value-placeholder+ "Convenience for representing an *optional* parameter present in a query but whose value is unspecified in the param+ values.++ **Code Health:** Healthy."+ metabase.lib.parameters.parse.types/no-value)diff --git a/src/metabase/lib/parameters/parse.cljc b/src/metabase/lib/parameters/parse.cljcindex 00eb100f4a3..8bd3c2caed8 100644--- a/src/metabase/lib/parameters/parse.cljc+++ b/src/metabase/lib/parameters/parse.cljc@@ -82,8 +82,8 @@{:type :metabase.lib.parse/param:name param-name}- (lib.params.parse.types/param {:k (or (match-and-normalize-tag-name param-name)- (str/trim param-name))})+ (lib.params.parse.types/param (or (match-and-normalize-tag-name param-name)+ (str/trim param-name))){:type :metabase.lib.parse/function-param:name param-name@@ -92,7 +92,7 @@{:type :metabase.lib.parse/optional:contents contents}- (lib.params.parse.types/optional {:args (mapv ->param contents)})+ (lib.params.parse.types/optional (mapv ->param contents))_ (throw (ex-info "Invalid value." {:value value}))))diff --git a/src/metabase/lib/parameters/parse/types.cljc b/src/metabase/lib/parameters/parse/types.cljcindex c7e606e5650..e30b4e87ba3 100644--- a/src/metabase/lib/parameters/parse/types.cljc+++ b/src/metabase/lib/parameters/parse/types.cljc@@ -2,7 +2,6 @@"Schemas and helper functions for various PARSED parameter maps. These are created from the `:parameters` passed inwith a query."(:require- [metabase.lib.schema.common :as lib.schema.common][metabase.lib.schema.id :as lib.schema.id][metabase.lib.schema.literal :as lib.schema.literal][metabase.lib.schema.metadata :as lib.schema.metadata]@@ -16,6 +15,8 @@::no-value)(mr/def ::no-value+ "Convenience for representing an *optional* parameter present in a query but whose value is unspecified in the param+ values."[:= ::no-value])(mr/def ::field-filter.value.map@@ -43,16 +44,24 @@{:type :date/single:value #t \"2019-09-20T19:52:00.000-07:00\"}- * A vector of maps like the one above (for multiple values)"+ * A vector of maps like the one above (for multiple values)++ * Alias is optional and added by #61118 (not sure what it does, look at PR for more info)"[:map[:lib/type [:= ::field-filter]][:field ::lib.schema.metadata/column]- [:value ::field-filter.value]])+ [:value ::field-filter.value]+ [:alias {:optional true} [:maybe string?]]])(mu/defn field-filter :- ::field-filter"Create a parsed `field-filter` parameter from map `m`."- [m]- (assoc m :lib/type ::field-filter))+ ([field :- ::lib.schema.metadata/column+ value :- ::field-filter.value]+ {:lib/type ::field-filter+ :field field+ :value value})+ ([field value param-alias]+ (assoc (field-filter field value) :alias param-alias)))(defn field-filter?"Whether `x` is a map representing a parsed [[field-filter]] parameter."@@ -62,14 +71,20 @@(mr/def ::temporal-unit[:map[:lib/type [:= ::temporal-unit]]- [:name ::lib.schema.common/non-blank-string]+ [:field ::lib.schema.metadata/column];; TODO (Cam 7/16/25) -- constrain `:value`- [:value some?]])+ [:value some?]+ [:alias {:optional true} [:maybe string?]]])(mu/defn temporal-unit :- ::temporal-unit"Create a parsed `temporal-unit` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::temporal-unit))+ ([column :- ::lib.schema.metadata/column+ value :- some?]+ {:lib/type ::temporal-unit+ :field column+ :value value})+ ([column value param-alias]+ (assoc (temporal-unit column value) :alias param-alias)))(defn temporal-unit?"Whether `x` is a map representing a parsed [[temporal-unit]] parameter."@@ -93,14 +108,72 @@(mu/defn referenced-card-query :- ::referenced-card-query"Create a parsed `referenced-card-query` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::referenced-card-query))+ ([card-id query]+ (referenced-card-query card-id query nil))+ ([card-id :- ::lib.schema.id/card+ query :- :string+ parameters :- [:maybe [:sequential :any]]]+ {:lib/type ::referenced-card-query+ :card-id card-id+ :query query+ :parameters parameters}))(defn referenced-card-query?"Whether `x` is a map representing a parsed [[referenced-card-query]] parameter."[x](= (:lib/type x) ::referenced-card-query))+(mr/def ::referenced-table-query.source-filter+ "Each filter map has:++ * `:field-id` - the ID of the field to filter on+ * `:op` - the comparison operator, one of :>, :>=, :<, :<=, :=, :!=+ * `:value` - the value to compare against"+ [:map+ [:field-id ::lib.schema.id/field]+ [:op [:enum :> :>= :< :<= := :!=]]+ [:value any?]])++(mr/def ::referenced-table-query+ "`table-id` is the id of the table being referenced++ `source-filters` is an optional sequence of filter maps applied to the table reference.++ When present, the table reference is rendered as a filtered subquery:++ (SELECT * FROM \"table\" WHERE \"col\" > ? AND \"col\" <= ?)++ `source-filters` was introduced to support incremental transforms, unused by the frontend.++ `alias` is an optional string alias for the table reference. When present, the expansion includes an AS clause:+ \"table\" AS \"alias\" or (SELECT ...) AS \"alias\".++ Resolved from the template tag's `:emit-alias` boolean and `:name` during parsing."+ [:map+ [:lib/type [:= ::referenced-table-query]]+ [:table-id ::lib.schema.id/table]+ [:source-filters {:optional true} [:maybe [:sequential ::referenced-table-query.source-filter]]]+ [:alias {:optional true} [:maybe string?]]])++(mu/defn referenced-table-query :- ::referenced-table-query+ "Create a parsed `referenced-table-query` parameter from map `m`."+ ([table-id]+ (referenced-table-query table-id nil))+ ([table-id source-filters]+ (referenced-table-query table-id source-filters nil))+ ([table-id :- ::lib.schema.id/table+ source-filters :- [:maybe [:sequential ::referenced-table-query.source-filter]]+ param-alias :- [:maybe string?]]+ {:lib/type ::referenced-table-query+ :table-id table-id+ :source-filters source-filters+ :alias param-alias}))++(defn referenced-table-query?+ "Whether `x` is a map representing a parsed [[referenced-table-query]] parameter."+ [x]+ (= (:lib/type x) ::referenced-table-query))+(mr/def ::referenced-query-snippet"A `ReferencedQuerySnippet` expands to the partial query snippet stored in the `NativeQuerySnippet` table in theapplication DB.@@ -115,24 +188,33 @@(mu/defn referenced-query-snippet :- ::referenced-query-snippet"Create a parsed `referenced-query-snippet` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::referenced-query-snippet))+ [snippet-id :- ::lib.schema.id/snippet+ content :- :string]+ {:lib/type ::referenced-query-snippet+ :snippet-id snippet-id+ :content content})(defn referenced-query-snippet?"Whether `x` is a map representing a parsed [[referenced-query-snippet]]."[x](= (:lib/type x) ::referenced-query-snippet))+(mr/def ::date.value+ [:or+ ::lib.schema.literal/string.date+ ::lib.schema.literal/string.datetime])++;; TODO (Cam 2026-05-14) -- rename to `::datetime`(mr/def ::date"As in a literal date, defined by date-string `s`."[:map[:lib/type [:= ::date]]- [:s ::lib.schema.literal/string.date]])+ [:s ::date.value]])(mu/defn date :- ::date"Create a parsed `date` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::date))+ [s :- ::date.value]+ {:lib/type ::date, :s s})(defn date?"Whether `x` is a map representing a parsed [[date]] parameter."@@ -148,8 +230,8 @@(mu/defn date-range :- ::date-range"Create a new parsed `date-range` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::date-range))+ [start end]+ {:lib/type ::date-range, :start start, :end end})(defn date-range?"Whether `x` is a map representing a parsed [[date-range]] parameter."@@ -165,8 +247,8 @@(mu/defn date-time-range :- ::date-time-range"Create a new parsed `date-time-range` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::date-time-range))+ [start end]+ {:lib/type ::date-time-range, :start start, :end end})(defn date-time-range?"Whether `x` is a map representing a parsed [[date-time-range]] parameter."@@ -180,8 +262,9 @@(mu/defn param :- ::param"Create a new parsed `param` parameter from map `m`."- [m :- :map]- (assoc m :lib/type ::param))+ [param-key :- :string]+ {:lib/type ::param+ :k param-key})(defn param?"Whether `x` is a map that represents a parsed [[param]] parameter."@@ -213,8 +296,9 @@(mu/defn optional :- ::optional"Create a new parsed `optional` param from map `m`."- [m :- :map]- (assoc m :lib/type ::optional))+ [args :- [:sequential :any]]+ {:lib/type ::optional+ :args args})(defn optional?"Whether `x` is a map that represents a parsed [[optional]] parameter."diff --git a/src/metabase/query_processor/util/persisted_cache.clj b/src/metabase/query_processor/util/persisted_cache.cljindex aa87477987e..490b3f8524b 100644--- a/src/metabase/query_processor/util/persisted_cache.clj+++ b/src/metabase/query_processor/util/persisted_cache.clj@@ -27,7 +27,7 @@(model-persistence/metadata->definition (:result-metadata card)(:table-name persisted-info)))))-(mu/defn persisted-info-native-query+(mu/defn persisted-info-native-query :- string?"Returns a native query that selects from the persisted cached table from `persisted-info`. Does not check ifpersistence is appropriate. Use [[can-substitute?]] for that check."[database-id :- ::lib.schema.id/databasediff --git a/src/metabase/sql_tools/sqlglot/core.clj b/src/metabase/sql_tools/sqlglot/core.cljindex 1fdd5f6fa56..364514382e6 100644--- a/src/metabase/sql_tools/sqlglot/core.clj+++ b/src/metabase/sql_tools/sqlglot/core.clj@@ -46,6 +46,7 @@:clickhouse "clickhouse":vertica nil:h2 nil+ :h2-mbql5 nil;; Default: try using the driver name as dialect(name driver)))diff --git a/src/metabase/util/namespaces.clj b/src/metabase/util/namespaces.cljindex 281577c679b..838f54a1421 100644--- a/src/metabase/util/namespaces.clj+++ b/src/metabase/util/namespaces.clj@@ -19,7 +19,9 @@([target]`(import-fn ~target nil))([target sym]- (redef target sym)))+ (macros/case+ :clj `(p/import-fn ~target ~sym)+ :cljs (redef target sym))))(defmacro import-fns"Imports defns from other namespaces.diff --git a/test/metabase/actions/http_action_test.clj b/test/metabase/actions/http_action_test.cljnew file mode 100644index 00000000000..8b5d8f0ad3c--- /dev/null+++ b/test/metabase/actions/http_action_test.clj@@ -0,0 +1,19 @@+(ns metabase.actions.http-action-test+ (:require+ [clojure.test :refer :all]+ [metabase.actions.http-action :as actions.http-action]))++(deftest ^:parallel parse-and-substitute-test+ (are [params expected] (= expected+ (#'actions.http-action/parse-and-substitute "https://example.com/{{param}}[[/{{optional-param}}]]" params))+ {"param" "X"}+ "https://example.com/X"++ {"param" "X", "optional-param" "Y"}+ "https://example.com/X/Y"))++(deftest ^:parallel parse-and-substitute-error-test+ (is (thrown-with-msg?+ clojure.lang.ExceptionInfo+ #"\QCannot call the service: missing required parameters: param\E"+ (#'actions.http-action/parse-and-substitute "https://example.com/{{param}}[[/{{optional-param}}]]" nil))))diff --git a/test/metabase/channel/params_test.clj b/test/metabase/channel/params_test.cljindex 368b981a1ae..d115680eb8c 100644--- a/test/metabase/channel/params_test.clj+++ b/test/metabase/channel/params_test.clj@@ -3,7 +3,7 @@[clojure.test :refer :all][metabase.channel.params :as channel.params]))-(deftest substitute-params-test+(deftest ^:parallel substitute-params-test(are [expected text context](= expected (channel.params/substitute-params text context))diff --git a/test/metabase/driver/common/parameters/parse_test.clj b/test/metabase/driver/common/parameters/parse_test.cljdeleted file mode 100644index 4ca54490289..00000000000--- a/test/metabase/driver/common/parameters/parse_test.clj+++ /dev/null@@ -1,154 +0,0 @@-(ns metabase.driver.common.parameters.parse-test- (:require- [clojure.test :refer :all]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse]- [metabase.lib.parse :as lib.parse]))--(defn- param [field-name] (params/->Param field-name))-(defn- optional [& args] (params/->Optional args))--(defn- normalize-tokens- [tokens]- (for [token tokens]- (or (:token token) token)))--(deftest ^:parallel tokenize-test- (doseq [[query expected]- {"{{num_toucans}}"- [:param-begin "num_toucans" :param-end]-- "[[AND num_toucans > {{num_toucans}}]]"- [:optional-begin "AND num_toucans > " :param-begin "num_toucans" :param-end :optional-end]-- "}}{{]][["- [:param-end :param-begin :optional-end :optional-begin]-- "SELECT * FROM toucanneries WHERE TRUE [[AND num_toucans > {{num_toucans}}]]"- ["SELECT * FROM toucanneries WHERE TRUE " :optional-begin "AND num_toucans > " :param-begin "num_toucans" :param-end :optional-end]-- "SELECT * FROM toucanneries WHERE TRUE [[AND num_toucans > {{num_toucans}}]] [[AND total_birds > {{total_birds}}]]"- ["SELECT * FROM toucanneries WHERE TRUE " :optional-begin "AND num_toucans > " :param-begin "num_toucans" :param-end :optional-end- " " :optional-begin "AND total_birds > " :param-begin "total_birds" :param-end :optional-end]-- "SELECT * FROM -- {{foo}}\n" ["SELECT * FROM " :line-comment-begin " " :param-begin "foo" :param-end :newline]-- "/*SELECT {{foo}}*/" [:block-comment-begin "SELECT " :param-begin "foo" :param-end :block-comment-end]}]- (is (= expected- (normalize-tokens (#'lib.parse/tokenize query true)))- (format "%s should get tokenized to %s" (pr-str query) (pr-str expected)))))--(deftest ^:parallel tokenize-no-sql-comments-test- (doseq [[query expected]- {"-- {{num_toucans}}"- ["-- " :param-begin "num_toucans" :param-end]-- "/* [[AND num_toucans > {{num_toucans}} --]] */"- ["/* " :optional-begin "AND num_toucans > " :param-begin "num_toucans" :param-end " --" :optional-end " */"]}]- (is (= expected- (normalize-tokens (#'lib.parse/tokenize query false)))- (format "%s should get tokenized to %s" (pr-str query) (pr-str expected)))))--(deftest ^:parallel parse-test- (doseq [[group s->expected]- {"queries with one param"- {"select * from foo where bar=1" ["select * from foo where bar=1"]- "select * from foo where bar={{baz}}" ["select * from foo where bar=" (param "baz")]- "select * from foo [[where bar = {{baz}} ]]" ["select * from foo " (optional "where bar = " (param "baz") " ")]}-- "multiple params"- {"SELECT * FROM bird_facts WHERE toucans_are_cool = {{toucans_are_cool}} AND bird_type = {{bird_type}}"- ["SELECT * FROM bird_facts WHERE toucans_are_cool = " (param "toucans_are_cool")- " AND bird_type = " (param "bird_type")]}-- "Multiple optional clauses"- {(str "select * from foo where bar1 = {{baz}} "- "[[and bar2 = {{baz}}]] "- "[[and bar3 = {{baz}}]] "- "[[and bar4 = {{baz}}]]")- ["select * from foo where bar1 = " (param "baz") " "- (optional "and bar2 = " (param "baz")) " "- (optional "and bar3 = " (param "baz")) " "- (optional "and bar4 = " (param "baz"))]-- "SELECT * FROM toucanneries WHERE TRUE [[AND num_toucans > {{num_toucans}}]] [[AND total_birds > {{total_birds}}]]"- ["SELECT * FROM toucanneries WHERE TRUE "- (optional "AND num_toucans > " (param "num_toucans"))- " "- (optional "AND total_birds > " (param "total_birds"))]-- "select * from foobars [[ where foobars.id in (string_to_array({{foobar_id}}, ',')::integer[]) ]]"- ["select * from foobars "- (optional " where foobars.id in (string_to_array(" (param "foobar_id") ", ',')::integer[]) ")]}-- "single square brackets shouldn't get parsed"- (let [query (str "SELECT [test_data.checkins.venue_id] AS [venue_id], "- " [test_data.checkins.user_id] AS [user_id], "- " [test_data.checkins.id] AS [checkins_id] "- "FROM [test_data.checkins] "- "LIMIT 2")]- {query [query]})-- "Valid syntax in PG -- shouldn't get parsed"- (let [query "SELECT array_dims(1 || '[0:1]={2,3}'::int[])"]- {query [query]})-- "Queries with newlines (#11526)"- {"SELECT count(*)\nFROM products\nWHERE category = {{category}}"- ["SELECT count(*)\nFROM products\nWHERE category = " (param "category")]}-- "Queries with params in SQL comments (#7742)"- {"SELECT -- {{foo}}" ["SELECT -- {{foo}}"]- "[[{{this}} -- and]] that" [(optional (param "this") " -- and") " that"]- "SELECT /* \n --{{foo}} */ {{bar}}" ["SELECT /* \n --{{foo}} */ " (param "bar")]}-- "JSON queries that contain non-param fragments like '}}'"- {"{x: {y: \"{{param}}\"}}" ["{x: {y: \"" (param "param") "\"}}"]- "{$match: {{{date}}, field: 1}}}" ["{$match: {" (param "date") ", field: 1}}}"]}-- "Queries that contain non-param fragments like '}}'"- {"select ']]' from t [[where x = {{foo}}]]" ["select ']]' from t " (optional "where x = " (param "foo"))]- "select '}}' from t [[where x = {{foo}}]]" ["select '}}' from t " (optional "where x = " (param "foo"))]}}]- (testing group- (doseq [[s expected] s->expected]- (is (= expected- (normalize-tokens (params.parse/parse s)))- (format "%s should get parsed to %s" (pr-str s) (pr-str expected))))))-- (testing "Testing that invalid/unterminated template params/clauses throw an exception"- (doseq [invalid ["select * from foo [[where bar = {{baz}} "- "select * from foo [[where bar = {{baz]]"- "select * from foo {{bar}} {{baz"- "select * from foo [[clause 1 {{bar}}]] [[clause 2"- "select * from foo where bar = {{baz]]"- "select * from foo [[where bar = {{baz}}}}"]]- (is (thrown? clojure.lang.ExceptionInfo- (params.parse/parse invalid))- (format "Parsing %s should throw an exception" (pr-str invalid))))))--(deftest ^:parallel disable-comment-handling-test- (testing "SQL comments are ignored when handle-sql-comments = false, e.g. in Mongo driver queries"- (doseq [[query result] [["{{{foo}}: -- {{bar}}}"- ["{" (param "foo") ": -- " (param "bar") "}"]]-- ["{{{foo}}: \"/* {{bar}} */\"}"- ["{" (param "foo") ": \"/* " (param "bar") " */\"}"]]]]- (is (= result (normalize-tokens (params.parse/parse query false)))))))--(deftest ^:parallel tokens-in-strings-test- (testing "skip malformed parameter tokens in strings"- (is (= ["'{{'"] (params.parse/parse "'{{'")))- (is (= ["'{{"] (params.parse/parse "'{{")))- (is (= ["'{{}}'"] (params.parse/parse "'{{}}'")))- (is (= ["'[['"] (params.parse/parse "'[['")))- (is (= ["'[[]]'"] (params.parse/parse "'[[]]'")))- (is (= ["'[[{{]]'"] (params.parse/parse "'[[{{]]'"))))- (testing "Parse well-formed tokens in strings"- (is (= ["'" (param "x") "'"] (params.parse/parse "'{{x}}'")))- (is (= ["'" (param "snippet: 'test'") "'"] (params.parse/parse "'{{snippet: 'test'}}'")))- (is (= ["'{{" (param "x") "'"] (params.parse/parse "'{{{{x}}'")))- (is (= ["'[[" (param "x") "'"] (params.parse/parse "'[[{{x}}'")))- (is (= ["'" (optional (param "x")) "'"] (params.parse/parse "'[[{{x}}]]'"))))- (testing "skip comment start in strings"- (is (= ["concat('--'," (param "x") ")"] (params.parse/parse "concat('--',{{x}})")))- (is (= ["concat('/*'," (param "x") ")"] (params.parse/parse "concat('/*',{{x}})")))))diff --git a/test/metabase/driver/common/parameters/values_test.clj b/test/metabase/driver/common/parameters/values_test.cljindex 79eaf632b95..ff2eb9d063f 100644--- a/test/metabase/driver/common/parameters/values_test.clj+++ b/test/metabase/driver/common/parameters/values_test.clj@@ -5,10 +5,10 @@[clojure.string :as str][clojure.test :refer :all][metabase.driver :as driver]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.values :as params.values][metabase.driver.ddl.interface :as ddl.i][metabase.driver.sql-jdbc.connection :as sql-jdbc.conn]+ [metabase.lib.core :as lib][metabase.lib.metadata :as lib.metadata][metabase.lib.test-metadata :as meta][metabase.lib.test-util :as lib.tu]@@ -24,8 +24,7 @@[metabase.util :as u][toucan2.core :as t2])(:import- (clojure.lang ExceptionInfo)- (metabase.driver.common.parameters ReferencedCardQuery ReferencedTableQuery)))+ (clojure.lang ExceptionInfo)))(set! *warn-on-reflection* true)@@ -55,7 +54,7 @@[{:type :number/=, :value ["20" "40"], :target [:variable [:template-tag "number_filter"]]}]))))(testing "Unspecified value"- (is (= params/no-value+ (is (= lib/parsed-param-no-value-placeholder(#'params.values/value-for-tag {:name "id", :display-name "ID", :type :text} nil))))(testing "Unspecified value when required"@@ -74,7 +73,7 @@{:name "id", :display-name "ID", :type :text, :required true, :default "100"} nil))))(testing "Default not used with empty value"- (is (= params/no-value+ (is (= lib/parsed-param-no-value-placeholder(#'params.values/value-for-tag{:name "id", :id test-uuid, :display-name "ID", :type :text, :default "100"}[{:type :category, :target [:variable [:template-tag {:id test-uuid}]], :value nil}]))))@@ -115,7 +114,7 @@[{:type :category, :target [:variable [:template-tag "id"]], :value nil}{:type :category, :target [:variable [:template-tag "id"]], :value nil}]))))(testing "optional tags get no value"- (is (= params/no-value+ (is (= lib/parsed-param-no-value-placeholder(#'params.values/value-for-tag{:name "id", :display-name "ID", :type :text, :required false, :default "100"}[{:type :category, :target [:variable [:template-tag "id"]], :value nil}@@ -229,7 +228,7 @@:table-id (mt/id :checkins):base-type :type/Date:semantic-type nil})- :value params/no-value}+ :value lib/parsed-param-no-value-placeholder}(value-for-tag{:name "checkin_date":display-name "Checkin Date"@@ -347,7 +346,7 @@:table-id (meta/id :checkins):base-type :type/Date:effective-type :type/Date})- :value params/no-value}+ :value lib/parsed-param-no-value-placeholder}(parse-tag{:name "checkin_date":display-name "Checkin Date"@@ -383,7 +382,7 @@[{:database (meta/id):type "native":native {:query test-query}}])- (is (=? {:card-id 1, :query test-query, :params nil}+ (is (=? {:card-id 1, :query test-query, :parameters nil}(value-for-tag{:name "card-template-tag-test":display-name "Card template tag test"@@ -410,7 +409,10 @@(qp.store/with-metadata-provider (lib.tu/metadata-provider-with-cards-for-queriesmeta/metadata-provider[mbql-query])- (is (= {:card-id 1, :query expected-sql, :params nil}+ (is (= {:lib/type :metabase.lib.parameters.parse.types/referenced-card-query+ :card-id 1+ :query expected-sql+ :parameters nil}(value-for-tag{:name "card-template-tag-test":display-name "Card template tag test"@@ -574,8 +576,7 @@(testing "Snippet parsing should work correctly for a valid Snippet"(mt/with-temp [:model/NativeQuerySnippet {snippet-id :id} {:name "expensive-venues":content "venues WHERE price = 4"}]- (let [expected {"expensive-venues" (params/map->ReferencedQuerySnippet {:snippet-id snippet-id- :content "venues WHERE price = 4"})}]+ (let [expected {"expensive-venues" (lib/parsed-referenced-query-snippet-param snippet-id "venues WHERE price = 4")}](is (= expected(query->params-map (query-with-snippet :snippet-id snippet-id))))(testing "`:snippet-name` property in query shouldn't have to match `:name` of Snippet in DB"@@ -588,8 +589,7 @@meta/metadata-provider{:native-query-snippets [{:id 1:content "venues WHERE price = 4"}]})- (let [expected {"expensive-venues" (params/map->ReferencedQuerySnippet {:snippet-id 1- :content "venues WHERE price = 4"})}]+ (let [expected {"expensive-venues" (lib/parsed-referenced-query-snippet-param 1 "venues WHERE price = 4")}](is (= expected(query->params-map (query-with-snippet :snippet-id 1))))(testing "`:snippet-name` property in query shouldn't have to match `:name` of Snippet in DB"@@ -600,26 +600,25 @@(testing "Snippet parsing should normalize snippet names when parsing"(mt/with-temp [:model/NativeQuerySnippet {snippet-id :id} {:name "expensive-venues":content "venues WHERE price = 4"}]- (let [expected {"snippet: expensive-venues" (params/map->ReferencedQuerySnippet {:snippet-id snippet-id- :content "venues WHERE price = 4"})}- query (assoc (mt/native-query {:query "SELECT * FROM {{snippet:expensive-venues}}"})- :template-tags {"snippet:expensive-venues" {:type :snippet- :name "expensive-venues"- :display-name "Expensive Venues"- :snippet-name "expensive-venues"- :snippet-id snippet-id}})]+ (let [expected {"snippet: expensive-venues" (lib/parsed-referenced-query-snippet-param snippet-id "venues WHERE price = 4")}+ query (assoc (mt/native-query {:query "SELECT * FROM {{snippet:expensive-venues}}"})+ :template-tags {"snippet:expensive-venues" {:type :snippet+ :name "expensive-venues"+ :display-name "Expensive Venues"+ :snippet-name "expensive-venues"+ :snippet-id snippet-id}})](is (= expected(query->params-map query)))))))(deftest ^:parallel table-tag-test(testing "Table template tag produces a ReferencedTableQuery"- (is (instance? ReferencedTableQuery- (#'params.values/value-for-tag- {:name "table-tag-test"- :display-name "Table tag test"- :type :table- :table-id 1}- [])))+ (is (=? {:lib/type :metabase.lib.parameters.parse.types/referenced-table-query}+ (#'params.values/value-for-tag+ {:name "table-tag-test"+ :display-name "Table tag test"+ :type :table+ :table-id 1}+ [])))(is (=? {:table-id 1}(value-for-tag {:name "table-tag-test":display-name "Table tag test"@@ -716,9 +715,9 @@[:count-where [:starts-with $product-id->products.category "G"]]{:name "G Monies", :display-name "G Monies"}]]:breakout [!month.created-at]}))]})- (is (=? {:card-id 1- :query (every-pred string? (complement str/blank?))- :params ["G%"]}+ (is (=? {:card-id 1+ :query (every-pred string? (complement str/blank?))+ :parameters ["G%"]}(#'params.values/parse-tag{:id "5aa37572-058f-14f6-179d-a158ad6c029d":name "#1"@@ -768,7 +767,7 @@(testing "Default values passed in as part of the request should not apply when the value is nil"(mt/dataset test-data(testing "Field filters"- (is (=? {"filter" {:value ::params/no-value}}+ (is (=? {"filter" {:value lib/parsed-param-no-value-placeholder}}(query->params-map{:template-tags {"filter"{:id "xyz456"@@ -786,7 +785,7 @@(deftest ^:parallel nil-value-parameter-template-tag-default-raw-value-test(testing "Raw value template tags"- (is (= {"filter" ::params/no-value}+ (is (= {"filter" lib/parsed-param-no-value-placeholder}(query->params-map{:template-tags {"filter"{:id "f0774ef5-a14a-e181-f557-2d4bb1fc94ae"@@ -820,7 +819,7 @@(testing "If parameter specifies a default value (but tag does not), don't use the default when the value is nil"(mt/dataset test-data(testing "Field filters"- (is (=? {"filter" {:value ::params/no-value}}+ (is (=? {"filter" {:value lib/parsed-param-no-value-placeholder}}(query->params-map{:template-tags {"filter"{:id "xyz456"@@ -838,7 +837,7 @@(deftest ^:parallel use-parameter-defaults-raw-value-template-tags-test(testing "If parameter specifies a default value (but tag does not), don't use the default when the value is nil"(testing "Raw value template tags"- (is (= {"filter" ::params/no-value}+ (is (= {"filter" lib/parsed-param-no-value-placeholder}(query->params-map{:template-tags {"filter"{:id "f0774ef5-a14a-e181-f557-2d4bb1fc94ae"@@ -874,13 +873,13 @@:id "__source__":name param-name}}](testing "With no parameters passed in"- (is (=? {param-name ReferencedCardQuery}+ (is (=? {param-name {:lib/type :metabase.lib.parameters.parse.types/referenced-card-query}}(query->params-map {:template-tags template-tags}))))(testing "WITH parameters passed in"(let [parameters [{:type :date/all-options:value "2022-04-20":target [:dimension [:template-tag "created_at"]]}]]- (is (=? {param-name ReferencedCardQuery}+ (is (=? {param-name {:lib/type :metabase.lib.parameters.parse.types/referenced-card-query}}(query->params-map {:template-tags template-tags:parameters parameters}))))))))))@@ -897,11 +896,11 @@(testing "with no parameters given, no value"(is (=? {"createdAt" {:field {:lib/type :metadata/column}- :value params/no-value}}+ :value lib/parsed-param-no-value-placeholder}}(query->params-map {:template-tags template-tags}))))(testing "with parameters given but blank, no value"(is (=? {"createdAt" {:field {:lib/type :metadata/column}- :value params/no-value}}+ :value lib/parsed-param-no-value-placeholder}}(query->params-map {:template-tags template-tags:parameters [{:type :date/relative:value nildiff --git a/test/metabase/driver/mysql_test.clj b/test/metabase/driver/mysql_test.cljindex 2e76e5bd301..c4b5b0e3053 100644--- a/test/metabase/driver/mysql_test.clj+++ b/test/metabase/driver/mysql_test.clj@@ -758,7 +758,7 @@:message "Some of your values violate the constraint: email_format_check":status-code 400:type actions.error/violate-check-constraint}- (sql-jdbc.actions-test/perform-action-ex-data+ (sql-jdbc.actions-test/perform-action-ex-data!:model.row/create (mt/$ids {:create-row {"email" "invalid-email""age" 25}:database (:id database)@@ -790,7 +790,7 @@:message "Column1 and Column2 already exist.":errors {"column1" "This Column1 value already exists." "column2" "This Column2 value already exists."}:status-code 400}- (sql-jdbc.actions-test/perform-action-ex-data+ (sql-jdbc.actions-test/perform-action-ex-data!:model.row/create (mt/$ids {:create-row {"id" 3"column1" "A""column2" "A"}@@ -803,7 +803,7 @@:message "Column1 and Column2 already exist.":status-code 400:type actions.error/violate-unique-constraint}- (sql-jdbc.actions-test/perform-action-ex-data+ (sql-jdbc.actions-test/perform-action-ex-data!:model.row/update (mt/$ids {:update-row {"column1" "A""column2" "A"}:database (:id database)diff --git a/test/metabase/driver/postgres_test.clj b/test/metabase/driver/postgres_test.cljindex 635b5b3afb8..2ead6d0c578 100644--- a/test/metabase/driver/postgres_test.clj+++ b/test/metabase/driver/postgres_test.clj@@ -1277,7 +1277,7 @@:message "Some of your values violate the constraint: email_format_check":status-code 400:type actions.error/violate-check-constraint}- (sql-jdbc.actions-test/perform-action-ex-data+ (sql-jdbc.actions-test/perform-action-ex-data!:model.row/create (mt/$ids {:create-row {"email" "invalid-email""age" 25}:database (:id database)@@ -1309,7 +1309,7 @@:message "Column1 and Column2 already exist.":status-code 400:type actions.error/violate-unique-constraint}- (sql-jdbc.actions-test/perform-action-ex-data+ (sql-jdbc.actions-test/perform-action-ex-data!:model.row/create (mt/$ids {:create-row {"id" 3"column1" "A""column2" "A"}@@ -1322,7 +1322,7 @@:message "Column1 and Column2 already exist.":status-code 400:type actions.error/violate-unique-constraint}- (sql-jdbc.actions-test/perform-action-ex-data+ (sql-jdbc.actions-test/perform-action-ex-data!:model.row/update (mt/$ids {:update-row {"column1" "A""column2" "A"}:database (:id database)diff --git a/test/metabase/driver/sql/parameters/substitute_test.clj b/test/metabase/driver/sql/parameters/substitute_test.cljindex d85e1330f43..913603e5359 100644--- a/test/metabase/driver/sql/parameters/substitute_test.clj+++ b/test/metabase/driver/sql/parameters/substitute_test.clj@@ -6,8 +6,6 @@[clojure.test :refer :all][java-time.api :as t][metabase.driver :as driver]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters.parse :as params.parse][metabase.driver.sql.parameters.substitute :as sql.params.substitute][metabase.driver.sql.query-processor :as sql.qp][metabase.legacy-mbql.normalize :as mbql.normalize]@@ -23,8 +21,7 @@[metabase.util.honey-sql-2 :as h2x][metabase.util.malli :as mu]))-(defn- optional [& args] (params/->Optional args))-(defn- param [param-name] (params/->Param param-name))+(defn- optional [& args] (lib/parsed-optional-param args))(defn- substitute [parsed param->value](driver/with-driver :h2@@ -43,51 +40,51 @@(testing "normal substitution"(is (= ["select * from foobars where bird_type = ?" ["Steller's Jay"]](substitute- ["select * from foobars where bird_type = " (param "bird_type")]+ ["select * from foobars where bird_type = " (lib/parsed-param "bird_type")]{"bird_type" "Steller's Jay"}))))(testing "make sure falsey values are substituted correctly"(testing "`nil` should get substituted as `NULL`"(is (= ["select * from foobars where bird_type = NULL" []](substitute- ["select * from foobars where bird_type = " (param "bird_type")]+ ["select * from foobars where bird_type = " (lib/parsed-param "bird_type")]{"bird_type" nil})))))(testing "`false` should get substituted as `false`"(is (= ["select * from foobars where bird_type = FALSE" []](substitute- ["select * from foobars where bird_type = " (param "bird_type")]+ ["select * from foobars where bird_type = " (lib/parsed-param "bird_type")]{"bird_type" false}))))(testing "optional substitution -- param present"(testing "should preserve whitespace inside optional params"(is (= ["select * from foobars where bird_type = ?" ["Steller's Jay"]](substitute- ["select * from foobars " (optional " where bird_type = " (param "bird_type"))]+ ["select * from foobars " (optional " where bird_type = " (lib/parsed-param "bird_type"))]{"bird_type" "Steller's Jay"})))))(testing "optional substitution -- param not present"(is (= ["select * from foobars" nil](substitute- ["select * from foobars " (optional " where bird_type = " (param "bird_type"))]+ ["select * from foobars " (optional " where bird_type = " (lib/parsed-param "bird_type"))]{}))))(testing "optional -- multiple params -- all present"(is (= ["select * from foobars where bird_type = ? AND color = ?" ["Steller's Jay" "Blue"]](substitute- ["select * from foobars " (optional " where bird_type = " (param "bird_type") " AND color = " (param "bird_color"))]+ ["select * from foobars " (optional " where bird_type = " (lib/parsed-param "bird_type") " AND color = " (lib/parsed-param "bird_color"))]{"bird_type" "Steller's Jay", "bird_color" "Blue"}))))(testing "optional -- multiple params -- some present"(is (= ["select * from foobars" nil](substitute- ["select * from foobars " (optional " where bird_type = " (param "bird_type") " AND color = " (param "bird_color"))]+ ["select * from foobars " (optional " where bird_type = " (lib/parsed-param "bird_type") " AND color = " (lib/parsed-param "bird_color"))]{"bird_type" "Steller's Jay"}))))(testing "nested optionals -- all present"(is (= ["select * from foobars where bird_type = ? AND color = ?" ["Steller's Jay" "Blue"]](substitute- ["select * from foobars " (optional " where bird_type = " (param "bird_type")- (optional " AND color = " (param "bird_color")))]+ ["select * from foobars " (optional " where bird_type = " (lib/parsed-param "bird_type")+ (optional " AND color = " (lib/parsed-param "bird_color")))]{"bird_type" "Steller's Jay", "bird_color" "Blue"}))))(testing "nested optionals -- some present"(is (= ["select * from foobars where bird_type = ?" ["Steller's Jay"]](substitute- ["select * from foobars " (optional " where bird_type = " (param "bird_type")- (optional " AND color = " (param "bird_color")))]+ ["select * from foobars " (optional " where bird_type = " (lib/parsed-param "bird_type")+ (optional " AND color = " (lib/parsed-param "bird_color")))]{"bird_type" "Steller's Jay"})))));;; ------------------------------------------------- Field Filters --------------------------------------------------@@ -96,15 +93,15 @@"Field filter 'values' returned by the `values` namespace are actualy `FieldFilter` record types that containinformation about"[]- (params/map->FieldFilter- {:field (meta/field-metadata :orders :created-at)- :value {:type :date/single- :value (str (t/offset-date-time "2019-09-20T19:52:00.000-07:00"))}}))+ (lib/parsed-field-filter-param+ (meta/field-metadata :orders :created-at)+ {:type :date/single+ :value (str (t/offset-date-time "2019-09-20T19:52:00.000-07:00"))}))(deftest ^:parallel substitute-field-filter-test(testing "field-filters"(testing "non-optional"- (let [query ["select * from orders where " (param "created_at")]]+ (let [query ["select * from orders where " (lib/parsed-param "created_at")]](testing "param is present"(is (= ["select * from orders where \"PUBLIC\".\"ORDERS\".\"CREATED_AT\" >= ? AND \"PUBLIC\".\"ORDERS\".\"CREATED_AT\" < ?"[(t/zoned-date-time "2019-09-20T19:52:00" (t/zone-id "UTC"))@@ -112,10 +109,10 @@(substitute query {"created_at" (date-field-filter-value)}))))(testing "param is missing"(is (= ["select * from orders where 1 = 1" []]- (substitute query {"created_at" (assoc (date-field-filter-value) :value params/no-value)}))+ (substitute query {"created_at" (assoc (date-field-filter-value) :value lib/parsed-param-no-value-placeholder)}))"should be replaced with 1 = 1"))))(testing "optional"- (let [query ["select * from orders " (optional "where " (param "created_at"))]]+ (let [query ["select * from orders " (optional "where " (lib/parsed-param "created_at"))]](testing "param is present"(is (= ["select * from orders where \"PUBLIC\".\"ORDERS\".\"CREATED_AT\" >= ? AND \"PUBLIC\".\"ORDERS\".\"CREATED_AT\" < ?"[(t/zoned-date-time "2019-09-20T19:52:00" (t/zone-id "UTC"))@@ -123,16 +120,16 @@(substitute query {"created_at" (date-field-filter-value)}))))(testing "param is missing — should be omitted entirely"(is (= ["select * from orders" nil]- (substitute query {"created_at" (assoc (date-field-filter-value) :value params/no-value)}))))))))+ (substitute query {"created_at" (assoc (date-field-filter-value) :value lib/parsed-param-no-value-placeholder)}))))))))(deftest ^:parallel substitute-field-filter-for-nested-field-test(testing "field filter for a nested field (with parent-id) should include parent field name in identifier (#47003)"(mt/test-drivers (set/intersection (sql-parameters-engines)(mt/normal-drivers-with-feature :nested-field-columns))- (let [;; Use high IDs that won't collide with existing test metadata+ (let [ ;; Use high IDs that won't collide with existing test metadataparent-field-id 999901nested-field-id 999902- ;; Create a metadata provider that has a parent struct field and a nested child field+ ;; Create a metadata provider that has a parent struct field and a nested child fieldmetadata-provider(lib.tu/merged-mock-metadata-providermeta/metadata-provider@@ -152,7 +149,7 @@:database-type "CHARACTER VARYING":parent-id parent-field-id:nfc-path nil}]})- query ["select * from venues where " (param "tag")]+ query ["select * from venues where " (lib/parsed-param "tag")]field-metadata (assoc (meta/field-metadata :venues :name):id nested-field-id:name "tag_name"@@ -161,10 +158,10 @@:database-type "CHARACTER VARYING":parent-id parent-field-id:nfc-path nil)- field-filter (params/map->FieldFilter- {:field field-metadata- :value {:type :string/=- :value ["banana"]}})+ field-filter (lib/parsed-field-filter-param+ field-metadata+ {:type :string/=+ :value ["banana"]})[sql _args] (mt/with-metadata-provider metadata-provider(sql.params.substitute/substitute query {"tag" field-filter}))](testing "The SQL identifier should include the parent field 'result' before 'tag_name'"@@ -347,15 +344,15 @@(deftest ^:parallel substitute-field-filter-test-2(testing "new operators"(testing "string operators"- (let [query ["select * from venues where " (param "param")]]+ (let [query ["select * from venues where " (lib/parsed-param "param")]](doseq [[operator {:keys [field value expected options]}] substitute-field-filter-test-2-test-cases](testing operator(is (= expected- (-> (substitute query {"param" (params/map->FieldFilter- {:field (meta/field-metadata :venues field)- :value {:type operator- :value value- :options options}})})+ (-> (substitute query {"param" (lib/parsed-field-filter-param+ (meta/field-metadata :venues field)+ {:type operator+ :value value+ :options options})})vec(update 0 (partial driver/prettify-native-form :h2))(update 0 str/split-lines))))))))))@@ -364,14 +361,13 @@(deftest ^:parallel substitute-referenced-card-query-test(testing "Referenced card query substitution"- (let [query ["SELECT * FROM " (param "#123")]]+ (let [query ["SELECT * FROM " (lib/parsed-param "#123")]](is (= ["SELECT * FROM (SELECT 1 `x`)" []]- (substitute query {"#123" (params/map->ReferencedCardQuery {:card-id 123, :query "SELECT 1 `x`"})})))))+ (substitute query {"#123" (lib/parsed-referenced-card-query-param 123 "SELECT 1 `x`")})))))(testing "Referenced card query substitution removes comments (#29168), trailing semicolons (#28218) and whitespace"- (let [query ["SELECT * FROM " (param "#123")]]+ (let [query ["SELECT * FROM " (lib/parsed-param "#123")]](are [nested expected] (= [(str "SELECT * FROM (" expected ")") []]- (substitute query {"#123" (params/map->ReferencedCardQuery- {:card-id 123, :query nested})}))+ (substitute query {"#123" (lib/parsed-referenced-card-query-param 123 nested)}))"SELECT ';' `x`; ; " "SELECT ';' `x`""SELECT * FROM table\n-- remark" "SELECT * FROM table\n-- remark\n"))))@@ -379,23 +375,23 @@(deftest ^:parallel substitute-native-query-snippets-test(testing "Native query snippet substitution"- (let [query ["SELECT * FROM test_scores WHERE " (param "snippet: symbol_is_A")]]+ (let [query ["SELECT * FROM test_scores WHERE " (lib/parsed-param "snippet: symbol_is_A")]](is (=? ["SELECT * FROM test_scores WHERE symbol = 'A'" nil]- (substitute query {"snippet: symbol_is_A" (params/->ReferencedQuerySnippet 123 "symbol = 'A'")}))))))+ (substitute query {"snippet: symbol_is_A" (lib/parsed-referenced-query-snippet-param 123 "symbol = 'A'")}))))))(deftest ^:parallel substitute-recursive-native-query-snippets-test(testing "Recursive native query snippet substitution"- (let [query ["SELECT * FROM test_scores WHERE " (param "snippet: outer")]]+ (let [query ["SELECT * FROM test_scores WHERE " (lib/parsed-param "snippet: outer")]](is (=? ["SELECT * FROM test_scores WHERE symbol = 'A'" nil]- (substitute query {"snippet: outer" (params/->ReferencedQuerySnippet 123 "{{snippet:symbol_is_A}}")- "snippet: symbol_is_A" (params/->ReferencedQuerySnippet 124 "symbol = 'A'")}))))))+ (substitute query {"snippet: outer" (lib/parsed-referenced-query-snippet-param 123 "{{snippet:symbol_is_A}}")+ "snippet: symbol_is_A" (lib/parsed-referenced-query-snippet-param 124 "symbol = 'A'")}))))));;; ------------------------------------------ simple substitution — {{x}} ------------------------------------------(defn- substitute-e2e [sql params](let [[query params] (driver/with-driver :h2(mt/with-metadata-provider meta/metadata-provider- (#'sql.params.substitute/substitute (params.parse/parse sql) (into {} params))))]+ (#'sql.params.substitute/substitute (lib/parse-parameters sql) (into {} params))))]{:query query, :params (vec params)}))(deftest ^:parallel basic-substitution-test@@ -1311,12 +1307,9 @@(is (= ["SELECT * FROM (SELECT * FROM table WHERE x LIKE ?)"["G%"]](sql.params.substitute/substitute- ["SELECT * FROM " (params/->Param "#1")]+ ["SELECT * FROM " (lib/parsed-param "#1")]{"#1"- (params/map->ReferencedCardQuery- {:card-id 1- :query "SELECT * FROM table WHERE x LIKE ?"- :params ["G%"]})}))))))+ (lib/parsed-referenced-card-query-param 1 "SELECT * FROM table WHERE x LIKE ?" ["G%"])}))))))(deftest ^:parallel offset-as-filter-variable-value-test(let [query "select 1 where {{variable}} is not null"]diff --git a/test/metabase/driver/sql/parameters/substitution_test.clj b/test/metabase/driver/sql/parameters/substitution_test.cljindex 23c0055cf16..1f112e3de50 100644--- a/test/metabase/driver/sql/parameters/substitution_test.clj+++ b/test/metabase/driver/sql/parameters/substitution_test.clj@@ -5,9 +5,9 @@[clojure.test :refer :all][java-time.api :as t][metabase.driver :as driver]- ^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.driver.common.parameters :as params][metabase.driver.sql.parameters.substitution :as sql.params.substitution][metabase.driver.sql.query-processor :as sql.qp]+ [metabase.lib.core :as lib][metabase.lib.metadata :as lib.metadata][metabase.lib.test-metadata :as meta]^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.query-processor.store :as qp.store]@@ -53,9 +53,9 @@:prepared-statement-args ["OR"]}(#'sql.params.substitution/field-filter->replacement-snippet-info:h2- (params/map->FieldFilter- {:field (lib.metadata/field (qp.store/metadata-provider) (meta/id :people :state))- :value {:type :string/!=, :slug "state", :value ["OR"]}}))))))))+ (lib/parsed-field-filter-param+ (lib.metadata/field (qp.store/metadata-provider) (meta/id :people :state))+ {:type :string/!=, :slug "state", :value ["OR"]}))))))))(deftest ^:parallel card-with-params->replacement-snippet-test(testing "Make sure Card params are preserved when expanding a Card reference (#12236)"@@ -63,10 +63,7 @@:prepared-statement-args ["G%"]}(sql.params.substitution/->replacement-snippet-info:h2- (params/map->ReferencedCardQuery- {:card-id 1- :query "SELECT * FROM table WHERE x LIKE ?"- :params ["G%"]}))))))+ (lib/parsed-referenced-card-query-param 1 "SELECT * FROM table WHERE x LIKE ?" ["G%"]))))));;; ------------------------------------ align-temporal-unit-with-param-type-and-value test ------------------------------------@@ -94,9 +91,9 @@(mt/with-clock #t "2018-07-01T12:30:00.000Z"(mt/with-metadata-provider meta/metadata-provider(testing "date"- (let [field-filter (params/map->FieldFilter- {:field (lib.metadata/field (qp.store/metadata-provider) (meta/id :orders :created-at))- :value {:type :date/all-options, :value "next3days"}})+ (let [field-filter (lib/parsed-field-filter-param+ (lib.metadata/field (qp.store/metadata-provider) (meta/id :orders :created-at))+ {:type :date/all-options, :value "next3days"})expected-args [(t/zoned-date-time 2018 7 2 0 0 0 0 (t/zone-id "UTC"))(t/zoned-date-time 2018 7 5 0 0 0 0 (t/zone-id "UTC"))]](testing "default implementation"@@ -112,9 +109,9 @@:replacement-snippet "\"PUBLIC\".\"ORDERS\".\"CREATED_AT\" >= ? AND \"PUBLIC\".\"ORDERS\".\"CREATED_AT\" < ?"}(sql.params.substitution/->replacement-snippet-info ::temporal-unit-alignment-override field-filter)))))))(testing "datetime"- (let [field-filter (params/map->FieldFilter- {:field (lib.metadata/field (qp.store/metadata-provider) (meta/id :orders :created-at))- :value {:type :date/all-options, :value "past30minutes"}})+ (let [field-filter (lib/parsed-field-filter-param+ (lib.metadata/field (qp.store/metadata-provider) (meta/id :orders :created-at))+ {:type :date/all-options, :value "past30minutes"})expected-args [(t/zoned-date-time 2018 7 1 12 0 0 0 (t/zone-id "UTC"))(t/zoned-date-time 2018 7 1 12 30 0 0 (t/zone-id "UTC"))]](testing "default implementation"@@ -137,17 +134,14 @@:prepared-statement-args []}(sql.params.substitution/->replacement-snippet-info:h2- (params/map->ReferencedTableQuery- {:table-id (meta/id :orders)}))))))+ (lib/parsed-referenced-table-query-param (meta/id :orders)))))))(testing "Basic table reference with alias"(mt/with-metadata-provider meta/metadata-provider(is (= {:replacement-snippet "\"PUBLIC\".\"ORDERS\" AS \"my_orders\"":prepared-statement-args []}(sql.params.substitution/->replacement-snippet-info:h2- (params/map->ReferencedTableQuery- {:table-id (meta/id :orders)- :alias "my_orders"})))))))+ (lib/parsed-referenced-table-query-param (meta/id :orders) nil "my_orders")))))))(deftest ^:parallel table-query-with-source-filters->replacement-snippet-test(testing "Table reference with a single source-filter produces a filtered subquery"@@ -156,25 +150,29 @@:prepared-statement-args []}(sql.params.substitution/->replacement-snippet-info:h2- (params/map->ReferencedTableQuery- {:table-id (meta/id :orders)- :source-filters [{:field-id (meta/id :orders :total)- :op :>- :value 100}]}))))))+ (lib/parsed-referenced-table-query-param+ (meta/id :orders)+ [{:field-id (meta/id :orders :total)+ :op :>+ :value 100}])))))))++(deftest ^:parallel table-query-with-source-filters->replacement-snippet-test-2(testing "Table reference with multiple source-filters joins them with AND"(mt/with-metadata-provider meta/metadata-provider(is (= {:replacement-snippet "(SELECT * FROM \"PUBLIC\".\"ORDERS\" WHERE (\"TOTAL\" > 100) AND (\"TOTAL\" <= 500))":prepared-statement-args []}(sql.params.substitution/->replacement-snippet-info:h2- (params/map->ReferencedTableQuery- {:table-id (meta/id :orders)- :source-filters [{:field-id (meta/id :orders :total)- :op :>- :value 100}- {:field-id (meta/id :orders :total)- :op :<=- :value 500}]}))))))+ (lib/parsed-referenced-table-query-param+ (meta/id :orders)+ [{:field-id (meta/id :orders :total)+ :op :>+ :value 100}+ {:field-id (meta/id :orders :total)+ :op :<=+ :value 500}])))))))++(deftest ^:parallel table-query-with-source-filters->replacement-snippet-test-3(testing "Table reference with a timestamp source-filter value"(driver/with-driver ::temporal-unit-alignment-override(mt/with-metadata-provider meta/metadata-provider@@ -183,20 +181,22 @@:prepared-statement-args [ts]}(sql.params.substitution/->replacement-snippet-info::temporal-unit-alignment-override- (params/map->ReferencedTableQuery- {:table-id (meta/id :orders)- :source-filters [{:field-id (meta/id :orders :created-at)- :op :>- :value ts}]}))))))))+ (lib/parsed-referenced-table-query-param+ (meta/id :orders)+ [{:field-id (meta/id :orders :created-at)+ :op :>+ :value ts}])))))))))++(deftest ^:parallel table-query-with-source-filters->replacement-snippet-test-4(testing "Table reference with source-filters and alias"(mt/with-metadata-provider meta/metadata-provider(is (= {:replacement-snippet "(SELECT * FROM \"PUBLIC\".\"ORDERS\" WHERE (\"TOTAL\" > 100)) AS \"src\"":prepared-statement-args []}(sql.params.substitution/->replacement-snippet-info:h2- (params/map->ReferencedTableQuery- {:table-id (meta/id :orders)- :alias "src"- :source-filters [{:field-id (meta/id :orders :total)- :op :>- :value 100}]})))))))+ (lib/parsed-referenced-table-query-param+ (meta/id :orders)+ [{:field-id (meta/id :orders :total)+ :op :>+ :value 100}]+ "src")))))))diff --git a/test/metabase/driver/sql_jdbc/actions_test.clj b/test/metabase/driver/sql_jdbc/actions_test.cljindex 4fa7d219384..f09506acbc4 100644--- a/test/metabase/driver/sql_jdbc/actions_test.clj+++ b/test/metabase/driver/sql_jdbc/actions_test.clj@@ -19,9 +19,9 @@[toucan2.core :as t2])(:import (clojure.lang ExceptionInfo)))-(use-fixtures :each (fn [t]+(use-fixtures :each (fn [thunk](mt/with-test-user :rasta- (t))))+ (thunk))))(mu/defn- cast-values :- ::actions.args/row[driver :- :keyword@@ -88,7 +88,7 @@[["hungry"]["happy"]]]])-(defn perform-action-ex-data+(defn perform-action-ex-data!"Calls [[actions/perform-action!]] and returns the `ex-data` of exception.Used to test error message when executing implicit action for SQL DBs."[& args]@@ -99,11 +99,11 @@(defn- field-id->name [id] (t2/select-one-fn :name :model/Field id))-(defn- test-action-error-handling! [f]+(mu/defn- test-action-error-handling! [f :- fn?](mt/test-drivers (filter #(isa? driver/hierarchy % :sql-jdbc) (mt/normal-drivers-with-feature :actions))(actions.tu/with-actions-temp-db action-error-handling(mt/with-actions-enabled- (let [db-id (mt/id)]+ (let [db-id (mt/id)](f {:db-id db-id:group-name (field-id->name (mt/id :group :name)):group-ranking (field-id->name (mt/id :group :ranking))@@ -118,10 +118,10 @@:errors {"ranking" "You must provide a value."}:type actions.error/violate-not-null-constraint:status-code 400}- (perform-action-ex-data :model.row/create (mt/$ids {:create-row {group-name "admin"}- :database db-id- :query {:source-table $$group}- :type :query}))))))))+ (perform-action-ex-data! :model.row/create (mt/$ids {:create-row {group-name "admin"}+ :database db-id+ :query {:source-table $$group}+ :type :query}))))))))(deftest action-error-handling-not-null-constraint-creating-test-2(test-action-error-handling!@@ -132,10 +132,10 @@:errors {"ranking" "You must provide a value."}:type actions.error/violate-not-null-constraint:status-code 400}- (perform-action-ex-data :model.row/create (mt/$ids {:create-row {group-name "admin"}- :database db-id- :query {:source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/create (mt/$ids {:create-row {group-name "admin"}+ :database db-id+ :query {:source-table $$group}+ :type :query})))))))))(deftest action-error-handling-not-null-constraint-updating-test(test-action-error-handling!@@ -146,11 +146,11 @@:errors {"ranking" "You must provide a value."}:type actions.error/violate-not-null-constraint:status-code 400}- (perform-action-ex-data :model.row/update (mt/$ids {:update-row {group-ranking nil}- :database db-id- :query {:filter [:= $group.id 1]- :source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/update (mt/$ids {:update-row {group-ranking nil}+ :database db-id+ :query {:filter [:= $group.id 1]+ :source-table $$group}+ :type :query})))))))))(deftest action-error-handling-unique-constraint-creating-test(test-action-error-handling!@@ -161,11 +161,11 @@:errors {"ranking" "This Ranking value already exists."}:type actions.error/violate-unique-constraint:status-code 400}- (perform-action-ex-data :model.row/create (mt/$ids {:create-row {group-name "new"- group-ranking 1}- :database db-id- :query {:source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/create (mt/$ids {:create-row {group-name "new"+ group-ranking 1}+ :database db-id+ :query {:source-table $$group}+ :type :query})))))))))(deftest action-error-handling-unique-constraint-updating-test(test-action-error-handling!@@ -176,11 +176,11 @@:errors {"ranking" "This Ranking value already exists."}:type actions.error/violate-unique-constraint:status-code 400}- (perform-action-ex-data :model.row/update (mt/$ids {:update-row {group-ranking 2}- :database db-id- :query {:filter [:= $group.id 1]- :source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/update (mt/$ids {:update-row {group-ranking 2}+ :database db-id+ :query {:filter [:= $group.id 1]+ :source-table $$group}+ :type :query})))))))))(defmethod driver/database-supports? [::driver/driver ::action-error-handling-incorrect-type-error-message][_driver _feature _database]@@ -205,11 +205,11 @@(mt/db)){"ranking" "This value should be of type Integer."}{})}- (perform-action-ex-data :model.row/create (mt/$ids {:create-row {group-name "new"- group-ranking "S"}- :database db-id- :query {:source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/create (mt/$ids {:create-row {group-name "new"+ group-ranking "S"}+ :database db-id+ :query {:source-table $$group}+ :type :query})))))))))(deftest action-error-handling-incorrect-type-updating-test(test-action-error-handling!@@ -225,11 +225,11 @@(mt/db)){"ranking" "This value should be of type Integer."}{})}- (perform-action-ex-data :model.row/update (mt/$ids {:update-row {group-ranking "S"}- :database db-id- :query {:filter [:= $group.id 1]- :source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/update (mt/$ids {:update-row {group-ranking "S"}+ :database db-id+ :query {:filter [:= $group.id 1]+ :source-table $$group}+ :type :query})))))))))(deftest action-error-handling-fk-constraint-creating-test(test-action-error-handling!@@ -240,11 +240,11 @@:errors {"group_id" "This value does not exist in table \"group\"."}:type actions.error/violate-foreign-key-constraint:status-code 400}- (perform-action-ex-data :model.row/create (mt/$ids {:create-row {user-name "new"- user-group-id 999}- :database db-id- :query {:source-table $$user}- :type :query})))))))))+ (perform-action-ex-data! :model.row/create (mt/$ids {:create-row {user-name "new"+ user-group-id 999}+ :database db-id+ :query {:source-table $$user}+ :type :query})))))))))(deftest action-error-handling-fk-constraint-updating-test(test-action-error-handling!@@ -255,11 +255,11 @@:errors {"group_id" "This value does not exist in table \"group\"."}:type actions.error/violate-foreign-key-constraint:status-code 400}- (perform-action-ex-data :model.row/update (mt/$ids {:update-row {user-group-id 999}- :database db-id- :query {:filter [:= $user.id 1]- :source-table $$user}- :type :query})))))))))+ (perform-action-ex-data! :model.row/update (mt/$ids {:update-row {user-group-id 999}+ :database db-id+ :query {:filter [:= $user.id 1]+ :source-table $$user}+ :type :query})))))))))(deftest action-error-handling-fk-constraint-deleting-test(test-action-error-handling!@@ -270,10 +270,10 @@:errors {}:type actions.error/violate-foreign-key-constraint:status-code 400}- (perform-action-ex-data :model.row/delete (mt/$ids {:database db-id- :query {:filter [:= $group.id 1]- :source-table $$group}- :type :query})))))))))+ (perform-action-ex-data! :model.row/delete (mt/$ids {:database db-id+ :query {:filter [:= $group.id 1]+ :source-table $$group}+ :type :query})))))))))(deftest actions-return-rows-with-correct-names-test(testing "rows returned by perform action should match the name in metabase_field.name"diff --git a/test/metabase/lib/parameters/parse_test.cljc b/test/metabase/lib/parameters/parse_test.cljcindex 353742e4039..0879450cc09 100644--- a/test/metabase/lib/parameters/parse_test.cljc+++ b/test/metabase/lib/parameters/parse_test.cljc@@ -6,8 +6,11 @@[metabase.lib.parse :as lib.parse][metabase.lib.util :as lib.util]))-(defn- param [field-name] (lib.parms.parse.types/param {:k field-name}))-(defn- optional [& args] (lib.parms.parse.types/optional {:args (vec args)}))+(defn- param [field-name]+ {:lib/type ::lib.parms.parse.types/param, :k field-name})++(defn- optional [& args]+ {:lib/type ::lib.parms.parse.types/optional, :args (vec args)})(defn- normalize-tokens[tokens]diff --git a/test/metabase/test/data/datasets.clj b/test/metabase/test/data/datasets.cljindex d537ef655bd..d4fe227b00a 100644--- a/test/metabase/test/data/datasets.clj+++ b/test/metabase/test/data/datasets.clj@@ -32,7 +32,7 @@"Like [[test-drivers]], but for a single driver."{:style/indent :defn}[driver & body]- `(-test-driver ~driver (^:once fn* [] ~@body)))+ `(-test-driver ~driver (fn [] ~@body)))(defmacro test-drivers"Execute body (presumably containing tests) against the drivers in `drivers` that we're currently testing against