enhance(perf): render references after table has been loaded

Also, use search index to check whether there're unlinked refs.

deps/db/src/logseq/db/common/view.cljs

@@ -414,89 +414,88 @@
   [db view-id {:keys [journals? _view-for-id view-feature-type group-by-property-ident input query-entity-ids filters sorting]
                :as opts}]
   ;; TODO: create a view for journals maybe?
-  (time
-   (cond
-     journals?
-     (let [ids (->> (ldb/get-latest-journals db)
-                    (mapv :db/id))]
-       {:count (count ids)
-        :data ids})
-     :else
-     (let [view (d/entity db view-id)
-           group-by-property (:logseq.property.view/group-by-property view)
-           list-view? (= :logseq.property.view/type.list (:db/ident (:logseq.property.view/type view)))
-           group-by-property-ident (or (:db/ident group-by-property) group-by-property-ident)
-           group-by-closed-values? (some? (:property/closed-values group-by-property))
-           ref-property? (= (:db/valueType group-by-property) :db.type/ref)
-           filters (or (:logseq.property.table/filters view) filters)
-           feat-type (or view-feature-type (:logseq.property.view/feature-type view))
-           query? (= feat-type :query-result)
-           entities-result (if query?
-                             (keep #(d/entity db %) query-entity-ids)
-                             (get-view-entities db view-id opts))
-           entities (if (= feat-type :linked-references)
-                      (:ref-blocks entities-result)
-                      entities-result)
-           sorting (let [sorting* (:logseq.property.table/sorting view)]
-                     (if (or (= sorting* :logseq.property/empty-placeholder) (empty? sorting*))
-                       (or sorting [{:id :block/updated-at, :asc? false}])
-                       sorting*))
-           filtered-entities (if (or (seq filters) (not (string/blank? input)))
-                               (filter (fn [row] (row-matched? db row filters input)) entities)
-                               entities)
-           group-by-page? (= group-by-property-ident :block/page)
-           readable-property-value-or-ent
-           (fn readable-property-value-or-ent [ent]
-             (let [pvalue (get ent group-by-property-ident)]
-               (if (de/entity? pvalue)
-                 (if (match-property-value-as-entity? pvalue group-by-property)
-                   pvalue
-                   (db-property/property-value-content pvalue))
-                 pvalue)))
-           result (if group-by-property-ident
-                    (->> filtered-entities
-                         (group-by readable-property-value-or-ent)
-                         (seq)
-                         (sort-by (fn [[by-value _]]
-                                    (cond
-                                      group-by-page?
-                                      (:block/updated-at by-value)
-                                      group-by-closed-values?
-                                      (:block/order by-value)
-                                      ref-property?
-                                      (db-property/property-value-content by-value)
-                                      :else
-                                      by-value))
-                                  (if group-by-page? #(compare %2 %1) compare)))
-                    (sort-entities db sorting filtered-entities))
-           data' (if group-by-property-ident
-                   (map
-                    (fn [[by-value entities]]
-                      (let [by-value' (if (de/entity? by-value)
-                                        (select-keys by-value [:db/id :db/ident :block/uuid :block/title :block/name :logseq.property/value :logseq.property/icon :block/tags])
-                                        by-value)
-                            pages? (not (some :block/page entities))
-                            group (if (and list-view? (not pages?))
-                                    (let [parent-groups (->> entities
-                                                             (group-by :block/parent)
-                                                             (sort-by (fn [[parent _]] (:block/order parent))))]
-                                      (map
-                                       (fn [[_parent blocks]]
-                                         [(:block/uuid (first blocks))
-                                          (map (fn [b]
-                                                 {:db/id (:db/id b)
-                                                  :block/parent (:block/uuid (:block/parent b))})
-                                               (ldb/sort-by-order blocks))])
-                                       parent-groups))
-                                    (->> (sort-entities db sorting entities)
-                                         (map :db/id)))]
-                        [by-value' group]))
-                    result)
-                   (map :db/id result))]
-       (cond->
-        {:count (count filtered-entities)
-         :data (distinct data')}
-         (= feat-type :linked-references)
-         (merge (select-keys entities-result [:ref-pages-count :ref-matched-children-ids]))
-         query?
-         (assoc :properties (get-query-properties entities-result)))))))
+  (cond
+    journals?
+    (let [ids (->> (ldb/get-latest-journals db)
+                   (mapv :db/id))]
+      {:count (count ids)
+       :data ids})
+    :else
+    (let [view (d/entity db view-id)
+          group-by-property (:logseq.property.view/group-by-property view)
+          list-view? (= :logseq.property.view/type.list (:db/ident (:logseq.property.view/type view)))
+          group-by-property-ident (or (:db/ident group-by-property) group-by-property-ident)
+          group-by-closed-values? (some? (:property/closed-values group-by-property))
+          ref-property? (= (:db/valueType group-by-property) :db.type/ref)
+          filters (or (:logseq.property.table/filters view) filters)
+          feat-type (or view-feature-type (:logseq.property.view/feature-type view))
+          query? (= feat-type :query-result)
+          entities-result (if query?
+                            (keep #(d/entity db %) query-entity-ids)
+                            (get-view-entities db view-id opts))
+          entities (if (= feat-type :linked-references)
+                     (:ref-blocks entities-result)
+                     entities-result)
+          sorting (let [sorting* (:logseq.property.table/sorting view)]
+                    (if (or (= sorting* :logseq.property/empty-placeholder) (empty? sorting*))
+                      (or sorting [{:id :block/updated-at, :asc? false}])
+                      sorting*))
+          filtered-entities (if (or (seq filters) (not (string/blank? input)))
+                              (filter (fn [row] (row-matched? db row filters input)) entities)
+                              entities)
+          group-by-page? (= group-by-property-ident :block/page)
+          readable-property-value-or-ent
+          (fn readable-property-value-or-ent [ent]
+            (let [pvalue (get ent group-by-property-ident)]
+              (if (de/entity? pvalue)
+                (if (match-property-value-as-entity? pvalue group-by-property)
+                  pvalue
+                  (db-property/property-value-content pvalue))
+                pvalue)))
+          result (if group-by-property-ident
+                   (->> filtered-entities
+                        (group-by readable-property-value-or-ent)
+                        (seq)
+                        (sort-by (fn [[by-value _]]
+                                   (cond
+                                     group-by-page?
+                                     (:block/updated-at by-value)
+                                     group-by-closed-values?
+                                     (:block/order by-value)
+                                     ref-property?
+                                     (db-property/property-value-content by-value)
+                                     :else
+                                     by-value))
+                                 (if group-by-page? #(compare %2 %1) compare)))
+                   (sort-entities db sorting filtered-entities))
+          data' (if group-by-property-ident
+                  (map
+                   (fn [[by-value entities]]
+                     (let [by-value' (if (de/entity? by-value)
+                                       (select-keys by-value [:db/id :db/ident :block/uuid :block/title :block/name :logseq.property/value :logseq.property/icon :block/tags])
+                                       by-value)
+                           pages? (not (some :block/page entities))
+                           group (if (and list-view? (not pages?))
+                                   (let [parent-groups (->> entities
+                                                            (group-by :block/parent)
+                                                            (sort-by (fn [[parent _]] (:block/order parent))))]
+                                     (map
+                                      (fn [[_parent blocks]]
+                                        [(:block/uuid (first blocks))
+                                         (map (fn [b]
+                                                {:db/id (:db/id b)
+                                                 :block/parent (:block/uuid (:block/parent b))})
+                                              (ldb/sort-by-order blocks))])
+                                      parent-groups))
+                                   (->> (sort-entities db sorting entities)
+                                        (map :db/id)))]
+                       [by-value' group]))
+                   result)
+                  (map :db/id result))]
+      (cond->
+       {:count (count filtered-entities)
+        :data (distinct data')}
+        (= feat-type :linked-references)
+        (merge (select-keys entities-result [:ref-pages-count :ref-matched-children-ids]))
+        query?
+        (assoc :properties (get-query-properties entities-result))))))

src/main/frontend/components/block.cljs

@@ -3494,7 +3494,7 @@
                  default-hide? (or (not (and current-block-page? (not embed-self?) (state/auto-expand-block-refs?)))
                                    (= (str (:id config)) (str (:block/uuid block))))
                  *refs-count (atom nil)]
-             (when-not (:view? config)
+             (when-not (or (:view? config) (ldb/page? block))
                (when-let [id (:db/id block)]
                  (p/let [count (db-async/<get-block-refs-count (state/get-current-repo) id)]
                    (reset! *refs-count count))))

src/main/frontend/components/objects.cljs

@@ -102,12 +102,10 @@
                                                                             :target (.-target e)}]))})]))
 
 (rum/defcs class-objects < rum/reactive db-mixins/query mixins/container-id
-  [state class {:keys [current-page? sidebar?]}]
+  [state class config]
   (when class
     (let [class (db/sub-block (:db/id class))
-          config {:container-id (:container-id state)
-                  :current-page? current-page?
-                  :sidebar? sidebar?}
+          config (assoc config :container-id (:container-id state))
           properties (outliner-property/get-class-properties class)]
       [:div.ml-1
        (class-objects-inner config class properties)])))
@@ -147,11 +145,10 @@
 
 ;; Show all nodes containing the given property
 (rum/defcs property-related-objects < rum/reactive db-mixins/query mixins/container-id
-  [state property current-page?]
+  [state property config]
   (when property
     (let [property' (db/sub-block (:db/id property))
-          config {:container-id (:container-id state)
-                  :current-page? current-page?}
+          config (assoc config :container-id (:container-id state))
           ;; Show tags to help differentiate property rows
           properties (if (= (:db/ident property) :block/tags)
                        [property']

src/main/frontend/components/page.cljs

@@ -503,10 +503,6 @@
        (plugins/hook-ui-items :pagebar)])))
 
 (rum/defc tabs < rum/static
-  {:did-mount (fn [state]
-                (let [*tabs-rendered? (:*tabs-rendered? (last (:rum/args state)))]
-                  (reset! *tabs-rendered? true)
-                  state))}
   [page opts]
   (let [class? (ldb/class? page)
         property? (ldb/property? page)
@@ -546,7 +542,7 @@
       (when property?
         (shui/tabs-content
          {:value "property"}
-         (objects/property-related-objects page (:current-page? opts)))))]))
+         (objects/property-related-objects page opts))))]))
 
 (rum/defc sidebar-page-properties
   [config page]
@@ -570,14 +566,18 @@
   (rum/local false ::all-collapsed?)
   (rum/local false ::control-show?)
   (rum/local nil   ::current-page)
-  (rum/local false ::tabs-rendered?)
+  (rum/local false ::objects-ready?)
   [state {:keys [repo page preview? sidebar? tag-dialog? linked-refs? unlinked-refs? config] :as option}]
   (let [current-repo (state/sub :git/current-repo)
-        *tabs-rendered? (::tabs-rendered? state)
+        *objects-ready? (::objects-ready? state)
+        config (assoc config :*objects-ready? *objects-ready?)
         repo (or repo current-repo)
         block? (some? (:block/page page))
         class-page? (ldb/class? page)
         property-page? (ldb/property? page)
+        objects-ready? (if (or class-page? property-page?)
+                         (rum/react *objects-ready?)
+                         true)
         title (:block/title page)
         journal? (db/journal-page? title)
         db-based? (config/db-based-graph? repo)
@@ -591,8 +591,7 @@
         *all-collapsed? (::all-collapsed? state)
         block-or-whiteboard? (or block? whiteboard?)
         home? (= :home (state/get-current-route))
-        show-tabs? (and db-based? (and (or class-page? (ldb/property? page)) (not tag-dialog?)))
-        tabs-rendered? (rum/react *tabs-rendered?)]
+        show-tabs? (and db-based? (and (or class-page? (ldb/property? page)) (not tag-dialog?)))]
     (if page
       (when (or title block-or-whiteboard?)
         [:div.flex-1.page.relative.cp__page-inner-wrap
@@ -639,9 +638,9 @@
                (sidebar-page-properties config page)])
 
             (when show-tabs?
-              (tabs page {:current-page? option :sidebar? sidebar? :*tabs-rendered? *tabs-rendered?}))
+              (tabs page {:current-page? option :sidebar? sidebar? :*objects-ready? *objects-ready?}))
 
-            (when (and (or (not show-tabs?) tabs-rendered?) (not tag-dialog?))
+            (when (and (not show-tabs?) (not tag-dialog?))
               [:div.ls-page-blocks
                {:style {:margin-left (if whiteboard? 0 -20)}
                 :class (when-not sidebar?
@@ -650,7 +649,7 @@
                                                    :container-id (:container-id state)
                                                    :whiteboard? whiteboard?}))])])
 
-         (when (and (not preview?) (or (not show-tabs?) tabs-rendered?))
+         (when (and (not preview?) (or (not show-tabs?) objects-ready?))
            [:div.ml-1.flex.flex-col.gap-8.mt-4
             (when today?
               (today-queries repo today? sidebar?))
@@ -664,7 +663,7 @@
             (when (and (ldb/page? page) (:logseq.property.class/_extends page))
               (class-component/class-children page))
 
-              ;; referenced blocks
+            ;; referenced blocks
             (when-not (or whiteboard? tag-dialog? linked-refs? (and block? (not db-based?)))
               [:div {:key "page-references"}
                (rum/with-key

src/main/frontend/components/reference.cljs

@@ -76,7 +76,7 @@
   (ui/lazy-visible
    (fn []
      (references-inner entity config))
-   {:trigger-once? true}))
+   {}))
 
 (rum/defc unlinked-references
   [entity config]

src/main/frontend/components/views.cljs

@@ -2032,9 +2032,9 @@
        ((fn [cs] (build-columns config cs {:add-tags-column? false})))))
 
 (defn- load-view-data-aux
-  [view-entity view-parent {:keys [query? query-entity-ids sorting filters input
-                                   view-feature-type group-by-property-ident
-                                   set-data! set-ref-pages-count! set-ref-matched-children-ids! set-properties! set-loading!]}]
+  [config view-entity view-parent {:keys [query? query-entity-ids sorting filters input
+                                          view-feature-type group-by-property-ident
+                                          set-data! set-ref-pages-count! set-ref-matched-children-ids! set-properties! set-loading!]}]
   (c.m/run-task*
    (m/sp
      (let [need-query? (and query? (seq query-entity-ids) (or sorting filters (not (string/blank? input))))]
@@ -2046,26 +2046,28 @@
          :else
          (when (or (not query?) need-query?)
            (try
-             (let [{:keys [data ref-pages-count ref-matched-children-ids properties]}
-                   (c.m/<?
-                    (<load-view-data view-entity
-                                     (cond->
-                                      {:view-for-id (or (:db/id (:logseq.property/view-for view-entity))
-                                                        (:db/id view-parent))
-                                       :view-feature-type view-feature-type
-                                       :group-by-property-ident group-by-property-ident
-                                       :input input
-                                       :filters filters
-                                       :sorting sorting}
-                                       query?
-                                       (assoc :query-entity-ids query-entity-ids))))]
+             (let [opts (cond->
+                         {:view-for-id (or (:db/id (:logseq.property/view-for view-entity))
+                                           (:db/id view-parent))
+                          :view-feature-type view-feature-type
+                          :group-by-property-ident group-by-property-ident
+                          :input input
+                          :filters filters
+                          :sorting sorting}
+                          query?
+                          (assoc :query-entity-ids query-entity-ids))
+                   {:keys [data ref-pages-count ref-matched-children-ids properties]}
+                   (c.m/<? (<load-view-data view-entity opts))]
                (set-data! data)
                (when ref-pages-count
                  (set-ref-pages-count! ref-pages-count)
                  (set-ref-matched-children-ids! ref-matched-children-ids))
                (set-properties! properties))
              (finally
-               (set-loading! false)))))))))
+               (set-loading! false)
+               (when (contains? #{:class-objects :property-objects} view-feature-type)
+                 (when-let [*objects-ready? (:*objects-ready? config)]
+                   (reset! *objects-ready? true)))))))))))
 
 (rum/defc view-aux
   [view-entity {:keys [config view-parent view-feature-type data query-entity-ids set-view-entity!] :as option}]
@@ -2101,7 +2103,7 @@
         [ref-pages-count set-ref-pages-count!] (hooks/use-state nil)
         [ref-matched-children-ids set-ref-matched-children-ids!] (hooks/use-state nil)
         load-view-data (fn load-view-data []
-                         (load-view-data-aux view-entity view-parent
+                         (load-view-data-aux config view-entity view-parent
                                              {:query? query?
                                               :query-entity-ids query-entity-ids
                                               :sorting sorting :filters filters :input input

src/main/frontend/worker/db_worker.cljs

@@ -43,7 +43,6 @@
             [logseq.db.common.view :as db-view]
             [logseq.db.frontend.schema :as db-schema]
             [logseq.db.sqlite.create-graph :as sqlite-create-graph]
-            [logseq.db.sqlite.debug :as sqlite-debug]
             [logseq.db.sqlite.export :as sqlite-export]
             [logseq.db.sqlite.gc :as sqlite-gc]
             [logseq.db.sqlite.util :as sqlite-util]
@@ -456,27 +455,22 @@
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (:db/id (first (:block/_alias (d/entity @conn id))))))
 
+(defn- search-blocks
+  [repo q option]
+  (p/let [search-db (get-search-db repo)
+          conn (worker-state/get-datascript-conn repo)]
+    (search/search-blocks repo conn search-db q option)))
+
 (def-thread-api :thread-api/block-refs-check
   [repo id {:keys [unlinked?]}]
   (when-let [conn (worker-state/get-datascript-conn repo)]
     (let [db @conn
-          block (d/entity db id)
-          db-based? (entity-plus/db-based-graph? db)]
+          block (d/entity db id)]
       (if unlinked?
-        (let [title (string/lower-case (:block/title block))]
-          (when-not (string/blank? title)
-            (let [datoms (d/datoms db :avet :block/title)]
-              (if db-based?
-                (some (fn [d]
-                        (and (not= id (:e d)) (string/includes? (string/lower-case (:v d)) title)))
-                      datoms)
-                (some (fn [d]
-                        (and (not= id (:e d))
-                             (string/includes? (string/lower-case (:v d)) title)
-                             (let [refs (map :db/id (:block/refs (d/entity db (:e d))))]
-                               (contains? (set refs) (:e d)))))
-                      datoms)))))
-        (> (ldb/get-block-refs-count db (:db/id block)) 0)))))
+        (p/let [title (string/lower-case (:block/title block))
+                result (search-blocks repo title {:limit 3})]
+          (boolean (some (fn [b] (not= id (:db/id b))) result)))
+        (some? (first (:block/_refs block)))))))
 
 (def-thread-api :thread-api/get-block-parents
   [repo id depth]
@@ -569,9 +563,7 @@
 
 (def-thread-api :thread-api/search-blocks
   [repo q option]
-  (p/let [search-db (get-search-db repo)
-          conn (worker-state/get-datascript-conn repo)]
-    (search/search-blocks repo conn search-db q option)))
+  (search-blocks repo q option))
 
 (def-thread-api :thread-api/search-upsert-blocks
   [repo blocks]

src/main/frontend/worker/export.cljs

@@ -1,11 +1,9 @@
 (ns frontend.worker.export
   "Export data"
-  (:require [cljs-bean.core :as bean]
-            [datascript.core :as d]
+  (:require [datascript.core :as d]
             [frontend.common.file.core :as common-file]
             [logseq.db :as ldb]
             [logseq.db.sqlite.create-graph :as sqlite-create-graph]
-            [logseq.db.sqlite.util :as sqlite-util]
             [logseq.graph-parser.property :as gp-property]
             [logseq.outliner.tree :as otree]))