Skip to content

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

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.edn
index 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.dates
metabase.driver.common.parameters.operators
- metabase.driver.common.parameters.parse
metabase.driver.common.parameters.values
metabase.legacy-mbql.jvm-util
metabase.legacy-mbql.normalize
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 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.driver
metabase.driver.common
- metabase.driver.common.parameters
- metabase.driver.common.parameters.parse
metabase.driver.connection
metabase.driver.ddl.interface
metabase.driver.h2
@@ -2665,6 +2663,7 @@
api-keys
app-db
driver
+ lib
permissions
premium-features
settings
diff --git a/docs/developers-guide/driver-changelog.md b/docs/developers-guide/driver-changelog.md
index 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 use
the 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.clj
index 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 @@
### Templates
After 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 code
metabase-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/postwalk
diff --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.clj
index 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 @@
LocalTime
OffsetDateTime
OffsetTime
- 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 contain
letters, 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-> result
field-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.clj
index 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-condition
end-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.clj
index 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 :mongo
diff --git a/modules/drivers/snowflake/test/metabase/driver/snowflake_test.clj b/modules/drivers/snowflake/test/metabase/driver/snowflake_test.clj
index 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 :snowflake
diff --git a/src/metabase/actions/http_action.clj b/src/metabase/actions/http_action.clj
index 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)))
nil
parsed))
-(defn substitute
+(defn- substitute
"Substitute `Optional` and `Param` objects in a `parsed-template`, a sequence of parsed string fragments and tokens, with
the values from the map `param->value` (using logic from `substitution` to decide what replacement SQL should be
generated).
@@ -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.clj
index 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.clj
deleted file mode 100644
index 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.clj
index 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.clj
deleted file mode 100644
index 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.clj
index 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/TemplateTag
params :- [: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 @@
:else
value))
-(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 field
are 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-filter
new-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 param
created, `value` here might be a raw value or a map including information about the Field it references as well as a
value.) 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 @@
:else
value))
-(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) query
under 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.clj
index 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 query
diff --git a/src/metabase/driver/sql/parameters/substitute.clj b/src/metabase/driver/sql/parameters/substitute.clj
index 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}))))
nil
parsed))
diff --git a/src/metabase/driver/sql/parameters/substitution.clj b/src/metabase/driver/sql/parameters/substitution.clj
index 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 for
inclusion 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.cljc
index 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-me
lib.order-by/keep-me
metabase.lib.parameters/keep-me
+ metabase.lib.parameters.parse/keep-me
+ metabase.lib.parameters.parse.types/keep-me
lib.parse/keep-me
lib.query/keep-me
lib.query.test-spec/keep-me
@@ -1514,7 +1517,7 @@
parameter-target-template-tag-name
update-parameter-target-dimension-options
update-parameter-target-field-ref]
- [lib.parameters.parse
+ [metabase.lib.parameters.parse
match-and-normalize-tag-name]
[lib.parse
parse]
@@ -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.cljc
index 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.cljc
index 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 in
with 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 the
application 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.clj
index 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 if
persistence is appropriate. Use [[can-substitute?]] for that check."
[database-id :- ::lib.schema.id/database
diff --git a/src/metabase/sql_tools/sqlglot/core.clj b/src/metabase/sql_tools/sqlglot/core.clj
index 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.clj
index 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.clj
new file mode 100644
index 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.clj
index 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.clj
deleted file mode 100644
index 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.clj
index 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-queries
meta/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 nil
diff --git a/test/metabase/driver/mysql_test.clj b/test/metabase/driver/mysql_test.clj
index 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.clj
index 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.clj
index 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 contain
information 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 metadata
parent-field-id 999901
nested-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 field
metadata-provider
(lib.tu/merged-mock-metadata-provider
meta/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.clj
index 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.clj
index 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.cljc
index 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.clj
index 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