datahike-browser-tests 1.0.0

package/src-hitchhiker-tree/datahike/index/hitchhiker_tree/upsert.cljc

@@ -0,0 +1,128 @@
+(ns ^:no-doc datahike.index.hitchhiker-tree.upsert
+  (:require [datahike.index.utils :as diu]
+            [hitchhiker.tree :as tree]
+            [hitchhiker.tree.op :as op]))
+
+(defn- increase-by-one?
+  "Returns true if elements in vector 'indices' form a prefix of the vector indices.
+  This is equivalent to check whether the elements increase by one and contains 0.
+  E.g., [0 1 2] => true, [0 2 3] => false, [1 2] => false."
+  [indices]
+  (if (.contains ^clojure.lang.PersistentVector indices 0)
+    (let [m (apply max indices)
+          s (apply + indices)]
+      (= s (/ (* m (+ 1 m)) 2)))
+    false))
+
+(def prefix? (memoize increase-by-one?))
+
+(defn mask [new indices]
+  (reduce (fn [mask pos]
+            (assoc mask pos (nth new pos)))
+          [nil nil nil nil]
+          indices))
+
+(defn old-key
+  "Returns the old version of the given 'new' key if it exists in 'old-keys'.
+  'indices' is a vector of integer indicating which positions in keys are significant,
+  i.e., [0 2] means that the first and third entry in the key are used for filtering."
+  [old-keys new indices]
+  (when (seq old-keys)
+    (let [mask (mask new indices)]
+      (when-let [candidates (subseq old-keys >= mask)]
+        (when (or (not (prefix? indices))
+                  (diu/equals-on-indices? new (-> candidates first first) indices))
+          (let [res (->> candidates
+                         (map first)
+                         ;; Returns the key which has not been retracted.
+                         ;; There will at most be one such key.
+                         ;; Because of the ordering in keys, we know that
+                         ;; when two successive keys have a positive
+                         ;; :t value, then the second key is our answer,
+                         ;; the one that has not been retracted."
+                         (reduce (fn [prev-pos? k]
+                                   (let [curr-pos? (pos? (nth k 3))]
+                                     (if (and curr-pos?
+                                              prev-pos?
+                                              (diu/equals-on-indices? new k indices))
+                                       (reduced k)
+                                       curr-pos?)))
+                                 true))]
+            (if (boolean? res) nil res)))))))
+
+(defn remove-old
+  "Removes old key from the 'kvs' map using 'remove-fn' function."
+  [kvs new remove-fn indices]
+  (when-let [old (old-key kvs new indices)]
+    (remove-fn old)))
+
+(defrecord UpsertOp [key op-count indices version]
+  op/IOperation
+  (-insertion-ts [_] op-count)
+  (-affects-key [_] key)
+  (-apply-op-to-coll [_ kvs]
+    (-> (or (remove-old kvs key (partial dissoc kvs) indices) kvs)
+        (assoc key nil)))
+  (-apply-op-to-tree [_ tree]
+    (let [children  (cond
+                      (tree/data-node? tree) (:children tree)
+                      :else (:children (peek (tree/lookup-path tree key))))]
+      (-> (or (remove-old children key (partial tree/delete tree) indices) tree)
+          (tree/insert key nil)))))
+
+(defn old-retracted
+  "Returns a new datom to be inserted in the tree to signal the retraction of
+  its corresponding 'old' datom."
+  [kvs key old indices]
+  (let [[a b c _] old
+        [_ _ _ nt] key]
+    ;; '-' means it is retracted and 'nt' is the current transaction time.
+    [a b c (- nt)]))
+
+(defrecord temporal-UpsertOp [key op-count indices version]
+  op/IOperation
+  (-insertion-ts [_] op-count)
+  (-affects-key [_] key)
+  (-apply-op-to-coll [_ kvs]
+    (if-let [old (old-key kvs key indices)]
+      (if (diu/equals-on-indices? key old [0 1 2])
+        kvs
+        (let [old-retracted (old-retracted kvs key old indices)]
+          (-> (assoc kvs old-retracted nil)
+              (assoc key nil))))
+      (assoc kvs key nil)))
+  (-apply-op-to-tree [_ tree]
+    (let [children (cond
+                     (tree/data-node? tree) (:children tree)
+                     :else (:children (peek (tree/lookup-path tree key))))
+          old (old-key children key indices)]
+      (if old
+        (if (diu/equals-on-indices? key old [0 1 2])
+          tree
+          (let [old-retracted (old-retracted children key old indices)]
+            (-> (tree/insert tree old-retracted nil)
+                (tree/insert key nil))))
+        (tree/insert tree key nil)))))
+
+(defn new-UpsertOp [key op-count indices]
+  (UpsertOp. key op-count indices 0))
+
+(defn new-temporal-UpsertOp [key op-count indices]
+  (temporal-UpsertOp. key op-count indices 0))
+
+(defn add-upsert-handler
+  "Tells the store how to deserialize upsert related operations"
+  [store]
+  (swap! (:read-handlers store)
+         merge
+         {'datahike.index.hitchhiker_tree.upsert.UpsertOp
+          ;; TODO Remove ts when Wanderung is available.
+          (fn [{:keys [key value op-count ts indices]}]
+            (map->UpsertOp {:key key :value value :op-count (or op-count ts) :indices (or indices [0 1])
+                            :version 0}))
+
+          'datahike.index.hitchhiker_tree.upsert.temporal_UpsertOp
+          (fn [{:keys [key value op-count ts indices]}]
+            (map->temporal-UpsertOp {:key key :value value :op-count (or op-count ts) :indices (or indices [0 1])
+                                     :version 0}))})
+  store)

package/src-hitchhiker-tree/datahike/index/hitchhiker_tree.cljc

@@ -0,0 +1,213 @@
+(ns ^:no-doc datahike.index.hitchhiker-tree
+  (:require [datahike.index.hitchhiker-tree.upsert :as ups]
+            [datahike.index.hitchhiker-tree.insert :as ins]
+            [datahike.index.utils :as diu]
+            [hitchhiker.tree.bootstrap.konserve :as hk]
+            [hitchhiker.tree.utils.async :as async]
+            [hitchhiker.tree.messaging :as hmsg]
+            [hitchhiker.tree.key-compare :as kc]
+            [hitchhiker.tree :as tree]
+            [datahike.array :refer [compare-arrays]]
+            [datahike.datom :as dd]
+            [datahike.constants :refer [e0 tx0 emax txmax]]
+            [clojure.spec.alpha :as s]
+            [datahike.index.interface :as di :refer [IIndex]])
+  #?(:clj (:import [clojure.lang AMapEntry]
+                   [hitchhiker.tree DataNode IndexNode]
+                   [datahike.datom Datom])))
+
+(def ^:const default-index-b-factor 17)
+(def ^:const default-index-data-node-size 300)
+(def ^:const default-index-log-size (- 300 17))
+
+(extend-protocol kc/IKeyCompare
+  clojure.lang.PersistentVector
+  (-compare [key1 key2]
+    (if-not (= (class key2) clojure.lang.PersistentVector)
+      (if (nil? key2)
+        +1    ;; Case for tuples. E.g. (compare [100 200] nil)
+        -1)   ;; HACK for nil
+      (let [[a b c d] key1
+            [e f g h] key2]
+        (dd/combine-cmp
+         (kc/-compare a e)
+         (kc/-compare b f)
+         (kc/-compare c g)
+         (kc/-compare d h)))))
+  java.lang.String
+  (-compare [key1 key2]
+    (compare key1 key2))
+  clojure.lang.Keyword
+  (-compare [key1 key2]
+    (compare key1 key2))
+  nil
+  (-compare [key1 key2]
+    (if (nil? key2)
+      0 -1)))
+
+(extend-protocol kc/IKeyCompare
+  (Class/forName "[B")
+  (-compare [key1 key2]
+    (compare-arrays key1 key2)))
+
+(defn- index-type->datom-fn [index-type]
+  (case index-type
+    :aevt (fn [a e v tx] (dd/datom e a v tx true))
+    :avet (fn [a v e tx] (dd/datom e a v tx true))
+    (fn [e a v tx] (dd/datom e a v tx true))))
+
+(defn slice [tree from to index-type]
+  (let [[a b c d] (diu/datom-to-vec from index-type true)
+        cmp (diu/prefix-scan kc/-compare (diu/datom-to-vec to index-type false))
+        xf (comp
+            (take-while (fn [^AMapEntry kv] (cmp (.key kv))))
+            (map (fn [kv]
+                   (let [[a b c d] (.key ^AMapEntry kv)]
+                     ((index-type->datom-fn index-type) a b c d)))))]
+    (->> (sequence xf (hmsg/lookup-fwd-iter tree [a b c d]))
+         seq)))
+
+(defn datom-seq [tree index-type]
+  (slice tree (dd/datom e0 nil nil tx0) (dd/datom emax nil nil txmax) index-type))
+
+(defn datom-count [tree index-type]
+  (count (datom-seq tree index-type)))
+
+(defn all-datoms [tree index-type]
+  (map
+   #(apply
+     (index-type->datom-fn index-type)
+     (first %))
+   (hmsg/lookup-fwd-iter tree [])))
+
+(defn- datom->node [^Datom datom index-type]
+  (case index-type
+    :aevt [(.-a datom) (.-e datom) (.-v datom) (.-tx datom)]
+    :avet [(.-a datom) (.-v datom) (.-e datom) (.-tx datom)]
+    :eavt [(.-e datom) (.-a datom) (.-v datom) (.-tx datom)]
+    (throw (IllegalArgumentException. (str "Unknown index-type: " index-type)))))
+
+(defn- index-type->indices [index-type]
+  (case index-type
+    :eavt [0 1]
+    :aevt [0 1]
+    :avet [0 2]
+    (throw (UnsupportedOperationException. "Unknown index type: " index-type))))
+
+(defn insert [tree ^Datom datom index-type op-count]
+  (let [datom-as-vec (datom->node datom index-type)]
+    (async/<?? (hmsg/enqueue tree [(ins/new-InsertOp datom-as-vec op-count)]))))
+
+(defn temporal-insert [tree ^Datom datom index-type op-count]
+  (let [datom-as-vec (datom->node datom index-type)]
+    (async/<?? (hmsg/enqueue tree [(ins/new-temporal-InsertOp datom-as-vec op-count)]))))
+
+(defn upsert [tree ^Datom datom index-type op-count]
+  (let [datom-as-vec (datom->node datom index-type)]
+    (async/<?? (hmsg/enqueue tree [(ups/new-UpsertOp datom-as-vec op-count (index-type->indices index-type))]))))
+
+(defn temporal-upsert [tree ^Datom datom index-type op-count]
+  (let [datom-as-vec (datom->node datom index-type)]
+    (async/<?? (hmsg/enqueue tree [(ups/new-temporal-UpsertOp datom-as-vec op-count (index-type->indices index-type))]))))
+
+(defn remove-datom [tree ^Datom datom index-type op-count]
+  (async/<?? (hmsg/delete tree (datom->node datom index-type) op-count)))
+
+(defn flush-tree [tree backend]
+  (:tree (async/<?? (tree/flush-tree-without-root tree backend))))
+
+(defn mark [_tree]
+  (throw (ex-info "Mark phase not implemented for hitchhiker-tree."
+                  {:type :gc-not-implemented})))
+
+(extend-type DataNode
+  IIndex
+  (-all [eavt-tree]
+    (all-datoms eavt-tree :eavt))
+  (-seq [eavt-tree]
+    (datom-seq eavt-tree :eavt))
+  (-count [eavt-tree]
+    (datom-count eavt-tree :eavt))
+  (-insert [tree datom index-type op-count]
+    (insert tree datom index-type op-count))
+  (-temporal-insert [tree datom index-type op-count]
+    (temporal-insert tree datom index-type op-count))
+  (-upsert [tree datom index-type op-count _old-datom]
+    (upsert tree datom index-type op-count))
+  (-temporal-upsert [tree datom index-type op-count _old-datom]
+    (temporal-upsert tree datom index-type op-count))
+  (-remove [tree datom index-type op-count]
+    (remove-datom tree datom index-type op-count))
+  (-slice [tree from to index-type]
+    (slice tree from to index-type))
+  (-flush [tree backend]
+    (flush-tree tree backend))
+  (-transient [tree]
+    (identity tree))
+  (-persistent! [tree]
+    (identity tree))
+  (-mark [tree]
+    (mark tree)))
+
+(extend-type IndexNode
+  IIndex
+  (-all [eavt-tree]
+    (all-datoms eavt-tree :eavt))
+  (-seq [eavt-tree]
+    (datom-seq eavt-tree :eavt))
+  (-count [eavt-tree]
+    (datom-count eavt-tree :eavt))
+  (-insert [tree datom index-type op-count]
+    (insert tree datom index-type op-count))
+  (-temporal-insert [index datom index-type op-count]
+    (temporal-insert index datom index-type op-count))
+  (-upsert [tree datom index-type op-count _old-datom]
+    (upsert tree datom index-type op-count))
+  (-temporal-upsert [tree datom index-type op-count _old-datom]
+    (temporal-upsert tree datom index-type op-count))
+  (-remove [tree datom index-type op-count]
+    (remove-datom tree datom index-type op-count))
+  (-slice [tree from to index-type]
+    (slice tree from to index-type))
+  (-flush [tree backend]
+    (flush-tree tree backend))
+  (-transient [tree]
+    (identity tree))
+  (-persistent! [tree]
+    (identity tree))
+  (-mark [tree]
+    (mark tree)))
+
+(defn empty-tree [b-factor data-node-size log-size]
+  (async/<?? (tree/b-tree (tree/->Config b-factor data-node-size log-size))))
+
+(defmethod di/empty-index :datahike.index/hitchhiker-tree
+  [_index-name _store _index-type {:keys [index-b-factor index-data-node-size index-log-size]}]
+  (empty-tree index-b-factor index-data-node-size index-log-size))
+
+(defmethod di/init-index :datahike.index/hitchhiker-tree
+  [_index-name _store datoms index-type op-count {:keys [index-b-factor index-data-node-size index-log-size]}]
+  (async/<??
+   (async/reduce<
+    (fn [tree [idx datom]]
+      (insert tree datom index-type (+ idx op-count)))
+    (empty-tree index-b-factor index-data-node-size index-log-size)
+    (map-indexed (fn [idx datom] [idx datom]) (seq datoms)))))
+
+(defmethod di/add-konserve-handlers :datahike.index/hitchhiker-tree [_config store]
+  (ups/add-upsert-handler
+   (ins/add-insert-handler
+    (hk/add-hitchhiker-tree-handlers
+     store))))
+
+(defmethod di/konserve-backend :datahike.index/hitchhiker-tree [_index-name store]
+  (hk/->KonserveBackend store true))
+
+(s/def ::index-b-factor long)
+(s/def ::index-log-size long)
+(s/def ::index-data-node-size long)
+
+(defmethod di/default-index-config :datahike.index/hitchhiker-tree [_index-name]
+  {:index-b-factor       default-index-b-factor
+   :index-log-size       default-index-log-size
+   :index-data-node-size default-index-data-node-size})

package/test/datahike/backward_compatibility_test/src/backward_test.clj

@@ -0,0 +1,37 @@
+(ns backward-test
+  (:require [datahike.api :as d]
+            [taoensso.timbre :as t]))
+
+(def schema [{:db/ident       :age
+              :db/cardinality :db.cardinality/one
+              :db/valueType   :db.type/long}])
+(def cfg {:store  {:backend :file
+                   :path "/tmp/datahike-backward-comp-test"
+                   :id #uuid "550e8400-e29b-41d4-a716-446655440000"}
+          :keep-history? true
+          :schema-flexibility :write
+          :initial-tx schema})
+
+(def size 10000)
+
+(defn write [opt]
+  (t/info "Writing to db using latest released version of datahike ....")
+  (t/set-level! :warn)
+
+  (d/delete-database cfg)
+  (d/create-database cfg)
+  (let [conn (d/connect cfg)]
+    (d/transact conn
+                (vec (for [i (range size)]
+                       [:db/add (inc i) :age i]))))
+  (t/info "Wrote " size " entries."))
+
+(defn read [opt]
+  (t/info "Reading using latest code ....")
+  (let [conn (d/connect cfg)
+        res (first (d/q '[:find (count ?a)
+                          :in $
+                          :where [?e :age ?a]]
+                        @conn))]
+    (assert (= [size] res))
+    (t/info "Read " (first res) " entries.")))

package/test/datahike/integration_test/config_record_file_test.clj

@@ -0,0 +1,14 @@
+(ns datahike.integration-test.config-record-file-test
+  (:require [clojure.test :refer :all]
+            [datahike.integration-test :as it]))
+
+(def config {:store {:backend :file :path "/tmp/file-test-1" :id #uuid "f11e0001-0000-0000-0000-000000000001"}})
+
+(defn config-record-file-test-fixture [f]
+  (it/integration-test-fixture config)
+  (f))
+
+(use-fixtures :once config-record-file-test-fixture)
+
+(deftest ^:integration config-record-file-test []
+  (it/integration-test config))

package/test/datahike/integration_test/config_record_test.clj

@@ -0,0 +1,14 @@
+(ns datahike.integration-test.config-record-test
+  (:require [clojure.test :refer :all]
+            [datahike.integration-test :as it]))
+
+(def config {:store {:backend :memory :id #uuid "c0ff1c00-0000-0000-0000-000000000001"}})
+
+(defn config-record-test-fixture [f]
+  (it/integration-test-fixture config)
+  (f))
+
+(use-fixtures :once config-record-test-fixture)
+
+(deftest ^:integration config-record-test []
+  (it/integration-test config))

package/test/datahike/integration_test/depr_config_uri_test.clj

@@ -0,0 +1,15 @@
+(ns datahike.integration-test.depr-config-uri-test
+  (:require [clojure.test :refer :all]
+            [datahike.integration-test :as it]))
+
+(def config "datahike:file:///tmp/file-test-3?id=5c6e0000-0000-0000-0000-000000000003")
+
+(defn depr-config-uri-fixture [f]
+  (println "deprecated file uri config: " config)
+  (it/integration-test-fixture config)
+  (f))
+
+(use-fixtures :once depr-config-uri-fixture)
+
+(deftest ^:integration depr-config-uri-test []
+  (it/integration-test config))

package/test/datahike/integration_test/return_map_test.clj

@@ -0,0 +1,62 @@
+(ns datahike.integration-test.return-map-test
+  (:require [clojure.test :refer [deftest is use-fixtures]]
+            [datahike.api :as d]))
+
+(def config {:store {:backend :memory :id #uuid "0e7000a9-0000-0000-0000-000000000001"}})
+
+(defn return-map-test-fixture [f]
+  (d/delete-database config)
+  (d/create-database config)
+  (def conn (d/connect config))
+  ;; the first transaction will be the schema we are using
+  (d/transact conn [{:db/ident :name
+                     :db/valueType :db.type/string
+                     :db/cardinality :db.cardinality/one}
+                    {:db/ident :age
+                     :db/valueType :db.type/long
+                     :db/cardinality :db.cardinality/one}])
+
+  ;; lets add some data and wait for the transaction
+  (d/transact conn [{:name  "Alice", :age   20}
+                    {:name  "Bob", :age   30}
+                    {:name  "Charlie", :age   40}])
+
+  (f))
+
+(use-fixtures :once return-map-test-fixture)
+
+(deftest return-keys-test
+  ;; search the data
+  (is (= [{:entity 4 :name "Bob" :age 30}
+          {:entity 5 :name "Charlie" :age 40}
+          {:entity 3 :name "Alice" :age 20}]
+         (d/q '[:find ?e ?n ?a
+                :keys entity name age
+                :where
+                [?e :name ?n]
+                [?e :age ?a]]
+              @conn))))
+
+(deftest return-syms-test
+  ;; search the data
+  (is (= [{'entity 4 'name "Bob" 'age 30}
+          {'entity 5 'name "Charlie" 'age 40}
+          {'entity 3 'name "Alice" 'age 20}]
+         (d/q '[:find ?e ?n ?a
+                :syms entity name age
+                :where
+                [?e :name ?n]
+                [?e :age ?a]]
+              @conn))))
+
+(deftest return-strs-test
+  ;; search the data
+  (is (= [{"entity" 4 "name" "Bob" "age" 30}
+          {"entity" 5 "name" "Charlie" "age" 40}
+          {"entity" 3 "name" "Alice" "age" 20}]
+         (d/q '[:find ?e ?n ?a
+                :strs entity name age
+                :where
+                [?e :name ?n]
+                [?e :age ?a]]
+              @conn))))

package/test/datahike/integration_test.cljc

@@ -0,0 +1,67 @@
+(ns ^:no-doc datahike.integration-test
+  "This namespace is the minimum test a Datahike backend needs to pass for compatibility assessment."
+  (:require [clojure.test :refer [is]]
+            [datahike.api :as d]
+            ;; Load hitchhiker-tree for backwards compatibility with existing test databases
+            #?(:clj [datahike.index.hitchhiker-tree])))
+
+(defn integration-test-fixture [config]
+  (d/delete-database config)
+  (d/create-database config)
+  (let [conn (d/connect config)]
+    (d/transact conn [{:db/ident :name
+                       :db/valueType :db.type/string
+                       :db/cardinality :db.cardinality/one}
+                      {:db/ident :age
+                       :db/valueType :db.type/long
+                       :db/cardinality :db.cardinality/one}])
+
+    ;; lets add some data and wait for the transaction
+    (d/transact conn [{:name  "Alice", :age   20}
+                      {:name  "Bob", :age   30}
+                      {:name  "Charlie", :age   40}
+                      {:age 15}])
+    (d/release conn)))
+
+(defn integration-test [config]
+  (let [conn (d/connect config)]
+    ;; search the data
+    (is (= #{[3 "Alice" 20] [4 "Bob" 30] [5 "Charlie" 40]}
+           (d/q '[:find ?e ?n ?a
+                  :where
+                  [?e :name ?n]
+                  [?e :age ?a]]
+                @conn)))
+
+    ;; add new entity data using a hash map
+    (d/transact conn {:tx-data [{:db/id 3 :age 25}]})
+
+    ;; if you want to work with queries like in
+    ;; https://grishaev.me/en/datomic-query/,
+    ;; you may use a hashmap
+    (is (= #{[5 "Charlie" 40] [4 "Bob" 30] [3 "Alice" 25]}
+           (d/q {:query '{:find [?e ?n ?a]
+                          :where [[?e :name ?n]
+                                  [?e :age ?a]]}
+                 :args [@conn]})))
+
+    ;; query the history of the data
+    (is (= #{[20] [25]}
+           (d/q '[:find ?a
+                  :where
+                  [?e :name "Alice"]
+                  [?e :age ?a]]
+                (d/history @conn))))
+
+    ;; you might need to release the connection, e.g. for leveldb
+    (is (= nil (d/release conn)))
+
+    ;; database should exist
+    (is (d/database-exists? config))
+
+    ;; clean up the database if it is not needed any more
+    (d/delete-database config)
+
+    ;; database should not exist
+    (is (not (d/database-exists? config)))))
+

package/test/datahike/norm/norm_test.clj

@@ -0,0 +1,124 @@
+(ns datahike.norm.norm-test
+  (:require [clojure.test :refer [deftest is]]
+            [clojure.string :as string]
+            [clojure.java.io :as io]
+            [datahike.api :as d]
+            [datahike.norm.norm :as sut :refer [verify-checksums]]
+            [datahike.test.utils :as tu]))
+
+(def ensure-norms #'sut/ensure-norms)
+
+(deftest simple-test
+  (let [conn (tu/setup-db {} true)
+        _ (verify-checksums (io/file "test/datahike/norm/resources/simple-test"))
+        _ (ensure-norms conn (io/file "test/datahike/norm/resources/simple-test"))
+        schema (d/schema (d/db conn))]
+    (is (= #:db{:valueType :db.type/string, :cardinality :db.cardinality/one, :doc "Place of occupation", :ident :character/place-of-occupation}
+           (-> (schema :character/place-of-occupation)
+               (dissoc :db/id))))
+    (is (= #:db{:valueType :db.type/string, :cardinality :db.cardinality/one, :doc "Simpsons character name", :ident :character/name, :db/unique :db.unique/identity}
+           (-> (schema :character/name)
+               (dissoc :db/id))))
+    (is (= #:db{:ident :tx/norm, :valueType :db.type/keyword, :cardinality :db.cardinality/one}
+           (-> (schema :tx/norm)
+               (dissoc :db/id))))
+    (d/release conn)))
+
+(defn tx-fn-test-fn [conn]
+  (-> (for [[eid value] (d/q '[:find ?e ?v
+                               :where
+                               [?e :character/place-of-occupation ?v]]
+                             (d/db conn))]
+        [:db/add eid
+         :character/place-of-occupation (string/lower-case value)])
+      vec))
+
+(deftest tx-fn-test
+  (let [conn (tu/setup-db {} true)
+        _ (verify-checksums (io/file "test/datahike/norm/resources/tx-fn-test/first"))
+        _ (ensure-norms conn (io/file "test/datahike/norm/resources/tx-fn-test/first"))
+        _ (d/transact conn {:tx-data [{:character/place-of-occupation "SPRINGFIELD ELEMENTARY SCHOOL"}
+                                      {:character/place-of-occupation "SPRINGFIELD NUCLEAR POWER PLANT"}]})
+        _ (verify-checksums (io/file "test/datahike/norm/resources/tx-fn-test/second"))
+        _ (ensure-norms conn (io/file "test/datahike/norm/resources/tx-fn-test/second"))]
+    (is (= #{["springfield elementary school"] ["springfield nuclear power plant"]}
+           (d/q '[:find ?v
+                  :where
+                  [_ :character/place-of-occupation ?v]]
+                (d/db conn))))
+    (d/release conn)))
+
+(defn tx-data-and-tx-fn-test-fn [conn]
+  (-> (for [[eid]
+            (d/q '[:find ?e
+                   :where
+                   [?e :character/name]
+                   (or-join [?e]
+                            [?e :character/name "Homer Simpson"]
+                            [?e :character/name "Marge Simpson"])]
+                 (d/db conn))]
+        {:db/id eid
+         :character/children [[:character/name "Bart Simpson"]
+                              [:character/name "Lisa Simpson"]
+                              [:character/name "Maggie Simpson"]]})
+      vec))
+
+(deftest tx-data-and-tx-fn-test
+  (let [conn (tu/setup-db {} true)
+        _ (verify-checksums (io/file "test/datahike/norm/resources/tx-data-and-tx-fn-test/first"))
+        _ (ensure-norms conn (io/file "test/datahike/norm/resources/tx-data-and-tx-fn-test/first"))
+        _ (d/transact conn {:tx-data [{:character/name "Homer Simpson"}
+                                      {:character/name "Marge Simpson"}
+                                      {:character/name "Bart Simpson"}
+                                      {:character/name "Lisa Simpson"}
+                                      {:character/name "Maggie Simpson"}]})
+        _ (verify-checksums (io/file "test/datahike/norm/resources/tx-data-and-tx-fn-test/second"))
+        _ (ensure-norms conn (io/file "test/datahike/norm/resources/tx-data-and-tx-fn-test/second"))
+        margehomer (d/q '[:find [?e ...]
+                          :where
+                          [?e :character/name]
+                          (or-join [?e]
+                                   [?e :character/name "Homer Simpson"]
+                                   [?e :character/name "Marge Simpson"])]
+                        (d/db conn))]
+    (is (= [#:character{:name "Homer Simpson",
+                        :children
+                        [#:character{:name "Bart Simpson"}
+                         #:character{:name "Lisa Simpson"}
+                         #:character{:name "Maggie Simpson"}]}
+            #:character{:name "Marge Simpson",
+                        :children
+                        [#:character{:name "Bart Simpson"}
+                         #:character{:name "Lisa Simpson"}
+                         #:character{:name "Maggie Simpson"}]}]
+           (d/pull-many (d/db conn) '[:character/name {:character/children [:character/name]}] margehomer)))
+    (d/release conn)))
+
+(defn naming-and-sorting-test-fn [conn]
+  (-> (for [[eid] (d/q '[:find ?e
+                         :where
+                         [?e :character/name]
+                         (or-join [?e]
+                                  [?e :character/name "Bart Simpson"]
+                                  [?e :character/name "Lisa Simpson"])]
+                       (d/db conn))]
+        {:db/id eid
+         :character/occupation :student})
+      vec))
+
+(deftest naming-and-sorting-test
+  (let [conn (tu/setup-db {} true)
+        _ (verify-checksums (io/file "test/datahike/norm/resources/naming-and-sorting-test"))
+        _ (sut/ensure-norms! conn (io/file "test/datahike/norm/resources/naming-and-sorting-test"))
+        lisabart (d/q '[:find [?e ...]
+                        :where
+                        [?e :character/occupation :student]]
+                      (d/db conn))]
+    (is (= [{:db/id 10,
+             :character/name "Bart Simpson",
+             :character/occupation :student}
+            {:db/id 11,
+             :character/name "Lisa Simpson",
+             :character/occupation :student}]
+           (d/pull-many (d/db conn) '[*] lisabart)))
+    (d/release conn)))