datahike-browser-tests 1.0.0

package/test/datahike/test/lookup_refs_test.cljc

@@ -0,0 +1,266 @@
+(ns datahike.test.lookup-refs-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is are deftest testing]]
+      :clj  [clojure.test :as t :refer        [is are deftest testing]])
+   [datahike.api :as d]
+   [datahike.db :as db]
+   [datahike.test.core-test :as tdc]))
+
+#?(:cljs (def Throwable js/Error))
+
+(deftest test-lookup-refs
+  (let [db (d/db-with (db/empty-db {:name  {:db/unique :db.unique/identity}
+                                    :email {:db/unique :db.unique/value}})
+                      [{:db/id 1 :name "Ivan" :email "@1" :age 35}
+                       {:db/id 2 :name "Petr" :email "@2" :age 22}])]
+
+    (are [eid res] (= (tdc/entity-map db eid) res)
+      [:name "Ivan"]   {:db/id 1 :name "Ivan" :email "@1" :age 35}
+      [:email "@1"]    {:db/id 1 :name "Ivan" :email "@1" :age 35}
+      [:name "Sergey"] nil
+      [:name nil]      nil)
+
+    (are [eid msg] (thrown-with-msg? Throwable msg (d/entity db eid))
+      [:name]     #"Lookup ref should contain 2 elements"
+      [:name 1 2] #"Lookup ref should contain 2 elements"
+      [:age 10]   #"Lookup ref attribute should be marked as :db/unique")))
+
+(deftest test-lookup-refs-transact
+  (let [db (d/db-with (db/empty-db {:name    {:db/unique :db.unique/identity}
+                                    :friend  {:db/valueType :db.type/ref}})
+                      [{:db/id 1 :name "Ivan"}
+                       {:db/id 2 :name "Petr"}])]
+    (are [tx res] (= res (tdc/entity-map (d/db-with db tx) 1))
+      ;; Additions
+      [[:db/add [:name "Ivan"] :age 35]]
+      {:db/id 1 :name "Ivan" :age 35}
+
+      [{:db/id [:name "Ivan"] :age 35}]
+      {:db/id 1 :name "Ivan" :age 35}
+
+      [[:db/add 1 :friend [:name "Petr"]]]
+      {:db/id 1 :name "Ivan" :friend {:db/id 2}}
+
+      [[:db/add 1 :friend [:name "Petr"]]]
+      {:db/id 1 :name "Ivan" :friend {:db/id 2}}
+
+      [{:db/id 1 :friend [:name "Petr"]}]
+      {:db/id 1 :name "Ivan" :friend {:db/id 2}}
+
+      [{:db/id 2 :_friend [:name "Ivan"]}]
+      {:db/id 1 :name "Ivan" :friend {:db/id 2}}
+
+      ;; lookup refs are resolved at intermediate DB value
+      [[:db/add 3 :name "Oleg"]
+       [:db/add 1 :friend [:name "Oleg"]]]
+      {:db/id 1 :name "Ivan" :friend {:db/id 3}}
+
+      ;; CAS
+      [[:db.fn/cas [:name "Ivan"] :name "Ivan" "Oleg"]]
+      {:db/id 1 :name "Oleg"}
+
+      [[:db/add 1 :friend 1]
+       [:db.fn/cas 1 :friend [:name "Ivan"] 2]]
+      {:db/id 1 :name "Ivan" :friend {:db/id 2}}
+
+      [[:db/add 1 :friend 1]
+       [:db.fn/cas 1 :friend 1 [:name "Petr"]]]
+      {:db/id 1 :name "Ivan" :friend {:db/id 2}}
+
+      ;; Retractions
+      [[:db/add 1 :age 35]
+       [:db/retract [:name "Ivan"] :age 35]]
+      {:db/id 1 :name "Ivan"}
+
+      [[:db/add 1 :friend 2]
+       [:db/retract 1 :friend [:name "Petr"]]]
+      {:db/id 1 :name "Ivan"}
+
+      [[:db/add 1 :age 35]
+       [:db.fn/retractAttribute [:name "Ivan"] :age]]
+      {:db/id 1 :name "Ivan"}
+
+      [[:db.fn/retractEntity [:name "Ivan"]]]
+      {:db/id 1})
+
+    (are [tx msg] (thrown-with-msg? Throwable msg (d/db-with db tx))
+      [{:db/id [:name "Oleg"], :age 10}]
+      #"Nothing found for entity id"
+
+      [[:db/add [:name "Oleg"] :age 10]]
+      #"Nothing found for entity id")))
+
+(deftest test-lookup-refs-transact-multi
+  (let [db (d/db-with (db/empty-db {:name    {:db/unique :db.unique/identity}
+                                    :friends {:db/valueType :db.type/ref
+                                              :db/cardinality :db.cardinality/many}})
+                      [{:db/id 1 :name "Ivan"}
+                       {:db/id 2 :name "Petr"}
+                       {:db/id 3 :name "Oleg"}
+                       {:db/id 4 :name "Sergey"}])]
+    (are [tx res] (= (tdc/entity-map (d/db-with db tx) 1) res)
+      ;; Additions
+      [[:db/add 1 :friends [:name "Petr"]]]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2}}}
+
+      [[:db/add 1 :friends [:name "Petr"]]
+       [:db/add 1 :friends [:name "Oleg"]]]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2} {:db/id 3}}}
+
+      [{:db/id 1 :friends [:name "Petr"]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2}}}
+
+      [{:db/id 1 :friends [[:name "Petr"]]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2}}}
+
+      [{:db/id 1 :friends [[:name "Petr"] [:name "Oleg"]]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2} {:db/id 3}}}
+
+      [{:db/id 1 :friends [2 [:name "Oleg"]]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2} {:db/id 3}}}
+
+      [{:db/id 1 :friends [[:name "Petr"] 3]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2} {:db/id 3}}}
+
+      ;; reverse refs
+      [{:db/id 2 :_friends [:name "Ivan"]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2}}}
+
+      [{:db/id 2 :_friends [[:name "Ivan"]]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2}}}
+
+      [{:db/id 2 :_friends [[:name "Ivan"] [:name "Oleg"]]}]
+      {:db/id 1 :name "Ivan" :friends #{{:db/id 2}}})))
+
+(deftest lookup-refs-index-access
+  (let [db (d/db-with (db/empty-db {:name    {:db/unique :db.unique/identity}
+                                    :friends {:db/valueType :db.type/ref
+                                              :db/cardinality :db.cardinality/many}})
+                      [{:db/id 1 :name "Ivan" :friends [2 3]}
+                       {:db/id 2 :name "Petr" :friends 3}
+                       {:db/id 3 :name "Oleg"}])]
+    (are [index attrs datoms] (= (map (juxt :e :a :v) (apply d/datoms db index attrs)) datoms)
+      :eavt [[:name "Ivan"]]
+      [[1 :friends 2] [1 :friends 3] [1 :name "Ivan"]]
+
+      :eavt [[:name "Ivan"] :friends]
+      [[1 :friends 2] [1 :friends 3]]
+
+      :eavt [[:name "Ivan"] :friends [:name "Petr"]]
+      [[1 :friends 2]]
+
+      :aevt [:friends [:name "Ivan"]]
+      [[1 :friends 2] [1 :friends 3]]
+
+      :aevt [:friends [:name "Ivan"] [:name "Petr"]]
+      [[1 :friends 2]]
+
+      :avet [:friends [:name "Oleg"]]
+      [[1 :friends 3] [2 :friends 3]]
+
+      :avet [:friends [:name "Oleg"] [:name "Ivan"]]
+      [[1 :friends 3]])
+
+    (are [index attrs resolved-attrs] (= (vec (apply d/seek-datoms db index attrs))
+                                         (vec (apply d/seek-datoms db index resolved-attrs)))
+      :eavt [[:name "Ivan"]] [1]
+      :eavt [[:name "Ivan"] :name] [1 :name]
+      :eavt [[:name "Ivan"] :friends [:name "Oleg"]] [1 :friends 3]
+
+      :aevt [:friends [:name "Petr"]] [:friends 2]
+      :aevt [:friends [:name "Ivan"] [:name "Oleg"]] [:friends 1 3]
+
+      :avet [:friends [:name "Oleg"]] [:friends 3]
+      :avet [:friends [:name "Oleg"] [:name "Petr"]] [:friends 3 2])
+
+    (are [attr start end datoms] (= (map (juxt :e :a :v) (d/index-range db {:attrid attr :start start :end end})) datoms)
+      :friends [:name "Oleg"] [:name "Oleg"]
+      [[1 :friends 3] [2 :friends 3]]
+
+      :friends [:name "Petr"] [:name "Petr"]
+      [[1 :friends 2]]
+
+      :friends [:name "Petr"] [:name "Oleg"]
+      [[1 :friends 2] [1 :friends 3] [2 :friends 3]])))
+
+(deftest test-lookup-refs-query
+  (let [schema {:name   {:db/unique :db.unique/identity}
+                :friend {:db/valueType :db.type/ref}}
+        db (d/db-with (db/empty-db schema)
+                      [{:db/id 1 :id 1 :name "Ivan" :age 11 :friend 2}
+                       {:db/id 2 :id 2 :name "Petr" :age 22 :friend 3}
+                       {:db/id 3 :id 3 :name "Oleg" :age 33}])]
+    (is (= (set (d/q '[:find ?e ?v
+                       :in $ ?e
+                       :where [?e :age ?v]]
+                     db [:name "Ivan"]))
+           #{[[:name "Ivan"] 11]}))
+
+    (is (= (set (d/q '[:find [?v ...]
+                       :in $ [?e ...]
+                       :where [?e :age ?v]]
+                     db [[:name "Ivan"] [:name "Petr"]]))
+           #{11 22}))
+
+    (is (= (set (d/q '[:find [?e ...]
+                       :in $ ?v
+                       :where [?e :friend ?v]]
+                     db [:name "Petr"]))
+           #{1}))
+
+    (is (= (set (d/q '[:find [?e ...]
+                       :in $ [?v ...]
+                       :where [?e :friend ?v]]
+                     db [[:name "Petr"] [:name "Oleg"]]))
+           #{1 2}))
+
+    (is (= (d/q '[:find ?e ?v
+                  :in $ ?e ?v
+                  :where [?e :friend ?v]]
+                db [:name "Ivan"] [:name "Petr"])
+           #{[[:name "Ivan"] [:name "Petr"]]}))
+
+    (is (= (d/q '[:find ?e ?v
+                  :in $ [?e ...] [?v ...]
+                  :where [?e :friend ?v]]
+                db [[:name "Ivan"] [:name "Petr"] [:name "Oleg"]]
+                [[:name "Ivan"] [:name "Petr"] [:name "Oleg"]])
+           #{[[:name "Ivan"] [:name "Petr"]]
+             [[:name "Petr"] [:name "Oleg"]]}))
+
+    (is (= (d/q '[:find ?e
+                  :in $ [?e ...]
+                  :where [?e :friend 3]]
+                db [1 2 3 "A"])
+           #{[2]}))
+
+    (let [db2 (d/db-with (db/empty-db schema)
+                         [{:db/id 3 :name "Ivan" :id 3}
+                          {:db/id 1 :name "Petr" :id 1}
+                          {:db/id 2 :name "Oleg" :id 2}])]
+      (is (= (d/q '[:find ?e ?e1 ?e2
+                    :in $1 $2 [?e ...]
+                    :where [$1 ?e :id ?e1]
+                    [$2 ?e :id ?e2]]
+                  db db2 [[:name "Ivan"] [:name "Petr"] [:name "Oleg"]])
+             #{[[:name "Ivan"] 1 3]
+               [[:name "Petr"] 2 1]
+               [[:name "Oleg"] 3 2]})))
+
+    (testing "inline refs"
+      (is (= (d/q '[:find ?v
+                    :where [[:name "Ivan"] :friend ?v]]
+                  db)
+             #{[2]}))
+
+      (is (= (d/q '[:find ?e
+                    :where [?e :friend [:name "Petr"]]]
+                  db)
+             #{[1]}))
+
+      (is (thrown-with-msg? Throwable #"Nothing found for entity id"
+                            (d/q '[:find ?e
+                                   :where [[:name "Valery"] :friend ?e]]
+                                 db))))))
+
+

package/test/datahike/test/lru_test.cljc

@@ -0,0 +1,27 @@
+(ns datahike.test.lru-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [are deftest]]
+      :clj  [clojure.test :as t :refer        [are deftest]])
+   [datahike.lru :as lru]))
+
+(deftest test-lru
+  (let [l0 (lru/lru 2)
+        l1 (assoc l0 :a 1)
+        l2 (assoc l1 :b 2)
+        l3 (assoc l2 :c 3)
+        l4 (assoc l3 :b 4)
+        l5 (assoc l4 :d 5)]
+    (are [l k v] (= (get l k) v)
+      l0 :a nil
+      l1 :a 1
+      l2 :a 1
+      l2 :b 2
+      l3 :a nil ;; :a get evicted on third insert
+      l3 :b 2
+      l3 :c 3
+      l4 :b 2 ;; assoc updates access time, but does not change a value
+      l4 :c 3
+      l5 :b 2   ;; :b remains
+      l5 :c nil ;; :c gets evicted as the oldest one
+      l5 :d 5)))
+

package/test/datahike/test/migrate_test.clj

@@ -0,0 +1,297 @@
+(ns datahike.test.migrate-test
+  (:require [clojure.test :refer :all]
+            [datahike.api :as d]
+            [datahike.datom :as datom]
+            [datahike.migrate :as m]
+            [datahike.db.utils :as dbu]
+            [datahike.test.utils :as utils]))
+
+(def tx-data [[:db/add 1 :db/cardinality :db.cardinality/one 536870913 true]
+              [:db/add 1 :db/ident :name 536870913 true]
+              [:db/add 1 :db/index true 536870913 true]
+              [:db/add 1 :db/unique :db.unique/identity 536870913 true]
+              [:db/add 1 :db/valueType :db.type/string 536870913 true]
+              [:db/add 2 :db/cardinality :db.cardinality/one 536870913 true]
+              [:db/add 2 :db/ident :age 536870913 true]
+              [:db/add 2 :db/valueType :db.type/long 536870913 true]
+              [:db/add 3 :age 25 536870913 true]
+              [:db/add 3 :name "Alice" 536870913 true]
+              [:db/add 4 :age 35 536870913 true]
+              [:db/add 4 :name "Bob" 536870913 true]])
+
+(def tx-meta [[:db/ident :db.install/attribute 536870912 true]
+              [:db/doc "An attribute's cardinality" 536870912 true]
+              [:db/valueType 28 536870912 true]
+              [:db/ident :db.type/instant 536870912 true]
+              [:db/ident :db.type/bigint 536870912 true]
+              [:db/cardinality 11 536870912 true]
+              [:db/ident :db/txInstant 536870912 true]
+              [:db/ident :db/isComponent 536870912 true]
+              [:db/ident :db/unique 536870912 true]
+              [:db/ident :db/valueType 536870912 true]
+              [:db/valueType 26 536870912 true]
+              [:db/ident :db.type/valueType 536870912 true]
+              [:db/ident :db.type/unique 536870912 true]
+              [:db/ident :db.part/tx 536870912 true]
+              [:db/ident :db/tupleAttrs 536870912 true]
+              [:db/doc "An attribute's unique selection" 536870912 true]
+              [:db/doc "An attribute's history selection" 536870912 true]
+              [:db/txInstant #inst "1970-01-01T00:00:00.000-00:00" 536870912 true]
+              [:db/ident :db.type/boolean 536870912 true]
+              [:db/valueType 31 536870912 true]
+              [:db/ident :db/noHistory 536870912 true]
+              [:db/valueType 17 536870912 true]
+              [:db/ident :db.type/float 536870912 true]
+              [:db/ident :db.part/sys 536870912 true]
+              [:db/ident :db/index 536870912 true]
+              [:db/noHistory true 536870912 true]
+              [:db/ident :db.part/user 536870912 true]
+              [:db/ident :db.type/tuple 536870912 true]
+              [:db/ident :db/doc 536870912 true]
+              [:db/ident :db/tupleType 536870912 true]
+              [:db/doc
+               "An attribute's or specification's identifier"
+               536870912
+               true]
+              [:db/ident :db.type/uuid 536870912 true]
+              [:db/doc "Only for interoperability with Datomic" 536870912 true]
+              [:db/ident :db.type/cardinality 536870912 true]
+              [:db/valueType 30 536870912 true]
+              [:db/ident :db/cardinality 536870912 true]
+              [:db/ident :db.cardinality/one 536870912 true]
+              [:db/ident :db.unique/identity 536870912 true]
+              [:db/valueType 23 536870912 true]
+              [:db/ident :db.type/number 536870912 true]
+              [:db/unique 33 536870912 true] [:db/ident :db/ident 536870912 true]
+              [:db/ident :db.type/ref 536870912 true]
+              [:db/ident :db.type/bigdec 536870912 true]
+              [:db/ident :db/tupleTypes 536870912 true]
+              [:db/ident :db.type/symbol 536870912 true]
+              [:db/valueType 22 536870912 true]
+              [:db/doc "An attribute's index selection" 536870912 true]
+              [:db/doc "A transaction's time-point" 536870912 true]
+              [:db/index true 536870912 true]
+              [:db/ident :db.type.install/attribute 536870912 true]
+              [:db/ident :db.unique/value 536870912 true]
+              [:db/valueType 19 536870912 true]
+              [:db/ident :db.type/long 536870912 true]
+              [:db/ident :db.cardinality/many 536870912 true]
+              [:db/ident :db.type/string 536870912 true]
+              [:db/ident :db.type/double 536870912 true]
+              [:db/doc "An attribute's value type" 536870912 true]
+              [:db/doc "An attribute's documentation" 536870912 true]
+              [:db/ident :db.type/keyword 536870912 true]])
+
+(deftest export-import-test
+  (let [os-prefix (case (System/getProperty "os.name")
+                    "Windows 10" (System/getProperty "java.io.tmpdir")
+                    "/tmp/")
+        old-path (str os-prefix "old-db")
+        new-path (str os-prefix "new-db")
+        export-path (str os-prefix "eavt-dump")
+        base-config {:store {:backend :file}
+                     :schema-flexibility :write
+                     :keep-history? false
+                     :attribute-refs? false}
+        add-uuid (fn [cfg] (assoc-in cfg [:store :id] (java.util.UUID/randomUUID)))
+        schema [{:db/ident       :name
+                 :db/cardinality :db.cardinality/one
+                 :db/index       true
+                 :db/unique      :db.unique/identity
+                 :db/valueType   :db.type/string}
+                {:db/ident       :parents
+                 :db/cardinality :db.cardinality/many
+                 :db/valueType   :db.type/ref}
+                {:db/ident       :age
+                 :db/cardinality :db.cardinality/one
+                 :db/valueType   :db.type/long}]
+        tx-data {:tx-data [{:name "Alice" :age  25}
+                           {:name "Bob" :age  35}
+                           {:name    "Charlie"
+                            :age     5
+                            :parents [[:name "Alice"] [:name "Bob"]]}
+                           {:name "Daisy" :age 20}
+                           {:name "Erhard" :age 20}]}]
+
+    (testing "Same configuration roundtrip for exporting and importing."
+      (doseq [hist [true false]
+              attr-ref [true false]]
+        (let [cfg (merge base-config
+                         {:keep-history? hist
+                          :attribute-refs? attr-ref})
+              old-cfg (add-uuid (assoc-in cfg [:store :path] (str old-path (utils/get-time))))
+              old-conn (utils/setup-db old-cfg)
+              new-cfg (add-uuid (assoc-in cfg [:store :path] (str new-path (utils/get-time))))
+              new-conn (utils/setup-db new-cfg)]
+          (d/transact old-conn schema)
+          (d/transact old-conn tx-data)
+          (d/transact old-conn {:tx-data [[:db/retractEntity [:name "Erhard"]]]})
+          (m/export-db old-conn export-path)
+          (m/import-db new-conn export-path)
+          (is (= (d/datoms (if (:keep-history? cfg) (d/history @old-conn) @old-conn) :eavt)
+                 (filter #(< (:e %) (:max-tx @new-conn))
+                         (d/datoms (if (:keep-history? cfg) (d/history @new-conn) @new-conn) :eavt))))
+          (d/release old-conn)
+          (d/release new-conn)
+          (d/delete-database old-cfg)
+          (d/delete-database new-cfg))))
+
+    (testing "Export history database, import non-history database"
+      (let [old-cfg (-> base-config
+                        (assoc-in [:store :path] (str old-path (utils/get-time)))
+                        (assoc :keep-history? true)
+                        add-uuid)
+            old-conn (utils/setup-db old-cfg)
+            new-cfg (-> base-config
+                        (assoc-in [:store :path] (str new-path (utils/get-time)))
+                        (assoc :keep-history? false)
+                        add-uuid)
+            new-conn (utils/setup-db new-cfg)]
+        (d/transact old-conn schema)
+        (d/transact old-conn tx-data)
+        (m/export-db old-conn export-path)
+        (m/import-db new-conn export-path)
+        (is (= (d/datoms @old-conn :eavt)
+               (d/datoms @new-conn :eavt)))
+        (d/release old-conn)
+        (d/release new-conn)
+        (d/delete-database old-cfg)
+        (d/delete-database new-cfg)))
+
+    (testing "Export non-history database, import history database"
+      (let [old-cfg (-> base-config
+                        (assoc-in [:store :path] (str old-path (utils/get-time)))
+                        (assoc :keep-history? false)
+                        add-uuid)
+            old-conn (utils/setup-db old-cfg)
+            new-cfg (-> base-config
+                        (assoc-in [:store :path] (str new-path (utils/get-time)))
+                        (assoc :keep-history? true)
+                        add-uuid)
+            new-conn (utils/setup-db new-cfg)]
+        (d/transact old-conn schema)
+        (d/transact old-conn tx-data)
+        (m/export-db old-conn export-path)
+        (m/import-db new-conn export-path)
+        (is (= (d/datoms @old-conn :eavt)
+               (filter #(< (:e %) (:max-tx @new-conn))
+                       (d/datoms @new-conn :eavt))))
+        (d/release old-conn)
+        (d/release new-conn)
+        (d/delete-database old-cfg)
+        (d/delete-database new-cfg)))))
+
+(deftest load-entities-test
+  (testing "Test migrate simple datoms without attribute refs"
+    (let [source-datoms (->> tx-data
+                             (mapv #(-> % rest vec))
+                             (concat [[536870913 :db/txInstant #inst "2020-03-11T14:54:27.979-00:00" 536870913 true]]))
+          cfg           {:store         {:backend :memory
+                                         :id      #uuid "001d0000-0000-0000-0000-00000000001d"}
+                         :keep-history? true
+                         :attribute-refs false}
+          conn (utils/setup-db cfg)]
+      @(d/load-entities conn source-datoms)
+      (is (= (into #{} source-datoms)
+             (d/q '[:find ?e ?a ?v ?t ?op :where [?e ?a ?v ?t ?op]] @conn)))
+      (d/release conn)))
+  (testing "Test migrate simple datoms with attribute refs"
+    (let [source-datoms (->> tx-data
+                             (mapv #(-> % rest vec))
+                             (concat [[536870913 :db/txInstant #inst "2020-03-11T14:54:27.979-00:00" 536870913 true]]))
+          cfg           {:store         {:backend :memory
+                                         :id      #uuid "001e0000-0000-0000-0000-00000000001e"}
+                         :keep-history? true
+                         :attribute-refs? true
+                         :schema-flexibility :write}
+          conn (utils/setup-db cfg)]
+      @(d/load-entities conn source-datoms)
+      (is (= (into #{} (->> source-datoms
+                            (mapv (comp vec rest))
+                            (concat tx-meta)))
+             (d/q '[:find ?a ?v ?t ?op
+                    :where
+                    [?e ?attr ?v ?t ?op]
+                    [?attr :db/ident ?a]] @conn)))
+      (d/release conn))))
+
+(deftest load-entities-history-test
+  (testing "Migrate predefined set with historical data"
+    (let [source-cfg {:store              {:backend :memory
+                                           :id      #uuid "001f0000-0000-0000-0000-00000000001f"}
+                      :name               "load-entities-history-test-source"
+                      :keep-history?      true
+                      :schema-flexibility :write
+                      :search-cache-size  0
+                      :store-cache-size   1
+                      :attribute-refs?    false}
+          schema      [{:db/ident       :name
+                        :db/cardinality :db.cardinality/one
+                        :db/index       true
+                        :db/unique      :db.unique/identity
+                        :db/valueType   :db.type/string}]
+          source-conn (utils/setup-db source-cfg)
+          txs         [schema
+                       [{:name "Alice"} {:name "Bob"}]
+                       [{:name "Charlie"} {:name "Daisy"}]
+                       [[:db/retractEntity [:name "Alice"]]]]
+          _           (doseq [tx-data txs]
+                        (d/transact source-conn {:tx-data tx-data}))
+          datoms-to-export (d/datoms (d/history @source-conn) :eavt)
+
+          ;; The datoms to export must primarily
+          ;; be sorted by transaction entity id
+          ;; and secondarily so that datoms with attribute `:db/txInstant`
+          ;; come before other datoms
+          export-data (->> datoms-to-export
+                           (map (comp vec seq))
+                           (sort-by (fn [[e a v tx]]
+                                      [tx
+
+                                       ;; TODO: It seems as if :db/txInstant
+                                       ;; datoms must come first. Is this a bug
+                                       ;; in load-entities?
+                                       (case a
+                                         :db/txInstant 0
+                                         1)]))
+                           (into []))
+          target-cfg  (-> source-cfg
+                          (assoc-in [:store :id] #uuid "00200000-0000-0000-0000-000000000020")
+                          (assoc-in [:name] "load-entities-history-test-target"))
+          target-conn (utils/setup-db target-cfg)
+          _           @(d/load-entities target-conn export-data)
+          current-q   (fn [conn] (d/q
+                                  '[:find ?n
+                                    :where
+                                    [?e :name ?n]]
+                                  @conn))
+          history-q   (fn [conn] (d/q '[:find ?n ?t ?op
+                                        :where
+                                        [?e :name ?n ?t ?op]]
+                                      (d/history @conn)))]
+      (is (dbu/distinct-sorted-datoms? :eavt datoms-to-export))
+      (is (= (current-q source-conn)
+             (current-q target-conn)))
+      (is (= (history-q source-conn)
+             (history-q target-conn)))
+      (d/release source-conn)
+      (d/release target-conn))))
+
+(deftest test-binary-support
+  (let [config {:store {:backend :memory
+                        :id #uuid "00210000-0000-0000-0000-000000000021"}
+                :schema-flexibility :read
+                :keep-history? false}
+        export-path "/tmp/test-export-binary-support"
+        conn (utils/setup-db config)
+        import-conn (utils/setup-db)]
+    (d/transact conn [{:db/id 1, :name "Jiayi", :payload (byte-array [0 2 3])}
+                      {:db/id 2, :name "Peter", :payload (byte-array [1 2 3])}])
+    (m/export-db conn export-path)
+    (m/import-db import-conn export-path)
+    (is (utils/all-true? (map #(or (= %1 %2) (utils/all-eq? (nth %1 2) (nth %2 2)))
+                              (d/datoms @conn :eavt)
+                              (filter #(< (datom/datom-tx %) (:max-tx @import-conn))
+                                      (d/datoms @import-conn :eavt)))))
+    (d/release conn)
+    (d/release import-conn)))