adds search param for database/:id/autocomplete_suggestions (#21887)

- search qp will search for a substring
- prefix qp works as it used to (searches for a prefix)
- if both are included, prefer search.

frontend/src/metabase/services.js

@@ -258,7 +258,7 @@ export const MetabaseApi = {
   db_fields: GET("/api/database/:dbId/fields"),
   db_idfields: GET("/api/database/:dbId/idfields"),
   db_autocomplete_suggestions: GET(
-    "/api/database/:dbId/autocomplete_suggestions?prefix=:prefix",
+    "/api/database/:dbId/autocomplete_suggestions?search=:prefix",
   ),
   db_sync_schema: POST("/api/database/:dbId/sync_schema"),
   db_rescan_values: POST("/api/database/:dbId/rescan_values"),

src/metabase/api/database.clj

@@ -398,19 +398,19 @@
 
 ;;; --------------------------------- GET /api/database/:id/autocomplete_suggestions ---------------------------------
 
-(defn- autocomplete-tables [db-id prefix limit]
+(defn- autocomplete-tables [db-id search-string limit]
   (db/select [Table :id :db_id :schema :name]
     {:where    [:and [:= :db_id db-id]
                      [:= :active true]
-                     [:like :%lower.name (str (str/lower-case prefix) "%")]
+                     [:like :%lower.name (str/lower-case search-string)]
                      [:= :visibility_type nil]]
      :order-by [[:%lower.name :asc]]
      :limit    limit}))
 
-(defn- autocomplete-fields [db-id prefix limit]
+(defn- autocomplete-fields [db-id search-string limit]
   (db/select [Field :name :base_type :semantic_type :id :table_id [:table.name :table_name]]
     :metabase_field.active          true
-    :%lower.metabase_field.name     [:like (str (str/lower-case prefix) "%")]
+    :%lower.metabase_field.name     [:like (str/lower-case search-string)]
     :metabase_field.visibility_type [:not-in ["sensitive" "retired"]]
     :table.db_id                    db-id
     {:order-by  [[:%lower.metabase_field.name :asc]
@@ -432,10 +432,12 @@
                          (when semantic_type
                            (str " " semantic_type)))]))))
 
-(defn- autocomplete-suggestions [db-id prefix]
+(defn- autocomplete-suggestions
+  "match-string is a string that will be used with ilike. The it will be lowercased by autocomplete-{tables,fields}. "
+  [db-id match-string]
   (let [limit  50
-        tables (filter mi/can-read? (autocomplete-tables db-id prefix limit))
-        fields (readable-fields-only (autocomplete-fields db-id prefix limit))]
+        tables (filter mi/can-read? (autocomplete-tables db-id match-string limit))
+        fields (readable-fields-only (autocomplete-fields db-id match-string limit))]
     (autocomplete-results tables fields limit)))
 
 (api/defendpoint GET "/:id/autocomplete_suggestions"
@@ -445,12 +447,18 @@
   and `Fields` in this `Database`.
 
   Tables are returned in the format `[table_name \"Table\"]`;
-  Fields are returned in the format `[field_name \"table_name base_type semantic_type\"]`"
-  [id prefix]
-  {prefix su/NonBlankString}
+  When Fields have a semantic_type, they are returned in the format `[field_name \"table_name base_type semantic_type\"]`
+  When Fields lack a semantic_type, they are returned in the format `[field_name \"table_name base_type\"]`"
+  [id prefix search]
   (api/read-check Database id)
   (try
-    (autocomplete-suggestions id prefix)
+    (cond
+      search
+      (autocomplete-suggestions id (str "%" search "%"))
+      prefix
+      (autocomplete-suggestions id (str prefix "%"))
+      :else
+      (ex-info "must include prefix or search" {}))
     (catch Throwable t
       (log/warn "Error with autocomplete: " (.getMessage t)))))
 

test/metabase/api/database_test.clj

@@ -306,10 +306,14 @@
                         (some (partial = "PRICE"))))))))))
 
 (deftest autocomplete-suggestions-test
-  (let [suggest-fn (fn [db-id prefix]
-                     (mt/user-http-request :rasta :get 200
-                                           (format "database/%d/autocomplete_suggestions" db-id)
-                                           :prefix prefix))]
+  (let [prefix-fn (fn [db-id prefix]
+                    (mt/user-http-request :rasta :get 200
+                                          (format "database/%d/autocomplete_suggestions" db-id)
+                                          :prefix prefix))
+        search-fn (fn [db-id search]
+                    (mt/user-http-request :rasta :get 200
+                                          (format "database/%d/autocomplete_suggestions" db-id)
+                                          :search search))]
     (testing "GET /api/database/:id/autocomplete_suggestions"
       (doseq [[prefix expected] {"u"   [["USERS" "Table"]
                                         ["USER_ID" "CHECKINS :type/Integer :type/FK"]]
@@ -318,8 +322,8 @@
                                         ["CATEGORY_ID" "VENUES :type/Integer :type/FK"]]
                                  "cat" [["CATEGORIES" "Table"]
                                         ["CATEGORY_ID" "VENUES :type/Integer :type/FK"]]}]
-        (is (= expected (suggest-fn (mt/id) prefix))))
-      (testing " handles large numbers of tables and fields sensibly"
+        (is (= expected (prefix-fn (mt/id) prefix))))
+      (testing " handles large numbers of tables and fields sensibly with prefix"
         (mt/with-model-cleanup [Field Table Database]
           (let [tmp-db (db/insert! Database {:name "Temp Autocomplete Pagination DB" :engine "h2" :details "{}"})]
             ;; insert more than 50 temporary tables and fields
@@ -327,15 +331,23 @@
               (let [tmp-tbl (db/insert! Table {:name (format "My Table %d" i) :db_id (u/the-id tmp-db) :active true})]
                 (db/insert! Field {:name (format "My Field %d" i) :table_id (u/the-id tmp-tbl) :base_type "type/Text" :database_type "varchar"})))
             ;; for each type-specific prefix, we should get 50 fields
-            (is (= 50 (count (suggest-fn (u/the-id tmp-db) "My Field"))))
-            (is (= 50 (count (suggest-fn (u/the-id tmp-db) "My Table"))))
-            (let [my-results (suggest-fn (u/the-id tmp-db) "My")]
+            (is (= 50 (count (prefix-fn (u/the-id tmp-db) "My Field"))))
+            (is (= 50 (count (prefix-fn (u/the-id tmp-db) "My Table"))))
+            (let [my-results (prefix-fn (u/the-id tmp-db) "My")]
               ;; for this prefix, we should a mixture of 25 fields and 25 tables
               (is (= 50 (count my-results)))
               (is (= 25 (-> (filter #(str/starts-with? % "My Field") (map first my-results))
                             count)))
               (is (= 25 (-> (filter #(str/starts-with? % "My Table") (map first my-results))
-                          count))))))))))
+                            count))))
+            (testing " behaves differently with search and prefix query params"
+              (is (= 0 (count (prefix-fn (u/the-id tmp-db) "a"))))
+              (is (= 50 (count (search-fn (u/the-id tmp-db) "a"))))
+              ;; setting both uses search:
+              (is (= 50 (count (mt/user-http-request :rasta :get 200
+                                                     (format "database/%d/autocomplete_suggestions" (u/the-id tmp-db))
+                                                     :prefix "a"
+                                                     :search "a")))))))))))
 
 
 (defn- card-with-native-query {:style/indent 1} [card-name & {:as kvs}]