perf: don't load block children if collapsed

Author: tiensonqin

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

@@ -146,7 +146,7 @@
         (d/pull-many db '[*] ids')))))
 
 (defn get-block-and-children
-  [db id {:keys [children? nested-children? including-property-vals? properties]
+  [db id {:keys [children? children-only? nested-children? including-property-vals? properties children-props]
           :or {including-property-vals? true}}]
   (let [block (d/entity db (if (uuid? id)
                              [:block/uuid id]
@@ -157,52 +157,48 @@
                            :block/tags :block/page]
         block-refs-count? (some #{:block.temp/refs-count} properties)]
     (when block
-      (let [block' (if (seq properties)
-                     (select-keys block properties)
-                     block)
-            block' (cond->
-                    (if (or children? nested-children?)
-                      (mark-block-fully-loaded block')
-                      block')
-                     including-property-vals?
-                     (update-vals (fn [v]
-                                    (cond
-                                      (de/entity? v)
-                                      (select-keys v property-value-ks)
+      (let [children (when (or children? children-only?)
+                       (let [page? (common-entity-util/page? block)
+                             children (cond
+                                        (and nested-children? (not page?))
+                                        (get-block-children db (:block/uuid block))
+                                        nested-children?
+                                        (:block/_page block)
+                                        :else
+                                        (let [short-page? (when page?
+                                                            (<= (count (:block/_page block)) 100))]
+                                          (if short-page?
+                                            (:block/_page block)
+                                            (:block/_parent block))))
+                             children-props (or children-props [:db/id :block/uuid :block/parent :block/order :block/collapsed?])]
+                         (map
+                          (fn [block]
+                            (select-keys block children-props))
+                          children)))]
+        (if children-only?
+          {:children children}
+          (let [block' (if (seq properties)
+                         (select-keys block properties)
+                         block)
+                block' (cond->
+                        (mark-block-fully-loaded block')
+                         including-property-vals?
+                         (update-vals (fn [v]
+                                        (cond
+                                          (de/entity? v)
+                                          (select-keys v property-value-ks)
 
-                                      (and (coll? v) (every? de/entity? v))
-                                      (map #(select-keys % property-value-ks) v)
+                                          (and (coll? v) (every? de/entity? v))
+                                          (map #(select-keys % property-value-ks) v)
 
-                                      :else
-                                      v)))
-                     block-refs-count?
-                     (assoc :block.temp/refs-count (count (:block/_refs block))))]
-        (cond->
-         {:block (assoc (into {} block') :db/id (:db/id block))}
-          children?
-          (assoc :children
-                 (let [page? (common-entity-util/page? block)
-                       children (if (and nested-children? (not page?))
-                                  (get-block-children db (:block/uuid block))
-                                  (if page?
-                                    (:block/_page block)
-                                    (:block/_parent block)))
-                       long-page? (and (> (count children) 500) (not (common-entity-util/whiteboard? block)))]
-                   (if long-page?
-                     (->> (map (fn [e]
-                                 (select-keys e [:db/id :block/uuid :block/page :block/order :block/parent :block/collapsed? :block/link]))
-                               children)
-                          (map #(with-block-link db %)))
-                     (->> (d/pull-many db '[*] (map :db/id children))
-                          (map #(with-block-refs db %))
-                          (map #(with-block-link db %))
-                          (mapcat (fn [block]
-                                    (let [e (d/entity db (:db/id block))]
-                                      (conj
-                                       (if (seq (:block/properties e))
-                                         (vec (property-with-values db e nil))
-                                         [])
-                                       block)))))))))))))
+                                          :else
+                                          v)))
+                         block-refs-count?
+                         (assoc :block.temp/refs-count (count (:block/_refs block))))]
+            (cond->
+             {:block (assoc (into {} block') :db/id (:db/id block))}
+              children?
+              (assoc :children children))))))))
 
 (defn get-latest-journals
   [db]

src/main/electron/listener.cljs

@@ -5,23 +5,23 @@
             [clojure.string :as string]
             [dommy.core :as dom]
             [electron.ipc :as ipc]
+            [frontend.db :as db]
+            [frontend.db.async :as db-async]
             [frontend.db.model :as db-model]
             [frontend.fs.sync :as sync]
             [frontend.fs.watcher-handler :as watcher-handler]
             [frontend.handler.file-sync :as file-sync-handler]
             [frontend.handler.notification :as notification]
+            [frontend.handler.property.util :as pu]
             [frontend.handler.route :as route-handler]
+            [frontend.handler.search :as search-handler]
             [frontend.handler.ui :as ui-handler]
             [frontend.handler.user :as user]
-            [frontend.handler.search :as search-handler]
             [frontend.state :as state]
             [frontend.ui :as ui]
             [logseq.common.path :as path]
             [logseq.common.util :as common-util]
-            [promesa.core :as p]
-            [frontend.handler.property.util :as pu]
-            [frontend.db :as db]
-            [frontend.db.async :as db-async]))
+            [promesa.core :as p]))
 
 (defn- safe-api-call
   "Force the callback result to be nil, otherwise, ipc calls could lead to
@@ -87,7 +87,7 @@
                          (route-handler/redirect-to-page! page-name {:block-id block-id}))
 
                        block-id
-                       (p/let [block (db-async/<get-block (state/get-current-repo) block-id)]
+                       (p/let [block (db-async/<get-block (state/get-current-repo) block-id {:children? false})]
                          (if block
                            (if (pu/shape-block? block)
                              (route-handler/redirect-to-page! (get-in block [:block/page :block/uuid]) {:block-id block-id})

src/main/frontend/components/block.cljs

@@ -3630,6 +3630,12 @@
                                    (select-keys (first (:rum/args new-state)) config-compare-keys)))]
     (boolean result)))
 
+(defn- set-collapsed-block!
+  [block-id v]
+  (if (false? v)
+    (editor-handler/expand-block! block-id {:skip-db-collpsing? true})
+    (state/set-collapsed-block! block-id v)))
+
 (rum/defcs loaded-block-container < rum/reactive db-mixins/query
   (rum/local false ::show-block-left-menu?)
   (rum/local false ::show-block-right-menu?)
@@ -3642,14 +3648,14 @@
              (cond
                (and (:page-title? config) (or (ldb/class? block) (ldb/property? block)) (not config/publishing?))
                (let [collapsed? (state/get-block-collapsed block-id)]
-                 (state/set-collapsed-block! block-id (if (some? collapsed?) collapsed? true)))
+                 (set-collapsed-block! block-id (if (some? collapsed?) collapsed? true)))
 
                (root-block? config block)
-               (state/set-collapsed-block! block-id false)
+               (set-collapsed-block! block-id false)
 
                (or (:ref? config) (:custom-query? config) (:view? config))
-               (state/set-collapsed-block! block-id
-                                           (boolean (editor-handler/block-default-collapsed? block config)))
+               (set-collapsed-block! block-id
+                                     (boolean (editor-handler/block-default-collapsed? block config)))
 
                :else
                nil)
@@ -3664,7 +3670,7 @@
                    (let [[config block] (:rum/args state)
                          block-id (:block/uuid block)]
                      (when (root-block? config block)
-                       (state/set-collapsed-block! block-id nil)))
+                       (set-collapsed-block! block-id nil)))
                    state)}
   [state config block & {:as opts}]
   (let [repo (state/get-current-repo)
@@ -3699,10 +3705,17 @@
       (hooks/use-effect!
        (fn []
          (p/do!
-          (db-async/<get-block (state/get-current-repo) (:db/id block*))
+          (db-async/<get-block (state/get-current-repo)
+                               (:db/id block*)
+                               {:children? (not
+                                            (if-some [result (state/get-block-collapsed (:block/uuid block))]
+                                              result
+                                              (:block/collapsed? block)))
+                                :skip-refresh? true})
           (set-block! (some-> (:db/id block*) db/entity))))
        []))
-    (loaded-block-container config block opts)))
+    (when (or (:view? config) (:block.temp/fully-loaded? block))
+      (loaded-block-container config block opts))))
 
 (defn divide-lists
   [[f & l]]

src/main/frontend/components/page.cljs

@@ -485,10 +485,11 @@
   [e *control-show? *all-collapsed?]
   (util/stop e)
   (reset! *control-show? true)
-  (let [all-collapsed?
-        (->> (editor-handler/all-blocks-with-level {:collapse? true})
-             (filter (fn [b] (editor-handler/collapsable? (:block/uuid b))))
-             (empty?))]
+  (p/let [blocks (editor-handler/<all-blocks-with-level {:collapse? true})
+          all-collapsed?
+          (->> blocks
+               (filter (fn [b] (editor-handler/collapsable? (:block/uuid b))))
+               (empty?))]
     (reset! *all-collapsed? all-collapsed?)))
 
 (defn- page-mouse-leave
@@ -670,7 +671,7 @@
                                         :preview? preview?})))
                (lsp-pagebar-slot)])
 
-            (when (and db-based? sidebar?)
+            (when (and db-based? sidebar? (ldb/page? page))
               [:div.-mb-8
                (sidebar-page-properties config page)])
 

src/main/frontend/components/property/config.cljs

@@ -757,8 +757,7 @@
                  repo (state/get-current-repo)
                  property (first (:rum/args state))
                  ident (:db/ident property)]
-             (p/let [_ (db-async/<get-block repo (:block/uuid property))
-                     result (db-async/<get-property-values ident)]
+             (p/let [result (db-async/<get-property-values ident)]
                (reset! *values result))
              (assoc state ::values *values)))}
   [state property* owner-block opts]

src/main/frontend/components/query/result.cljs

@@ -47,7 +47,8 @@
             (util/react (query-dsl/query (state/get-current-repo) q {:cards? (:cards? config)}))))
 
         :else
-        (util/react (query-custom/custom-query query {:current-block-uuid current-block-uuid})))
+        (util/react (query-custom/custom-query query {:current-block-uuid current-block-uuid
+                                                      :built-in-query? (:built-in-query? config)})))
       (catch :default e
         (reset! *query-error e)))))
 

src/main/frontend/components/views.cljs

@@ -579,7 +579,7 @@
         sized-columns (get-in table [:state :sized-columns])
         row-cell-f (fn [column {:keys [_lazy?]}]
                      (when-let [render (get column :cell)]
-                       (let [id (str row "-" (:id column))
+                       (let [id (str (:id row) "-" (:id column))
                              width (get-column-size column sized-columns)
                              select? (= (:id column) :select)
                              add-property? (= (:id column) :add-property)
@@ -1234,7 +1234,7 @@
           (let [[first-block-id blocks] row]
             [:div
              {:key (str "partition-" first-block-id)}
-             [:div.ml-2
+             [:div.ml-6.text-sm.opacity-70.hover:opacity-100.mt-1
               (breadcrumb (assoc config :list-view? true)
                           (state/get-current-repo) first-block-id
                           {:show-page? false})]

src/main/frontend/db/async.cljs

@@ -100,7 +100,7 @@
 
 (defonce *block-cache (atom (cache/lru-cache-factory {} :threshold 1000)))
 (defn <get-block
-  [graph id-uuid-or-name & {:keys [children? skip-transact? skip-refresh? block-only? _properties]
+  [graph id-uuid-or-name & {:keys [children? nested-children? skip-transact? skip-refresh? block-only? children-only? _properties]
                             :or {children? true}
                             :as opts}]
 
@@ -124,7 +124,9 @@
                (and (util/uuid-string? name') name')
                id-uuid-or-name)]
     (cond
-      (:block.temp/fully-loaded? e)
+      (and (:block.temp/fully-loaded? e) ; children may not be fully loaded
+           (not children-only?)
+           (not nested-children?))
       e
 
       cached-response
@@ -139,18 +141,23 @@
           (state/update-state! :db/async-query-loading (fn [s] (disj s name')))
           (if skip-transact?
             (reset! *block-cache (cache/miss @*block-cache cache-key
-                                             (if (or children? block-only?)
+                                             (if (and (not children-only?) (or children? block-only?))
                                                (:block result')
                                                result')))
             (let [conn (db/get-db graph false)
-                  block-and-children (cons block children)
-                  affected-keys [[:frontend.worker.react/block (:db/id block)]]]
-              (d/transact! conn (remove (fn [b] (:block.temp/fully-loaded? (db/entity (:db/id b)))) block-and-children))
+                  block-and-children (if block (cons block children) children)
+                  affected-keys [[:frontend.worker.react/block (:db/id block)]]
+                  tx-data (remove (fn [b] (:block.temp/fully-loaded? (db/entity (:db/id b)))) block-and-children)]
+              (when (seq tx-data) (d/transact! conn tx-data))
               (when-not skip-refresh?
                 (react/refresh-affected-queries! graph affected-keys))))
 
-          (if (or children? block-only?)
+          (cond
+            children-only?
+            children
+            (or children? block-only?)
             block
+            :else
             result'))))))
 
 (defn <get-blocks

src/main/frontend/db/react.cljs

@@ -86,11 +86,17 @@
     (:result result)))
 
 (defn- <q-aux
-  [repo db query-fn async-query-fn inputs-fn k query inputs]
+  [repo db query-fn async-query-fn inputs-fn k query inputs built-in-query?]
   (let [kv? (and (vector? k) (= :kv (second k)))
         q (if util/node-test?
             (fn [query inputs] (apply d/q query db inputs))
-            (fn [query inputs] (apply db-async-util/<q repo {} (cons query inputs))))]
+            (fn [query inputs]
+              (let [q-f #(apply db-async-util/<q repo {} (cons query inputs))]
+                (if built-in-query?
+                  ;; delay built-in-queries to not block journal rendering
+                  (p/let [_ (p/delay 100)]
+                    (q-f))
+                  (q-f)))))]
     (when (or query-fn async-query-fn query kv?)
       (cond
         async-query-fn
@@ -113,7 +119,8 @@
         (q query nil)))))
 
 (defn q
-  [repo k {:keys [use-cache? transform-fn query-fn async-query-fn inputs-fn disable-reactive? return-promise?]
+  [repo k {:keys [use-cache? transform-fn query-fn async-query-fn inputs-fn
+                  disable-reactive? return-promise? built-in-query?]
            :or {use-cache? true
                 transform-fn identity}} query & inputs]
   ;; {:pre [(s/valid? :frontend.worker.react/block k)]}
@@ -128,7 +135,7 @@
         (if (and use-cache? result-atom)
           result-atom
           (let [result-atom (or result-atom (atom nil))
-                p-or-value (<q-aux repo db query-fn async-query-fn inputs-fn k query inputs)]
+                p-or-value (<q-aux repo db query-fn async-query-fn inputs-fn k query inputs built-in-query?)]
             (when-not disable-reactive?
               (add-q! k query inputs result-atom transform-fn query-fn async-query-fn inputs-fn))
             (cond
@@ -162,9 +169,9 @@
         (ldb/get-page (conn/get-db) page)))))
 
 (defn- execute-query!
-  [graph db k {:keys [query inputs transform-fn query-fn async-query-fn inputs-fn result]
+  [graph db k {:keys [query inputs transform-fn query-fn async-query-fn inputs-fn result built-in-query?]
                :or {transform-fn identity}}]
-  (p/let [p-or-value (<q-aux graph db query-fn async-query-fn inputs-fn k query inputs)
+  (p/let [p-or-value (<q-aux graph db query-fn async-query-fn inputs-fn k query inputs built-in-query?)
           result' (transform-fn p-or-value)]
     (when-not (= result' result)
       (set-new-result! k result'))))

src/main/frontend/extensions/fsrs.cljs

@@ -1,6 +1,7 @@
 (ns frontend.extensions.fsrs
   "Flashcards functions based on FSRS, only works in db-based graphs"
   (:require [clojure.string :as string]
+            [frontend.common.missionary :as c.m]
             [frontend.components.block :as component-block]
             [frontend.config :as config]
             [frontend.context.i18n :refer [t]]
@@ -16,7 +17,6 @@
             [frontend.state :as state]
             [frontend.ui :as ui]
             [frontend.util :as util]
-            [frontend.common.missionary :as c.m]
             [logseq.db :as ldb]
             [logseq.db.frontend.entity-plus :as entity-plus]
             [logseq.shui.ui :as shui]
@@ -189,7 +189,7 @@
 (rum/defcs ^:private card-view < rum/reactive db-mixins/query
   {:will-mount (fn [state]
                  (when-let [[repo block-id _] (:rum/args state)]
-                   (db-async/<get-block repo block-id))
+                   (db-async/<get-block repo block-id {:children? false}))
                  state)}
   [state repo block-id *card-index *phase]
   (when-let [block-entity (db/sub-block block-id)]