datahike-browser-tests 1.0.0

package/benchmark/src/benchmark/config.clj

@@ -0,0 +1,316 @@
+(ns benchmark.config)
+
+(def comparison-context-cell-order [:fn :backend :index :schema :history :db-datoms :tx-datoms :data-type :data-in-db?])
+
+(def csv-cols
+  [{:name :fn           :title "Function"      :path [:context :function]}
+   {:name :index        :title "Index"         :path [:context :dh-config :index]}
+   {:name :backend      :title "Backend"       :path [:context :dh-config :backend]}
+   {:name :schema       :title "Schema"        :path [:context :dh-config :schema-flexibility]}
+   {:name :history      :title "History"       :path [:context :dh-config :keep-history?]}
+   {:name :db-datoms    :title "DB Datoms"     :path [:context :db-datoms]}
+   {:name :db-entities  :title "DB Entities"   :path [:context :db-entities]}
+   {:name :tx-datoms    :title "TX Datoms"     :path [:context :execution :tx-datoms]}
+   {:name :tx-entities  :title "TX Entities"   :path [:context :execution :tx-entities]}
+   {:name :data-type    :title "Data Type"     :path [:context :execution :data-type]}
+   {:name :data-in-db?  :title "Q Data in DB?" :path [:context :execution :data-in-db?]}
+   {:name :mean         :title "Mean Time"     :path [:time :mean]}
+   {:name :std          :title "Time Std"      :path [:time :std]}
+   {:name :median       :title "Median Time"   :path [:time :median]}
+   {:name :min          :title "Minimum Time"  :path [:time :min]}
+   {:name :max          :title "Maximum Time"  :path [:time :max]}
+   {:name :count        :title "Time Count"    :path [:time :count]}
+   {:name :tags         :title "Tags"          :path [:tag]}])
+
+(def named-db-configs
+  {"mem-set" {:store {:backend :mem :id "performance-set"}
+              :index :datahike.index/persistent-set
+              :keep-history? false
+              :search-cache-size 0
+              :store-cache-size 1
+              :schema-flexibility :write}
+   "mem-hht" {:store {:backend :mem :id "performance-hht"}
+              :index :datahike.index/hitchhiker-tree
+              :keep-history? false
+              :search-cache-size 0
+              :store-cache-size 1
+              :schema-flexibility :write}
+   "file-set" {:store {:backend :file :path "/tmp/performance-set"}
+               :index :datahike.index/persistent-set
+               :keep-history? false
+               :search-cache-size 0
+               :store-cache-size 1
+               :schema-flexibility :write}
+   "file-hht" {:store {:backend :file :path "/tmp/performance-hht"}
+               :index :datahike.index/hitchhiker-tree
+               :keep-history? false
+               :search-cache-size 0
+               :store-cache-size 1
+               :schema-flexibility :write}})
+
+(def schema
+  [{:db/ident       :s1
+    :db/valueType   :db.type/string
+    :db/cardinality :db.cardinality/one}
+   {:db/ident       :s2
+    :db/valueType   :db.type/string
+    :db/cardinality :db.cardinality/one}
+   {:db/ident       :i1
+    :db/valueType   :db.type/bigint
+    :db/cardinality :db.cardinality/one}
+   {:db/ident       :i2
+    :db/valueType   :db.type/bigint
+    :db/cardinality :db.cardinality/one}])
+
+(defn rand-str [max-int]
+  (format "%15d" (rand-int max-int)))
+
+(defn rand-entity [max-int]
+  {:s1 (rand-str max-int)
+   :s2 (rand-str max-int)
+   :i1 (rand-int max-int)
+   :i2 (rand-int max-int)})
+
+(defn known [attr entities]
+  (mapv attr entities))
+
+(def m-known (memoize known))
+
+(defn known-set [attr entities]
+  (set (m-known attr entities)))
+
+(def m-known-set (memoize known-set))
+
+(defn rand-val-not-in [datatype val-set]
+  (let [rand-gen (if (= datatype :int) rand-int rand-str)]
+    (loop [i (rand-gen Integer/MAX_VALUE)]
+      (if (contains? val-set i)
+        (recur (rand-gen Integer/MAX_VALUE))
+        i))))
+
+(defn rand-attr-val [datatype attr entities in-set?]
+  (if in-set?
+    #(rand-nth (m-known attr entities))
+    #(rand-val-not-in datatype (m-known-set attr entities))))
+
+(defn vec-of [n f]
+  (vec (repeatedly n f)))
+
+;;; Queries
+
+(defn simple-query [db attr val]
+  {:query (conj '[:find ?e :where]
+                (conj '[?e] attr val))
+   :args [db]})
+
+(defn limit-query [db attr]
+  {:query (conj '[:find ?e ?v :where] ;; pulls entity-count datoms
+                (conj '[?e] attr '?v))
+   :offset 0
+   :limit 100
+   :args [db]})
+
+(defn e-join-query [db attr1 attr2] ;; entity-count res lines
+  {:query (conj '[:find ?e :where]
+                (conj '[?e] attr1 '?v1) ;; pulls entity-count datoms
+                (conj '[?e] attr2 '?v2)) ;; pulls entity-count datoms
+   :args [db]})
+
+(defn a-join-query [db attr] ;; entity-count res lines
+  {:query (conj '[:find ?v1 ?v2 :where]
+                (conj '[?e1] attr '?v1) ;; pulls entity-count datoms
+                (conj '[?e2] attr '?v2)) ;; pulls entity-count datoms
+   :args [db]})
+
+(defn v-join-query [db attr1 attr2] ;; on average entity-count res lines
+  {:query (conj '[:find ?e1 ?e2 :where]
+                (conj '[?e1] attr1 '?v) ;; pulls entity-count datoms
+                (conj '[?e2] attr2 '?v)) ;; pulls entity-count datoms
+   :args [db]})
+
+(defn e-join-query-first-fixed [db attr1 val1 attr2]
+  {:query (conj '[:find ?v2 :where]
+                (conj '[?e] attr1 val1)
+                (conj '[?e] attr2 '?v2))
+   :args [db]})
+
+(defn e-join-query-second-fixed [db attr1 attr2 val2]
+  {:query (conj '[:find ?v1 :where]
+                (conj '[?e] attr1 '?v1)
+                (conj '[?e] attr2 val2))
+   :args [db]})
+
+(defn scalar-arg-query [db attr val]
+  {:query (conj '[:find ?e
+                  :in $ ?v
+                  :where]
+                (conj '[?e] attr '?v))
+   :args [db val]})
+
+(defn scalar-arg-query-with-join [db attr val]
+  {:query (conj '[:find ?e1 ?e2 ?v2
+                  :in $ ?v1
+                  :where]
+                (conj '[?e1] attr '?v1)
+                (conj '[?e2] attr '?v2))
+   :args [db val]})
+
+(defn vector-arg-query [db attr vals]
+  {:query (conj '[:find ?e
+                  :in $ [?v ...]
+                  :where]
+                (conj '[?e] attr '?v))
+   :args [db vals]})
+
+(defn less-than-query [db attr]
+  {:query (conj '[:find ?e1 ?e2 :where]
+                (conj '[?e1] attr '?v1)
+                (conj '[?e2] attr '?v2)
+                '[(< ?v1 ?v2)])
+   :args [db]})
+
+(defn equals-query [db attr]
+  {:query (conj '[:find ?e1 ?e2 :where]
+                (conj '[?e1] attr '?v1)
+                (conj '[?e2] attr '?v2)
+                '[(= ?v1 ?v2)])
+   :args [db]})
+
+(defn less-than-query-1-fixed [db attr comp-val]
+  {:query (conj '[:find ?e :where]
+                (conj '[?e] attr '?v)
+                (conj '[]
+                      (sequence (conj '[< ?v] comp-val))))
+   :args [db]})
+
+(defn equals-query-1-fixed [db attr comp-val]
+  {:query (conj '[:find ?e :where]
+                (conj '[?e] attr '?v)
+                (conj '[]
+                      (sequence (conj '[= ?v] comp-val))))
+   :args [db]})
+
+(defn non-var-queries [db datatypes max-int]
+  (apply concat
+         (for [data-type datatypes]
+           (let [[attr1 attr2 middle-elem] (if (= data-type :int)
+                                             [:i1 :i2 (int (/ max-int 2.0))]
+                                             [:s1 :s2 (format "%15d" (int (/ max-int 2.0)))])]
+
+             [{:function :e-join-query
+               :query (e-join-query db attr1 attr2)
+               :details {:data-type data-type}}
+
+              {:function :a-join-query
+               :query (a-join-query db attr1)
+               :details {:data-type data-type}}
+
+              {:function :v-join-query
+               :query (v-join-query db attr1 attr2)
+               :details {:data-type data-type}}
+
+              {:function :equals-query
+               :query (equals-query db attr1)
+               :details {:data-type data-type}}
+
+              {:function :less-than-query
+               :query (less-than-query db attr1)
+               :details {:data-type data-type}}
+
+              {:function :equals-query-1-fixed
+               :query (equals-query-1-fixed db attr1 middle-elem)
+               :details {:data-type data-type}}
+
+              {:function :less-than-query-1-fixed
+               :query (less-than-query-1-fixed db attr1 middle-elem)
+               :details {:data-type data-type}}
+               
+               {:function :limit-query
+                :query (limit-query db attr1)
+                :details {:data-type data-type}}]))))
+
+(defn var-queries [db entities datatypes data-found-opts]
+  (apply concat
+         (for [data-type datatypes
+               data-in-db? data-found-opts]
+
+           (let [attr1 (if (= data-type :int) :i1 :s1)
+                 attr2 (if (= data-type :int) :i2 :s2)
+                 rand-val1 (rand-attr-val data-type attr1 entities data-in-db?)
+                 rand-val2 (rand-attr-val data-type attr2 entities data-in-db?)]
+
+             [{:function :simple-query
+               :query (simple-query db attr1 (rand-val1))
+               :details {:data-type data-type :data-in-db? data-in-db?}}
+
+              {:function :e-join-query-first-fixed
+               :query (e-join-query-first-fixed db :i1 (rand-val1) :i2)
+               :details {:data-type data-type :data-in-db? data-in-db?}}
+
+              {:function :e-join-query-second-fixed
+               :query (e-join-query-second-fixed db :i1 :i2 (rand-val2))
+               :details {:data-type data-type :data-in-db? data-in-db?}}
+
+              {:function :scalar-arg-query
+               :query (scalar-arg-query db :i1 (rand-val1))
+               :details {:data-type data-type :data-in-db? data-in-db?}}
+
+              {:function :scalar-arg-query-with-join
+               :query (scalar-arg-query-with-join db :i1 (rand-val1))
+               :details {:data-type data-type :data-in-db? data-in-db?}}
+
+              {:function :vector-arg-query
+               :query (vector-arg-query db :i1 (vec-of 10 rand-val1))
+               :details {:data-type data-type :data-in-db? data-in-db?}}]))))
+
+(defn cache-check-queries [db entities datatypes data-found-opts]
+  (apply concat
+         (for [data-type datatypes
+               data-in-db? data-found-opts]
+           (let [attr (if (= data-type :int) :i1 :s1)
+                 rand-val (rand-attr-val data-type attr entities data-in-db?)
+                 val (rand-val)]
+             [{:function :simple-query-first-run
+               :query (simple-query db attr val)
+               :details {:data-type data-type :data-in-db? data-in-db?}}
+              {:function :simple-query-second-run
+               :query (simple-query db attr val)
+               :details {:data-type data-type :data-in-db? data-in-db?}}]))))
+
+(defn aggregate-queries [entities]
+  [{:function :sum-query
+    :query {:query '[:find (sum ?x)
+                     :in [?x ...]]
+            :args [(repeatedly (count entities) #(rand-int 100))]}
+    :details {:data-type :int}}
+   {:function :avg-query
+    :query {:query '[:find (avg ?x)
+                     :in [?x ...]]
+            :args [(repeatedly (count entities) #(rand-int 100))]}
+    :details {:data-type :int}}
+   {:function :median-query
+    :query {:query '[:find (median ?x)
+                     :in [?x ...]]
+            :args [(repeatedly (count entities) #(rand-int 100))]}
+    :details {:data-type :int}}
+   {:function :variance-query
+    :query {:query '[:find (variance ?x)
+                     :in [?x ...]]
+            :args [(repeatedly (count entities) #(rand-int 100))]}
+    :details {:data-type :int}}
+   {:function :stddev-query
+    :query {:query '[:find (stddev ?x)
+                     :in [?x ...]]
+            :args [(repeatedly (count entities) #(rand-int 100))]}
+    :details {:data-type :int}}
+   {:function :max-query
+    :query {:query '[:find (max ?x)
+                     :in [?x ...]]
+            :args [(repeatedly (count entities) #(rand-int 100))]}
+    :details {:data-type :int}}])
+
+(defn all-queries [db entities datatypes data-found-opts]
+  (concat (non-var-queries db datatypes (count entities))
+          (var-queries db entities datatypes data-found-opts)
+          (cache-check-queries db entities datatypes data-found-opts)
+          (aggregate-queries entities)))

package/benchmark/src/benchmark/measure.clj

@@ -0,0 +1,187 @@
+(ns benchmark.measure
+  (:require [benchmark.config :as c]
+            [taoensso.timbre :as log]
+            [datahike.api :as d]
+            [datahike.store :as ds]
+            [datahike.index :as di])
+  (:import [java.util UUID]))
+
+(defmacro timed
+  "Evaluates expr. Returns the value of expr and the time in a map."
+  [expr]
+  `(let [start# (. System (nanoTime))
+         ret# ~expr]
+     {:res ret# :t (/ (double (- (. System (nanoTime)) start#)) 1000000.0)}))
+
+(defn init-db [config]
+  (d/delete-database config)
+  (let [config (d/create-database config)]
+    [(d/connect config) config]))
+
+(defn init-tx [entity-count conn]
+  (when (= :write (get-in @conn [:config :schema-flexibility]))
+    (d/transact conn c/schema))
+  (if (pos? entity-count)
+    (vec (for [entities (->> (repeatedly entity-count (partial c/rand-entity entity-count))
+                             (partition 100000 100000 nil))]
+           (d/transact conn (vec entities))))
+    []))
+
+(defn time-context-map
+  ([t config function db-entities db-datoms]
+   (time-context-map t config function db-entities db-datoms nil))
+  ([t config function db-entities db-datoms exec]
+   (cond-> {:time    t
+            :context {:dh-config   config
+                      :function    function
+                      :db-entities db-entities
+                      :db-datoms   db-datoms}}
+           (some? exec) (assoc-in [:context :execution] exec))))
+
+(defn measure-connection-time [iterations unique-cfg simple-cfg db-entities db-datoms]
+  (->> (range iterations)
+       (map #(do (log/debug (str "  - iteration no. " % ))
+                 (let [timed-conn (timed (d/connect unique-cfg))]
+                   (d/release (:res timed-conn))
+                   (time-context-map (:t timed-conn) simple-cfg :connection db-entities db-datoms))) )
+       doall))
+
+(defn measure-query-times
+  [{:keys [iterations data-found-opts query data-types]} initial-tx conn config db-entities db-datoms]
+  (let [data-found (case data-found-opts
+                     true [true]
+                     false [false]
+                     :all [true false])
+        queries (if (pos? (count initial-tx))
+                  (c/all-queries @conn initial-tx data-types data-found)
+                  (c/non-var-queries @conn data-types (count initial-tx)))
+        filtered-queries (if (= query :all)
+                           queries
+                           (filter #(= query (:function %)) queries))]
+    (->> filtered-queries
+         (mapcat (fn [{:keys [function query details]}]
+                (log/info (str "   Querying with " function " using " details ))
+                (->> (range iterations)
+                     (map #(do (log/debug (str "   - iteration no. " % ))
+                               (time-context-map (:t (timed (d/q query @conn)))
+                                                 config function db-entities db-datoms details)))
+                     doall)))
+         doall)))
+
+(defn measure-transaction-times
+  [{:keys [iterations tx-entity-counts]} conn config db-entities db-datoms]
+  (->> tx-entity-counts
+       (mapcat (fn [tx-entities]
+              (let [tx-datoms (* (count c/schema) tx-entities)]
+                (log/info (str "   Transacting " tx-datoms " entities"))
+                (->> (range iterations)
+                     (map #(do (log/debug (str "   - iteration no. " % ))
+                               (let [tx (vec (repeatedly tx-entities (partial c/rand-entity Integer/MAX_VALUE)))
+                                     timed-transact (timed (d/transact conn tx))]
+                                 (d/transact conn (mapv (fn [dat]
+                                                          [(if (:keep-history? (:config @conn))
+                                                             :db.purge/entity
+                                                             :db/retractEntity)
+                                                           (.-e dat)])
+                                                        (:tx-data (:res timed-transact))))
+                                 (time-context-map (:t timed-transact) config :transaction db-entities db-datoms
+                                                   {:tx-entities tx-entities :tx-datoms tx-datoms}))))
+                     doall))))
+       doall))
+
+(defn measure-performance-full
+  ([entity-count options cfg] (measure-performance-full entity-count options cfg {}))
+  ([entity-count {:keys [iterations function] :as options} config
+    {:keys [spec-fn-name make-fn-invocation] :as _specified-fn}]
+   (let [unique-cfg (assoc config :name (str (UUID/randomUUID)))
+         simple-cfg (-> config
+                        (assoc :backend (get-in config [:store :backend]))
+                        (dissoc :store))
+         datom-count (* entity-count (count c/schema))
+         [conn unique-cfg] (init-db unique-cfg)
+         initial-tx (init-tx entity-count conn)
+         measurements (vec (if (some? make-fn-invocation)
+                             (do
+                               (log/info (str " Measuring function '" spec-fn-name "'..."))
+                               (->> (range iterations)
+                                    (map #(do (log/debug (str " - iteration no. " % ))
+                                              (time-context-map (:t (timed (make-fn-invocation conn))) simple-cfg (keyword spec-fn-name)
+                                                                entity-count datom-count)))
+                                    doall))
+                             (let [query-times
+                                   (when (#{:all :query} function)
+                                     (log/info (str " Measuring query times..." ))
+                                     (measure-query-times options initial-tx conn simple-cfg entity-count datom-count))
+                                   transaction-times
+                                   (when (contains? #{:all :transaction} function)
+                                     (log/info (str " Measuring transaction times..."))
+                                     (measure-transaction-times options conn simple-cfg entity-count datom-count))
+                                   connection-times
+                                   (when (#{:all :connection} function)
+                                     (log/info (str " Measuring connection times..."))
+                                     (d/release conn)
+                                     (measure-connection-time iterations unique-cfg simple-cfg entity-count datom-count))]
+                               (concat query-times transaction-times connection-times))))]
+     (d/delete-database unique-cfg)
+     measurements)))
+
+(defn time-statistics [times]
+  (let [n (count times)
+        sorted (sort times)
+        mean (/ (apply + times) n)]
+    {:mean mean
+     :median (nth sorted (int (/ n 2)))
+     :std (->> times
+               (map #(* (- % mean) (- % mean)))
+               (apply +)
+               (* (/ 1.0 n))
+               Math/sqrt)
+     :min (first sorted)
+     :max (last sorted)
+     :count n
+     :observations (vec times)}))
+
+(defn requested-configs [{:keys [config-name history backend search-caches store-caches schema index] :as _options}]
+  (if config-name
+    [(get c/named-db-configs config-name)]
+    (vec (for [index-type (if (= :all index)
+                            (-> (methods di/default-index-config) keys set (disj :default))
+                            [index])
+               backend-type (if (= :all backend)
+                              (-> (methods ds/default-config) keys set (disj :default))
+                              [backend])
+               keep-history (if (= :all history)
+                              [true false]
+                              [history])
+               schema-flexibility (if (= :all schema)
+                                    [:read :write]
+                                    [schema])
+               search-cache search-caches
+               store-cache store-caches]
+           {:index index-type
+            :store {:backend backend-type}
+            :keep-history? keep-history
+            :search-cache-size search-cache
+            :store-cache-size store-cache
+            :schema-flexibility schema-flexibility}))))
+
+(defn get-measurements
+  ([options] (get-measurements options (requested-configs options) {}))
+  ([options configs] (get-measurements options configs {}))
+  ([{:keys [db-entity-counts db-samples] :as options} configs specified-fn]
+   (->> (for [cfg configs
+              entity-count db-entity-counts]
+          (let [datom-count (* entity-count (count c/schema))
+                simple-cfg (-> cfg
+                               (assoc :backend (get-in cfg [:store :backend]))
+                               (update :index name)
+                               (dissoc :store))]
+            (log/info "Get measurements for DB of size" datom-count "and config:" simple-cfg)
+            (->> (range db-samples)
+                 (mapcat #(do (log/debug (str "- db instance no. " % ))
+                              (measure-performance-full entity-count options cfg specified-fn)))
+                 doall)))
+        (apply concat)
+        (group-by :context)
+        (map (fn [[context group]]
+               {:context context :time (time-statistics (map :time group))})))))

package/benchmark/src/benchmark/store.clj

@@ -0,0 +1,190 @@
+(ns benchmark.store
+  (:require [clojure.edn :as edn]
+            [clj-http.client :as client]
+            [clojure.string :refer [join]]
+            [clojure.pprint :refer [pprint]]
+            [benchmark.config :as c]))
+
+;; Remote server output
+
+(defrecord RemoteDB [baseurl token dbname])
+
+(def schema
+  [{:db/ident :dh-config
+    :db/valueType :db.type/ref
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :dh-config/name
+    :db/valueType :db.type/string
+    :db/cardinality :db.cardinality/one
+    :db/unique :db.unique/identity}
+   {:db/ident :dh-config/index
+    :db/valueType :db.type/keyword
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :dh-config/keep-history?
+    :db/valueType :db.type/boolean
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :dh-config/schema-flexibility
+    :db/valueType :db.type/keyword
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :dh-config/backend
+    :db/valueType :db.type/keyword
+    :db/cardinality :db.cardinality/one}
+
+   {:db/ident :time
+    :db/valueType :db.type/ref
+    :db/cardinality :db.cardinality/one
+    :db/isComponent true}
+   {:db/ident :time/mean
+    :db/valueType :db.type/double
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :time/median
+    :db/valueType :db.type/double
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :time/std
+    :db/valueType :db.type/double
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :time/std
+    :db/valueType :db.type/double
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :time/count
+    :db/valueType :db.type/long
+    :db/cardinality :db.cardinality/one}
+
+   {:db/ident :function
+    :db/valueType :db.type/keyword
+    :db/cardinality :db.cardinality/one}
+
+   {:db/ident :db-size
+    :db/valueType :db.type/long
+    :db/cardinality :db.cardinality/one}
+
+   {:db/ident :execution
+    :db/valueType :db.type/ref
+    :db/cardinality :db.cardinality/one
+    :db/isComponent true}
+   {:db/ident :execution/tx-size
+    :db/valueType :db.type/long
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :execution/data-type
+    :db/valueType :db.type/keyword
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :execution/data-in-db?
+    :db/valueType :db.type/boolean
+    :db/cardinality :db.cardinality/one}
+
+   {:db/ident :tag                                          ;; for branch identifier
+    :db/valueType :db.type/string
+    :db/cardinality :db.cardinality/many}])
+
+
+(defn parse-body [{:keys [body] :as _response}]
+  (if-not (empty? body)
+    (edn/read-string body)
+    ""))
+
+(defn db-request
+  ([db method route] (db-request db method route nil))
+  ([db method route body]
+   (-> (client/request (merge {:url (str (:baseurl db) "/" route)
+                               :method method
+                               :content-type "application/edn"
+                               :accept "application/edn"}
+                              (when (or (= method :post) body)
+                                {:body (str body)})
+                              {:headers {:authorization (str "token " (:token db))
+                                         :db-name (:dbname db)}}))
+       parse-body)))
+
+(defn transact-data [db tx-data]
+  (db-request db :post "transact" {:tx-data tx-data}))
+
+(defn get-datoms [db]
+  (db-request db :post "datoms" {:index :eavt}))
+
+(defn get-schema [db]
+  (db-request db :get "schema"))
+
+(defn transact-results [db results]
+  (transact-data db results))
+
+(defn transact-missing-schema [db]
+  (let [current-schema (get-schema db)
+        defined-attribs (vals current-schema)
+        missing-schema (filterv (fn [entity] (not-any? #(= % (:db/ident entity))
+                                                       defined-attribs))
+                                schema)]
+    (when (not-empty missing-schema)
+      (transact-data db missing-schema))))
+
+(defn add-ns-to-keys [current-ns hmap]
+  (reduce-kv (fn [m k v]
+               (let [next-key (if (= current-ns "") k (keyword (str current-ns "/" (name k))))
+                     next-ns (name k)
+                     next-val (cond
+                                (map? v)
+                                (add-ns-to-keys next-ns v)
+
+                                (and (vector? v) (map? (first v)))
+                                (mapv (partial add-ns-to-keys next-ns) v)
+
+                                :else v)]
+                 (assoc m next-key next-val)))
+             {}
+             hmap))
+
+(defn server-description [options]
+  (select-keys options [:db-server-url :db-token :db-name]))
+
+;; file output
+
+(defn save-measurements-to-file [paths measurements]
+  (let [filename (first paths)]
+    (try
+      (if (pos? (count paths))
+        (do (spit filename measurements)
+            (println "Measurements successfully saved to" filename))
+        (println measurements))
+      (catch Exception e
+        (println measurements)
+        (println (str "Something went wrong while trying to save measurements to file " filename ":"))
+        (.printStackTrace e)))))
+
+;; multi method implementations
+
+(defmulti save
+          (fn [options _paths _measurements] (:output-format options)))
+
+(defmethod save :default  [_options _paths measurements]
+  (println "No output format given!")
+  (println "Using standard output channel...")
+  (pprint measurements))
+
+(defmethod save "edn"  [_options paths measurements]
+  (save-measurements-to-file paths measurements))
+
+(defmethod save "csv"  [_options paths measurements]
+  (let [col-paths (map :path c/csv-cols)
+        titles (map :title c/csv-cols)
+        csv (str (join "\t" titles) "\n"
+                 (join "\n" (for [result (sort-by (apply juxt (map (fn [path] (fn [measurement] (get-in measurement path)))
+                                                                   col-paths))
+                                                  measurements)]
+                              (join "\t" (map (fn [path] (get-in result path ""))
+                                              col-paths)))))]
+    (save-measurements-to-file paths csv)))
+
+(defmethod save "remote-db"  [options _paths measurements]
+  (let [rdb (apply ->RemoteDB (server-description options))
+        db-entry (mapv #(->> (dissoc % :context)
+                             (merge (:context %))
+                             (add-ns-to-keys ""))
+                       measurements)]
+    (println "Database used:" rdb)
+    (try
+      (transact-missing-schema rdb)
+      (transact-results rdb db-entry)
+      (println "Successfully saved measurements to remote database.")
+      (catch Exception e
+        (println measurements)
+        (println (str "Something went wrong while trying to save measurements to remote database:"))
+        (.printStackTrace e)))))