Skip to content

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

MBQL5ize snowflake and bigquery drivers. (#76769)

technomancy660ea0625197
diff --git a/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk.clj b/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk.clj
index d911962e1af..c518638c84c 100644
--- a/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk.clj
+++ b/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk.clj
@@ -70,7 +70,7 @@
(set! *warn-on-reflection* true)
-(driver/register! :bigquery-cloud-sdk, :parent #{:sql
+(driver/register! :bigquery-cloud-sdk, :parent #{:sql-mbql5
::like-escape-char-built-in/like-escape-char-built-in})
;;; +----------------------------------------------------------------------------------------------------------------+
diff --git a/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj b/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj
index 461daf44eea..8b0a4541387 100644
--- a/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj
+++ b/modules/drivers/bigquery-cloud-sdk/src/metabase/driver/bigquery_cloud_sdk/query_processor.clj
@@ -198,7 +198,7 @@
;;; +----------------------------------------------------------------------------------------------------------------+
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :split-part]
- [driver [_ text divider position]]
+ [driver [_ _opts text divider position]]
[:coalesce
[:at
[:split
@@ -208,13 +208,13 @@
""])
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :text]
- [driver [_ value]]
+ [driver [_ _opts value]]
(h2x/maybe-cast "STRING" (sql.qp/->honeysql driver value)))
;; BigQuery's string type is `STRING`. Mirrors the `:text` handler above.
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk ::sql.qp/cast-to-text]
- [driver [_ expr]]
- (sql.qp/->honeysql driver [::sql.qp/cast expr "string"]))
+ [driver [_ _opts expr]]
+ (sql.qp/->honeysql driver (sql.qp/mbql-clause driver ::sql.qp/cast expr "string")))
;; TODO -- all this [[temporal-type]] stuff below can be replaced with the more generalized
;; [[h2x/with-database-type-info]] stuff we've added. [[h2x/with-database-type-info]] was inspired by this BigQuery code
@@ -277,7 +277,7 @@
(:bigquery-cloud-sdk/base-temporal-type (meta identifier))))
(defmethod temporal-type :absolute-datetime
- [[_ t _]]
+ [[_ _opts t _unit]]
(temporal-type t))
(defmethod temporal-type :time
@@ -285,7 +285,7 @@
:time)
(defmethod temporal-type :field
- [[_ id-or-name {:keys [base-type effective-type temporal-unit]} :as clause]]
+ [[_ {:keys [base-type effective-type temporal-unit]} id-or-name :as clause]]
(cond
(contains? (meta clause) :bigquery-cloud-sdk/temporal-type)
(:bigquery-cloud-sdk/temporal-type (meta clause))
@@ -396,8 +396,8 @@
x))))
(defmethod ->temporal-type [:temporal-type :absolute-datetime]
- [target-type [_ t unit]]
- [:absolute-datetime (->temporal-type target-type t) unit])
+ [target-type [_ opts t unit]]
+ [:absolute-datetime opts (->temporal-type target-type t) unit])
(def ^:private temporal-type->supported-units
{:timestamp #{:microsecond :millisecond :second :minute :hour :day}
@@ -406,7 +406,7 @@
:time #{:microsecond :millisecond :second :minute :hour}})
(defmethod ->temporal-type [:temporal-type :relative-datetime]
- [target-type [_ _ unit :as clause]]
+ [target-type [_ _opts _amount unit :as clause]]
{:post [(= target-type (temporal-type %))]}
(with-temporal-type
;; check and see whether we need to do a conversion. If so, use the parent method which will just wrap this in a
@@ -563,7 +563,7 @@
(sql.qp/unix-timestamp->honeysql driver :microseconds [:div expr 1000]))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :convert-timezone]
- [driver [_ arg target-timezone source-timezone]]
+ [driver [_ _opts arg target-timezone source-timezone]]
(let [datetime (fn [x target-timezone]
[:datetime x target-timezone])
hsql-form (sql.qp/->honeysql driver arg)
@@ -581,7 +581,7 @@
:float64)
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :regex-match-first]
- [driver [_ arg pattern]]
+ [driver [_ _opts arg pattern]]
[:regexp_extract (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver pattern)])
(defn- percentile->quantile
@@ -616,13 +616,13 @@
[::approx-quantiles expr offset quantiles]))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :percentile]
- [driver [_ expr p]]
+ [driver [_ _opts expr p]]
(let [[offset quantiles] (percentile->quantile p)]
(approx-quantiles (sql.qp/->honeysql driver expr) offset quantiles)))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :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)))
;;; +----------------------------------------------------------------------------------------------------------------+
;;; | Query Processor |
@@ -678,13 +678,13 @@
true (vary-meta assoc ::do-not-qualify? true))))
(defn- with-base-temporal-type
- [[_ _id-or-name {:keys [base-type]} :as clause]]
+ [[_ {:keys [base-type]} _id-or-name :as clause]]
(if (not (instance? clojure.lang.IObj clause))
clause
(vary-meta clause assoc :bigquery-cloud-sdk/base-temporal-type (base-type->temporal-type base-type))))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :field]
- [driver [_field id-or-name opts :as field-clause]]
+ [driver [_field opts id-or-name :as field-clause]]
(let [source-table (get opts driver-api/qp.add.source-table)
source-alias (get opts driver-api/qp.add.source-alias)
parent-method (get-method sql.qp/->honeysql [:sql :field])]
@@ -697,9 +697,13 @@
(let [field-clause (-> field-clause
(with-temporal-type (temporal-type field-clause))
with-base-temporal-type)
+ ;; convert to the legacy clause shape the [:sql :field] parent method expects ourselves, rather than going
+ ;; through the generic [:sql-mbql5 :field] conversion, which returns a fresh vector that loses the
+ ;; temporal type metadata we just attached
+ legacy-clause (with-meta [:field id-or-name opts] (meta field-clause))
stored-field (when (integer? id-or-name)
(driver-api/field (driver-api/metadata-provider) id-or-name))
- result (parent-method driver field-clause)
+ result (parent-method driver legacy-clause)
result (cond-> result
(not (temporal-type result))
(with-temporal-type (temporal-type field-clause)))]
@@ -713,7 +717,7 @@
[driver clause]
;; wrap the parent method, converting the result if `clause` itself is typed
(let [t (temporal-type clause)]
- (cond->> ((get-method sql.qp/->honeysql [:sql :relative-datetime]) driver clause)
+ (cond->> ((get-method sql.qp/->honeysql [:sql-mbql5 :relative-datetime]) driver clause)
t (->temporal-type t))))
(defn- datetime-diff-check-args
@@ -730,7 +734,7 @@
:type driver-api/qp.error-type.invalid-query}))))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :datetime-diff]
- [driver [_ x y unit]]
+ [driver [_ _opts x y unit]]
(let [x (sql.qp/->honeysql driver x)
y (sql.qp/->honeysql driver y)]
(datetime-diff-check-args x y)
@@ -787,7 +791,7 @@
u/remove-diacritical-marks
(str/replace #"[^\p{L}\p{N}\p{M}\p{Pc}]" "_")
(str/replace #"(^[^\p{L}_])" "_$1"))]
- ((get-method driver/escape-alias :sql) driver s)))
+ ((get-method driver/escape-alias :sql-mbql5) driver s)))
;; See:
;;
@@ -832,21 +836,22 @@
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :cum-count]
[driver expr]
(binding [*compiling-cumulative-aggregation* true]
- ((get-method sql.qp/->honeysql [:sql :cum-count]) driver expr)))
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :cum-count]) driver expr)))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :cum-sum]
[driver expr]
(binding [*compiling-cumulative-aggregation* true]
- ((get-method sql.qp/->honeysql [:sql :cum-sum]) driver expr)))
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :cum-sum]) driver expr)))
(defmethod sql.qp/apply-top-level-clause [:bigquery-cloud-sdk :breakout]
[driver top-level-clause honeysql-form query]
(if *compiling-cumulative-aggregation*
- ((get-method sql.qp/apply-top-level-clause [:sql :breakout]) driver top-level-clause honeysql-form query)
+ ((get-method sql.qp/apply-top-level-clause [:sql-mbql5 :breakout]) driver top-level-clause honeysql-form query)
;; If stuff in `:fields` still needs to be qualified like `dataset.table.field`, just the stuff in `:group-by` should
;; not. So we'll actually call the parent method twice, once with the fields as is (i.e., qualifiable) and once with
;; them removed. Then we'll splice the unqualified `:group-by` in
- (let [parent-method (partial (get-method sql.qp/apply-top-level-clause [:sql :breakout])
+ (let [parent-method (partial (get-method sql.qp/apply-top-level-clause
+ [:sql-mbql5 :breakout])
driver top-level-clause honeysql-form)
qualified (parent-method query)
unqualified (parent-method (update query :breakout sql.qp/rewrite-fields-to-force-using-column-aliases))]
@@ -854,8 +859,8 @@
(select-keys unqualified #{:group-by})))))
(defn- adjust-order-by-clause
- [[dir [_clause _id-or-name opts :as clause]]]
- [dir
+ [[dir outer-opts [_clause opts _id-or-name :as clause]]]
+ [dir outer-opts
;; Following code ensures that only selected columns (with exception of those coming from different source than
;; this source table and having no binning and no bucketing) are forced to use aliases.
;;
@@ -875,13 +880,13 @@
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :asc]
[driver clause]
- ((get-method sql.qp/->honeysql [:sql :asc])
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :asc])
driver
(adjust-order-by-clause clause)))
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :desc]
[driver clause]
- ((get-method sql.qp/->honeysql [:sql :desc])
+ ((get-method sql.qp/->honeysql [:sql-mbql5 :desc])
driver
(adjust-order-by-clause clause)))
@@ -915,7 +920,7 @@
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk filter-type]
[driver clause]
(reconcile-temporal-types
- ((get-method sql.qp/->honeysql [:sql filter-type])
+ ((get-method sql.qp/->honeysql [:sql-mbql5 filter-type])
driver
clause))))
@@ -989,7 +994,7 @@
(defmethod driver/mbql->native :bigquery-cloud-sdk
[driver outer-query]
- (let [parent-method (get-method driver/mbql->native :sql)
+ (let [parent-method (get-method driver/mbql->native :sql-mbql5)
compiled (parent-method driver outer-query)]
(assoc compiled
:table-name (or (when-let [source-table-id (-> outer-query :stages last :source-table)]
@@ -1033,7 +1038,7 @@
;; In BigQuery, log syntax is `log(x, base)`
(defmethod sql.qp/->honeysql [:bigquery-cloud-sdk :log]
- [driver [_ field]]
+ [driver [_ _opts field]]
[:log (sql.qp/->honeysql driver field) [:inline 10]])
(defmethod sql.qp/quote-style :bigquery-cloud-sdk
@@ -1045,7 +1050,8 @@
{:keys [field], :as field-filter} :- [:map
[:field driver-api/schema.metadata.column]]]
(let [field-temporal-type (temporal-type field)
- parent-method (get-method sql.params.substitution/->replacement-snippet-info [:sql :metabase.lib.parameters.parse.types/field-filter])
+ parent-method (get-method sql.params.substitution/->replacement-snippet-info
+ [:sql-mbql5 :metabase.lib.parameters.parse.types/field-filter])
result (parent-method driver field-filter)]
(cond-> result
field-temporal-type (update :prepared-statement-args (fn [args]
diff --git a/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test.clj b/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test.clj
index 1d609089f5d..332b494af07 100644
--- a/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test.clj
+++ b/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test.clj
@@ -319,8 +319,8 @@
(testing "Make sure we can detect temporal types correctly"
(are [expr expected-type] (= expected-type
(#'bigquery.qp/temporal-type expr))
- [:field "x" {:base-type :type/DateTime}] :datetime
- [:field "x" {:base-type :type/DateTime, :temporal-unit :day-of-week}] nil
+ [:field {:base-type :type/DateTime} "x"] :datetime
+ [:field {:base-type :type/DateTime, :temporal-unit :day-of-week} "x"] nil
(meta/field-metadata :checkins :date) :date)))
(deftest ^:parallel reconcile-temporal-types-test
@@ -344,33 +344,36 @@
(is (= [:=
[::bigquery.qp/extract :dayofweek expected-identifier nil]
[:inline 1]]
- (sql.qp/->honeysql :bigquery-cloud-sdk [:= [:field (:id field) {:temporal-unit :day-of-week
- ::add/source-table "ABC"}] 1]))))))))))
+ (sql.qp/->honeysql :bigquery-cloud-sdk [:= {} [:field {:temporal-unit :day-of-week
+ ::add/source-table "ABC"} (:id field)] 1]))))))))))
(deftest reconcile-unix-timestamps-test
(testing "temporal type reconciliation should work for UNIX timestamps (#15376)"
(mt/test-driver :bigquery-cloud-sdk
(mt/with-report-timezone-id! nil
(mt/dataset test-data
- (qp.store/with-metadata-provider (lib.tu/merged-mock-metadata-provider
- (mt/metadata-provider)
- {:fields [{:id (mt/id :reviews :rating)
- :coercion-strategy :Coercion/UNIXMilliSeconds->DateTime
- :effective-type :type/Instant}]})
- (let [query (mt/mbql-query reviews
- {:filter [:=
- [:field %rating {::add/source-table $$reviews}]
- [:relative-datetime -30 :day]]
- :order-by [[:asc
- [:field %id {:add/source-table $$reviews}]]]
- :limit 1})
- filter-clause (get-in query [:query :filter])]
- (is (= [(str (format "TIMESTAMP_MILLIS(%s.reviews.rating)" (get-test-data-name))
- " = "
- "TIMESTAMP_TRUNC(TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL -30 day), day)")]
- (sql/format-expr (sql.qp/->honeysql :bigquery-cloud-sdk filter-clause))))
- (is (= :completed
- (:status (qp/process-query query)))))))))))
+ (let [mp (lib.tu/merged-mock-metadata-provider
+ (mt/metadata-provider)
+ {:fields [{:id (mt/id :reviews :rating)
+ :coercion-strategy :Coercion/UNIXMilliSeconds->DateTime
+ :effective-type :type/Instant}]})]
+ (qp.store/with-metadata-provider mp
+ (let [rating-ref (-> (lib/ref (lib.metadata/field mp (mt/id :reviews :rating)))
+ ;; compiling the filter clause directly below bypasses `add-alias-info`, and
+ ;; the UNIX-timestamp coercion cast is only applied to fields whose options
+ ;; carry the source table it would normally add
+ (lib/update-options assoc ::add/source-table (mt/id :reviews)))
+ query (-> (lib/query mp (lib.metadata/table mp (mt/id :reviews)))
+ (lib/filter (lib/= rating-ref (lib/relative-datetime -30 :day)))
+ (lib/order-by (lib.metadata/field mp (mt/id :reviews :id)) :asc)
+ (lib/limit 1))
+ filter-clause (first (lib/filters query))]
+ (is (= [(str (format "TIMESTAMP_MILLIS(%s.reviews.rating)" (get-test-data-name))
+ " = "
+ "TIMESTAMP_TRUNC(TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL -30 day), day)")]
+ (sql/format-expr (sql.qp/->honeysql :bigquery-cloud-sdk filter-clause))))
+ (is (= :completed
+ (:status (qp/process-query query))))))))))))
(deftest temporal-type-conversion-test
(mt/with-driver :bigquery-cloud-sdk
@@ -418,7 +421,7 @@
;; TIMESTAMP_ADD doesn't support `year` so this should cast a datetime instead
[:timestamp :year "TIMESTAMP_TRUNC(TIMESTAMP(DATETIME_ADD(CURRENT_DATETIME(), INTERVAL -1 year)), year)"]]]
(testing t
- (let [hsql (->> (sql.qp/->honeysql :bigquery-cloud-sdk [:relative-datetime -1 unit])
+ (let [hsql (->> (sql.qp/->honeysql :bigquery-cloud-sdk [:relative-datetime {} -1 unit])
(#'bigquery.qp/->temporal-type t))]
(testing "Should have correct type metadata after reconciliation"
(is (= t
@@ -459,7 +462,7 @@
:let [expected-sql (for [line expected-sql]
(str/replace line #"\Q{{timezone}}\E" timezone))]]
(testing t
- (let [hsql (->> (sql.qp/->honeysql :bigquery-cloud-sdk [:relative-datetime -1 unit])
+ (let [hsql (->> (sql.qp/->honeysql :bigquery-cloud-sdk [:relative-datetime {} -1 unit])
(#'bigquery.qp/->temporal-type t))]
(testing "Should have correct type metadata after reconciliation"
(is (= t
@@ -481,8 +484,9 @@
(testing expected-type
(let [[_ _ relative-datetime :as clause] (sql.qp/->honeysql :bigquery-cloud-sdk
[:=
+ {}
t
- [:relative-datetime -1 :year]])]
+ [:relative-datetime {} -1 :year]])]
(testing (format "\nclause = %s" (pr-str clause))
(is (= expected-type
(#'bigquery.qp/temporal-type relative-datetime)))))))))))
@@ -497,11 +501,11 @@
:bigquery-cloud-sdk
(sql.qp/->honeysql
:bigquery-cloud-sdk
- [:field "date" {:temporal-unit :week
- :base-type :type/Date
- ::add/source-table ::add/source
- ::add/source-alias "date"
- ::add/desired-alias "date"}])))))))))
+ [:field {:temporal-unit :week
+ :base-type :type/Date
+ ::add/source-table ::add/source
+ ::add/source-alias "date"
+ ::add/desired-alias "date"} "date"])))))))))
(deftest ^:parallel between-test
(testing "Make sure :between clauses reconcile the temporal types of their args"
@@ -513,6 +517,7 @@
(t/local-date-time "2019-11-11T00:00")
(t/local-date-time "2019-11-12T00:00")]
(between->sql [:between
+ {}
(with-meta (sql.qp/compiled [:raw "field"]) {:bigquery-cloud-sdk/temporal-type :datetime})
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]))))
@@ -521,6 +526,7 @@
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]
(between->sql [:between
+ {}
(sql.qp/compiled [:raw "field"])
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]))))
@@ -529,6 +535,7 @@
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]
(between->sql [:between
+ {}
(with-meta (sql.qp/compiled [:raw "field"]) {:bigquery-cloud-sdk/temporal-type :date})
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]))))
@@ -540,21 +547,24 @@
(testing "Should be able to get temporal type from a `:field` with integer ID"
(is (= expected
(between->sql [:between
- [:field (mt/id :checkins :date) {::add/source-table (mt/id :checkins)}]
+ {}
+ [:field {::add/source-table (mt/id :checkins)} (mt/id :checkins :date)]
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]))))
(testing "Should be able to get temporal type from a `:field` with `:temporal-unit`"
(is (= (cons (with-test-db-name "WHERE DATE_TRUNC(`v4_test_data.checkins`.`date`, day) BETWEEN ? AND ?")
(rest expected))
(between->sql [:between
- [:field (mt/id :checkins :date) {::add/source-table (mt/id :checkins)
- :temporal-unit :day}]
+ {}
+ [:field {::add/source-table (mt/id :checkins)
+ :temporal-unit :day} (mt/id :checkins :date)]
(t/local-date "2019-11-11")
(t/local-date "2019-11-12")]))))
(testing "Should work with a field literal"
(is (= ["WHERE `date` BETWEEN ? AND ?" (t/local-date "2019-11-11") (t/local-date "2019-11-12")]
(between->sql [:between
- [:field "date" {:base-type :type/Date}]
+ {}
+ [:field {:base-type :type/Date} "date"]
(t/local-date-time "2019-11-11T12:00:00")
(t/local-date-time "2019-11-12T12:00:00")]))))))))))
@@ -815,9 +825,10 @@
(sql/format {:where (sql.qp/->honeysql
:bigquery-cloud-sdk
[:=
- [:field 1 {:temporal-unit unit
- ::add/source-table "ABC"}]
- [:relative-datetime -1 unit]])}
+ {}
+ [:field {:temporal-unit unit
+ ::add/source-table "ABC"} 1]
+ [:relative-datetime {} -1 unit]])}
{:dialect ::h2x/unquoted-dialect}))))))))))
(deftest filter-by-relative-date-ranges-test-2
@@ -839,9 +850,10 @@
(let [[sql] (sql/format {:where (sql.qp/->honeysql
:bigquery-cloud-sdk
[:=
- [:field 1 {:temporal-unit unit
- ::add/source-table "ABC"}]
- [:relative-datetime -1 unit]])}
+ {}
+ [:field {:temporal-unit unit
+ ::add/source-table "ABC"} 1]
+ [:relative-datetime {} -1 unit]])}
{:dialect ::h2x/unquoted-dialect})]
(str/split-lines (driver/prettify-native-form :bigquery-cloud-sdk sql)))))]
(are [field-type unit expected-sql] (= (for [line expected-sql]
@@ -1264,7 +1276,7 @@
(deftest ^:parallel test-bigquery-log
(testing "correct format of log10 for BigQuery"
(is (= ["LOG(150, 10)"]
- (sql/format-expr (sql.qp/->honeysql :bigquery-cloud-sdk [:log 150]))))))
+ (sql/format-expr (sql.qp/->honeysql :bigquery-cloud-sdk [:log {} 150]))))))
(deftest ^:parallel mixed-cumulative-and-non-cumulative-aggregations-test
(mt/test-driver :bigquery-cloud-sdk
diff --git a/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test/reconciliation_test_util.clj b/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test/reconciliation_test_util.clj
index bdd634de990..7f0699c6338 100644
--- a/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test/reconciliation_test_util.clj
+++ b/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk/query_processor_test/reconciliation_test_util.clj
@@ -82,14 +82,14 @@
:type :timestamp
:as {:date (t/local-date "2019-12-10")
:datetime (t/local-date-time "2019-12-10T14:47:00")}}
- :unix-timestamp-seconds {:value [:field 4 {::add/source-table (meta/id :checkins)}]
+ :unix-timestamp-seconds {:value [:field {::add/source-table (meta/id :checkins)} 4]
:type :timestamp
:as (let [expected (-> [:timestamp_seconds (h2x/identifier :field "PUBLIC.CHECKINS" "unix_seconds")]
(h2x/with-database-type-info "timestamp"))]
{:date [:date expected]
:datetime [:datetime expected]
:timestamp expected})}
- :unix-timestamp-milliseconds {:value [:field 5 {::add/source-table (meta/id :checkins)}]
+ :unix-timestamp-milliseconds {:value [:field {::add/source-table (meta/id :checkins)} 5]
:type :timestamp
:as (let [expected (-> [:timestamp_millis (h2x/identifier :field "PUBLIC.CHECKINS" "unix_milliseconds")]
(h2x/with-database-type-info "timestamp"))]
@@ -101,23 +101,23 @@
{:identity identity
:absolute-datetime (fn [filter-value]
(when (instance? java.time.temporal.Temporal filter-value)
- [:absolute-datetime filter-value :default]))}
+ [:absolute-datetime {} filter-value :default]))}
:fields mock-temporal-fields
:field-ref-fns
{:basic (fn [field]
- [:field (:id field) {::add/source-table "ABC"}])
+ [:field {::add/source-table "ABC"} (:id field)])
:default-temporal-unit (fn [field]
- [:field (:id field) {:temporal-unit :default
- ::add/source-table "ABC"}])
+ [:field {:temporal-unit :default
+ ::add/source-table "ABC"} (:id field)])
:base-type (fn [field]
- [:field (:name field) {:base-type (:base-type field)
- ::add/source-table "ABC"}])
+ [:field {:base-type (:base-type field)
+ ::add/source-table "ABC"} (:name field)])
:base-type-and-default-temporal-unit (fn [field]
- [:field (:name field) {:base-type (:base-type field)
- :temporal-unit :default
- ::add/source-table "ABC"}])}
+ [:field {:base-type (:base-type field)
+ :temporal-unit :default
+ ::add/source-table "ABC"} (:name field)])}
:filter-types
{:= {:honeysql-filter-fn :=
@@ -171,7 +171,7 @@
(defn- temporal-type-reconciliation-expected-value
[{:keys [field temporal-type expected-value honeysql-filter-fn num-args], :as _test-case}]
- (let [field-literal? (match/match-one field [:field (_ :guard string?) _] true)
+ (let [field-literal? (match/match-one field [:field {} (_ :guard string?)] true)
mock-field (get mock-temporal-fields temporal-type)
expected-identifier (cond-> (-> (h2x/identifier :field "ABC" (name temporal-type))
(vary-meta assoc ::bigquery.qp/do-not-qualify? true))
@@ -184,7 +184,7 @@
(defn- temporal-type-reconciliation-actual-value
[{:keys [field num-args filter-value filter-type], :as _test-case}]
- (let [filter-clause (into [filter-type field]
+ (let [filter-clause (into [filter-type {} field]
(repeat (dec num-args) filter-value))]
(sql.qp/->honeysql :bigquery-cloud-sdk filter-clause)))
diff --git a/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk_test.clj b/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk_test.clj
index 650377d2d3f..c98403039b5 100644
--- a/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk_test.clj
+++ b/modules/drivers/bigquery-cloud-sdk/test/metabase/driver/bigquery_cloud_sdk_test.clj
@@ -847,8 +847,12 @@
(deftest query-integer-pk-or-fk-test
(mt/test-driver :bigquery-cloud-sdk
(testing "We should be able to query a Table that has a :type/Integer column marked as a PK or FK"
- (is (= [[1 "Plato Yeshua" "2014-04-01T08:30:00Z"]]
- (mt/rows (mt/user-http-request :rasta :post 202 "dataset" (mt/mbql-query users {:limit 1, :order-by [[:asc $id]]}))))))))
+ (let [mp (mt/metadata-provider)
+ query (-> (lib/query mp (lib.metadata/table mp (mt/id :users)))
+ (lib/order-by (lib.metadata/field mp (mt/id :users :id)) :asc)
+ (lib/limit 1))]
+ (is (= [[1 "Plato Yeshua" "2014-04-01T08:30:00Z"]]
+ (mt/rows (mt/user-http-request :rasta :post 202 "dataset" query))))))))
(deftest return-errors-test
(mt/test-driver :bigquery-cloud-sdk
diff --git a/modules/drivers/snowflake/src/metabase/driver/snowflake.clj b/modules/drivers/snowflake/src/metabase/driver/snowflake.clj
index 217ffbbc786..e00968d401a 100644
--- a/modules/drivers/snowflake/src/metabase/driver/snowflake.clj
+++ b/modules/drivers/snowflake/src/metabase/driver/snowflake.clj
@@ -49,7 +49,8 @@
(set! *warn-on-reflection* true)
-(driver/register! :snowflake, :parent #{:sql-jdbc ::sql-jdbc.legacy/use-legacy-classes-for-read-and-set})
+(driver/register! :snowflake, :parent #{:sql-jdbc :sql-mbql5
+ ::sql-jdbc.legacy/use-legacy-classes-for-read-and-set})
(doseq [[feature supported?] {:connection-impersonation true
:connection-impersonation-requires-role true
@@ -612,15 +613,15 @@
(h2x/with-database-type-info [:to_timestamp expr (h2x/literal "YYYYMMDDHH24MISS")] "timestamp"))
(defmethod sql.qp/->honeysql [:snowflake :regex-match-first]
- [driver [_ arg pattern]]
+ [driver [_ _opts arg pattern]]
[:regexp_substr (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver pattern)])
(defmethod sql.qp/->honeysql [:snowflake :median]
- [driver [_ arg]]
- (sql.qp/->honeysql driver [:percentile arg 0.5]))
+ [driver [_ opts arg]]
+ (sql.qp/->honeysql driver [:percentile opts arg 0.5]))
(defmethod sql.qp/->honeysql [:snowflake :split-part]
- [driver [_ text divider position]]
+ [driver [_ _opts text divider position]]
(let [position (sql.qp/->honeysql driver position)]
[:case
[:< position 1]
@@ -629,11 +630,11 @@
[:split_part (sql.qp/->honeysql driver text) (sql.qp/->honeysql driver divider) position]]))
(defmethod sql.qp/->honeysql [:snowflake :text]
- [driver [_ value]]
+ [driver [_ _opts value]]
[:to_char (sql.qp/->honeysql driver value)])
(defmethod sql.qp/->honeysql [:snowflake :collate]
- [driver [_ arg collation]]
+ [driver [_ _opts arg collation]]
[:collate (sql.qp/->honeysql driver arg) (sql.qp/->honeysql driver collation)])
(defn- db-name
@@ -677,9 +678,9 @@
;;; TODO -- I don't think these actually ever get qualified since the parent method returns things wrapped
;;; in [[h2x/with-database-type-info]] thus nothing will ever be an identifier.
(defmethod sql.qp/->honeysql [:snowflake :field]
- [driver [_ _ opts :as field-clause]]
+ [driver [_ opts _ :as field-clause]]
(let [source-table (get opts driver-api/qp.add.source-table)
- parent-method (get-method sql.qp/->honeysql [:sql :field])
+ parent-method (get-method sql.qp/->honeysql [:sql-mbql5 :field])
qualify? (and
;; `query-db-name` is not currently set, e.g. because we're generating DDL statements for tests
(seq (query-db-name))
@@ -692,11 +693,11 @@
qualify-identifier)))
(defmethod sql.qp/->honeysql [:snowflake :time]
- [driver [_ value _unit]]
+ [driver [_ _opts value _unit]]
(h2x/->time (sql.qp/->honeysql driver value)))
(defmethod sql.qp/->honeysql [:snowflake :convert-timezone]
- [driver [_ arg target-timezone source-timezone]]
+ [driver [_ _opts arg target-timezone source-timezone]]
(let [hsql-form (sql.qp/->honeysql driver arg)
timestamptz? (or (sql.qp.u/field-with-tz? arg)
(h2x/is-of-type? hsql-form "timestamptz"))]
@@ -709,7 +710,7 @@
(h2x/with-database-type-info "timestampntz"))))
(defmethod sql.qp/->honeysql [:snowflake :relative-datetime]
- [driver [_ amount unit]]
+ [driver [_ _opts amount unit]]
(driver-api/maybe-cacheable-relative-datetime-honeysql
driver unit amount
sql.qp/*parent-honeysql-col-type-info*))
@@ -1133,12 +1134,12 @@
(defn get-string-filter-arg
"Generate the argument to match in the string filters. It's based on sql.qp/generate-pattern."
[driver
- [type val :as arg]
+ [type opts val :as arg]
{:keys [case-sensitive] :or {case-sensitive true} :as _options}]
(if case-sensitive
(sql.qp/->honeysql driver arg)
(if (= :value type)
- (sql.qp/->honeysql driver [type (u/lower-case-en val)])
+ (sql.qp/->honeysql driver [type opts (u/lower-case-en val)])
[:lower (sql.qp/->honeysql driver arg)])))
(defn- string-filter
@@ -1149,16 +1150,16 @@
(get-string-filter-arg driver arg options)]))
(defmethod sql.qp/->honeysql [:snowflake :contains]
- [driver [_ field arg options]]
- (string-filter driver :contains field arg options))
+ [driver [_ opts field arg]]
+ (string-filter driver :contains field arg opts))
(defmethod sql.qp/->honeysql [:snowflake :starts-with]
- [driver [_ field arg options]]
- (string-filter driver :startswith field arg options))
+ [driver [_ opts field arg]]
+ (string-filter driver :startswith field arg opts))
(defmethod sql.qp/->honeysql [:snowflake :ends-with]
- [driver [_ field arg options]]
- (string-filter driver :endswith field arg options))
+ [driver [_ opts field arg]]
+ (string-filter driver :endswith field arg opts))
;;; +----------------------------------------------------------------------------------------------------------------+
;;; | Workspace Isolation |