test fixes

test/metabase/test/data/datasets.clj

@@ -51,26 +51,31 @@
   (load-data! [_]
     @mongo-data/mongo-test-db
     (assert (integer? @mongo-data/mongo-test-db-id)))
+
   (dataset-loader [_]
     (mongo/dataset-loader))
+
   (db [_]
     @mongo-data/mongo-test-db)
+
   (table-name->table [_ table-name]
     (mongo-data/table-name->table table-name))
+
   (table-name->id [_ table-name]
     (mongo-data/table-name->id table-name))
+
   (field-name->id [_ table-name field-name]
     (mongo-data/field-name->id table-name (if (= field-name :id) :_id
                                               field-name)))
-  (fks-supported? [_]
-    false)
+  (fks-supported? [_] false)
+
   (format-name [_ table-or-field-name]
     (if (= table-or-field-name "id") "_id"
         table-or-field-name))
-  (id-field-type [_]
-    :IntegerField)
-  (timestamp-field-type [_]
-    :DateField))
+
+  (id-field-type [_] :IntegerField)
+
+  (timestamp-field-type [_] :DateField))
 
 
 ;; ## Generic SQL (H2)
@@ -79,21 +84,20 @@
 (def ^:private memoized-table-name->id
   (memoize
    (fn [db-id table-name]
-     (sel :one :id Table :name (s/upper-case (name table-name)), :db_id db-id))))
+     {:pre [(string? table-name)]}
+     (sel :one :id Table :name table-name, :db_id db-id))))
 
 (def ^:private memoized-field-name->id
   (memoize
    (fn [db-id table-name field-name]
-     (sel :one :id Field :name (s/upper-case (name field-name)), :table_id (memoized-table-name->id db-id table-name)))))
+     {:pre [(string? field-name)]}
+     (sel :one :id Field :name field-name, :table_id (memoized-table-name->id db-id table-name)))))
 
-(def ^:private generic-sql-db
-  (delay ))
 
-(deftype GenericSqlDriverData [dataset-loader-fn
-                               dbpromise]
+(deftype H2DriverData [dbpromise]
   IDataset
   (dataset-loader [_]
-    (dataset-loader-fn))
+    (h2/dataset-loader))
 
   (load-data! [this]
     (when-not (realized? dbpromise)
@@ -104,25 +108,52 @@
     (load-data! this))
 
   (table-name->id [this table-name]
-    (memoized-table-name->id (:id (db this)) table-name))
+    (memoized-table-name->id (:id (db this)) (s/upper-case (name table-name))))
 
   (table-name->table [this table-name]
-    (sel :one Table :id (table-name->id this table-name)))
+    (sel :one Table :id (table-name->id this (s/upper-case (name table-name)))))
 
   (field-name->id [this table-name field-name]
-    (memoized-field-name->id (:id (db this)) table-name field-name))
-
-  (fks-supported? [_]
-    true)
+    (memoized-field-name->id (:id (db this)) (s/upper-case (name table-name)) (s/upper-case (name field-name))))
 
   (format-name [_ table-or-field-name]
     (clojure.string/upper-case table-or-field-name))
 
-  (id-field-type [_]
-    :BigIntegerField)
+  (fks-supported?       [_] true)
+  (id-field-type        [_] :BigIntegerField)
+  (timestamp-field-type [_] :DateTimeField))
+
 
-  (timestamp-field-type [_]
-    :DateTimeField))
+;; ## Postgres
+
+(deftype PostgresDriverData [dbpromise]
+  IDataset
+  (dataset-loader [_]
+    (postgres/dataset-loader))
+
+  (load-data! [this]
+    (when-not (realized? dbpromise)
+      (deliver dbpromise ((u/runtime-resolved-fn 'metabase.test.data 'get-or-create-database!) (dataset-loader this) data/test-data)))
+    @dbpromise)
+
+  (db [this]
+    (load-data! this))
+
+  (table-name->id [this table-name]
+    (memoized-table-name->id (:id (db this)) (name table-name)))
+
+  (table-name->table [this table-name]
+    (sel :one Table :id (table-name->id this (name table-name))))
+
+  (field-name->id [this table-name field-name]
+    (memoized-field-name->id (:id (db this)) (name table-name) (name field-name)))
+
+  (format-name [_ table-or-field-name]
+    table-or-field-name)
+
+  (fks-supported?       [_] true)
+  (id-field-type        [_] :IntegerField)
+  (timestamp-field-type [_] :DateTimeField))
 
 
 ;; # Concrete Instances
@@ -130,10 +161,9 @@
 (def dataset-name->dataset
   "Map of dataset keyword name -> dataset instance (i.e., an object that implements `IDataset`)."
   {:mongo       (MongoDriverData.)
-   :generic-sql (GenericSqlDriverData. h2/dataset-loader (promise))
-
-   ;; TODO - make sure we have pg connection info
-   :postgres    (GenericSqlDriverData. postgres/dataset-loader (promise))})
+   :generic-sql (H2DriverData. (promise))
+   :postgres    (PostgresDriverData. (promise))})
+;; TODO - :generic-sql should be renamed H2
 
 (def ^:const all-valid-dataset-names
   "Set of names of all valid datasets."

test/metabase/test/data/generic_sql.clj

@@ -18,6 +18,9 @@
   (pk-sql-type ^String [this]
     "SQL that should be used for creating the PK Table ID, e.g. `SERIAL` or `BIGINT AUTOINCREMENT`.")
 
+  (pk-field-name ^String [this]
+    "e.g. `id` or `ID`.")
+
   (field-base-type->sql-type ^String [this base-type]
     "Given a `Field.base_type`, return the SQL type we should use for that column when creating a DB."))
 
@@ -28,14 +31,16 @@
 
   ;; Now create the new table
   (execute-sql! dataset-loader database-definition
-    (format "CREATE TABLE \"%s\" (%s, \"ID\" %s, PRIMARY KEY (\"ID\"));"
+    (format "CREATE TABLE \"%s\" (%s, \"%s\" %s, PRIMARY KEY (\"%s\"));"
             table-name
             (->> field-definitions
                  (map (fn [{:keys [field-name base-type]}]
                         (format "\"%s\" %s" field-name (field-base-type->sql-type dataset-loader base-type))))
                  (interpose ", ")
                  (apply str))
-            (pk-sql-type dataset-loader))))
+            (pk-field-name dataset-loader)
+            (pk-sql-type dataset-loader)
+            (pk-field-name dataset-loader))))
 
 
 (defn drop-physical-table! [dataset-loader database-definition table-definition]
@@ -54,17 +59,17 @@
     (doseq [{dest-table-name :fk, field-name :field-name} field-definitions]
       (when dest-table-name
         (execute-sql! dataset-loader database-definition
-          (format "ALTER TABLE \"%s\" ADD CONSTRAINT \"FK_%s_%s\" FOREIGN KEY (\"%s\") REFERENCES \"%s\" (\"ID\");"
+          (format "ALTER TABLE \"%s\" ADD CONSTRAINT \"FK_%s_%s\" FOREIGN KEY (\"%s\") REFERENCES \"%s\" (\"%s\");"
                   table-name
-                  field-name dest-table-name
+                  field-name (name dest-table-name)
                   field-name
-                  (name dest-table-name)))))))
+                  (name dest-table-name)
+                  (pk-field-name dataset-loader)))))))
 
 
 (defn load-table-data! [dataset-loader database-definition table-definition]
   (let [rows              (:rows table-definition)
         fields-for-insert (map :field-name (:field-definitions table-definition))]
-    (println (korma-entity dataset-loader database-definition table-definition))
     (-> (korma-entity dataset-loader database-definition table-definition)
         (k/insert (k/values (->> (for [row rows]
                                    (for [v row]

test/metabase/test/data/h2.clj

@@ -47,25 +47,14 @@
 
 ;; ## Implementation
 
-(defprotocol IH2DatasetFormat
-  (format-for-h2 [this]
-    "Format dataset definitions for H2, e.g. upcasing `Table` and `Field` names."))
-
-(extend-protocol IH2DatasetFormat
-  DatabaseDefinition
-  (format-for-h2 [this]
-    (update-in this [:table-definitions] (partial map format-for-h2)))
-
-  TableDefinition
-  (format-for-h2 [this]
-    (-> this
-        (update-in [:table-name] s/upper-case)
-        (update-in [:field-definitions] (partial map format-for-h2))))
-
-  FieldDefinition
-  (format-for-h2 [this]
-    (cond-> (update-in this [:field-name] s/upper-case)
-      (:pk this) (update-in [:pk] (comp s/upper-case name)))))
+(defn- format-for-h2 [obj]
+  (cond
+    (:database-name obj) (update-in obj [:table-definitions] (partial map format-for-h2))
+    (:table-name obj)    (-> obj
+                             (update-in [:table-name] s/upper-case)
+                             (update-in [:field-definitions] (partial map format-for-h2)))
+    (:field-name obj)    (cond-> (update-in obj [:field-name] s/upper-case)
+                           (:fk obj) (update-in [:fk] (comp s/upper-case name)))))
 
 
 ;; ## Public Concrete DatasetLoader instance
@@ -81,8 +70,8 @@
     (-> (k/create-entity (:table-name table-definition))
         (k/database (korma-connection-pool database-definition))))
 
-  (generic/pk-sql-type [_]
-    "BIGINT AUTO_INCREMENT")
+  (generic/pk-sql-type   [_] "BIGINT AUTO_INCREMENT")
+  (generic/pk-field-name [_] "ID")
 
   (generic/field-base-type->sql-type [_ field-type]
     (field-base-type->sql-type field-type)))

test/metabase/test/data/postgres.clj

@@ -57,8 +57,8 @@
                         (assoc :make-pool? false)
                         kdb/create-db))))
 
-  (generic/pk-sql-type [_]
-    "SERIAL")
+  (generic/pk-sql-type   [_] "SERIAL")
+  (generic/pk-field-name [_] "id")
 
   (generic/field-base-type->sql-type [_ field-type]
     (field-base-type->sql-type field-type)))