Fixes for SQLite [ci drivers]

src/metabase/driver/generic_sql.clj

@@ -79,6 +79,17 @@
 
      Return `nil` to prevent FIELD from being aliased.")
 
+  (prepare-sql-param [this obj]
+    "*OPTIONAL*. Do any neccesary type conversions, etc. to an object being passed as a prepared statment argument in a parameterized raw SQL query.
+     For example, a raw SQL query with a date param, `x`, e.g. `WHERE date > {{x}}`, is converted to SQL like `WHERE date > ?`, and the value of
+     `x` is passed as a `java.sql.Timestamp`. Some databases, notably SQLite, don't work with `Timestamps`, and dates must be passed as string literals
+     instead; the SQLite driver overrides this method to convert dates as needed.
+
+  The default implementation is `identity`.
+
+  NOTE - This method is only used for parameters in raw SQL queries. It's not needed for MBQL queries because other functions like `prepare-value` are
+  used for similar purposes; at some point in the future, we might be able to combine them into a single method used in both places.")
+
   (prepare-value [this, ^Value value]
     "*OPTIONAL*. Prepare a value (e.g. a `String` or `Integer`) that will be used in a HoneySQL form. By default, this returns VALUE's `:value` as-is, which
      is eventually passed as a parameter in a prepared statement. Drivers such as BigQuery that don't support prepared statements can skip this
@@ -424,6 +435,7 @@
    :field->identifier    (u/drop-first-arg (comp (partial apply hsql/qualify) field/qualified-name-components))
    :field->alias         (u/drop-first-arg name)
    :field-percent-urls   fast-field-percent-urls
+   :prepare-sql-param    (u/drop-first-arg identity)
    :prepare-value        (u/drop-first-arg :value)
    :quote-style          (constantly :ansi)
    :set-timezone-sql     (constantly nil)

src/metabase/driver/sqlite.clj

@@ -97,10 +97,13 @@
                                    :quarter [3 "months"]
                                    :year    [1 "years"])]
     ;; Make a string like DATETIME(DATE('now', 'start of month'), '-1 month')
-    ;; The date bucketing will end up being done twice since `date` is called on the results of `date-interval` automatically. This shouldn't be a big deal because it's used for relative dates and only needs to be done once.
-    ;; It's important to call `date` on 'now' to apply bucketing *before* adding/subtracting dates to handle certain edge cases as discussed in issue #2275 (https://github.com/metabase/metabase/issues/2275).
+    ;; The date bucketing will end up being done twice since `date` is called on the results of `date-interval` automatically.
+    ;; This shouldn't be a big deal because it's used for relative dates and only needs to be done once.
+    ;; It's important to call `date` on 'now' to apply bucketing *before* adding/subtracting dates to handle certain edge cases as discussed in
+    ;; issue #2275 (https://github.com/metabase/metabase/issues/2275).
     ;; Basically, March 30th minus one month becomes Feb 30th in SQLite, which becomes March 2nd. DATE(DATETIME('2016-03-30', '-1 month'), 'start of month') is thus March 1st.
-    ;; The SQL we produce instead (for "last month") ends up looking something like: DATE(DATETIME(DATE('2015-03-30', 'start of month'), '-1 month'), 'start of month'). It's a little verbose, but gives us the correct answer (Feb 1st).
+    ;; The SQL we produce instead (for "last month") ends up looking something like: DATE(DATETIME(DATE('2015-03-30', 'start of month'), '-1 month'), 'start of month').
+    ;; It's a little verbose, but gives us the correct answer (Feb 1st).
     (->datetime (date unit (hx/literal "now"))
                 (hx/literal (format "%+d %s" (* amount multiplier) sqlite-unit)))))
 
@@ -109,6 +112,17 @@
     :seconds      (->datetime expr (hx/literal "unixepoch"))
     :milliseconds (recur (hx// expr 1000) :seconds)))
 
+
+;; SQLite doesn't like things like Timestamps getting passed in as prepared statement args, so we need to convert them to date literal strings instead to get things to work
+;; TODO - not sure why this doesn't need to be done in `prepare-value` as well? I think it's because the MBQL date values are funneled through the `date` family of functions above
+(defn- prepare-sql-param [obj]
+  (if (instance? java.util.Date obj)
+    ;; for anything that's a Date (usually a java.sql.Timestamp) convert it to a yyyy-MM-dd formatted date literal string
+    ;; For whatever reason the SQL generated from parameters ends up looking like `WHERE date(some_field) = ?` sometimes so we need to use just the date rather than a full ISO-8601 string
+    (u/format-date "yyyy-MM-dd" obj)
+    ;; every other prepared statement arg can be returned as-is
+    obj))
+
 ;; SQLite doesn't support `TRUE`/`FALSE`; it uses `1`/`0`, respectively; convert these booleans to numbers.
 (defn- prepare-value [{value :value}]
   (cond
@@ -145,8 +159,9 @@
          {:active-tables             sql/post-filtered-active-tables
           :column->base-type         (sql/pattern-based-column->base-type pattern->type)
           :connection-details->spec  (u/drop-first-arg dbspec/sqlite3)
-          :current-datetime-fn       (constantly (hsql/raw "datetime('now')"))
+          :current-datetime-fn       (constantly (hsql/call :datetime (hx/literal :now)))
           :date                      (u/drop-first-arg date)
+          :prepare-sql-param         (u/drop-first-arg prepare-sql-param)
           :prepare-value             (u/drop-first-arg prepare-value)
           :string-length-fn          (u/drop-first-arg string-length-fn)
           :unix-timestamp->timestamp (u/drop-first-arg unix-timestamp->timestamp)}))

src/metabase/query_processor/sql_parameters.clj

@@ -377,7 +377,8 @@
   (log/debug (format "PARAM INFO: %s\n%s" (u/emoji "🔥") (u/pprint-to-str 'yellow param-snippets-info)))
   (loop [sql sql, prepared-statement-args [], [snippet-info & more] param-snippets-info]
     (if-not snippet-info
-      {:query (str/trim sql), :params prepared-statement-args}
+      {:query (str/trim sql), :params (for [arg prepared-statement-args]
+                                        ((resolve 'metabase.driver.generic-sql/prepare-sql-param) *driver* arg))}
       (recur (substitute-one sql snippet-info)
              (concat prepared-statement-args (:prepared-statement-args snippet-info))
              more))))