more improvements

src/metabase/driver/generic_sql/query_processor.clj

@@ -19,19 +19,20 @@
 
 ;; # INTERFACE
 
+
+(def ^:dynamic ^:private *query* nil)
+
 (defn- uncastify
   "Remove CAST statements from a column name if needed.
 
     (uncastify \"DATE\")               -> \"DATE\"
     (uncastify \"CAST(DATE AS DATE)\") -> \"DATE\""
-  [column-name]
+  [driver column-name]
   (let [column-name (name column-name)]
     (keyword (or (second (re-find #"CAST\([^.\s]+\.([^.\s]+) AS [\w]+\)" column-name))
-                 (second (re-find (:uncastify-timestamp-regex qp/*driver*) column-name))
+                 (second (re-find (:uncastify-timestamp-regex driver) column-name))
                  column-name))))
 
-(def ^:dynamic ^:private *query* nil)
-
 (defn process-structured
   "Convert QUERY into a korma `select` form, execute it, and annotate the results."
   [{{:keys [source-table]} :query, database :database, :as query}]
@@ -43,7 +44,7 @@
                                                       (filter identity)
                                                       (mapcat #(if (vector? %) % [%]))))
             set-timezone-sql  (when-let [timezone (:timezone (:details database))]
-                                (when-let [set-timezone-sql (:timezone->set-timezone-sql qp/*driver*)]
+                                (when-let [set-timezone-sql (:timezone->set-timezone-sql (:driver *query*))]
                                   `(exec-raw ~(set-timezone-sql timezone))))
             korma-form        `(let [~entity (korma-entity ~database ~source-table)]
                                  ~(if set-timezone-sql `(korma.db/with-db (:db ~entity)
@@ -58,7 +59,7 @@
 
         (let [results (eval korma-form)]
           {:results      results
-           :uncastify-fn uncastify}))
+           :uncastify-fn (partial uncastify (:driver query))}))
 
       (catch java.sql.SQLException e
         (let [^String message (or (->> (.getMessage e) ; error message comes back like "Error message ... [status-code]" sometimes
@@ -103,8 +104,8 @@
     ;; TODO - add Table names
     (cond
       (contains? #{:DateField :DateTimeField} base-type) `(raw ~(format "CAST(\"%s\".\"%s\" AS DATE)" table-name field-name))
-      (= special-type :timestamp_seconds)                `(raw ~((:cast-timestamp-seconds-field-to-date-fn qp/*driver*) table-name field-name))
-      (= special-type :timestamp_milliseconds)           `(raw ~((:cast-timestamp-milliseconds-field-to-date-fn qp/*driver*) table-name field-name))
+      (= special-type :timestamp_seconds)                `(raw ~((:cast-timestamp-seconds-field-to-date-fn (:driver *query*)) table-name field-name))
+      (= special-type :timestamp_milliseconds)           `(raw ~((:cast-timestamp-milliseconds-field-to-date-fn (:driver *query*)) table-name field-name))
       :else                                              (keyword (format "%s.%s" table-name field-name))))
 
   ;; e.g. the ["aggregation" 0] fields we allow in order-by

src/metabase/driver/mongo.clj

@@ -153,10 +153,9 @@
   (datasets/with-dataset :mongo
     (data/with-temp-db [db (data/dataset-loader) defs/geographical-tips]
       (->> (sel :many :fields [Field :id :name :parent_id] :table_id (sel :one :id Table :db_id (:id db)))
-           unflatten-nested-fields))))
+           metabase.models.field/unflatten-nested-fields))))
 
 ;; TODO
-;; "structure nested fields" method ?
 ;; 4. API
 ;;    4A. API Tweaks as Needed
 ;; 5. Cleanup + Tests

src/metabase/driver/query_processor.clj

@@ -30,10 +30,6 @@
   "Should we disable logging for the QP? (e.g., during sync we probably want to turn it off to keep logs less cluttered)."
   false)
 
-(def ^:dynamic *driver*
-  "The driver currently being used to process this query."
-  (atom nil))
-
 
 ;; +----------------------------------------------------------------------------------------------------+
 ;; |                                     QP INTERNAL IMPLEMENTATION                                     |
@@ -50,8 +46,7 @@
 
 (defn- pre-expand [qp]
   (fn [query]
-    (qp (assoc (expand/expand *driver* query)
-               :query-id (str (java.util.UUID/randomUUID))))))
+    (qp (expand/expand query))))
 
 
 (defn- post-add-row-count-and-status
@@ -416,9 +411,7 @@
         (log/debug "\nRESULTS:\n" (u/pprint-to-str 'cyan results)))
       results)))
 
-(defn- process-structured [driver query]
-  (when-not *disable-qp-logging*
-    (println "PROCESS STRUCTURED!"))
+(defn- process-structured [{:keys [driver], :as query}]
   (let [driver-process-query (partial i/process-query driver)]
     ((<<- wrap-catch-exceptions
           pre-expand
@@ -434,7 +427,7 @@
           wrap-guard-multiple-calls
           driver-process-query) query)))
 
-(defn- process-native [driver query]
+(defn- process-native [{:keys [driver], :as query}]
   (let [driver-process-query (partial i/process-query driver)]
     ((<<- wrap-catch-exceptions
           post-add-row-count-and-status
@@ -448,8 +441,8 @@
   [driver query]
   (when-not *disable-qp-logging*
     (log/info (u/format-color 'blue "\nQUERY:\n%s" (u/pprint-to-str query))))
-  (binding [*driver* driver]
-    ((case (keyword (:type query))
-       :native process-native
-       :query  process-structured)
-     driver query)))
+  ((case (keyword (:type query))
+     :native process-native
+     :query  process-structured)
+   (assoc query
+          :driver driver)))

src/metabase/driver/query_processor/expand.clj

@@ -40,6 +40,7 @@
                      [string :as s]
                      [walk :as walk])
             [medley.core :as m]
+            [korma.core :as k]
             [swiss.arrows :refer [-<>]]
             [metabase.db :refer [sel]]
             [metabase.driver.interface :as i]
@@ -129,14 +130,14 @@
 
 (defn- resolve-fields
   "Resolve the `Fields` in an EXPANDED-QUERY-DICT."
-  [expanded-query-dict field-ids]
+  [expanded-query-dict field-ids & [count]]
   (if-not (seq field-ids)
     ;; Base case: if there's no field-ids to expand we're done
     expanded-query-dict
 
     ;; Re-bind *field-ids* in case we need to do recursive Field resolution
     (binding [*field-ids* (atom #{})]
-      (let [fields (->> (sel :many :id->fields [field/Field :name :base_type :special_type :table_id :parent_id] :id [in field-ids])
+      (let [fields (->> (sel :many :id->fields [field/Field :name :base_type :special_type :table_id :parent_id], :id [in field-ids])
                         (m/map-vals rename-mb-field-keys)
                         (m/map-vals #(assoc % :parent (when (:parent-id %)
                                                         (ph (:parent-id %))))))]
@@ -145,7 +146,8 @@
         ;; Recurse in case any new [nested] Field placeholders were emitted and we need to do recursive Field resolution
         ;; We can't use recur here because binding wraps body in try/catch
         (resolve-fields (walk/postwalk #(resolve-field % fields) expanded-query-dict)
-                        @*field-ids*)))))
+                        @*field-ids*
+                        (inc (or count 0)))))))
 
 (defn- resolve-database
   "Resolve the `Database` in question for an EXPANDED-QUERY-DICT."
@@ -203,7 +205,7 @@
 
 (defn expand
   "Expand a QUERY-DICT."
-  [driver query-dict]
+  [{:keys [driver], :as query-dict}]
   (binding [*driver*       driver
             *field-ids*    (atom #{})
             *fk-field-ids* (atom #{})