The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:
TypeScript analyticsbibusiness-intelligencebusinessintelligenceclojuredashboarddatadata-analysisdata-visualizationdatabasemetabasemysqlpostgrespostgresqlreportingslacksql-editorvisualization
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.cljindex 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.cljindex 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-ver15diff --git a/modules/drivers/sqlserver/test/metabase/driver/sqlserver_test.clj b/modules/drivers/sqlserver/test/metabase/driver/sqlserver_test.cljindex 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.cljindex 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-aliasdiff --git a/src/metabase/driver/sql/query_processor/boolean_to_comparison.clj b/src/metabase/driver/sql/query_processor/boolean_to_comparison.cljindex 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 lookupexpression 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 lookupexpression 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 :fieldref. This is useful for drivers that do not have a separately distinguishable boolean type (for example Oracle usesa 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.cljindex 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.cljindex 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)))falsetruetrue-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)))01"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)))01"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]