revert xform

deps.edn

@@ -45,7 +45,6 @@
   com.cognitect/transit-cljs            {:mvn/version "0.8.280"}
   missionary/missionary                 {:mvn/version "b.46"}
   meander/epsilon                       {:mvn/version "0.0.650"}
-  net.cgrand/xforms                     {:mvn/version "0.19.6"}
 
   io.github.open-spaced-repetition/cljc-fsrs {:git/sha "eeef3520df664e51c3d0ba2031ec2ba071635442"
                                               :git/url "https://github.com/open-spaced-repetition/cljc-fsrs"}

deps/db/src/logseq/db/common/entity_plus.cljc

@@ -9,7 +9,6 @@
             [cljs.core]
             [clojure.data :as data]
             [datascript.core :as d]
-            [datascript.impl.entity :as de]
             [datascript.impl.entity :as entity :refer [Entity]]
             [logseq.common.util.date-time :as date-time-util]
             [logseq.db.frontend.content :as db-content]
@@ -75,13 +74,6 @@
         (d/entity db eid)))
     (d/entity db eid)))
 
-(defn unsafe->Entity
-  "Faster version of d/entity without checking e exists.
-  Only use it in performance-critical areas and where the existence of 'e' is confirmed."
-  [db e]
-  {:pre [(pos-int? e)]}
-  (de/->Entity db e (volatile! false) (volatile! {})))
-
 (defn db-based-graph?
   "Whether the current graph is db-only"
   [db]

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

@@ -12,8 +12,7 @@
             [logseq.db.frontend.class :as db-class]
             [logseq.db.frontend.db :as db-db]
             [logseq.db.frontend.entity-util :as entity-util]
-            [logseq.db.frontend.rules :as rules]
-            [net.cgrand.xforms :as x]))
+            [logseq.db.frontend.rules :as rules]))
 
 ;; FIXME: For DB graph built-in pages, look up by name -> uuid like
 ;; get-built-in-page instead of this approach which is more error prone
@@ -37,29 +36,16 @@
 
 (defn get-block-alias
   [db eid]
-  (d/q
-   '[:find [?e ...]
-     :in $ ?eid %
-     :where
-     (alias ?eid ?e)]
-   db
-   eid
-   (:alias rules/rules)))
-
-(defn get-blocks-aliases
-  "Return eid->aliases map"
-  [db eids]
-  (into
-   {}
-   (x/by-key (x/into []))
+  (->>
    (d/q
-    '[:find ?eid ?e
-      :in $ [?eid ...] %
+    '[:find [?e ...]
+      :in $ ?eid %
       :where
       (alias ?eid ?e)]
     db
-    eids
-    (:alias rules/rules))))
+    eid
+    (:alias rules/rules))
+   distinct))
 
 (comment
   (defn- get-built-in-files
@@ -178,35 +164,35 @@
         (assoc :db/id (:db/id entity)))))
 
 (defn hidden-ref?
-  "Whether ref-block should be hidden."
-  [db ref-block entity]
-  (let [db-based? (entity-plus/db-based-graph? db)
-        id (:db/id entity)]
+  "Whether ref-block (for block with the `id`) should be hidden."
+  [db ref-block id]
+  (let [db-based? (entity-plus/db-based-graph? db)]
     (if db-based?
-      (or
-       (= (:db/id ref-block) id)
-       (= id (:db/id (:block/page ref-block)))
-       (= id (:db/id (:logseq.property/view-for ref-block)))
-       (entity-util/hidden? (:block/page ref-block))
-       (entity-util/hidden? ref-block)
-       (and (entity-util/class? entity)
-            (let [children (db-class/get-structured-children db id)
-                  class-ids (set (conj children id))]
-              (some class-ids (map :db/id (:block/tags ref-block)))))
-       (some? (get ref-block (:db/ident entity))))
+      (let [entity (d/entity db id)]
+        (or
+         (= (:db/id ref-block) id)
+         (= id (:db/id (:block/page ref-block)))
+         (= id (:db/id (:logseq.property/view-for ref-block)))
+         (entity-util/hidden? (:block/page ref-block))
+         (entity-util/hidden? ref-block)
+         (and (entity-util/class? entity)
+              (let [children (db-class/get-structured-children db id)
+                    class-ids (set (conj children id))]
+                (some class-ids (map :db/id (:block/tags ref-block)))))
+         (some? (get ref-block (:db/ident entity)))))
       (or
        (= (:db/id ref-block) id)
        (= id (:db/id (:block/page ref-block)))))))
 
 (defn get-block-refs
-  [db id & [e->aliases]]
-  (let [ent (d/entity db id)]
-    (eduction
-     (distinct)
-     (map #(d/entity db %))
-     (mapcat :block/_refs)
-     (remove (fn [ref-block] (hidden-ref? db ref-block ent)))
-     (cons id (if e->aliases (e->aliases id) (get-block-alias db id))))))
+  [db id]
+  (let [with-alias (->> (get-block-alias db id)
+                        (cons id)
+                        distinct)]
+    (some->> with-alias
+             (map #(d/entity db %))
+             (mapcat :block/_refs)
+             (remove (fn [ref-block] (hidden-ref? db ref-block id))))))
 
 (defn get-block-refs-count
   [db id]

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

@@ -67,8 +67,7 @@
   [db id ref-blocks children-ids]
   (when (seq ref-blocks)
     (let [children (->> children-ids
-                        (map (fn [id] (d/entity db id))))
-          ent (d/entity db id)]
+                        (map (fn [id] (d/entity db id))))]
       (->> (concat (mapcat #(get-path-refs db %) ref-blocks)
                    (mapcat :block/refs (concat ref-blocks children)))
            frequencies
@@ -76,26 +75,25 @@
                    (when (and (ldb/page? ref)
                               (not= (:db/id ref) id)
                               (not= :block/tags (:db/ident ref))
-                              (not (common-initial-data/hidden-ref? db ref ent)))
+                              (not (common-initial-data/hidden-ref? db ref id)))
                      [(:block/title ref) size])))
            (sort-by second #(> %1 %2))))))
 
 (defn- get-block-parents-until-top-ref
   [db id ref-id ref-block-ids *result]
-  (let [ent (d/entity db id)]
-    (loop [eid ref-id
-           parents' []]
-      (when eid
-        (cond
-          (contains? @*result eid)
-          (swap! *result into parents')
+  (loop [eid ref-id
+         parents' []]
+    (when eid
+      (cond
+        (contains? @*result eid)
+        (swap! *result into parents')
 
-          (contains? ref-block-ids eid)
-          (when-not (common-initial-data/hidden-ref? db (d/entity db eid) ent)
-            (swap! *result into (conj parents' eid)))
-          :else
-          (let [e (d/entity db eid)]
-            (recur (:db/id (:block/parent e)) (conj parents' eid))))))))
+        (contains? ref-block-ids eid)
+        (when-not (common-initial-data/hidden-ref? db (d/entity db eid) id)
+          (swap! *result into (conj parents' eid)))
+        :else
+        (let [e (d/entity db eid)]
+          (recur (:db/id (:block/parent e)) (conj parents' eid)))))))
 
 (defn get-linked-references
   [db id]

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

@@ -13,9 +13,7 @@
             [logseq.db.frontend.entity-util :as entity-util]
             [logseq.db.frontend.property :as db-property]
             [logseq.db.frontend.property.type :as db-property-type]
-            [logseq.db.frontend.rules :as rules]
-            [medley.core :as medley]
-            [net.cgrand.xforms :as x]))
+            [logseq.db.frontend.rules :as rules]))
 
 (def valid-type-for-sort? (some-fn number? string? boolean?))
 
@@ -82,37 +80,37 @@
   [db {:keys [id asc?] :as sorting} entities partition?]
   (let [property (or (d/entity db id) {:db/ident id})
         get-value-fn (memoize (get-value-for-sort property))
-        sorted-entities (cond
-                          (= id :block.temp/refs-count)
-                          (cond-> (sort-by :block.temp/refs-count entities)
-                            (not asc?) reverse
-                            true distinct)
-
-                          :else
-                          (let [ref-type? (= :db.type/ref (:db/valueType property))]
-                            (if (or ref-type? (not (contains?
-                                                    #{:block/updated-at :block/created-at :block/title}
-                                                    (:db/ident property))))
-                              (sort-ref-entities-by-single-property entities sorting get-value-fn)
-                              (let [{:keys [row-ids id->row]}
-                                    (x/transjuxt
-                                     {:row-ids (comp (map :db/id) (x/into #{}))
-                                      :id->row (comp (map (juxt :db/id identity)) (x/into {}))}
-                                     entities)
-                                    xforms
-                                    (comp
-                                     (medley/distinct-by :e)
-                                     (keep
-                                      (fn [d]
-                                        (when (row-ids (:e d))
-                                          (id->row (:e d)))))
-                                     (distinct)
-                                     (if partition? (partition-by get-value-fn) identity))]
-                                (into
-                                 (if asc? [] ())
-                                 xforms
-                                 (d/datoms db :avet id))))))]
-    sorted-entities))
+        sorted-entities (->>
+                         (cond
+                           (= id :block.temp/refs-count)
+                           (cond-> (sort-by :block.temp/refs-count entities)
+                             (not asc?)
+                             reverse)
+
+                           :else
+                           (let [ref-type? (= :db.type/ref (:db/valueType property))]
+                             (if (or ref-type? (not (contains?
+                                                     #{:block/updated-at :block/created-at :block/title}
+                                                     (:db/ident property))))
+                               (sort-ref-entities-by-single-property entities sorting get-value-fn)
+                               (let [datoms (cond->
+                                             (->> (d/datoms db :avet id)
+                                                  (common-util/distinct-by :e)
+                                                  vec)
+                                              (not asc?)
+                                              rseq)
+                                     row-ids (set (map :db/id entities))
+                                     id->row (zipmap (map :db/id entities) entities)]
+                                 (keep
+                                  (fn [d]
+                                    (when (row-ids (:e d))
+                                      (id->row (:e d))))
+                                  datoms)))))
+
+                         distinct)]
+    (if partition?
+      (partition-by get-value-fn sorted-entities)
+      sorted-entities)))
 
 (defn- sort-entities-by-minor-sorting
   "minor-sorting - [{:keys [id asc?]} ...]"
@@ -284,40 +282,28 @@
 
 (defn- get-exclude-page-ids
   [db]
-  (into #{}
-        (comp cat (map :e))
-        [(d/datoms db :avet :logseq.property/hide? true)
-         (d/datoms db :avet :logseq.property/built-in? true)
-         (d/datoms db :avet :block/tags (:db/id (d/entity db :logseq.class/Property)))]))
-
-(defn- get-entities-for-all-pages
-  [db sorting property-ident {:keys [db-based?]}]
+  (->>
+   (concat
+    (d/datoms db :avet :logseq.property/hide? true)
+    (d/datoms db :avet :logseq.property/built-in? true)
+    (d/datoms db :avet :block/tags (:db/id (d/entity db :logseq.class/Property))))
+   (map :e)
+   set))
+
+(defn- get-entities-for-all-pages [db sorting property-ident {:keys [db-based?]}]
   (let [refs-count? (and (coll? sorting) (some (fn [m] (= (:id m) :block.temp/refs-count)) sorting))
-        exclude-ids (when db-based? (get-exclude-page-ids db))
-        datoms (d/datoms db :avet property-ident)
-        datom->entity-xf1
-        (keep
-         (fn [d]
-           (if db-based?
-             (when-not (exclude-ids (:e d))
-               (entity-plus/unsafe->Entity db (:e d)))
-             (let [e (d/entity db (:e d))]
-               (when-not (or (ldb/hidden-or-internal-tag? e)
-                             (entity-util/property? e)
-                             (entity-util/built-in? e))
-                 e)))))
-        xfs (cond-> [(comp datom->entity-xf1 (x/into []))]
-              refs-count? (conj (comp datom->entity-xf1 (map :db/id) (x/into []))))
-        [ents eids] (x/transjuxt xfs datoms)
-        e->aliases (when refs-count? (common-initial-data/get-blocks-aliases db eids))]
-    (eduction
-     (if refs-count?
-       (map
-        #(assoc %
-                :block.temp/refs-count
-                (count (common-initial-data/get-block-refs db (:db/id %) e->aliases))))
-       identity)
-     ents)))
+        exclude-ids (when db-based? (get-exclude-page-ids db))]
+    (keep (fn [d]
+            (let [e (d/entity db (:e d))]
+              (when-not (if db-based?
+                          (exclude-ids (:db/id e))
+                          (or (ldb/hidden-or-internal-tag? e)
+                              (entity-util/property? e)
+                              (entity-util/built-in? e)))
+                (cond-> e
+                  refs-count?
+                  (assoc :block.temp/refs-count (common-initial-data/get-block-refs-count db (:e d)))))))
+          (d/datoms db :avet property-ident))))
 
 (defn- get-entities
   [db view feat-type property-ident view-for-id* sorting]
@@ -508,8 +494,8 @@
                                      (let [v (get by-value groups-sort-by-property-ident)]
                                        (if (and (= groups-sort-by-property-ident :block/journal-day) (not desc?)
                                                 (nil? (:block/journal-day by-value)))
-                                          ;; Use MAX_SAFE_INTEGER so non-journal pages (without :block/journal-day) are sorted
-                                          ;; after all journal pages when sorting by journal date.
+                                         ;; Use MAX_SAFE_INTEGER so non-journal pages (without :block/journal-day) are sorted
+                                         ;; after all journal pages when sorting by journal date.
                                          js/Number.MAX_SAFE_INTEGER
                                          v))
                                      group-by-closed-values?
@@ -550,18 +536,11 @@
                                         (map :db/id)))]
                        [by-value' group]))
                    result)
-                  (mapv :db/id result))]
+                  (map :db/id result))]
       (cond->
        {:count (count filtered-entities)
-        :data (into [] (distinct) data')}
+        :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 query entities-result))))))
-
-(comment
-  (def entities (get-view-entities db 78982 {:group-by-property-ident nil, :view-for-id 152, :sorting [{:id :block/updated-at, :asc? false}], :view-feature-type :all-pages, :input "", :filters {}}))
-
-  (def entities2 (get-view-entities db 78982 {:group-by-property-ident nil, :view-for-id 152, :sorting [{:id :block.temp/refs-count, :asc? false} {:id :block/updated-at, :asc? false}], :view-feature-type :all-pages, :input "", :filters {}}))
-
-  (time (vec (take 10 entities2))))