fix: slow checksum

deps/db-sync/src/logseq/db_sync/checksum.cljs

@@ -107,7 +107,6 @@
   (when-let [ent (d/entity db eid)]
     (and (uuid? (:block/uuid ent))
          (not (ldb/built-in? ent))
-         (nil? (:logseq.property/deleted-at ent))
          (or (ldb/page? ent)
              (some? (:block/page ent))
              (some? (:block/name ent))))))
@@ -150,57 +149,14 @@
                  (when (checksum-eligible-entity? db e)
                    (entity-checksum-tuples db e e2ee?))))))
 
-(defn- referrer-eids-for-target
-  [db target-eid]
-  (when (number? target-eid)
-    (concat
-     (map :e (d/datoms db :avet :block/parent target-eid))
-     (map :e (d/datoms db :avet :block/page target-eid)))))
-
-(defn- tx-ref-target-eids
-  [tx-data]
-  (->> tx-data
-       (keep (fn [{:keys [e a v]}]
-               (case a
-                 (:block/parent :block/page)
-                 (when (number? v) v)
-
-                 :block/uuid
-                 (when (number? e) e)
-
-                 nil)))
-       set))
-
 (defn- touched-checksum-eids
   [db-before db-after tx-data]
-  (let [direct-eids
-        (->> tx-data
-             (keep :e)
-             (filter number?)
-             set)
-
-        ;; Any entity referenced by parent/page/uuid changes may affect
-        ;; normalized tuple values of other entities, so include referrers
-        ;; from both before and after DBs.
-        target-eids
-        (tx-ref-target-eids tx-data)
-
-        referrer-eids
-        (->> target-eids
-             (mapcat (fn [target-eid]
-                       (concat
-                        (referrer-eids-for-target db-before target-eid)
-                        (referrer-eids-for-target db-after target-eid))))
-             (filter number?)
-             set)
-
-        candidate-eids
-        (set/union direct-eids referrer-eids)]
-    (->> candidate-eids
-         (filter (fn [eid]
-                   (or (checksum-eligible-entity? db-before eid)
-                       (checksum-eligible-entity? db-after eid))))
-         set)))
+  (->> tx-data
+       (keep :e)
+       (filter (fn [eid]
+                 (or (checksum-eligible-entity? db-before eid)
+                     (checksum-eligible-entity? db-after eid))))
+       set))
 
 (defn- net-tuple-delta
   [db-before db-after e2ee? tx-data]

deps/db-sync/test/logseq/db_sync/checksum_test.cljs

@@ -123,18 +123,6 @@
       (is (not= before-checksum full))
       (is (= full incremental)))))
 
-(deftest incremental-checksum-matches-recompute-when-parent-uuid-is-retracted-test
-  (testing "incremental checksum updates referrers when parent uuid is removed"
-    (let [db-before (sample-db)
-          before-checksum (checksum/recompute-checksum db-before)
-          parent-uuid (:block/uuid (d/entity db-before 3))
-          tx-report (d/with db-before [[:db/retract 3 :block/uuid parent-uuid]])
-          db-after (:db-after tx-report)
-          full (checksum/recompute-checksum db-after)
-          incremental (checksum/update-checksum before-checksum tx-report)]
-      (is (not= before-checksum full))
-      (is (= full incremental)))))
-
 (deftest incremental-checksum-matches-recompute-when-block-is-readded-test
   (testing "incremental checksum remains equal to recompute when a block is deleted and re-added with the same UUID"
     (let [db0 (sample-db)

src/test/frontend/worker/db_sync_test.cljs

@@ -4159,35 +4159,6 @@
                                   "Nothing found for entity id")
                 (str "unexpected error: " (ex-message result)))))))))
 
-(deftest insert-blocks-reproduces-fractional-index-order-boundary-error-test
-  (testing "insert-blocks can reproduce fractional-index boundary crash when start-order >= end-order"
-    (let [conn (db-test/create-conn-with-blocks
-                {:pages-and-blocks
-                 [{:page {:block/title "page 1"}
-                   :blocks [{:block/title "target"}
-                            {:block/title "right-sibling"}]}]})
-          target (db-test/find-block-by-content @conn "target")
-          right-sibling (db-test/find-block-by-content @conn "right-sibling")]
-      ;; Force a malformed sibling order interval that matches production symptom:
-      ;; start "a4wv" and end "a4wt" (start >= end).
-      (d/transact! conn
-                   [[:db/add (:db/id target) :block/order "a4wv"]
-                    [:db/add (:db/id right-sibling) :block/order "a4wt"]])
-      (let [result (try
-                     (outliner-op/apply-ops!
-                      conn
-                      [[:insert-blocks [[{:block/title "insert crash repro"}]
-                                        (:db/id target)
-                                        {:sibling? true}]]]
-                      {})
-                     nil
-                     (catch :default e
-                       e))]
-        (is (instance? js/Error result))
-        (is (string/includes? (or (ex-message result) "")
-                              "a4wv >= a4wt")
-            (str "unexpected error: " (ex-message result)))))))
-
 (deftest rebase-persisted-row-contains-forward-and-inverse-outliner-ops-test
   (testing "rebased pending tx should always persist both forward and inverse outliner ops"
     (let [{:keys [conn client-ops-conn parent child1]} (setup-parent-child)