datahike-browser-tests 1.0.0

package/test/datahike/test/attribute_refs/query_test.cljc

@@ -0,0 +1,241 @@
+(ns datahike.test.attribute-refs.query-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj [clojure.test :as t :refer [is deftest testing]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               shift-entities
+                                               wrap-direct-datoms]]
+   [datahike.api :as d])
+  #?(:clj
+     (:import [clojure.lang ExceptionInfo])))
+
+(deftest test-joins
+  (let [entities [{:db/id 1, :name "Ivan", :age 15}
+                  {:db/id 2, :name "Petr", :age 37}
+                  {:db/id 4, :age 15}]
+        db (d/db-with ref-db (shift-entities ref-e0 entities))]
+    (is (= (d/q '[:find ?e
+                  :where [?e :name]] db)
+           #{[(+ ref-e0 1)] [(+ ref-e0 2)]}))
+    (is (= (d/q '[:find ?v
+                  :where [?e :name "Ivan"]
+                  [?e :age ?v]] db)
+           #{[15]}))
+    (is (= (d/q '[:find ?e1 ?e2
+                  :where [?e1 :name ?n]
+                  [?e2 :name ?n]] db)
+           #{[(+ ref-e0 1) (+ ref-e0 1)] [(+ ref-e0 2) (+ ref-e0 2)]}))
+    (is (= (d/q '[:find ?e ?e2 ?n
+                  :where [?e :name "Ivan"]
+                  [?e :age ?a]
+                  [?e2 :age ?a]
+                  [?e2 :name ?n]] db)
+           #{[(+ ref-e0 1) (+ ref-e0 1) "Ivan"]}))))
+
+(deftest test-q-many
+  (let [datoms [[1 :name "Ivan"]
+                [1 :aka "ivolga"]
+                [1 :aka "pi"]
+                [2 :name "Petr"]
+                [2 :aka "porosenok"]
+                [2 :aka "pi"]]
+        db (d/db-with ref-db (wrap-direct-datoms ref-db ref-e0 :db/add datoms))]
+    (is (= (d/q '[:find ?n1 ?n2
+                  :where [?e1 :aka ?x]
+                  [?e2 :aka ?x]
+                  [?e1 :name ?n1]
+                  [?e2 :name ?n2]] db)
+           #{["Ivan" "Ivan"]
+             ["Petr" "Petr"]
+             ["Ivan" "Petr"]
+             ["Petr" "Ivan"]}))))
+
+(deftest test-q-in
+  (let [entities [{:db/id 1, :name "Ivan", :age 15}
+                  {:db/id 2, :name "Petr", :age 37}]
+        db (d/db-with ref-db (shift-entities ref-e0 entities))
+        query '{:find [?e]
+                :in [$ ?attr ?value]
+                :where [[?e ?attr ?value]]}
+        ref (fn [key] (get-in db [:ident-ref-map key]))]
+    (is (= (d/q query db (ref :name) "Ivan")
+           #{[(+ ref-e0 1)]}))
+    (is (= (d/q query db (ref :age) 37)
+           #{[(+ ref-e0 2)]}))
+
+    (testing "DB join with collection"
+      (is (= (d/q '[:find ?e ?email
+                    :in $ $b
+                    :where [?e :name ?n]
+                    [$b ?n ?email]]
+                  db
+                  [["Ivan" "ivan@mail.ru"]
+                   ["Petr" "petr@gmail.com"]])
+             #{[(+ ref-e0 1) "ivan@mail.ru"]
+               [(+ ref-e0 2) "petr@gmail.com"]})))
+
+    (testing "Query without DB"
+      (is (= (d/q '[:find ?a ?b
+                    :in ?a ?b]
+                  10 20)
+             #{[10 20]})))))
+
+(deftest test-bindings
+  (let [entities [{:db/id 1, :name "Ivan", :age 15}
+                  {:db/id 2, :name "Petr", :age 37}]
+        db (d/db-with ref-db (shift-entities ref-e0 entities))]
+    (testing "Relation binding"
+      (is (= (d/q '[:find ?e ?email
+                    :in $ [[?n ?email]]
+                    :where [?e :name ?n]]
+                  db
+                  [["Ivan" "ivan@mail.ru"]
+                   ["Petr" "petr@gmail.com"]])
+             #{[(+ ref-e0 1) "ivan@mail.ru"]
+               [(+ ref-e0 2) "petr@gmail.com"]})))
+
+    (testing "Tuple binding"
+      (is (= (d/q '[:find ?e
+                    :in $ [?name ?age]
+                    :where [?e :name ?name]
+                    [?e :age ?age]]
+                  db ["Petr" 37])
+             #{[(+ ref-e0 2)]})))
+
+    (testing "Collection binding"
+      (is (= (d/q '[:find ?attr ?value
+                    :in $ ?e [?attr ...]
+                    :where [?e ?r ?value]
+                    [?r :db/ident ?attr]]
+                  db (+ ref-e0 1) [:name :age])
+             #{[:name "Ivan"] [:age 15]})))
+
+    #_(testing "Collection binding with direct attribute"   ;; TODO: make work in next query engine version
+        (is (= (d/q '[:find ?attr ?value
+                      :in $ ?e [?attr ...]
+                      :where [?e ?attr ?value]]
+                    db (+ ref-e0 1) [:name :age])
+               #{[:name "Ivan"] [:age 15]}))))
+
+  (testing "Placeholders"
+    (is (= (d/q '[:find ?x ?z
+                  :in [?x _ ?z]]
+                [:x :y :z])
+           #{[:x :z]}))
+    (is (= (d/q '[:find ?x ?z
+                  :in [[?x _ ?z]]]
+                [[:x :y :z] [:a :b :c]])
+           #{[:x :z] [:a :c]})))
+
+  (testing "Error reporting"
+    (is (thrown-with-msg? ExceptionInfo #"Cannot bind value :a to tuple \[\?a \?b\]"
+                          (d/q '[:find ?a ?b :in [?a ?b]] :a)))
+    (is (thrown-with-msg? ExceptionInfo #"Cannot bind value :a to collection \[\?a \.\.\.\]"
+                          (d/q '[:find ?a :in [?a ...]] :a)))
+    (is (thrown-with-msg? ExceptionInfo #"Not enough elements in a collection \[:a\] to bind tuple \[\?a \?b\]"
+                          (d/q '[:find ?a ?b :in [?a ?b]] [:a])))))
+
+(deftest test-nested-bindings
+  (is (= (d/q '[:find ?k ?v
+                :in [[?k ?v] ...]
+                :where [(> ?v 1)]]
+              {:a 1, :b 2, :c 3})
+         #{[:b 2] [:c 3]}))
+
+  (is (= (d/q '[:find ?k ?min ?max
+                :in [[?k ?v] ...] ?minmax
+                :where [(?minmax ?v) [?min ?max]]
+                [(> ?max ?min)]]
+              {:a [1 2 3 4]
+               :b [5 6 7]
+               :c [3]}
+              #(vector (reduce min %) (reduce max %)))
+         #{[:a 1 4] [:b 5 7]}))
+
+  (is (= (d/q '[:find ?k ?x
+                :in [[?k [?min ?max]] ...] ?range
+                :where [(?range ?min ?max) [?x ...]]
+                [(even? ?x)]]
+              {:a [1 7]
+               :b [2 4]}
+              range)
+         #{[:a 2] [:a 4] [:a 6]
+           [:b 2]})))
+
+(deftest test-offset
+  (let [entities [{:db/id 1, :name "Alice", :age 15}
+                  {:db/id 2, :name "Bob", :age 37}
+                  {:db/id 3, :name "Charlie", :age 37}]
+        db (d/db-with ref-db (shift-entities ref-e0 entities))]
+    (is (= (count (d/q {:query '[:find ?e :where [?e :name _]]
+                        :args [db]}))
+           3))
+    (is (= (count (d/q {:query '[:find ?e :where [?e :name _]]
+                        :args [db]
+                        :offset 1
+                        :limit 1}))
+           1))
+    (is (= (count (d/q {:query '[:find ?e :where [?e :name _]]
+                        :args [db]
+                        :limit 2}))
+           2))
+    (is (= (count (d/q {:query '[:find ?e :where [?e :name _]]
+                        :args [db]
+                        :offset 1
+                        :limit 2}))
+           2))
+    (is (= (count (d/q {:query '[:find ?e :where [?e :name _]]
+                        :args [db]
+                        :offset 2
+                        :limit 2}))
+           1))
+    (is (not (= (d/q {:query '[:find ?e :where [?e :name _]]
+                      :args [db]
+                      :limit 2})
+                (d/q {:query '[:find ?e :where [?e :name _]]
+                      :args [db]
+                      :offset 1
+                      :limit 2}))))
+    (is (= (d/q {:query '[:find ?e :where [?e :name _]]
+                 :args [db]
+                 :offset 4})
+           #{}))
+    (is (= (d/q {:query '[:find ?e :where [?e :name _]]
+                 :args [db]
+                 :offset 10
+                 :limit 5})
+           #{}))
+    (is (= (d/q {:query '[:find ?e :where [?e :name _]]
+                 :args [db]
+                 :offset 1
+                 :limit 0})
+           #{}))))
+
+(deftest test-return-maps
+  (let [entities [{:db/id 1, :name "Alice", :age 15}
+                  {:db/id 2, :name "Bob", :age 37}
+                  {:db/id 3, :name "Charlie", :age 37}]
+        db (d/db-with ref-db (shift-entities ref-e0 entities))]
+    (testing "returns map"
+      (is (map? (first (d/q {:query '[:find ?e :keys name :where [?e :name _]]
+                             :args [db]})))))
+    (testing "returns set without return-map"
+      (is (= #{["Charlie"] ["Alice"] ["Bob"]}
+             (d/q {:query '[:find ?name :where [_ :name ?name]]
+                   :args [db]}))))
+    (testing "returns map with key return-map"
+      (is (= #{{:foo (+ ref-e0 2)} {:foo (+ ref-e0 3)} {:foo (+ ref-e0 1)}}
+             (set (d/q {:query '[:find ?e :keys foo :where [?e :name _]]
+                        :args [db]})))))
+    (testing "returns map with string return-map"
+      (is (= [{"foo" "Charlie"} {"foo" "Alice"} {"foo" "Bob"}]
+             (d/q {:query '[:find ?name :strs foo :where [?e :name ?name]]
+                   :args [db]}))))
+    (testing "return map with keys using multiple find vars"
+      (is (= #{["Bob" {:age 37 :db/id  (+ ref-e0 2)}]
+               ["Charlie" {:age 37 :db/id  (+ ref-e0 3)}]
+               ["Alice" {:age 15 :db/id  (+ ref-e0 1)}]}
+             (into #{} (d/q {:find '[?name (pull ?e ?p)]
+                             :args [db '[:age :db/id]]
+                             :in '[$ ?p]
+                             :where '[[?e :name ?name]]})))))))

package/test/datahike/test/attribute_refs/temporal_search.cljc

@@ -0,0 +1,22 @@
+(ns datahike.test.attribute-refs.temporal-search
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest]]
+      :clj [clojure.test :refer [is deftest]])
+   [datahike.api :as d]))
+
+(deftest q-with-history-should-contain-sys-attributes
+  (let [cfg {:store {:backend :memory
+                     :id #uuid "00220000-0000-0000-0000-000000000022"}
+             :attribute-refs? true
+             :keep-history? true
+             :schema-flexibility :write}
+        conn (do (d/delete-database cfg)
+                 (d/create-database cfg)
+                 (d/connect cfg))
+        query '[:find ?e ?a ?v ?t ?s
+                :where [?e ?a ?v ?t ?s]]]
+    (is (= (d/q query @conn)
+           (d/q query (d/history @conn))))
+    (is (< 1
+           (count (d/q query (d/history @conn)))))
+    (d/release conn)))

package/test/datahike/test/attribute_refs/transact_test.cljc

@@ -0,0 +1,220 @@
+(ns datahike.test.attribute-refs.transact-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer        [is deftest testing]])
+   [datahike.api :as d]
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               setup-new-connection
+                                               wrap-direct-datoms]]))
+
+#?(:cljs (def Throwable js/Error))
+
+(deftest test-with
+  (let [datoms  [[1 :name "Ivan"]
+                 [1 :name "Petr"]
+                 [1 :aka  "Devil"]
+                 [1 :aka  "Tupen"]]
+        db  (d/db-with ref-db (wrap-direct-datoms ref-db ref-e0 :db/add datoms))]
+    (is (= (d/q '[:find ?v
+                  :in $ ?e
+                  :where [?e :name ?v]]
+                db (+ ref-e0 1))
+           #{["Petr"]}))
+    (is (= (d/q '[:find ?v
+                  :in $ ?e
+                  :where [?e :aka ?v]]
+                db (+ ref-e0 1))
+           #{["Devil"] ["Tupen"]}))
+
+    (testing "Retract"
+      (let [datoms2 [[1 :name "Petr"]
+                     [1 :aka "Devil"]]
+            db2 (d/db-with db (wrap-direct-datoms ref-db ref-e0 :db/retract datoms2))]
+        (is (= (d/q '[:find ?v
+                      :in $ ?e
+                      :where [?e :name ?v]]
+                    db2 (+ ref-e0 1))
+               #{}))
+        (is (= (d/q '[:find ?v
+                      :in $ ?e
+                      :where [?e :aka ?v]]
+                    db2 (+ ref-e0 1))
+               #{["Tupen"]}))
+
+        (is (= (into {} (d/entity db2 (+ ref-e0 1)))
+               {:aka #{"Tupen"}}))))
+
+    (testing "Cannot retract what's not there"
+      (let [datoms3 [[1 :name "Ivan"]]
+            db3 (d/db-with db (wrap-direct-datoms ref-db ref-e0 :db/retract datoms3))]
+        (is (= (d/q '[:find ?v
+                      :in $ ?e
+                      :where [?e :name ?v]]
+                    db3 (+ ref-e0 1))
+               #{["Petr"]}))))))
+
+(deftest test-retract-fns
+  (let [db (d/db-with ref-db
+                      [{:db/id (+ ref-e0 1), :name "Ivan", :age 15,
+                        :aka ["X" "Y" "Z"], :friend (+ ref-e0 2)}
+                       {:db/id (+ ref-e0 2), :name  "Petr", :age 37}])]
+    (let [db (d/db-with db [[:db.fn/retractEntity (+ ref-e0 1)]])]
+      (is (= (d/q '[:find ?a ?v
+                    :in $ ?e
+                    :where [?e ?a ?v]]
+                  db (+ ref-e0 1))
+             #{}))
+      (is (= (d/q '[:find ?a ?v
+                    :in $ ?e
+                    :where [?e ?r ?v]
+                    [?r :db/ident ?a]]
+                  db (+ ref-e0 2))
+             #{[:name "Petr"] [:age 37]})))
+
+    (is (= (d/db-with db [[:db.fn/retractEntity (+ ref-e0 1)]])
+           (d/db-with db [[:db/retractEntity (+ ref-e0 1)]])))
+
+    (testing "Retract entity with incoming refs"
+      (is (= (d/q '[:find ?e
+                    :in $ ?e1
+                    :where [?e1 :friend ?e]]
+                  db (+ ref-e0 1))
+             #{[(+ ref-e0 2)]}))
+
+      (let [db2 (d/db-with db [[:db.fn/retractEntity (+ ref-e0 2)]])]
+        (is (= (d/q '[:find ?e
+                      :in $ ?e1
+                      :where [?e1 :friend ?e]]
+                    db2 (+ ref-e0 1))
+               #{}))))
+
+    (let [name-ref (get-in db [:ident-ref-map :name])
+          db2 (d/db-with db [[:db.fn/retractAttribute (+ ref-e0 1) name-ref]])]
+      (is (= (d/q '[:find ?a ?v
+                    :in $ ?e
+                    :where [?e ?r ?v]
+                    [?r :db/ident ?a]]
+                  db2 (+ ref-e0 1))
+             #{[:age 15] [:aka "X"] [:aka "Y"] [:aka "Z"] [:friend (+ ref-e0 2)]}))
+      (is (= (d/q '[:find ?a ?v
+                    :in $ ?e
+                    :where [?e ?r ?v]
+                    [?r :db/ident ?a]]
+                  db2 (+ ref-e0 2))
+             #{[:name "Petr"] [:age 37]})))
+
+    (let [aka-ref (get-in db [:ident-ref-map :aka])
+          db2 (d/db-with db [[:db.fn/retractAttribute (+ ref-e0 1) aka-ref]])]
+      (is (= (d/q '[:find ?a ?v
+                    :in $ ?e
+                    :where [?e ?r ?v]
+                    [?r :db/ident ?a]]
+                  db2 (+ ref-e0 1))
+             #{[:name "Ivan"] [:age 15] [:friend (+ ref-e0 2)]}))
+      (is (= (d/q '[:find ?a ?v
+                    :in $ ?e
+                    :where [?e ?r ?v]
+                    [?r :db/ident ?a]]
+                  db2 (+ ref-e0 2))
+             #{[:name "Petr"] [:age 37]})))))
+
+(deftest test-db-fn-cas
+  (let [conn (setup-new-connection)
+        e0 (:max-eid @conn)
+        weight-ref (get-in @conn [:ident-ref-map :weight])]
+    (d/transact conn [[:db/cas (+ e0 1) weight-ref nil 100]])
+    (is (= (:weight (d/entity @conn (+ e0 1))) 100))
+    (d/transact conn [[:db/add (+ e0 1) weight-ref 200]])
+    (d/transact conn [[:db.fn/cas (+ e0 1) weight-ref 200 300]])
+    (is (= (:weight (d/entity @conn (+ e0 1))) 300))
+    (d/transact conn [[:db/cas (+ e0 1) weight-ref 300 400]])
+    (is (= (:weight (d/entity @conn (+ e0 1))) 400))
+    (is (thrown-with-msg? Throwable
+                          (re-pattern (str ":db\\.fn/cas failed on datom \\[" (+ ref-e0 1) " " weight-ref " 400\\], expected 200"))
+                          (d/transact conn [[:db.fn/cas (+ ref-e0 1) weight-ref 200 210]])))
+    (d/release conn))
+
+  (let [conn (setup-new-connection)
+        e0 (:max-eid @conn)
+        label-ref (get-in @conn [:ident-ref-map :label])]
+    (d/transact conn [[:db/add (+ e0 1) label-ref :x]])
+    (d/transact conn [[:db/add (+ e0 1) label-ref :y]])
+    (d/transact conn [[:db.fn/cas (+ e0 1) label-ref :y :z]])
+    (is (= (:label (d/entity @conn (+ e0 1))) #{:x :y :z}))
+    (is (thrown-with-msg? Throwable
+                          (re-pattern (str ":db\\.fn/cas failed on datom \\[" (+ ref-e0 1) " " label-ref " \\(:x :y :z\\)\\], expected :s"))
+                          (d/transact conn [[:db.fn/cas (+ ref-e0 1) label-ref :s :t]])))
+    (d/release conn))
+
+  (let [conn (setup-new-connection)
+        e0 (:max-eid @conn)
+        name-ref (get-in @conn [:ident-ref-map :name])
+        age-ref (get-in @conn [:ident-ref-map :age])]
+    (d/transact conn [[:db.fn/retractEntity (+ e0 1)]])
+    (d/transact conn [[:db/add (+ e0 1) name-ref "Ivan"]])
+    (d/transact conn [[:db.fn/cas (+ e0 1) age-ref nil 42]])
+    (is (= (:age (d/entity @conn (+ e0 1))) 42))
+    (is (thrown-with-msg? Throwable (re-pattern (str ":db\\.fn/cas failed on datom \\[" (+ ref-e0 1) " " age-ref " 42\\], expected nil"))
+                          (d/transact conn [[:db.fn/cas (+ ref-e0 1) age-ref nil 4711]])))
+    (d/release conn)))
+
+(deftest test-db-fn
+  (let [conn (setup-new-connection)
+        e0 (:max-eid @conn)
+        had-birthday-ref (get-in @conn [:ident-ref-map :had-birthday])
+        inc-age (fn [db name]
+                  (if-let [[eid age] (first (d/q '{:find [?e ?age]
+                                                   :in [$ ?name]
+                                                   :where [[?e :name ?name]
+                                                           [?e :age ?age]]}
+                                                 db name))]
+                    [{:db/id eid :age (inc age)} [:db/add eid had-birthday-ref true]]
+                    (throw (ex-info (str "No entity with name: " name) {}))))]
+    (d/transact conn [{:db/id (+ e0 1) :name "Ivan" :age 31}
+                      {:db/id (+ e0 1) :name "Petr"}
+                      {:db/id (+ e0 1) :aka "Devil"}
+                      {:db/id (+ e0 1) :aka "Tupen"}])
+
+    (is (= (d/q '[:find ?v ?a
+                  :where [?e :name ?v]
+                  [?e :age ?a]] @conn)
+           #{["Petr" 31]}))
+    (is (= (d/q '[:find ?v
+                  :where [?e :aka ?v]] @conn)
+           #{["Devil"] ["Tupen"]}))
+    (is (thrown-with-msg? Throwable #"No entity with name: Bob"
+                          (d/transact conn [[:db.fn/call inc-age "Bob"]])))
+    (let [{:keys [db-after]} (d/transact conn [[:db.fn/call inc-age "Petr"]])
+          e (d/entity db-after (+ e0 1))]
+      (is (= (:age e) 32))
+      (is (:had-birthday e)))
+    (d/release conn)))
+
+(deftest transact-with-ident-attrs
+  (let [conn (setup-new-connection)
+        e0 (:max-eid @conn)
+        i (inc e0)]
+    (d/transact conn [[:db/add i :aka "Devil"]])
+    (d/transact conn [[:db/add i :aka "Tupen"]])
+    (is (= #{["Devil"] ["Tupen"]}
+           (d/q `[:find ?v
+                  :where [~i :aka ?v]] @conn)))
+    (d/transact conn [[:db/retract i :aka  "Tupen"]])
+    (is (= #{["Devil"]}
+           (d/q `[:find ?v
+                  :where [~i :aka ?v]] @conn)))
+    (d/release conn)))
+
+(deftest test-tuples
+  (let [conn (setup-new-connection)]
+    (d/transact conn [#:db{:ident :mapping/attributes,
+                           :valueType :db.type/tuple,
+                           :tupleTypes
+                           [:db.type/keyword :db.type/keyword :db.type/keyword],
+                           :cardinality :db.cardinality/many}])
+    (d/transact conn [{:mapping/attributes [[:mapping :mapped-id :remote-id]]}])
+    (is (= #{[[:mapping :mapped-id :remote-id]]}
+           (d/q '[:find ?v
+                  :where [?e :mapping/attributes ?v]]
+                @conn)))
+    (d/release conn)))

package/test/datahike/test/attribute_refs/utils.cljc

@@ -0,0 +1,128 @@
+(ns datahike.test.attribute-refs.utils
+  (:require [datahike.api :as d]
+            [datahike.db.interface :as dbi])
+  #?(:clj (:import [java.util UUID])))
+
+(def ref-config {:store {:backend :memory
+                         :id #?(:clj (UUID/randomUUID) :cljs (random-uuid))}
+                 :writer {:backend :self}
+                 :attribute-refs? true
+                 :keep-history? false
+                 :schema-flexibility :write})
+
+(def test-schema
+  [{:db/ident       :name
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/string
+    :db/unique      :db.unique/identity}
+   {:db/ident       :mname
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/string}
+   {:db/ident       :aka
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/string}
+   {:db/ident       :age
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/long}
+   {:db/ident       :sex
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/string}
+   {:db/ident       :huh?
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/boolean}
+   {:db/ident       :father
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/ref}
+   {:db/ident       :parent
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/ref}
+   {:db/ident       :children
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/ref}
+   {:db/ident       :had-birthday
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/boolean}
+   {:db/ident       :weight
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/long}
+   {:db/ident       :height
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/long}
+   {:db/ident       :child
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/ref}
+   {:db/ident       :friend
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/ref}
+   {:db/ident       :enemy
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/ref}
+   {:db/ident       :label
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/keyword}
+   {:db/ident       :part
+    :db/valueType   :db.type/ref
+    :db/isComponent true
+    :db/cardinality :db.cardinality/many}
+   {:db/ident       :spec
+    :db/valueType   :db.type/ref
+    :db/isComponent true
+    :db/cardinality :db.cardinality/one}
+   {:db/ident       :attr
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/keyword}
+   {:db/ident       :follow
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/ref}
+   {:db/ident       :value
+    :db/cardinality :db.cardinality/many
+    :db/valueType   :db.type/long}
+   {:db/ident       :f1
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/ref}
+   {:db/ident       :f2
+    :db/cardinality :db.cardinality/one
+    :db/valueType   :db.type/ref}])
+
+(defn setup-new-connection []
+  (let [ref-config (assoc-in ref-config [:store :id] #?(:clj (UUID/randomUUID) :cljs (random-uuid)))]
+    (d/delete-database ref-config)
+    (d/create-database ref-config)
+    (let [conn (d/connect ref-config)]
+      (d/transact conn test-schema)
+      conn)))
+
+(def test-setup
+  (let [conn (setup-new-connection)
+        max-eid (:max-eid @conn)]
+    {:conn conn :db @conn :e0 max-eid}))
+
+(def ref-db (:db test-setup))
+(def ref-conn (:conn test-setup))
+(def ref-e0 (:e0 test-setup))
+
+(defn wrap-ref-datoms [db offset op datoms]
+  (mapv (fn [[e a v]] [op (+ offset e) (dbi/-ref-for db a) (+ offset v)])
+        datoms))
+
+(defn wrap-direct-datoms [db offset op datoms]
+  (mapv (fn [[e a v]] [op (+ offset e) (dbi/-ref-for db a) v])
+        datoms))
+
+(defn shift-entities [offset entities]
+  (mapv (fn [entity] (if (:db/id entity)
+                       (update entity :db/id (partial + offset))
+                       entity))
+        entities))
+
+(defn shift-in [coll-of-coll indices offset]
+  (into (empty coll-of-coll)
+        (map (fn [item] (reduce (fn [acc i] (update acc i + offset))
+                                item
+                                indices))
+             coll-of-coll)))
+
+(defn shift [coll offset]
+  (into (empty coll)
+        (map (partial + offset)
+             coll)))

package/test/datahike/test/cache_test.cljc

@@ -0,0 +1,38 @@
+(ns datahike.test.cache-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is are deftest testing]]
+      :clj  [clojure.test :as t :refer [is deftest]])
+   [datahike.api :as d]))
+
+(defn setup-db [cfg]
+  (d/delete-database cfg)
+  (d/create-database cfg)
+  (d/connect cfg))
+
+(deftest test-history-cache-miss
+  (let [cfg {:store              {:backend :memory
+                                  :id      #uuid "001a0000-0000-0000-0000-00000000001a"}
+             :name               "cache-test"
+             :keep-history?      true
+             :schema-flexibility :write
+             :search-cache-size  2
+             :attribute-refs?    true}
+        conn (setup-db cfg)
+        schema [{:db/ident       :name
+                 :db/cardinality :db.cardinality/one
+                 :db/index       true
+                 :db/unique      :db.unique/identity
+                 :db/valueType   :db.type/string}]]
+    (d/transact conn {:tx-data schema})
+
+    (d/transact conn {:tx-data [{:name "Alice"}
+                                {:name "Bob"}]})
+
+    (d/transact conn [[:db/retractEntity [:name "Alice"]]])
+    (is (= #{["Bob" true] ["Alice" false] ["Alice" true]}
+           (d/q {:query '[:find ?n ?op
+                          :where
+                          [?e :name ?n _ ?op]]
+                 :args  [(d/history @conn)]})))
+    (d/release conn)))
+