include :segments as part of our database metadata api call.

src/metabase/api/database.clj

@@ -132,7 +132,7 @@
   (->404 (Database id)
          read-check
          ;; TODO - this is a bit slow due to the nested hydration.  needs some optimizing.
-         (hydrate [:tables [:fields :target :values]])))
+         (hydrate [:tables [:fields :target :values] :segments])))
 
 (defendpoint GET "/:id/autocomplete_suggestions"
   "Return a list of autocomplete suggestions for a given PREFIX.

src/metabase/models/segment.clj

@@ -37,7 +37,7 @@
         :description (u/jdbc-clob->str description))))
 
   (pre-cascade-delete [_ {:keys [id]}]
-    (when-not (config/is-test?)
+    (when (config/is-prod?)
       (throw (Exception. "deleting a Segment is not supported.")))))
 
 (extend-ICanReadWrite SegmentEntity :read :always, :write :superuser)
@@ -70,9 +70,9 @@
       (hydrate :creator)))
 
 (defn retrieve-segments
-  "Fetch all `Segments`."
-  []
-  (-> (db/sel :many Segment (k/order :name :ASC))
+  "Fetch all `Segments` for a given `Table`."
+  [table-id]
+  (-> (db/sel :many Segment :table_id table-id (k/order :name :ASC))
       (hydrate :creator)))
 
 (defn update-segment

src/metabase/models/table.clj

 (ns metabase.models.table
-  (:require [korma.core :refer :all, :exclude [defentity update]]
-            [metabase.db :refer :all]
-            (metabase.models [common :as common]
-                             [database :as db]
+  (:require [korma.core :as k, :exclude [defentity update]]
+            [metabase.db :as db]
+            (metabase.models [common :refer :all]
+                             [database :as database]
                              [field :refer [Field]]
                              [field-values :refer [FieldValues]]
                              [interface :refer :all]
-                             [segment :refer [Segment]])
+                             [segment :refer [Segment retrieve-segments]])
             [metabase.util :as u]))
 
 (def ^:const entity-types
@@ -25,33 +25,34 @@
 (extend-ICanReadWrite TableInstance :read :always, :write :superuser)
 
 (defentity Table
-  [(table :metabase_table)
+  [(k/table :metabase_table)
    (hydration-keys table)
    (types :entity_type :keyword, :visibility_type :keyword)
    timestamped]
 
   (post-select [_ {:keys [id db db_id description] :as table}]
     (map->TableInstance
-     (u/assoc* table
-       :db                  (or db (delay (sel :one db/Database :id db_id)))
-       :fields              (delay (sel :many Field :table_id id :active true (order :position :ASC) (order :name :ASC)))
+     (assoc table
+       :db                  (or db (delay (db/sel :one database/Database :id db_id)))
+       :description         (u/jdbc-clob->str description)
+       :fields              (delay (db/sel :many Field :table_id id :active true (k/order :position :ASC) (k/order :name :ASC)))
        :field_values        (delay
-                             (let [field-ids (sel :many :field [Field :id]
+                             (let [field-ids (db/sel :many :field [Field :id]
                                                   :table_id id
                                                   :active true
                                                   :field_type [not= "sensitive"]
-                                                  (order :position :asc)
-                                                  (order :name :asc))]
-                               (sel :many :field->field [FieldValues :field_id :values] :field_id [in field-ids])))
-       :description         (u/jdbc-clob->str description)
-       :pk_field            (delay (:id (sel :one :fields [Field :id] :table_id id (where {:special_type "id"})))))))
+                                                  (k/order :position :asc)
+                                                  (k/order :name :asc))]
+                               (db/sel :many :field->field [FieldValues :field_id :values] :field_id [in field-ids])))
+       :pk_field            (delay (:id (db/sel :one :fields [Field :id] :table_id id (k/where {:special_type "id"}))))
+       :segments            (delay (retrieve-segments id)))))
 
   (pre-insert [_ table]
-    (let [defaults {:display_name (common/name->human-readable-name (:name table))}]
+    (let [defaults {:display_name (name->human-readable-name (:name table))}]
       (merge defaults table)))
 
   (pre-cascade-delete [_ {:keys [id] :as table}]
-    (cascade-delete Segment :table_id id)
-    (cascade-delete Field :table_id id)))
+    (db/cascade-delete Segment :table_id id)
+    (db/cascade-delete Field :table_id id)))
 
 (extend-ICanReadWrite TableEntity :read :always, :write :superuser)

test/metabase/api/database_test.clj

@@ -191,6 +191,7 @@
                                         :parent_id       nil
                                         :parent          nil
                                         :values          []})]
+                   :segments        []
                    :rows            75
                    :updated_at      $
                    :entity_name     nil

test/metabase/models/segment_test.clj

@@ -48,7 +48,6 @@
 
 
 ;; retrieve-segment
-;; this should cover all the basic Segment attributes
 (expect
   {:creator_id   (user->id :rasta)
    :creator      (user-details :rasta)
@@ -75,6 +74,40 @@
               (assoc :creator (dissoc creator :date_joined :last_login))))))))
 
 
+;; retrieve-segements
+(expect
+  {:creator_id   (user->id :rasta)
+   :creator      (user-details :rasta)
+   :name         "Segment 1"
+   :description  nil
+   :definition   {}}
+  (tu/with-temp Database [{database-id :id} {:name      "Hillbilly"
+                                             :engine    :yeehaw
+                                             :details   {}
+                                             :is_sample false}]
+    (tu/with-temp Table [{table-id1 :id} {:name   "Table 1"
+                                          :db_id  database-id
+                                          :active true}]
+      (tu/with-temp Table [{table-id2 :id} {:name   "Table 2"
+                                            :db_id  database-id
+                                            :active true}]
+        (tu/with-temp Segment [{segement-id1 :id} {:creator_id  (user->id :rasta)
+                                                   :table_id    table-id1
+                                                   :name        "Segment 1"
+                                                   :definition  {}}]
+          (tu/with-temp Segment [{segment-id2 :id} {:creator_id  (user->id :rasta)
+                                                    :table_id    table-id2
+                                                    :name        "Segment 2"
+                                                    :definition  {}}]
+            (let [segments (retrieve-segments table-id1)]
+              (assert (= 1 (count segments)))
+              (->> segments
+                   (mapv #(dissoc % :id :table_id :created_at :updated_at))
+                   (mapv (fn [{:keys [creator] :as segment}]
+                           (assoc segment :creator (dissoc creator :date_joined :last_login))))
+                   first))))))))
+
+
 ;; update-segment
 ;; basic update.  we are testing several things here
 ;;  1. ability to update the Segment name