Skip to content

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

Improved `mu/defn` and `mu/fn` macros: only evaluate schemas once (#63737)

Cam Saulc863f41c2ab4
diff --git a/src/metabase/util/malli/fn.clj b/src/metabase/util/malli/fn.clj
index 44cbbde909c..a17fcc64956 100644
--- a/src/metabase/util/malli/fn.clj
+++ b/src/metabase/util/malli/fn.clj
@@ -314,6 +314,56 @@
(for [schema schemas]
(instrumented-arity error-context schema)))))
+(defn- should-capture-schema? [schema]
+ (cond
+ (keyword? schema) false
+ ;; default varargs schema (no validation)
+ (= schema [:* :any]) false
+ :else true))
+
+(defn- capture-input-schema [arity-number input-schema]
+ (if (= input-schema :cat)
+ [input-schema {}]
+ (let [[input-schema-tag & arg-schemas] input-schema]
+ (assert (= input-schema-tag :cat))
+ (reduce
+ (core/fn [[schema captured] arg-schema]
+ (if-not (should-capture-schema? arg-schema)
+ [(conj schema arg-schema)
+ captured]
+ (let [symb (symbol (format "&input-schema-%d-%s"
+ arity-number
+ (str (char (+ (int \a) (count captured))))))]
+ [(conj schema symb)
+ (assoc captured symb arg-schema)])))
+ [(-> [:cat]
+ (with-meta (meta input-schema)))
+ {}]
+ arg-schemas))))
+
+(defn- capture-arity [arity-number [_=> input-schema return-schema]]
+ (let [[input-schema captured] (capture-input-schema arity-number input-schema)]
+ (if-not (should-capture-schema? return-schema)
+ [[:=> input-schema return-schema]
+ captured]
+ ;; return schema has to be the same for each arity so use the same symbol across the fn
+ [[:=> input-schema '&return-schema]
+ (assoc captured '&return-schema return-schema)])))
+
+(defn- capture-function [[_function & arity-schemas]]
+ (reduce
+ (core/fn [[schema captured] [arity-number arity-schema]]
+ (let [[arity-schema arity-captured] (capture-arity arity-number arity-schema)]
+ [(conj schema arity-schema)
+ (merge captured arity-captured)]))
+ [[:function] {}]
+ (map-indexed vector arity-schemas)))
+
+(defn- capture-schemas [fn-schema]
+ (case (first fn-schema)
+ :=> (capture-arity 0 fn-schema)
+ :function (capture-function fn-schema)))
+
(defn instrumented-fn-form
"Nota Bene: not safe for expansion into Clojurescript!
Given a `fn-tail` like
@@ -327,8 +377,10 @@
(mc/-instrument {:schema [:=> [:cat :int :any] :any]}
(fn [x y] (+ 1 2)))"
[error-context parsed & [fn-name]]
- `(let [~'&f ~(deparameterized-fn-form parsed fn-name)]
- (core/fn ~@(instrumented-fn-tail error-context (fn-schema parsed)))))
+ (let [[fn-schema captured] (capture-schemas (fn-schema parsed))]
+ `(let [~'&f ~(deparameterized-fn-form parsed fn-name)
+ ~@(into [] cat captured)]
+ (core/fn ~@(instrumented-fn-tail error-context fn-schema)))))
;; ------------------------------ Skipping Namespace Enforcement in prod ------------------------------
diff --git a/test/metabase/util/malli/fn_test.clj b/test/metabase/util/malli/fn_test.clj
index f9f0022b9e7..0890bd644a5 100644
--- a/test/metabase/util/malli/fn_test.clj
+++ b/test/metabase/util/malli/fn_test.clj
@@ -69,6 +69,23 @@
unit :- [:maybe :keyword]]
(str n \space (or unit :day)))))))))
+(deftest ^:parallel capture-schemas-test
+ (are [fn-schema expected] (= expected
+ (#'mu.fn/capture-schemas fn-schema))
+ [:=> [:cat :int :int [:map [:integer? :boolean]]] :map]
+ '[[:=> [:cat :int :int &input-schema-0-a] :map]
+ {&input-schema-0-a [:map [:integer? :boolean]]}]
+
+ [:function
+ [:=> [:cat string? :any] keyword?]
+ [:=> [:cat string? :any [:* :any]] keyword?]]
+ [[:function
+ [:=> [:cat '&input-schema-0-a :any] '&return-schema]
+ [:=> [:cat '&input-schema-1-a :any [:* :any]] '&return-schema]]
+ {'&input-schema-0-a string?
+ '&return-schema keyword?
+ '&input-schema-1-a string?}]))
+
(deftest ^:parallel instrumented-fn-form-test
(are [form expected] (= expected
(walk/macroexpand-all (mu.fn/instrumented-fn-form {} (mu.fn/parse-fn-tail form))))
@@ -198,13 +215,14 @@
& more :- [:* :int]]
(reduce + (list* x y more)))]
(is (= '(let* [&f (clojure.core/fn [x y & more]
- (reduce + (list* x y more)))]
+ (reduce + (list* x y more)))
+ &input-schema-0-a [:* :int]]
(clojure.core/fn
([a b & more]
(try
(metabase.util.malli.fn/validate-input {:fn-name 'my-plus} :int a)
(metabase.util.malli.fn/validate-input {:fn-name 'my-plus} :int b)
- (metabase.util.malli.fn/validate-input {:fn-name 'my-plus} [:maybe [:* :int]] more)
+ (metabase.util.malli.fn/validate-input {:fn-name 'my-plus} [:maybe &input-schema-0-a] more)
(clojure.core/->>
(clojure.core/apply &f a b more)
(metabase.util.malli.fn/validate-output {:fn-name 'my-plus} :int))
@@ -236,13 +254,14 @@
& {:as options} :- [:map [:integer? :boolean]]]
{:options options, :output (+ x y)})]
(is (= '(let* [&f (clojure.core/fn [x y & {:as options}]
- {:options options, :output (+ x y)})]
+ {:options options, :output (+ x y)})
+ &input-schema-0-a [:map [:integer? :boolean]]]
(clojure.core/fn
([a b & {:as kvs}]
(try
(metabase.util.malli.fn/validate-input {:fn-name 'my-plus} :int a)
(metabase.util.malli.fn/validate-input {:fn-name 'my-plus} :int b)
- (metabase.util.malli.fn/validate-input {:fn-name 'my-plus} [:map [:integer? :boolean]] kvs)
+ (metabase.util.malli.fn/validate-input {:fn-name 'my-plus} &input-schema-0-a kvs)
(clojure.core/->>
(&f a b kvs)
(metabase.util.malli.fn/validate-output {:fn-name 'my-plus} :map))