Skip to content

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

Move sqlserver and oracle to mbql5 (#77414)

Riley Thompson7a73a7a68a61
diff --git a/modules/drivers/oracle/src/metabase/driver/oracle.clj b/modules/drivers/oracle/src/metabase/driver/oracle.clj
index 1ae51e20ce1..35a62f03d04 100644
--- a/modules/drivers/oracle/src/metabase/driver/oracle.clj
+++ b/modules/drivers/oracle/src/metabase/driver/oracle.clj
@@ -47,7 +47,7 @@
(set! *warn-on-reflection* true)
-(driver/register! :oracle, :parent #{:sql-jdbc
+(driver/register! :oracle, :parent #{:sql-mbql5 :sql-jdbc
::sql.qp.empty-string-is-null/empty-string-is-null})
(doseq [[feature supported?] {:convert-timezone true
@@ -301,7 +301,7 @@
(h2x/with-database-type-info [:raw "CURRENT_TIMESTAMP"] "timestamp with time zone"))
(defmethod sql.qp/->honeysql [:oracle :convert-timezone]
- [driver [_ arg target-timezone source-timezone]]
+ [driver [_ _opts arg target-timezone source-timezone]]
(let [expr (sql.qp/->honeysql driver arg)
has-timezone? (or (sql.qp.u/field-with-tz? arg)
(h2x/is-of-type? expr #"timestamp(\(\d\))? with time zone"))]
@@ -328,13 +328,13 @@
(driver.impl/truncate-alias s legacy-max-identifier-length)))
(defmethod sql.qp/->honeysql [:oracle :substring]
- [driver [_ arg start length]]
+ [driver [_ _opts arg start length]]
(if length
[:substr (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver start) (sql.qp/->honeysql driver length)]
[:substr (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver start)]))
(defmethod sql.qp/->honeysql [:oracle :concat]
- [driver [_ & args]]
+ [driver [_ _opts & args]]
(transduce
(map (partial sql.qp/->honeysql driver))
(completing
@@ -347,7 +347,7 @@
args))
(defmethod sql.qp/->honeysql [:oracle :regex-match-first]
- [driver [_ arg pattern]]
+ [driver [_ _opts arg pattern]]
[:regexp_substr (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver pattern)])
(defn- num-to-ds-interval [unit v]
@@ -546,13 +546,18 @@
;; Oracle 23+ supports booleans in conditional expressions. Once Oracle 21c and 19c are no longer supported, we can
;; drop these boolean->comparison conversions.
-(defn- boolean->comparison [clause]
- (sql.qp.boolean-to-comparison/boolean->comparison clause boolean-field-types))
+(defn- boolean->comparison [driver clause]
+ (sql.qp.boolean-to-comparison/boolean->comparison driver clause boolean-field-types))
(defmethod sql.qp/apply-top-level-clause [:oracle :filter]
[driver _ honeysql-form query]
- (->> (update query :filter boolean->comparison)
- ((get-method sql.qp/apply-top-level-clause [:sql-jdbc :filter]) driver :filter honeysql-form)))
+ (->> (update query :filter (partial boolean->comparison driver))
+ ((get-method sql.qp/apply-top-level-clause [:sql-mbql5 :filter]) driver :filter honeysql-form)))
+
+(defmethod sql.qp/apply-top-level-clause [:oracle :filters]
+ [driver _ honeysql-form query]
+ (->> (update query :filters #(mapv (partial boolean->comparison driver) %))
+ ((get-method sql.qp/apply-top-level-clause [:sql-mbql5 :filters]) driver :filters honeysql-form)))
;; Oracle doesn't support `TRUE`/`FALSE`; use `1`/`0`, respectively; convert these booleans to numbers.
(defmethod sql.qp/->honeysql [:oracle Boolean]
@@ -561,27 +566,27 @@
(defmethod sql.qp/->honeysql [:oracle :and]
[driver clause]
- (->> (mapv boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :and]) driver)))
+ (->> (mapv #(boolean->comparison driver %) clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :and]) driver)))
(defmethod sql.qp/->honeysql [:oracle :or]
[driver clause]
- (->> (mapv boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :or]) driver)))
+ (->> (mapv #(boolean->comparison driver %) clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :or]) driver)))
(defmethod sql.qp/->honeysql [:oracle :not]
[driver clause]
- (->> (mapv boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :not]) driver)))
+ (->> (mapv #(boolean->comparison driver %) clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :not]) driver)))
(defmethod sql.qp/->honeysql [:oracle :case]
[driver clause]
- (->> (sql.qp.boolean-to-comparison/case-boolean->comparison clause boolean-field-types)
- ((get-method sql.qp/->honeysql [:sql-jdbc :case]) driver)))
+ (->> (sql.qp.boolean-to-comparison/case-boolean->comparison driver clause boolean-field-types)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :case]) driver)))
(defmethod sql.qp/->honeysql [:oracle ::sql.qp/cast-to-text]
- [driver [_ expr]]
- (sql.qp/->honeysql driver [::sql.qp/cast expr "varchar2(256)"]))
+ [driver [_ _opts expr]]
+ (sql.qp/->honeysql driver (sql.qp/mbql-clause driver ::sql.qp/cast expr "varchar2(256)")))
(defmethod driver/humanize-connection-error-message :oracle
[_ messages]
@@ -817,3 +822,9 @@
(defmethod sql.qp/transform-literal-like-pattern-honeysql :oracle
[_driver like-rhs-honeysql]
[:escape like-rhs-honeysql [:raw "CHR(92)"]])
+
+(defmethod sql.qp/->honeysql [:oracle :value]
+ [driver [_ {:keys [base-type effective-type]} value]]
+ ((get-method sql.qp/->honeysql [::sql.qp.empty-string-is-null/empty-string-is-null :value])
+ driver
+ [:value value {:base_type base-type :effective_type effective-type}]))
diff --git a/modules/drivers/sqlserver/src/metabase/driver/sqlserver.clj b/modules/drivers/sqlserver/src/metabase/driver/sqlserver.clj
index 9201cbfb68f..97b16c296ba 100644
--- a/modules/drivers/sqlserver/src/metabase/driver/sqlserver.clj
+++ b/modules/drivers/sqlserver/src/metabase/driver/sqlserver.clj
@@ -26,6 +26,7 @@
[metabase.driver.sql.query-processor.util :as sql.qp.u]
[metabase.driver.sql.util :as sql.u]
[metabase.driver.util :as driver.u]
+ [metabase.lib.options :as lib.options]
[metabase.lib.schema.metadata :as lib.schema.metadata]
[metabase.sql-tools.core :as sql-tools]
[metabase.util :as u]
@@ -45,7 +46,7 @@
(set! *warn-on-reflection* true)
-(driver/register! :sqlserver, :parent #{:sql-jdbc ::like-escape-char-built-in/like-escape-char-built-in})
+(driver/register! :sqlserver, :parent #{:sql-mbql5 :sql-jdbc ::like-escape-char-built-in/like-escape-char-built-in})
(doseq [[feature supported?] {:case-sensitivity-string-filter-options false
:connection-impersonation true
@@ -227,8 +228,8 @@
nil)
(defmethod sql.qp/->honeysql [:sqlserver :field]
- [driver [_ _ options :as field-clause]]
- (let [parent-method (get-method sql.qp/->honeysql [:sql :field])]
+ [driver [_ options _ :as field-clause]]
+ (let [parent-method (get-method sql.qp/->honeysql [:sql-mbql5 :field])]
(binding [*field-options* options]
(parent-method driver field-clause))))
@@ -482,7 +483,7 @@
(apply merge {"UTC" "UTC"}))))
(defmethod sql.qp/->honeysql [:sqlserver :convert-timezone]
- [driver [_ arg target-timezone source-timezone]]
+ [driver [_ _opts arg target-timezone source-timezone]]
(let [expr (sql.qp/->honeysql driver arg)
datetimeoffset? (or (sql.qp.u/field-with-tz? arg)
(h2x/is-of-type? expr "datetimeoffset"))]
@@ -494,7 +495,7 @@
h2x/->datetime)))
(defmethod sql.qp/->honeysql [:sqlserver :datetime-diff]
- [driver [_ x y unit]]
+ [driver [_ _opts x y unit]]
(let [x (sql.qp/->honeysql driver x)
y (sql.qp/->honeysql driver y)
_ (sql.qp/datetime-diff-check-args x y (partial re-find #"(?i)^(timestamp|date)"))
@@ -593,11 +594,11 @@
query is much more efficient. See #9934 for more details."
[field-clause]
(when (driver-api/is-clause? :field field-clause)
- (let [[_ id-or-name {:keys [temporal-unit], :as opts}] field-clause]
+ (let [[_ {:keys [temporal-unit], :as opts} id-or-name] field-clause]
(when (#{:year :month :day} temporal-unit)
(mapv
(fn [unit]
- [:field id-or-name (assoc opts :temporal-unit unit, ::optimized-bucketing? true)])
+ [:field (assoc opts :temporal-unit unit, ::optimized-bucketing? true) id-or-name])
(case temporal-unit
:year [:year]
:month [:year :month]
@@ -634,24 +635,24 @@
;; remove duplicate group by clauses (from the optimize breakout clauses stuff)
(update new-hsql :group-by distinct))))
+(defn- maybe-add-cast
+ "Tell [[sql.qp/as]] to insert a cast to :bit for boolean expressions. This ensures the :type/Boolean is
+ preserved in results metadata, so downstream questions and query stages can use the column in contexts
+ where a boolean is required; otherwise, SQL Server returns a value of type int for `SELECT 1 AS MyBool`.
+ For comparison expressions (e.g. [:> field1 field2]), tell [[sql.qp/as]] to wrap it in a case statement
+ and then cast it to a :bit. See #53805 for more details."
+ [driver clause]
+ (cond-> clause
+ (sql.qp.boolean-to-comparison/predicate-expression-clause? driver clause)
+ (lib.options/update-options assoc ::sql.qp/add-cast :bit ::sql.qp/wrap-in-case true)
+
+ (sql.qp.boolean-to-comparison/boolean-expression-clause? driver clause)
+ (lib.options/update-options assoc ::sql.qp/add-cast :bit)))
+
(defmethod sql.qp/apply-top-level-clause [:sqlserver :fields]
[driver _ honeysql-form query]
- (let [parent-method (get-method sql.qp/apply-top-level-clause [:sql-jdbc :fields])
- ;; Tell [[sql.qp/as]] to insert a cast to :bit for boolean expressions. This ensures the :type/Boolean is
- ;; preserved in results metadata, so downstream questions and query stages can use the column in contexts
- ;; where a boolean is required; otherwise, SQL Server returns a value of type int for `SELECT 1 AS MyBool`.
- ;; For comparison expressions (e.g. [:> field1 field2]), tell [[sql.qp/as]] to wrap it in a case statement
- ;; and then cast it to a :bit. See #53805 for more details.
- maybe-add-cast #(cond
- (sql.qp.boolean-to-comparison/predicate-expression-clause? %)
- (-> %
- (driver-api/assoc-field-options ::sql.qp/wrap-in-case true)
- (driver-api/assoc-field-options ::sql.qp/add-cast :bit))
- (sql.qp.boolean-to-comparison/boolean-expression-clause? %)
- (driver-api/assoc-field-options % ::sql.qp/add-cast :bit)
- :else
- %)]
- (->> (update query :fields #(mapv maybe-add-cast %))
+ (let [parent-method (get-method sql.qp/apply-top-level-clause [:sql-mbql5 :fields])]
+ (->> (update query :fields #(mapv (partial maybe-add-cast driver) %))
(parent-method driver :fields honeysql-form))))
(defn- optimize-order-by-subclauses
@@ -659,10 +660,10 @@
[subclauses]
(vec
(mapcat
- (fn [[direction field :as subclause]]
+ (fn [[direction opts field :as subclause]]
(if-let [optimized (optimized-temporal-buckets field)]
(for [optimized-clause optimized]
- [direction optimized-clause])
+ [direction opts optimized-clause])
[subclause]))
subclauses)))
@@ -671,17 +672,26 @@
;; similar to the way we optimize GROUP BY above, optimize temporal bucketing in the ORDER BY if possible, because
;; year(), month(), and day() can make use of indexes while DateFromParts() cannot.
(let [query (update query :order-by optimize-order-by-subclauses)
- parent-method (get-method sql.qp/apply-top-level-clause [:sql-jdbc :order-by])]
+ parent-method (get-method sql.qp/apply-top-level-clause [:sql-mbql5 :order-by])]
(-> (parent-method driver :order-by honeysql-form query)
;; order bys have to be distinct in SQL Server!!!!!!!1
(update :order-by distinct))))
+(defn- boolean->comparison [driver clause]
+ (sql.qp.boolean-to-comparison/boolean->comparison driver clause))
+
(defmethod sql.qp/apply-top-level-clause [:sqlserver :filter]
[driver _k honeysql-form query]
- (let [parent-method (get-method sql.qp/apply-top-level-clause [:sql-jdbc :filter])]
- (->> (update query :filter sql.qp.boolean-to-comparison/boolean->comparison)
+ (let [parent-method (get-method sql.qp/apply-top-level-clause [:sql-mbql5 :filter])]
+ (->> (update query :filter #(boolean->comparison driver %))
(parent-method driver :filter honeysql-form))))
+(defmethod sql.qp/apply-top-level-clause [:sqlserver :filters]
+ [driver _k honeysql-form query]
+ (let [parent-method (get-method sql.qp/apply-top-level-clause [:sql-mbql5 :filters])]
+ (->> (update query :filters #(mapv (partial boolean->comparison driver) %))
+ (parent-method driver :filters honeysql-form))))
+
;; SQL Server doesn't like backslashes as the escape character for `LIKE` clauses. Use character classes instead to
;; escape the `LIKE` metacharacters `%` and `_`.
(defmethod sql.qp/escape-like-pattern :sqlserver
@@ -698,60 +708,60 @@
(defmethod sql.qp/->honeysql [:sqlserver :and]
[driver clause]
- (->> (mapv sql.qp.boolean-to-comparison/boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :and]) driver)))
+ (->> (mapv #(boolean->comparison driver %) clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :and]) driver)))
(defmethod sql.qp/->honeysql [:sqlserver :or]
[driver clause]
- (->> (mapv sql.qp.boolean-to-comparison/boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :or]) driver)))
+ (->> (mapv #(boolean->comparison driver %) clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :or]) driver)))
(defmethod sql.qp/->honeysql [:sqlserver :not]
[driver clause]
- (->> (mapv sql.qp.boolean-to-comparison/boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :not]) driver)))
+ (->> (mapv #(boolean->comparison driver %) clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :not]) driver)))
(defmethod sql.qp/->honeysql [:sqlserver :case]
[driver clause]
- (->> (sql.qp.boolean-to-comparison/case-boolean->comparison clause)
- ((get-method sql.qp/->honeysql [:sql-jdbc :case]) driver)))
+ (->> (sql.qp.boolean-to-comparison/case-boolean->comparison driver clause)
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :case]) driver)))
(defmethod sql.qp/->honeysql [:sqlserver Time]
[_ time-value]
(h2x/->time time-value))
(defmethod sql.qp/->honeysql [:sqlserver :stddev]
- [driver [_ field]]
+ [driver [_ _opts field]]
[:stdevp (sql.qp/->honeysql driver field)])
(defmethod sql.qp/->honeysql [:sqlserver :var]
- [driver [_ field]]
+ [driver [_ _opts field]]
[:varp (sql.qp/->honeysql driver field)])
(defmethod sql.qp/->honeysql [:sqlserver :substring]
- [driver [_ arg start length]]
+ [driver [_ _opts arg start length]]
(if length
[:substring (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver start) (sql.qp/->honeysql driver length)]
[:substring (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver start) [:len (sql.qp/->honeysql driver arg)]]))
(defmethod sql.qp/->honeysql [:sqlserver :length]
- [driver [_ arg]]
+ [driver [_ _opts arg]]
[:len (sql.qp/->honeysql driver arg)])
(defmethod sql.qp/->honeysql [:sqlserver :ceil]
- [driver [_ arg]]
+ [driver [_ _opts arg]]
[:ceiling (sql.qp/->honeysql driver arg)])
(defmethod sql.qp/->honeysql [:sqlserver :round]
- [driver [_ arg]]
+ [driver [_ _opts arg]]
[:round (h2x/cast :float (sql.qp/->honeysql driver arg)) 0])
(defmethod sql.qp/->honeysql [:sqlserver :power]
- [driver [_ arg power]]
+ [driver [_ _opts arg power]]
[:power (h2x/cast :float (sql.qp/->honeysql driver arg)) (sql.qp/->honeysql driver power)])
(defmethod sql.qp/->honeysql [:sqlserver :avg]
- [driver [_ field]]
+ [driver [_ _opts field]]
[:avg [:cast (sql.qp/->honeysql driver field) :float]])
(defn- format-approx-percentile-cont
@@ -765,14 +775,14 @@
(sql/register-fn! ::approx-percentile-cont #'format-approx-percentile-cont)
(defmethod sql.qp/->honeysql [:sqlserver :percentile]
- [driver [_ arg val]]
+ [driver [_ _opts arg val]]
[::approx-percentile-cont
(sql.qp/->honeysql driver arg)
(sql.qp/->honeysql driver val)])
(defmethod sql.qp/->honeysql [:sqlserver :median]
- [driver [_ arg]]
- (sql.qp/->honeysql driver [:percentile arg 0.5]))
+ [driver [_ _opts arg]]
+ (sql.qp/->honeysql driver (sql.qp/mbql-clause driver :percentile arg 0.5)))
(def ^:private ^:dynamic *compared-field-options*
"This variable is set to the options of the field we are comparing
@@ -821,43 +831,45 @@
;;; this is a psuedo-MBQL clause to signify that we need to do a cast, see the code below where we add it for an
;;; explanation.
(defmethod sql.qp/->honeysql [:sqlserver ::cast]
- [driver [_tag expr database-type]]
+ [driver [_tag _opts expr database-type]]
(h2x/maybe-cast database-type (sql.qp/->honeysql driver expr)))
(doseq [op [:= :!= :< :<= :> :>= :between]]
(defmethod sql.qp/->honeysql [:sqlserver op]
- [driver [_tag field & args :as _clause]]
+ [driver [_tag opts field & args :as _clause]]
(binding [*compared-field-options* (when (and (vector? field)
(= (get field 0) :field))
- (get field 2))]
+ (get field 1))]
;; We read string literals like `2019-11-05T14:23:46.410` as `datetime2`, which is never going to be `=` to a
;; `datetime` (etc.). Wrap all args after the first in temporal filters in a cast() to the same type as the first
;; arg so filters work correctly. Do this before we fully compile to Honey SQL so we can still use the parent
;; method to take care of things like `[:= <string> <expr>]` generating `WHERE <string> = ? AND <string> IS NOT
;; NULL` for us.
- (let [clause (into [op field]
+ (let [clause (into [op opts field]
;; we're compiling this ahead of time and throwing out the compiled value to make it easier to
;; get the real database type of the expression... maybe when we convert this to MBQL 5 we can
;; just use Lib metadata or type calculation functions instead.
(or (when-let [field-database-type (h2x/database-type (sql.qp/->honeysql driver field))]
(when (#{"datetime" "datetime2" "datetimeoffset" "smalldatetime"} field-database-type)
- (map (fn [[_type val :as expr]]
+ (map (fn [expr]
;; Do not cast nil arguments to enable transformation to IS NULL.
- (if (some? val)
- [::cast expr field-database-type]
+ (if (some? (driver-api/match-one expr
+ [_ (_opts :guard :lib/uuid) val & _] val
+ [_ val & _] val))
+ (sql.qp/mbql-clause driver ::cast expr field-database-type)
expr)))))
identity)
args)]
- ((get-method sql.qp/->honeysql [:sql-jdbc op]) driver clause)))))
+ ((get-method sql.qp/->honeysql [:sql-mbql5 op]) driver clause)))))
(defmethod sql.qp/->honeysql [:sqlserver ::sql.qp/cast-to-text]
- [driver [_ expr]]
- (sql.qp/->honeysql driver [::sql.qp/cast expr "varchar(256)"]))
+ [driver [_ _opts expr]]
+ (sql.qp/->honeysql driver (sql.qp/mbql-clause driver ::sql.qp/cast expr "varchar(256)")))
;; This is used to wrap comparison expressions (e.g. [:> field1 field2]) in a case statement as
;; SQL server does not have a boolean data type. See #53805 for more details.
(defmethod sql.qp/->honeysql [:sqlserver ::sql.qp/wrap-in-case]
- [driver [_tag expr]]
+ [driver [_tag _opts expr]]
[:case (sql.qp/->honeysql driver expr) [:inline 1] :else [:inline 0]])
(defmethod driver/db-default-timezone :sqlserver
@@ -895,43 +907,38 @@
;;
;; - Add a max-results `:limit` to source queries if there's not already one
-(defn- fix-order-bys [inner-query]
- (letfn [;; `in-source-query?` = whether the DIRECT parent is `:source-query`. This is only called on maps that have
- ;; `:limit`, and the only two possible parents there are `:query` (for top-level queries) or `:source-query`.
- (in-source-query? [path]
- (= (last path) :source-query))
- ;; `in-join-source-query?` = whether the parent is `:source-query`, and the grandparent is `:joins`, i.e. we
- ;; are a source query being joined against. In this case it's apparently ok to remove the ORDER BY.
- ;;
- ;; What about source-query in source-query in Join? Not sure about that case. Probably better to be safe and
- ;; not do the aggressive optimizations. See
- ;; https://github.com/metabase/metabase/pull/19384#discussion_r787002558 for more details.
- (in-join-source-query? [path]
- (and (in-source-query? path)
- (= (last (butlast path)) :joins)))
- (has-order-by-without-limit? [m]
- (and (map? m)
- (:order-by m)
- (not (:limit m))))
- (remove-order-by? [path m]
- (and (has-order-by-without-limit? m)
- (in-join-source-query? path)))
- (add-limit? [path m]
- (and (has-order-by-without-limit? m)
- (not (in-join-source-query? path))
- (in-source-query? path)))]
- (match/replace inner-query
- ;; remove order by and then recurse in case we need to do more transformations at another level
- (m :guard (remove-order-by? &parents m))
- (fix-order-bys (dissoc m :order-by))
-
- (m :guard (add-limit? &parents m))
- (fix-order-bys (assoc m :limit driver-api/absolute-max-results)))))
+(defn- has-order-by-without-limit? [stage]
+ (and (:order-by stage)
+ (not (:limit stage))))
+
+(defn- fix-order-bys
+ [stages join-source?]
+ (let [n (count stages)]
+ (vec
+ (map-indexed
+ (fn [i stage]
+ (let [last? (= i (dec n))
+ ;; recurse into any joins first — each join's own `:stages` is a fresh derived table
+ stage (cond-> stage
+ (:joins stage)
+ (update :joins (fn [joins]
+ (mapv #(update % :stages fix-order-bys true) joins))))]
+ (cond
+ ;; last stage of a join = the derived table directly under JOIN → dropping the ORDER BY is fine
+ (and last? join-source? (has-order-by-without-limit? stage))
+ (dissoc stage :order-by)
+
+ ;; any non-final subquery stage → make the ORDER BY legal by giving it a TOP
+ (and (not last?) (has-order-by-without-limit? stage))
+ (assoc stage :limit driver-api/absolute-max-results)
+
+ :else stage)))
+ stages))))
(defmethod sql.qp/preprocess :sqlserver
[driver inner-query]
- (let [parent-method (get-method sql.qp/preprocess :sql)]
- (fix-order-bys (parent-method driver inner-query))))
+ (let [parent-method (get-method sql.qp/preprocess :sql-mbql5)]
+ (fix-order-bys (parent-method driver inner-query) false)))
;; SQL server only supports setting holdability at the connection level, not the statement level, as per
;; https://docs.microsoft.com/en-us/sql/connect/jdbc/using-holdability?view=sql-server-ver15
diff --git a/modules/drivers/sqlserver/test/metabase/driver/sqlserver_test.clj b/modules/drivers/sqlserver/test/metabase/driver/sqlserver_test.clj
index 1a1fae497db..c573705cb59 100644
--- a/modules/drivers/sqlserver/test/metabase/driver/sqlserver_test.clj
+++ b/modules/drivers/sqlserver/test/metabase/driver/sqlserver_test.clj
@@ -19,9 +19,9 @@
[metabase.driver.sql.query-processor :as sql.qp]
[metabase.driver.sqlserver :as sqlserver]
[metabase.lib.core :as lib]
+ [metabase.lib.expression :as lib.expression]
[metabase.lib.metadata :as lib.metadata]
[metabase.query-processor.compile :as qp.compile]
- [metabase.query-processor.middleware.limit :as limit]
[metabase.query-processor.preprocess :as qp.preprocess]
^{:clj-kondo/ignore [:deprecated-namespace]} [metabase.query-processor.store :as qp.store]
[metabase.query-processor.test :as qp]
@@ -47,46 +47,52 @@
(deftest ^:parallel fix-order-bys-test
(testing "Remove order-by from joins"
- (let [original {:joins [{:alias "C3"
- :source-query {:source-table 1
- :order-by [[:asc [:field 2 nil]]]}}
- {:alias "C4"
- :source-query {:source-table 1
- :order-by [[:asc [:field 2 nil]]]
- :limit 10}}]}
- expected {:joins [{:alias "C3"
- :source-query {:source-table 1}}
- {:alias "C4"
- :source-query {:source-table 1
- :order-by [[:asc [:field 2 nil]]]
- :limit 10}}]}]
+ (let [original [{:joins [{:alias "C3"
+ :stages [{:source-table 1
+ :order-by [[:asc [:field 2 nil]]]}]}
+ {:alias "C4"
+ :stages [{:source-table 1
+ :order-by [[:asc [:field 2 nil]]]
+ :limit 10}]}]}]
+ expected [{:joins [{:alias "C3"
+ :stages [{:source-table 1}]}
+ {:alias "C4"
+ :stages [{:source-table 1
+ :order-by [[:asc [:field 2 nil]]]
+ :limit 10}]}]}]]
(is (= expected
- (#'sqlserver/fix-order-bys original)))
- (testing "Inside `:source-query`"
- (is (= {:source-query expected}
- (#'sqlserver/fix-order-bys {:source-query original})))))))
+ (#'sqlserver/fix-order-bys original false)))
+ (testing "Inside a non-final stage"
+ (is (= (conj expected {})
+ (#'sqlserver/fix-order-bys (conj original {}) false)))))))
(deftest ^:parallel fix-order-bys-test-2
- (testing "Add limit for :source-query order bys"
+ (testing "Add limit for non-final stage order bys"
(mt/$ids nil
(let [original {:source-table 1
:order-by [[:asc 2]]}]
- (testing "Not in a source query -- don't do anything"
+ (testing "Final stage -- don't do anything"
(is (= original
- (#'sqlserver/fix-order-bys original))))
- (testing "In source query -- add `:limit`"
- (is (= {:source-query (assoc original :limit limit/absolute-max-results)}
- (#'sqlserver/fix-order-bys {:source-query original}))))
- (testing "In source query in source query-- add `:limit` at both levels"
- (is (= {:source-query {:source-query (assoc original :limit limit/absolute-max-results)
- :order-by [[:asc [:field 1]]]
- :limit limit/absolute-max-results}}
- (#'sqlserver/fix-order-bys {:source-query {:source-query original
- :order-by [[:asc [:field 1]]]}}))))
- (testing "In source query inside source query for join -- add `:limit`"
- (is (= {:joins [{:source-query {:source-query (assoc original :limit limit/absolute-max-results)}}]}
+ (first (#'sqlserver/fix-order-bys [original] false)))))
+ (testing "Non-final stage -- add `:limit`"
+ (is (= [(assoc original :limit driver-api/absolute-max-results)
+ {}]
+ (#'sqlserver/fix-order-bys [original {}] false))))
+ (testing "Nested non-final stages -- add `:limit` at both levels"
+ (is (= [(assoc original :limit driver-api/absolute-max-results)
+ {:order-by [[:asc [:field 1]]]
+ :limit driver-api/absolute-max-results}
+ {}]
+ (#'sqlserver/fix-order-bys [original
+ {:order-by [[:asc [:field 1]]]}
+ {}]
+ false))))
+ (testing "Non-final stage inside join -- add `:limit`"
+ (is (= [{:joins [{:stages [(assoc original :limit driver-api/absolute-max-results)
+ {}]}]}]
(#'sqlserver/fix-order-bys
- {:joins [{:source-query {:source-query original}}]}))))))))
+ [{:joins [{:stages [original {}]}]}]
+ false))))))))
;;; -------------------------------------------------- VARCHAR(MAX) --------------------------------------------------
@@ -382,9 +388,11 @@
(mt/test-driver :sqlserver
(testing "Should use efficient functions like year() for date bucketing (#9934)"
(letfn [(query-with-bucketing [unit]
- (mt/mbql-query checkins
- {:aggregation [[:count]]
- :breakout [[:field $date {:temporal-unit unit}]]}))]
+ (let [mp (mt/metadata-provider)
+ date (lib.metadata/field mp (mt/id :checkins :date))]
+ (-> (lib/query mp (lib.metadata/table mp (mt/id :checkins)))
+ (lib/aggregate (lib/count))
+ (lib/breakout (lib/with-temporal-bucket date (keyword unit))))))]
(doseq [[unit {:keys [expected-sql expected-rows]}]
{"year"
{:expected-sql
@@ -476,10 +484,18 @@
(deftest ^:parallel truncated-datetime-still-datetime-test
(mt/test-driver :sqlserver
(testing "When truncating a `:type/DateTime` to a date-sized unit, return datetime"
- (letfn [(query-with-bucketing [unit]
- (mt/mbql-query orders
- {:aggregation [[:count]]
- :breakout [[:field $created_at {:temporal-unit unit}]]}))]
+ (letfn [(orders-query-with-bucketing [unit]
+ (let [mp (mt/metadata-provider)
+ created-at (lib.metadata/field mp (mt/id :orders :created_at))]
+ (-> (lib/query mp (lib.metadata/table mp (mt/id :orders)))
+ (lib/aggregate (lib/count))
+ (lib/breakout (lib/with-temporal-bucket created-at (keyword unit))))))
+ (checkins-query-with-bucketing [unit]
+ (let [mp (mt/metadata-provider)
+ date (lib.metadata/field mp (mt/id :checkins :date))]
+ (-> (lib/query mp (lib.metadata/table mp (mt/id :checkins)))
+ (lib/aggregate (lib/count))
+ (lib/breakout (lib/with-temporal-bucket date (keyword unit))))))]
(doseq [[unit {:keys [expected-sql expected-rows]}]
{"year"
{:expected-sql
@@ -556,40 +572,51 @@
["2013-01-22T00:00:00Z" 1]
["2013-01-23T00:00:00Z" 1]]}}]
(testing (format "\nUnit = %s\n" unit)
- (testing "Should generate the correct SQL query"
- (is (= expected-sql
- (pretty-sql (:query (qp.compile/compile (query-with-bucketing unit)))))))
- (testing "Should still return correct results"
- (is (= expected-rows
- (take 5 (mt/rows
- (mt/run-mbql-query checkins
- {:aggregation [[:count]]
- :breakout [[:field $date {:temporal-unit unit}]]})))))
- (is (= [:type/DateTime :type/Integer]
- (->> {:aggregation [[:count]]
- :breakout [[:field $created_at {:temporal-unit unit}]]}
- (mt/run-mbql-query orders)
- :data
- :results_metadata
- :columns
- (map :base_type)))))))))))
+ (let [orders-query (orders-query-with-bucketing unit)
+ checkins-query (checkins-query-with-bucketing unit)]
+ (testing "Should generate the correct SQL query"
+ (is (= expected-sql
+ (pretty-sql (:query (qp.compile/compile orders-query))))))
+ (testing "Should still return correct results"
+ (is (= expected-rows
+ (take 5 (mt/rows (qp/process-query checkins-query)))))
+ (is (= [:type/DateTime :type/Integer]
+ (->> orders-query
+ qp/process-query
+ :data
+ :results_metadata
+ :columns
+ (map :base_type))))))))))))
(deftest ^:parallel top-level-boolean-expressions-test
(mt/test-driver :sqlserver
(testing "BIT values like 0 and 1 get converted to equivalent boolean expressions"
- (let [true-value [:value true {:base_type :type/Boolean}]
- false-value [:value false {:base_type :type/Boolean}]]
- (letfn [(orders-query [args]
- (-> (mt/mbql-query orders
- {:expressions {"MyTrue" true-value
- "MyFalse" false-value}
- :fields [[:expression "MyTrue"]]
- :limit 1})
- (update :query merge args)))]
+ (let [opts {:base-type :type/Boolean :effective-type :type/Boolean}
+ bool-val (fn [b] (sql.qp/mbql-clause-with-opts :sqlserver :value opts b))]
+ (letfn [(expression-ref [expression-name]
+ (sql.qp/mbql-clause :sqlserver :expression expression-name))
+ (orders-query [{:keys [expressions fields filters]
+ :or {expressions [["MyTrue" (bool-val true)] ["MyFalse" (bool-val false)]]
+ fields ["MyTrue"]}}]
+ (let [returned-expression? (fn [[expr-name _]] ((set fields) expr-name))
+ returned-exprs (filter returned-expression? expressions)
+ hidden-exprs (remove returned-expression? expressions)
+ mp (mt/metadata-provider)
+ query (lib/query mp (lib.metadata/table mp (mt/id :orders)))
+ query (reduce (fn [query [expression-name expression]]
+ (lib/expression query expression-name expression))
+ query
+ returned-exprs)
+ query (lib/with-fields query (mapv #(lib/expression-ref query %) fields))
+ query (reduce (fn [query [expr-name expr]]
+ (lib.expression/expression query -1 expr-name expr {:add-to-fields? false}))
+ query
+ hidden-exprs)]
+ (-> (reduce lib/filter query filters) (lib/limit 1))))]
(doseq [{:keys [desc query expected-sql expected-types expected-rows]}
[{:desc "true filter"
:query
- (orders-query {:filter true-value})
+ (orders-query {:filters [(bool-val true)]})
:expected-sql
["SELECT"
" TOP(1) CAST(1 AS bit) AS MyTrue"
@@ -601,7 +628,7 @@
:expected-rows [[true]]}
{:desc "false filter"
:query
- (orders-query {:filter false-value})
+ (orders-query {:filters [(bool-val false)]})
:expected-sql
["SELECT"
" TOP(1) CAST(1 AS bit) AS MyTrue"
@@ -613,7 +640,7 @@
:expected-rows []}
{:desc "not filter"
:query
- (orders-query {:filter [:not false-value]})
+ (orders-query {:filters [(sql.qp/mbql-clause :sqlserver :not (bool-val false))]})
:expected-sql
["SELECT"
" TOP(1) CAST(1 AS bit) AS MyTrue"
@@ -625,11 +652,13 @@
:expected-rows [[true]]}
{:desc "nested logical operators"
:query
- (orders-query {:filter [:and
- [:not false-value]
- [:or
- [:expression "MyFalse"]
- [:expression "MyTrue"]]]})
+ (orders-query {:filters [(sql.qp/mbql-clause
+ :sqlserver :and
+ (sql.qp/mbql-clause :sqlserver :not (bool-val false))
+ (sql.qp/mbql-clause
+ :sqlserver :or
+ (expression-ref "MyFalse")
+ (expression-ref "MyTrue")))]})
:expected-sql
["SELECT"
" TOP(1) CAST(1 AS bit) AS MyTrue"
@@ -644,27 +673,31 @@
:expected-types [:type/Boolean]
:expected-rows [[true]]}
{:desc "case expression"
- :query
- (orders-query {:expressions {"MyTrue" true-value
- "MyFalse" false-value
- "MyCase" [:case [[[:expression "MyFalse"] false-value]
- [[:expression "MyTrue"] true-value]]]}
- :fields [[:expression "MyCase"]]})
+ :query (orders-query
+ {:expressions [["MyTrue" (bool-val true)]
+ ["MyFalse" (bool-val false)]
+ ["MyCase" (sql.qp/mbql-clause
+ :sqlserver :case
+ [[(expression-ref "MyFalse") (bool-val false)]
+ [(expression-ref "MyTrue") (bool-val true)]])]]
+ :fields ["MyCase" "MyTrue" "MyFalse"]})
:expected-sql
["SELECT"
" TOP(1) CASE"
" WHEN 0 = 1 THEN 0"
" WHEN 1 = 1 THEN 1"
- " END AS MyCase"
+ " END AS MyCase,"
+ " CAST(1 AS bit) AS MyTrue,"
+ " CAST(0 AS bit) AS MyFalse"
"FROM"
" dbo.orders"]
- :expected-types [:type/Integer]
- :expected-rows [[1]]}
+ :expected-types [:type/Integer :type/Boolean :type/Boolean]
+ :expected-rows [[1 true false]]}
;; only top-level booleans should be transformed; otherwise an expression like 1 = 1 gets compiled
;; to (1 = 1) = (1 = 1)
{:desc "non-top-level booleans"
:query
- (orders-query {:filter [:= true-value true-value]})
+ (orders-query {:filters [(sql.qp/mbql-clause :sqlserver := (bool-val true) (bool-val true))]})
:expected-sql
["SELECT"
" TOP(1) CAST(1 AS bit) AS MyTrue"
@@ -813,9 +846,10 @@
:from [:attempts]
:where (sql.qp/->honeysql
:sqlserver
- [:=
- [:field (mt/id :attempts :datetime) nil]
- (sql.qp/compiled [:raw "?"])])})))]
+ (sql.qp/mbql-clause
+ :sqlserver :=
+ (sql.qp/mbql-clause :sqlserver :field (mt/id :attempts :datetime))
+ (sql.qp/compiled [:raw "?"])))})))]
(doseq [param [datetime-string datetime-localdatetime]
:let [query [base-query param]]]
(testing (pr-str query)
@@ -854,20 +888,22 @@
(driver/with-driver :sqlserver
(qp.store/with-metadata-provider (mt/id)
(binding [sql.qp/*inner-query* {:expressions
- {"NameEquals"
- [:=
- [:field
- "LiteralString"
+ [(sql.qp/mbql-clause-with-opts
+ :sqlserver := {:lib/expression-name "NameEquals"}
+ (sql.qp/mbql-clause-with-opts
+ :sqlserver :field
{:base-type :type/Text
:join-alias "JoinedCategories"
driver-api/qp.add.source-table "JoinedCategories"
driver-api/qp.add.source-alias "LiteralString"
- driver-api/qp.add.desired-alias "JoinedCategories__LiteralString"}]
- [:field
- (mt/id :venues :name)
+ driver-api/qp.add.desired-alias "JoinedCategories__LiteralString"}
+ "LiteralString")
+ (sql.qp/mbql-clause-with-opts
+ :sqlserver :field
{driver-api/qp.add.source-table (mt/id :venues)
driver-api/qp.add.source-alias "name"
- driver-api/qp.add.desired-alias "name"}]]}}]
+ driver-api/qp.add.desired-alias "name"}
+ (mt/id :venues :name)))]}]
(is (= {:where
[:=
[::h2x/identifier :field ["JoinedCategories" "LiteralString"]]
@@ -876,11 +912,14 @@
{:database-type "varchar"}]]}
(sql.qp/apply-top-level-clause
:sqlserver
- :filter
+ :filters
{}
- {:filter [:expression "NameEquals" {:base-type :type/Boolean
- driver-api/qp.add.source-table driver-api/qp.add.none
- driver-api/qp.add.desired-alias nil}]})))))))
+ {:filters [(sql.qp/mbql-clause-with-opts
+ :sqlserver :expression
+ {:base-type :type/Boolean
+ driver-api/qp.add.source-table driver-api/qp.add.none
+ driver-api/qp.add.desired-alias nil}
+ "NameEquals")]})))))))
(mt/defdataset ^:private bigint-identity-data
[["bigint_identity_test"
diff --git a/src/metabase/driver/sql/query_processor.clj b/src/metabase/driver/sql/query_processor.clj
index 8811e73c281..94b0c7a9801 100644
--- a/src/metabase/driver/sql/query_processor.clj
+++ b/src/metabase/driver/sql/query_processor.clj
@@ -1621,10 +1621,12 @@
;; -> SELECT CASE WHEN ... > ... THEN 1 ELSE 0 END AS \"x\""
[driver clause & _unique-name-fn]
(let [{cast-type ::add-cast
- wrap-in-case? ::wrap-in-case} (driver-api/field-options clause)
+ wrap-in-case? ::wrap-in-case} (driver-api/match-one clause
+ [_ (opts :guard :lib/uuid) _] opts ;; mbql5
+ [_ _ opts] opts)
maybe-cast #(cond-> %
- wrap-in-case? (as-> <> (vector ::wrap-in-case <>))
- cast-type (as-> <> (vector ::cast <> cast-type)))
+ wrap-in-case? (as-> <> (mbql-clause driver ::wrap-in-case <>))
+ cast-type (as-> <> (mbql-clause driver ::cast <> cast-type)))
honeysql-form (->honeysql driver (maybe-cast clause))
field-alias (field-clause->alias driver clause)]
(if field-alias
diff --git a/src/metabase/driver/sql/query_processor/boolean_to_comparison.clj b/src/metabase/driver/sql/query_processor/boolean_to_comparison.clj
index eb4d397a72e..d4fe2d42537 100644
--- a/src/metabase/driver/sql/query_processor/boolean_to_comparison.clj
+++ b/src/metabase/driver/sql/query_processor/boolean_to_comparison.clj
@@ -57,7 +57,9 @@
(defn- boolean-field-clause? [clause boolean-types]
(and (driver-api/is-clause? :field clause)
- (let [[_ id-or-name options] clause
+ (let [[id-or-name options] (driver-api/match-one clause
+ [_ (options :guard :lib/uuid) id-or-name] [id-or-name options] ;; mbql5
+ [_ id-or-name options] [id-or-name options])
has-some-type? (some-fn :base-type :base_type :effective-type :effective_type)]
(or (boolean-typed? options boolean-types)
;; If :base-type is not present in the options, try looking it up in the metadata provider.
@@ -68,7 +70,9 @@
(defn- boolean-value-clause? [clause]
(and (driver-api/is-clause? :value clause)
- (or (boolean? (second clause))
+ (or (boolean? (driver-api/match-one clause
+ [_ (opts :guard :lib/uuid) val & _] val ;; mbql5
+ [_ val & _] val))
(boolean-typed-clause? clause))))
(defn boolean-expression-clause?
@@ -76,19 +80,25 @@
This function expects to be called in a context where sql.qp/*inner-query* is bound, so that it can lookup
expression refs by name, if necessary, to determine whether their value is a boolean literal."
- [clause]
+ [driver clause]
(and (driver-api/is-clause? :expression clause)
- (boolean-value-clause? (driver-api/expression-with-name sql.qp/*inner-query* (second clause)))))
+ (->> (driver-api/match-one clause
+ [_ (opts :guard :lib/uuid) name] name ;; mbql5
+ [_ name] name)
+ (sql.qp/expression-by-name driver sql.qp/*inner-query*)
+ (boolean-value-clause?))))
(defn predicate-expression-clause?
"Is `clause` an :expression clause containing a predicate operator (e.g. :and, :=, :contains, etc.)?
This function expects to be called in a context where sql.qp/*inner-query* is bound, so that it can lookup
expression refs by name, if necessary, to determine whether the expression is a predicate operator."
- [clause]
+ [driver clause]
(and (driver-api/is-clause? :expression clause)
- (->> (second clause)
- (driver-api/expression-with-name sql.qp/*inner-query*)
+ (->> (driver-api/match-one clause
+ [_ (opts :guard :lib/uuid) name] name ;; mbql5
+ [_ name] name)
+ (sql.qp/expression-by-name driver sql.qp/*inner-query*)
(driver-api/is-clause? lib.schema.filter/predicate-operators))))
(defn boolean->comparison
@@ -102,22 +112,23 @@
If `boolean-field-types` is provided, it will override the set of types that are considered boolean for a :field
ref. This is useful for drivers that do not have a separately distinguishable boolean type (for example Oracle uses
a numeric type)."
- ([clause]
- (boolean->comparison clause default-boolean-types))
- ([clause boolean-field-types]
+ ([driver clause]
+ (boolean->comparison driver clause default-boolean-types))
+ ([driver clause boolean-field-types]
(if (or (boolean? clause)
(boolean-value-clause? clause)
(boolean-field-clause? clause boolean-field-types)
- (boolean-expression-clause? clause))
- [:= clause true]
+ (boolean-expression-clause? driver clause))
+ (sql.qp/mbql-clause driver := clause true)
clause)))
(defn case-boolean->comparison
"Replace booleans with comparisons in a CASE clause."
- ([clause]
- (case-boolean->comparison clause default-boolean-types))
- ([[_ cond-cases :as clause] boolean-field-types]
- (->> cond-cases
- (mapv (fn [[e1 e2]]
- [(boolean->comparison e1 boolean-field-types) e2]))
- (assoc clause 1))))
+ ([driver clause]
+ (case-boolean->comparison driver clause default-boolean-types))
+ ([driver clause boolean-field-types]
+ (let [rewrite-cases (fn [cond-cases]
+ (mapv (fn [[e1 e2]]
+ [(boolean->comparison driver e1 boolean-field-types) e2])
+ cond-cases))]
+ (update clause (sql.qp/clause-value-idx driver) rewrite-cases))))
diff --git a/src/metabase/driver/sql_mbql5.clj b/src/metabase/driver/sql_mbql5.clj
index 1085677187f..8fe22b6a1a3 100644
--- a/src/metabase/driver/sql_mbql5.clj
+++ b/src/metabase/driver/sql_mbql5.clj
@@ -28,23 +28,29 @@
driver-api/add-alias-info
:stages))
-(defn- add-source-query [driver prev-stage prev-hsql stage-hsql]
- (let [table-alias (sql.qp/->honeysql driver (h2x/identifier :table-alias sql.qp/source-query-alias))
- columns-metadata (get-in prev-stage [:lib/stage-metadata :columns])
- desired-aliases (mapv :lib/desired-column-alias columns-metadata)
- cur-hsql (cond-> (assoc stage-hsql :from [[prev-hsql [table-alias]]])
- (sql.qp/needs-cte-for-duplicate-cols? columns-metadata)
- (assoc :with [[[sql.qp/source-query-alias {:columns (mapv #(h2x/identifier :field %) desired-aliases)}]
- prev-hsql]]
- :from [[table-alias]])
-
- ;; Clear the default select if it's just :* so add-default-select can recompute it
- (= (:select stage-hsql) [[:*]])
- (dissoc :select))]
- (#'sql.qp/add-default-select driver cur-hsql)))
-
-(defn- stage->honeysql [driver stage]
+(defn- desired-col-alias-ident [col]
+ (h2x/identifier :field (:lib/desired-column-alias col)))
+
+(defn- stage-source-form
+ [driver hsql stage]
+ (let [table-alias (sql.qp/->honeysql driver (h2x/identifier :table-alias sql.qp/source-query-alias))
+ columns-metadata (get-in stage [:lib/stage-metadata :columns])]
+ (cond
+ (nil? hsql)
+ {}
+
+ (sql.qp/needs-cte-for-duplicate-cols? columns-metadata)
+ {:with [[[sql.qp/source-query-alias {:columns (mapv desired-col-alias-ident columns-metadata)}]
+ hsql]]
+ :from [[table-alias]]}
+
+ :else
+ {:from [[hsql [table-alias]]]})))
+
+(defn- stage->honeysql [driver prev-from stage]
(cond
+ ;; We don't add the source query if the stage is persisted, because the persisted query
+ ;; is already all of the previous stages materialized from the cached table
(:persisted-info/native stage)
(sql.qp/sql-source-query (:persisted-info/native stage) nil)
@@ -53,18 +59,14 @@
:else
(binding [sql.qp/*inner-query* stage]
- (#'sql.qp/apply-top-level-clauses driver {} stage))))
+ (#'sql.qp/apply-top-level-clauses driver prev-from stage))))
(defn- stages->honeysql [driver stages]
(first
(reduce
(fn [[prev-hsql prev-stage] stage]
- [(cond->> (stage->honeysql driver stage)
- ;; We don't add the source query if the stage is persisted, because the persisted query
- ;; is already all of the previous stages materialized from the cached table
- (and prev-hsql (not (:persisted-info/native stage)))
- (add-source-query driver prev-stage prev-hsql))
- stage])
+ (let [prev-from (stage-source-form driver prev-hsql prev-stage)]
+ [(stage->honeysql driver prev-from stage) stage]))
[nil nil]
stages)))
diff --git a/test/metabase/driver/sql/query_processor/boolean_to_comparison_test.clj b/test/metabase/driver/sql/query_processor/boolean_to_comparison_test.clj
index 8c5e6dda094..075446710b8 100644
--- a/test/metabase/driver/sql/query_processor/boolean_to_comparison_test.clj
+++ b/test/metabase/driver/sql/query_processor/boolean_to_comparison_test.clj
@@ -23,7 +23,7 @@
(deftest ^:parallel boolean->comparison-test
(are [clause] (binding [sql.qp/*inner-query* (:query (basic-filter-query clause))]
(= [:= clause true]
- (sql.qp.boolean-to-comparison/boolean->comparison clause)))
+ (sql.qp.boolean-to-comparison/boolean->comparison :sql clause)))
false
true
true-value
@@ -37,7 +37,7 @@
(deftest ^:parallel non-boolean->comparison-test
(are [clause] (binding [sql.qp/*inner-query* (:query (basic-filter-query clause))]
(= clause
- (sql.qp.boolean-to-comparison/boolean->comparison clause)))
+ (sql.qp.boolean-to-comparison/boolean->comparison :sql clause)))
0
1
"not a boolean"
@@ -48,19 +48,19 @@
(deftest ^:parallel boolean-expression-clause?-test
(are [clause] (binding [sql.qp/*inner-query* (:query (basic-filter-query clause))]
- (sql.qp.boolean-to-comparison/boolean-expression-clause? clause))
+ (sql.qp.boolean-to-comparison/boolean-expression-clause? :sql clause))
[:expression "T"]
[:expression "F"]))
(deftest ^:parallel nested-boolean-expression-clause?-test
(are [clause] (binding [sql.qp/*inner-query* (:query (nested-filter-query clause))]
- (sql.qp.boolean-to-comparison/boolean-expression-clause? clause))
+ (sql.qp.boolean-to-comparison/boolean-expression-clause? :sql clause))
[:expression "T"]
[:expression "F"]))
(deftest ^:parallel non-boolean-expression-clause?-test
(are [clause] (binding [sql.qp/*inner-query* (:query (basic-filter-query clause))]
- (not (sql.qp.boolean-to-comparison/boolean-expression-clause? clause)))
+ (not (sql.qp.boolean-to-comparison/boolean-expression-clause? :sql clause)))
0
1
"not a boolean"
@@ -73,7 +73,7 @@
(deftest ^:parallel case-boolean->comparison
(are [clause expected] (= expected
- (sql.qp.boolean-to-comparison/case-boolean->comparison clause))
+ (sql.qp.boolean-to-comparison/case-boolean->comparison :sql clause))
[:case
[[true true]
[true-value true]