resolve the DB as well in query expansion. Remove Generic SQL util method to do table resolution

src/metabase/driver/generic_sql/query_processor.clj

@@ -32,10 +32,10 @@
 
 (defn process-structured
   "Convert QUERY into a korma `select` form, execute it, and annotate the results."
-  [{{:keys [source_table]} :query, :as query}]
+  [{{:keys [source-table]} :query, database :database, :as query}]
   (try
     ;; Process the expanded query and generate a korma form
-    (let [korma-form `(let [entity# (table-id->korma-entity ~source_table)]
+    (let [korma-form `(let [entity# (korma-entity ~database ~source-table)]
                         (select entity# ~@(->> (map apply-form (:query query))
                                                (filter identity)
                                                (mapcat #(if (vector? %) % [%])))))]

src/metabase/driver/generic_sql/util.clj

@@ -66,21 +66,16 @@
        ~@body)))
 
 (defn korma-entity
-  "Return a Korma entity for TABLE.
+  "Return a Korma entity for [DB and] TABLE .
 
     (-> (sel :one Table :id 100)
         korma-entity
         (select (aggregate (count :*) :count)))"
-  [{:keys [name db] :as table}]
-  {:pre [(delay? db)]}
-  {:table name
-   :pk    :id
-   :db    (db->korma-db @db)})
-
-(defn table-id->korma-entity
-  "Lookup `Table` with TABLE-ID and return a korma entity that can be used in a korma form."
-  [table-id]
-  {:pre  [(integer? table-id)]
-   :post [(map? %)]}
-  (korma-entity (or (sel :one Table :id table-id)
-                    (throw (Exception. (format "Table with ID %d doesn't exist!" table-id))))))
+  ([{db-delay :db, :as table}]
+   {:pre [(delay? db-delay)]}
+   (korma-entity @db-delay table))
+  ([db {table-name :name}]
+   {:pre [(map? db)]}
+   {:table table-name
+    :pk    :id
+    :db    (db->korma-db db)}))

src/metabase/driver/query_processor/expand.clj

@@ -42,7 +42,8 @@
             [medley.core :as m]
             [swiss.arrows :refer [-<>]]
             [metabase.db :refer [sel]]
-            (metabase.models [field :as field]
+            (metabase.models [database :refer [Database]]
+                             [field :as field]
                              [table :refer [Table]])
             [metabase.util :as u])
   (:import (clojure.lang Keyword)))
@@ -107,10 +108,14 @@
             ;; they may have nil values; this was we don't have to write an implementation of resolve-field for nil
             (walk/postwalk #(resolve-field % fields) expanded-query-dict))))
 
+(defn- resolve-database
+  "Resolve the `Database` in question for an EXPANDED-QUERY-DICT."
+  [{database-id :database, :as expanded-query-dict}]
+  (assoc expanded-query-dict :database (sel :one :fields [Database :name :id :engine :details] :id database-id)))
+
 (defn- resolve-tables
-  "Resolve the `Tables` in an EXPANDED-QUERY-DICT`."
-  [{{source-table-id :source-table} :query, :as expanded-query-dict}]
-  ;; TODO - do we need any other information about a Table besides its name and ID?
+  "Resolve the `Tables` in an EXPANDED-QUERY-DICT."
+  [{{source-table-id :source-table} :query, database-id :database, :as expanded-query-dict}]
   ;; TODO - this doesn't handle join tables yet
   (let [table (sel :one :fields [Table :name :id] :id source-table-id)]
     (->> (assoc-in expanded-query-dict [:query :source-table] table)
@@ -126,6 +131,7 @@
     (some-> query-dict
             parse
             (resolve-fields @*field-ids*)
+            resolve-database
             resolve-tables)))