Skip to content

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

Pure Lib QP: remove code to wrap legacy middleware (#63645)

Cam Saul066d3a233d73
diff --git a/src/metabase/legacy_mbql/schema/helpers.cljc b/src/metabase/legacy_mbql/schema/helpers.cljc
index 6daf38a0571..32012dad83a 100644
--- a/src/metabase/legacy_mbql/schema/helpers.cljc
+++ b/src/metabase/legacy_mbql/schema/helpers.cljc
@@ -7,8 +7,6 @@
(comment metabase.types.core/keep-me)
-;;; --------------------------------------------------- defclause ----------------------------------------------------
-
(defn mbql-clause?
"True if `x` is an MBQL clause (a sequence with a keyword as its first arg)."
[x]
@@ -88,10 +86,6 @@
[:ref schema]
schema)])))
-(def KeywordOrString
- "Schema for any keyword or string."
- [:or :keyword :string])
-
(defn non-empty
"Add an addditonal constraint to `schema` (presumably an array) that requires it to be non-empty
(i.e., it must satisfy `seq`)."
diff --git a/src/metabase/legacy_mbql/util.cljc b/src/metabase/legacy_mbql/util.cljc
index 59690eb750f..f03053331d3 100644
--- a/src/metabase/legacy_mbql/util.cljc
+++ b/src/metabase/legacy_mbql/util.cljc
@@ -28,7 +28,7 @@
(mu/defn normalize-token :- [:or :keyword :string]
"Convert a string or keyword in various cases (`lisp-case`, `snake_case`, or `SCREAMING_SNAKE_CASE`) to a lisp-cased
keyword."
- [token :- schema.helpers/KeywordOrString]
+ [token :- [:or :keyword :string]]
(let [s (u/qualified-name token)]
(if (str/starts-with? s "type/")
;; TODO (Cam 8/12/25) -- there's tons of code using incorrect parameter types or normalizing base types
@@ -550,21 +550,6 @@
:else
source-table-id))
-(mu/defn add-order-by-clause :- mbql.s/MBQLQuery
- "Add a new `:order-by` clause to an MBQL `inner-query`. If the new order-by clause references a Field that is
- already being used in another order-by clause, this function does nothing."
- [inner-query :- mbql.s/MBQLQuery
- [dir orderable] :- ::mbql.s/OrderBy]
- (let [existing-orderables (into #{}
- (map (fn [[_dir orderable]]
- orderable))
- (:order-by inner-query))]
- (if (existing-orderables orderable)
- ;; Field already referenced, nothing to do
- inner-query
- ;; otherwise add new clause at the end
- (update inner-query :order-by (comp vec distinct conj) [dir orderable]))))
-
(defn dispatch-by-clause-name-or-class
"Dispatch function perfect for use with multimethods that dispatch off elements of an MBQL query. If `x` is an MBQL
clause, dispatches off the clause name; otherwise dispatches off `x`'s class."
diff --git a/src/metabase/pivot/core.cljc b/src/metabase/pivot/core.cljc
index 59e0c402166..e55fadb0184 100644
--- a/src/metabase/pivot/core.cljc
+++ b/src/metabase/pivot/core.cljc
@@ -51,7 +51,7 @@
(defn columns-without-pivot-group
"Removes the pivot-grouping column from a list of columns, identifying it by name."
[columns]
- (filter #(not (pivot-group-column? %)) columns))
+ (remove pivot-group-column? columns))
(def ^:private get-active-breakout-indexes
"For a given pivot group value (k), returns the indexes of active breakouts.
diff --git a/src/metabase/query_processor/middleware/normalize_query.clj b/src/metabase/query_processor/middleware/normalize_query.clj
index d8a6874c1f7..75e8707ada2 100644
--- a/src/metabase/query_processor/middleware/normalize_query.clj
+++ b/src/metabase/query_processor/middleware/normalize_query.clj
@@ -17,14 +17,11 @@
(when (lib.metadata.protocols/metadata-provider? existing)
existing))
(qp.store/metadata-provider))]
- ;; removing `:lib/converted?` will keep MLv2 from doing a bunch of extra transformations to something that's already
- ;; a well-formed pMBQL query, we don't need that and it actually ends up breaking some stuff
- ;; TODO: Get the library to a stable state, where `lib/query` is idempotent, then this can be dropped.
- (lib/query metadata-provider (dissoc query :lib.convert/converted?))))
+ (lib/query metadata-provider query)))
(mu/defn normalize-preprocessing-middleware :- ::lib.schema/query
"Preprocessing middleware. Normalize a query, meaning do things like convert keys and MBQL clause tags to kebab-case
- keywords. Convert query to pMBQL if needed."
+ keywords. Convert query to MBQL 5 if needed."
[query :- [:map [:database ::lib.schema.id/database]]]
(try
(u/prog1 (normalize* query)
diff --git a/src/metabase/query_processor/pivot/postprocess.clj b/src/metabase/query_processor/pivot/postprocess.clj
index 71d089330ed..ec7a6716148 100644
--- a/src/metabase/query_processor/pivot/postprocess.clj
+++ b/src/metabase/query_processor/pivot/postprocess.clj
@@ -39,9 +39,11 @@
[:pivot-measures {:optional true}
[:sequential [:int {:min 0}]]]])
-(def NON_PIVOT_ROW_GROUP
+(def non-pivot-row-group
"Pivot query results have a 'pivot-grouping' column. Rows whose pivot-grouping value is 0 are expected results.
- Rows whose pivot-grouping values are greater than 0 represent subtotals, and should not be included in non-pivot result outputs."
+
+ Rows whose pivot-grouping values are greater than 0 represent subtotals, and should not be included in non-pivot
+ result outputs."
0)
(defn pivot-grouping-index
@@ -57,19 +59,24 @@
;; every possible idx is just the range over the count of cols
(set (range (count column-titles)))
;; we exclude indices already used in pivot rows and cols, and the pivot-grouping key
- ;; recall that a raw pivot row will always contain this 'pivot-grouping' column, which we don't actually need to use.
+ ;;
+ ;; recall that a raw pivot row will always contain this 'pivot-grouping' column, which we don't actually need
+ ;; to use.
(set (concat pivot-rows pivot-cols [(pivot-grouping-index column-titles)])))
sort
vec))
(mu/defn add-pivot-measures :- ::pivot-spec
- "Given a pivot-spec map without the `:pivot-measures` key, determine what key(s) the measures will be and assoc that value into `:pivot-measures`."
+ "Given a pivot-spec map without the `:pivot-measures` key, determine what key(s) the measures will be and assoc that
+ value into `:pivot-measures`."
[{measure-indices :pivot-measures :as pivot-spec} :- ::pivot-spec]
(let [pivot-grouping-key (pivot-grouping-index (:column-titles pivot-spec))]
(cond-> pivot-spec
- ;; if pivot-measures don't already exist (from the pivot qp), we add them ourselves, assuming lowest ID -> highest ID sort order
+ ;; if pivot-measures don't already exist (from the pivot qp), we add them ourselves, assuming lowest ID ->
+ ;; highest ID sort order
(not (seq measure-indices)) (assoc :pivot-measures (pivot-measures pivot-spec))
- ;; otherwise, we modify indices to skip over whatever the pivot-grouping idx is, so we pull the correct values per row
+ ;; otherwise, we modify indices to skip over whatever the pivot-grouping idx is, so we pull the correct values
+ ;; per row
(seq measure-indices) (update :pivot-measures (fn [indices]
(mapv (fn [idx]
(if (>= idx pivot-grouping-key)
diff --git a/src/metabase/query_processor/postprocess.clj b/src/metabase/query_processor/postprocess.clj
index 8ea0c2f9e74..861b9e2917a 100644
--- a/src/metabase/query_processor/postprocess.clj
+++ b/src/metabase/query_processor/postprocess.clj
@@ -1,6 +1,5 @@
(ns metabase.query-processor.postprocess
(:require
- [metabase.lib.core :as lib]
[metabase.lib.schema :as lib.schema]
[metabase.query-processor.error-type :as qp.error-type]
[metabase.query-processor.middleware.add-remaps :as qp.add-remaps]
@@ -29,21 +28,23 @@
Where `rff` has the form
- (f metadata) -> rf"
- [[::mbql5 #'format-rows/format-rows]
- [::mbql5 #'results-metadata/record-and-return-metadata!]
- [::mbql5 #'limit/limit-result-rows]
- [::mbql5 #'qp.middleware.enterprise/limit-download-result-rows]
- [::mbql5 #'qp.add-rows-truncated/add-rows-truncated]
- [::mbql5 #'qp.add-timezone-info/add-timezone-info]
- [::mbql5 #'qp.middleware.enterprise/merge-sandboxing-metadata]
- [::mbql5 #'qp.add-remaps/remap-results]
- [::mbql5 #'pivot-export/add-data-for-pivot-export]
- [::mbql5 #'large-int/convert-large-int-to-string]
- [::mbql5 #'viz-settings/update-viz-settings]
- [::mbql5 #'qp.cumulative-aggregations/sum-cumulative-aggregation-columns]
- [::mbql5 #'annotate/add-column-info]
- [::mbql5 #'fetch-source-query/add-dataset-info]])
+ (f metadata) -> rf
+
+ All of these middlewares assume MBQL 5."
+ [#'format-rows/format-rows
+ #'results-metadata/record-and-return-metadata!
+ #'limit/limit-result-rows
+ #'qp.middleware.enterprise/limit-download-result-rows
+ #'qp.add-rows-truncated/add-rows-truncated
+ #'qp.add-timezone-info/add-timezone-info
+ #'qp.middleware.enterprise/merge-sandboxing-metadata
+ #'qp.add-remaps/remap-results
+ #'pivot-export/add-data-for-pivot-export
+ #'large-int/convert-large-int-to-string
+ #'viz-settings/update-viz-settings
+ #'qp.cumulative-aggregations/sum-cumulative-aggregation-columns
+ #'annotate/add-column-info
+ #'fetch-source-query/add-dataset-info])
;; ↑↑↑ POST-PROCESSING ↑↑↑ happens from BOTTOM TO TOP
(mu/defn post-processing-rff :- ::qp.schema/rff
@@ -51,19 +52,14 @@
[preprocessed-query :- ::lib.schema/query
rff :- ::qp.schema/rff]
(qp.setup/with-qp-setup [preprocessed-query preprocessed-query]
- (let [legacy-query (lib/->legacy-MBQL preprocessed-query)]
- (try
- (reduce
- (fn [rff [middleware-expected-mbql-version middleware-fn]]
- (u/prog1 (middleware-fn
- (case middleware-expected-mbql-version
- ::mbql5 preprocessed-query
- ::legacy legacy-query)
- rff)
- (assert (fn? <>) (format "%s did not return a valid function" (pr-str middleware)))))
- rff
- middleware)
- (catch Throwable e
- (throw (ex-info (i18n/tru "Error building query results reducing function: {0}" (ex-message e))
- {:query preprocessed-query, :type qp.error-type/qp}
- e)))))))
+ (try
+ (reduce
+ (fn [rff middleware-fn]
+ (u/prog1 (middleware-fn preprocessed-query rff)
+ (assert (fn? <>) (format "%s did not return a valid function" (pr-str middleware)))))
+ rff
+ middleware)
+ (catch Throwable e
+ (throw (ex-info (i18n/tru "Error building query results reducing function: {0}" (ex-message e))
+ {:query preprocessed-query, :type qp.error-type/qp}
+ e))))))
diff --git a/src/metabase/query_processor/preprocess.clj b/src/metabase/query_processor/preprocess.clj
index 4516abd138e..d3c790fba7c 100644
--- a/src/metabase/query_processor/preprocess.clj
+++ b/src/metabase/query_processor/preprocess.clj
@@ -1,14 +1,11 @@
(ns metabase.query-processor.preprocess
(:require
[metabase.config.core :as config]
- ;; legacy usage -- don't use Legacy MBQL utils in QP code going forward, prefer Lib. This will be updated to use
- ;; Lib soon
+ ;; legacy usage -- don't use Legacy MBQL utils in QP code going forward, prefer Lib. This is allowed for now
+ ;; because the QP still returns legacy-style metadata (for now)
^{:clj-kondo/ignore [:discouraged-namespace]}
[metabase.legacy-mbql.schema :as mbql.s]
- [metabase.lib.core :as lib]
[metabase.lib.schema :as lib.schema]
- [metabase.lib.schema.id :as lib.schema.id]
- [metabase.lib.schema.info :as lib.schema.info]
[metabase.query-processor.debug :as qp.debug]
[metabase.query-processor.error-type :as qp.error-type]
[metabase.query-processor.middleware.add-default-temporal-unit :as qp.add-default-temporal-unit]
@@ -46,7 +43,6 @@
[metabase.query-processor.middleware.validate-temporal-bucketing :as validate-temporal-bucketing]
[metabase.query-processor.middleware.wrap-value-literals :as qp.wrap-value-literals]
[metabase.query-processor.setup :as qp.setup]
- [metabase.query-processor.store :as qp.store]
[metabase.util :as u]
[metabase.util.i18n :as i18n]
[metabase.util.log :as log]
@@ -54,96 +50,57 @@
(set! *warn-on-reflection* true)
-;;; the following helper functions are temporary, to aid in the transition from a legacy MBQL QP to a pMBQL QP. Each
-;;; individual middleware function is wrapped in either [[ensure-legacy]] or [[ensure-mbql5]], and will then see the
-;;; flavor of MBQL it is written for.
-
-(mu/defn- ->legacy :- mbql.s/Query
- [query :- [:map
- [:database ::lib.schema.id/database]]]
- (lib/->legacy-MBQL query))
-
-(defn- ^:deprecated ensure-legacy [middleware-fn]
- (-> (fn [query]
- (let [query (cond-> query
- (:lib/type query) ->legacy)]
- (vary-meta (middleware-fn query)
- assoc :converted-form query)))
- (with-meta (meta middleware-fn))))
-
-(mu/defn- ->mbql5 :- ::lib.schema/query
- [query :- [:map
- [:database ::lib.schema.id/database]
- ;; sanity check: info should only get added in Clojure-land and shouldn't get transformed back and forth
- ;; from JSON; make sure it's in the expected shape
- [:info {:optional true} [:maybe ::lib.schema.info/info]]]]
- (cond->> query
- (not (:lib/type query)) (lib/query (qp.store/metadata-provider))))
-
-(defn- ensure-mbql5 [middleware-fn]
- (-> (fn [query]
- (let [query (->mbql5 query)]
- (vary-meta (middleware-fn query)
- assoc :converted-form query)))
- (with-meta (meta middleware-fn))))
-
(def ^:private middleware
"Pre-processing middleware. Has the form
- (f query) -> query"
+ (f query) -> query
+
+ All of these middlewares assume MBQL 5."
;; ↓↓↓ PRE-PROCESSING ↓↓↓ happens from TOP TO BOTTOM
- #_{:clj-kondo/ignore [:deprecated-var]}
[#'normalize/normalize-preprocessing-middleware
- (ensure-mbql5 #'qp.perms/remove-permissions-key)
- (ensure-mbql5 #'qp.perms/remove-source-card-keys)
- (ensure-mbql5 #'qp.perms/remove-sandboxed-table-keys)
- (ensure-mbql5 #'qp.constraints/maybe-add-default-userland-constraints)
- (ensure-mbql5 #'validate/validate-query)
- (ensure-mbql5 #'fetch-source-query/resolve-source-cards)
- (ensure-mbql5 #'drop-fields-in-summaries/drop-fields-in-summaries)
- (ensure-mbql5 #'expand-aggregations/expand-aggregations)
- (ensure-mbql5 #'metrics/adjust)
- (ensure-mbql5 #'expand-macros/expand-macros)
- (ensure-mbql5 #'qp.resolve-referenced/resolve-referenced-card-resources)
- (ensure-mbql5 #'parameters/substitute-parameters)
- (ensure-mbql5 #'qp.resolve-source-table/resolve-source-tables)
- (ensure-mbql5 #'qp.auto-bucket-datetimes/auto-bucket-datetimes)
- (ensure-mbql5 #'reconcile-bucketing/reconcile-breakout-and-order-by-bucketing)
- (ensure-mbql5 #'qp.middleware.enterprise/apply-impersonation)
- (ensure-mbql5 #'qp.middleware.enterprise/attach-destination-db-middleware)
- (ensure-mbql5 #'qp.middleware.enterprise/apply-sandboxing)
- (ensure-mbql5 #'qp.persistence/substitute-persisted-query)
- (ensure-mbql5 #'qp.add-implicit-clauses/add-implicit-clauses) ; #61398
+ #'qp.perms/remove-permissions-key
+ #'qp.perms/remove-source-card-keys
+ #'qp.perms/remove-sandboxed-table-keys
+ #'qp.constraints/maybe-add-default-userland-constraints
+ #'validate/validate-query
+ #'fetch-source-query/resolve-source-cards
+ #'drop-fields-in-summaries/drop-fields-in-summaries
+ #'expand-aggregations/expand-aggregations
+ #'metrics/adjust
+ #'expand-macros/expand-macros
+ #'qp.resolve-referenced/resolve-referenced-card-resources
+ #'parameters/substitute-parameters
+ #'qp.resolve-source-table/resolve-source-tables
+ #'qp.auto-bucket-datetimes/auto-bucket-datetimes
+ #'reconcile-bucketing/reconcile-breakout-and-order-by-bucketing
+ #'qp.middleware.enterprise/apply-impersonation
+ #'qp.middleware.enterprise/attach-destination-db-middleware
+ #'qp.middleware.enterprise/apply-sandboxing
+ #'qp.persistence/substitute-persisted-query
+ #'qp.add-implicit-clauses/add-implicit-clauses ; #61398
;; this needs to be done twice, once before adding remaps (since we want to add remaps inside joins) and then again
;; after adding any implicit joins. Implicit joins do not need to get remaps since we only use them for fetching
;; specific columns.
- (ensure-mbql5 #'resolve-joins/resolve-joins)
- (ensure-mbql5 #'qp.add-remaps/add-remapped-columns)
- #'qp.resolve-fields/resolve-fields ; this middleware actually works with either MBQL 5 or legacy
- (ensure-mbql5 #'binning/update-binning-strategy)
- (ensure-mbql5 #'desugar/desugar)
- (ensure-mbql5 #'qp.add-default-temporal-unit/add-default-temporal-unit)
- (ensure-mbql5 #'qp.add-implicit-joins/add-implicit-joins)
- (ensure-mbql5 #'resolve-joins/resolve-joins)
- (ensure-mbql5 #'fix-bad-field-id-refs/fix-bad-field-id-refs)
- (ensure-mbql5 #'qp.remove-inactive-field-refs/remove-inactive-field-refs)
+ #'resolve-joins/resolve-joins
+ #'qp.add-remaps/add-remapped-columns
+ #'qp.resolve-fields/resolve-fields
+ #'binning/update-binning-strategy
+ #'desugar/desugar
+ #'qp.add-default-temporal-unit/add-default-temporal-unit
+ #'qp.add-implicit-joins/add-implicit-joins
+ #'resolve-joins/resolve-joins
+ #'fix-bad-field-id-refs/fix-bad-field-id-refs
+ #'qp.remove-inactive-field-refs/remove-inactive-field-refs
;; yes, this is called a second time, because we need to handle any joins that got added
- (ensure-mbql5 #'qp.middleware.enterprise/apply-sandboxing)
- (ensure-mbql5 #'qp.cumulative-aggregations/rewrite-cumulative-aggregations)
- (ensure-mbql5 #'qp.wrap-value-literals/wrap-value-literals)
- (ensure-mbql5 #'auto-parse-filter-values/auto-parse-filter-values)
- (ensure-mbql5 #'validate-temporal-bucketing/validate-temporal-bucketing)
- (ensure-mbql5 #'optimize-temporal-filters/optimize-temporal-filters)
- (ensure-mbql5 #'limit/add-default-limit)
- (ensure-mbql5 #'qp.middleware.enterprise/apply-download-limit)
- (ensure-mbql5 #'check-features/check-features)])
-
-(defn- middleware-fn-name [middleware-fn]
- (if-let [fn-name (:name (meta middleware-fn))]
- (if-let [fn-ns (:ns (meta middleware-fn))]
- (symbol (format "%s/%s" (ns-name fn-ns) fn-name))
- fn-name)
- middleware-fn))
+ #'qp.middleware.enterprise/apply-sandboxing
+ #'qp.cumulative-aggregations/rewrite-cumulative-aggregations
+ #'qp.wrap-value-literals/wrap-value-literals
+ #'auto-parse-filter-values/auto-parse-filter-values
+ #'validate-temporal-bucketing/validate-temporal-bucketing
+ #'optimize-temporal-filters/optimize-temporal-filters
+ #'limit/add-default-limit
+ #'qp.middleware.enterprise/apply-download-limit
+ #'check-features/check-features])
(def ^:private ^Long slow-middleware-warning-threshold-ms
"Warn about slow middleware if it takes longer than this many milliseconds."
@@ -172,20 +129,18 @@
(u/prog1 (middleware-fn query)
(let [duration-ms (u/since-ms start-timer)]
(when (> duration-ms slow-middleware-warning-threshold-ms)
- (log/warnf "Slow middleware: %s took %s" (middleware-fn-name middleware-fn) (u/format-milliseconds duration-ms))))
+ (log/warnf "Slow middleware: %s took %s" middleware-fn (u/format-milliseconds duration-ms))))
(qp.debug/debug>
(when-not (= <> query)
- (let [middleware-fn-name (middleware-fn-name middleware-fn)]
- (list middleware-fn-name '=> <>
- ^{:portal.viewer/default :portal.viewer/diff}
- [(or (-> <> meta :converted-form) query)
- <>]))))
+ (list middleware-fn '=> <>
+ ^{:portal.viewer/default :portal.viewer/diff}
+ [query <>])))
;; make sure the middleware returns a valid query... this should be dev-facing only so no need to i18n
(when-not (map? <>)
(throw (ex-info (format "Middleware did not return a valid query.")
- {:fn (middleware-fn-name middleware-fn), :query query, :result <>, :type qp.error-type/qp})))))
+ {:fn middleware-fn, :query query, :result <>, :type qp.error-type/qp})))))
(catch Throwable e
- (let [middleware-fn (middleware-fn-name middleware-fn)]
+ (let [middleware-fn middleware-fn]
(throw (ex-info (i18n/tru "Error preprocessing query in {0}: {1}" middleware-fn ((some-fn ex-message class) e))
{:fn middleware-fn, :query query, :type qp.error-type/qp}
e)))))))
diff --git a/src/metabase/query_processor/streaming/csv.clj b/src/metabase/query_processor/streaming/csv.clj
index 00fa1fe625d..69c2fd5fe88 100644
--- a/src/metabase/query_processor/streaming/csv.clj
+++ b/src/metabase/query_processor/streaming/csv.clj
@@ -128,7 +128,7 @@
(vswap! pivot-data update-in [:data :rows] conj! ordered-row)
(if pivot-group
;; Non-pivoted pivot table: we have to remove the pivot-grouping column
- (when (= qp.pivot.postprocess/NON_PIVOT_ROW_GROUP (int pivot-group))
+ (when (= qp.pivot.postprocess/non-pivot-row-group (int pivot-group))
(let [formatted-row (->> (perf/mapv (fn [formatter r]
(formatter (streaming.common/format-value r)))
@ordered-formatters ordered-row)
diff --git a/src/metabase/query_processor/streaming/json.clj b/src/metabase/query_processor/streaming/json.clj
index 1e652ffaec8..161fe899646 100644
--- a/src/metabase/query_processor/streaming/json.clj
+++ b/src/metabase/query_processor/streaming/json.clj
@@ -59,7 +59,7 @@
;; when a pivot-grouping col exists, we check its group number. When it's zero,
;; we keep it, otherwise don't include it in the results as it's a row representing a subtotal of some kind
(when (or (not group)
- (= qp.pivot.postprocess/NON_PIVOT_ROW_GROUP (int group)))
+ (= qp.pivot.postprocess/non-pivot-row-group (int group)))
(when-not (zero? row-num)
(.write writer ",\n"))
(json/encode-to
diff --git a/src/metabase/query_processor/streaming/xlsx.clj b/src/metabase/query_processor/streaming/xlsx.clj
index 1f273336bed..62580116a89 100644
--- a/src/metabase/query_processor/streaming/xlsx.clj
+++ b/src/metabase/query_processor/streaming/xlsx.clj
@@ -12,7 +12,6 @@
[metabase.query-processor.settings :as qp.settings]
[metabase.query-processor.streaming.common :as streaming.common]
[metabase.query-processor.streaming.interface :as qp.si]
-
[metabase.util :as u]
[metabase.util.currency :as currency]
[metabase.util.date-2 :as u.date]
@@ -673,10 +672,9 @@
(let [pivot-spec (when (and pivot? pivot-export-options (qp.settings/enable-pivoted-exports))
(pivot-opts->pivot-spec (merge {:pivot-cols []
:pivot-rows []}
- pivot-export-options) ordered-cols))
+ (m/filter-vals some? pivot-export-options)) ordered-cols))
non-pivot-cols (pivot/columns-without-pivot-group ordered-cols)]
(vreset! pivot-grouping-index (qp.pivot.postprocess/pivot-grouping-index (mapv :display_name ordered-cols)))
- (def pivot-spec pivot-spec)
(if pivot-spec
;; If we're generating a pivot table, just initialize the `pivot-data` volatile but not the workbook, yet
(vreset! pivot-data
@@ -710,7 +708,7 @@
(if @pivot-data
(vswap! pivot-data update-in [:data :rows] conj! ordered-row)
(when (or (not group)
- (= qp.pivot.postprocess/NON_PIVOT_ROW_GROUP (int group)))
+ (= qp.pivot.postprocess/non-pivot-row-group (int group)))
(let [{:keys [cell-styles typed-cell-styles]} @styles]
(add-row! @workbook-sheet (inc row-num) row' ordered-cols' viz-settings cell-styles typed-cell-styles)
(when (= (inc row-num) *auto-sizing-threshold*)
diff --git a/test/metabase/api/downloads_exports_test.clj b/test/metabase/api/downloads_exports_test.clj
index 57585c9d40f..e88b1254728 100644
--- a/test/metabase/api/downloads_exports_test.clj
+++ b/test/metabase/api/downloads_exports_test.clj
@@ -8,7 +8,9 @@
- Shared Question downloads
- Static Embedding Dashboard/dashcard downloads
- Dashboard Subscription Attachments
- - Alert attachments"
+ - Alert attachments
+
+ TODO (Cam 9/17/25) -- these tests need to get moved into appropriate module(s)."
(:require
[clojure.data :as data]
[clojure.data.csv :as csv]
diff --git a/test/metabase/legacy_mbql/util_test.cljc b/test/metabase/legacy_mbql/util_test.cljc
index 8fede3ebb83..e54ce90389a 100644
--- a/test/metabase/legacy_mbql/util_test.cljc
+++ b/test/metabase/legacy_mbql/util_test.cljc
@@ -116,43 +116,6 @@
(t/is (= [:= [:field 1 nil] nil]
(mbql.u/simplify-compound-filter [:and nil [:= [:field 1 nil] nil]])))))
-(t/deftest ^:parallel add-order-by-clause-test
- (t/testing "can we add an order-by clause to a query?"
- (t/is (= {:source-table 1, :order-by [[:asc [:field 10 nil]]]}
- (mbql.u/add-order-by-clause {:source-table 1} [:asc [:field 10 nil]])))
-
- (t/is (= {:source-table 1
- :order-by [[:asc [:field 10 nil]]
- [:asc [:field 20 nil]]]}
- (mbql.u/add-order-by-clause {:source-table 1
- :order-by [[:asc [:field 10 nil]]]}
- [:asc [:field 20 nil]])))))
-
-(t/deftest ^:parallel add-order-by-clause-test-2
- (t/testing "duplicate clauses should get ignored"
- (t/is (= {:source-table 1
- :order-by [[:asc [:field 10 nil]]]}
- (mbql.u/add-order-by-clause {:source-table 1
- :order-by [[:asc [:field 10 nil]]]}
- [:asc [:field 10 nil]])))))
-
-(t/deftest ^:parallel add-order-by-clause-test-3
- (t/testing "as should clauses that reference the same Field"
- (t/is (= {:source-table 1
- :order-by [[:asc [:field 10 nil]]]}
- (mbql.u/add-order-by-clause {:source-table 1
- :order-by [[:asc [:field 10 nil]]]}
- [:desc [:field 10 nil]])))))
-
-(t/deftest ^:parallel add-order-by-clause-test-4
- (t/testing "fields with different temporal-units should still get added (#40995)"
- (t/is (= {:source-table 1
- :order-by [[:asc [:field 10 nil]]
- [:asc [:field 10 {:temporal-unit :day}]]]}
- (mbql.u/add-order-by-clause {:source-table 1
- :order-by [[:asc [:field 10 nil]]]}
- [:asc [:field 10 {:temporal-unit :day}]])))))
-
(t/deftest ^:parallel combine-filter-clauses-test
(t/is (= [:and [:= [:field 1 nil] 100] [:= [:field 2 nil] 200]]
(mbql.u/combine-filter-clauses