datahike-browser-tests 1.0.0

package/src/datahike/query_stats.cljc

@@ -0,0 +1,88 @@
+(ns datahike.query-stats
+  (:require [clojure.set :as set]
+            [datahike.tools :as dt]))
+
+(defn round [precision x]
+  #?(:clj (with-precision ^long precision ^java.math.BigDecimal x)
+     :cljs (let [y (Math/pow 10 precision)]
+             (/ (.round js/Math (* y x)) y))))
+
+(defn compatible-abs [^long n]
+  #?(:clj  (Math/abs n)
+     :cljs (js/Math.abs n)))
+
+(defn get-stats [context]
+  {:rels (mapv (fn [rel] {:rows (count (:tuples rel))
+                          :bound (set (keys (:attrs rel)))})
+               (:rels context))})
+
+(defn update-ctx-with-stats
+  "update-fn must expect [context] as argument"
+  [context clause update-fn]
+  (if (:stats context)
+    (let [{:keys [res t]} (dt/timed #(update-fn context))
+          clause-stats (merge (get-stats res)
+                              {:clause clause
+                               :t t}
+                              (:tmp-stats res))]
+      (-> res
+          (update :stats conj clause-stats)
+          (dissoc :tmp-stats)))
+    (update-fn context)))
+
+(defn extend-stat
+  "Adds summarized row counts, bindings and clause time for convenience"
+  [{:keys [branches rels] :as stat}]
+  (assoc stat
+         :id (subs (str (compatible-abs (hash stat))) 0 6)
+         :t-branches (reduce #(+ %1 (:t %2)) 0.0 branches)
+         :rel-count (count rels)
+         :rows (reduce #(+ %1 (:rows %2)) 0 rels)
+         :bound (reduce #(set/union %1 (:bound %2)) #{} rels)
+         :branches (mapv extend-stat branches)))
+
+(defn get-stat-diffs [parent-node prev-node {:keys [t t-branches rows bound] :as node}]
+  (let [extend-and-branches (fn [branches]
+                              (mapv (partial get-stat-diffs node)
+                                    (cons prev-node branches)
+                                    branches))
+        extend-or-branches (fn [branches]
+                             (mapv (partial get-stat-diffs node prev-node) branches))]
+    (-> node
+        (dissoc :rows :bound)
+        (assoc :prev (:id prev-node)
+               :parent (:id parent-node)
+               :t-diff (round 6 (- t t-branches))
+               :rows-in (:rows prev-node)
+               :rows-out rows
+               :rows-diff (- rows (:rows prev-node))
+               :bound-in (:bound prev-node)
+               :bound-out bound
+               :bound-diff (set/difference bound (:bound prev-node)))
+        (update :branches (case (:type node)
+                            :and extend-and-branches
+                            :or extend-or-branches
+                            :or-join extend-or-branches
+                            :rule extend-or-branches
+                            :solve extend-and-branches
+                            identity)))))
+
+(defn extend-stats [stats]
+  (let [extended (map extend-stat stats)
+        root {:rows 0 :bound (set []) :id "_root_"}]
+    (mapv (partial get-stat-diffs root)
+          (cons root extended)
+          extended)))
+
+(defn stats-table
+  ([stats]
+   (stats-table stats [:id :prev :parent :clause :type
+                       :rows-in :rows-diff :bound-in :bound-diff
+                       :t :t-diff :clauses]))
+  ([stats cols]
+   (->> stats
+        extend-stats
+        (hash-map :branches)
+        (tree-seq map? :branches)
+        rest
+        (map (apply juxt cols)))))

package/src/datahike/readers.cljc

@@ -0,0 +1,62 @@
+(ns datahike.readers
+  (:require [datahike.connections :refer [get-connection *connections*]]
+            [datahike.writing :as dw]
+            [datahike.datom :refer [datom] :as dd]
+            #?(:cljs [datahike.db :refer [HistoricalDB AsOfDB SinceDB]])
+            [datahike.impl.entity :as de]
+            [datahike.core :refer [init-db] :as dc]
+            [datahike.tools :refer [raise]]
+            [konserve.core :as k])
+  #?(:clj
+     (:import [datahike.datom Datom]
+              [datahike.db HistoricalDB AsOfDB SinceDB])))
+
+(def tempid dc/tempid)
+
+(def datom-from-reader dd/datom-from-reader)
+
+(defn db-from-reader [{:keys [schema datoms store-id commit-id] :as raw-db}]
+  (if (and store-id commit-id)
+    #?(:cljs (throw (ex-info "Reader not supported." {:type   :reader-not-supported
+                                                      :raw-db raw-db}))
+       :clj
+       (if-let [conn (get-connection store-id)]
+         (let [store (:store @conn)]
+           (when-let [raw-db (k/get store commit-id nil {:sync? true})]
+             (dw/stored->db raw-db store)))
+         (raise (ex-info "Could not find active connection. Did you connect already?"
+                         {:type :no-connection-for-db
+                          :raw-db raw-db}))))
+    (init-db (map (fn [[e a v tx]] (datom e a v tx)) datoms) schema)))
+
+(defn history-from-reader [{:keys [origin]}]
+  (HistoricalDB. origin))
+
+(defn since-from-reader [{:keys [origin time-point]}]
+  (AsOfDB. origin time-point))
+
+(defn as-of-from-reader [{:keys [origin time-point]}]
+  (SinceDB. origin time-point))
+
+(defn connection-from-reader [conn-id]
+  (:conn (@*connections* conn-id)))
+
+(defn entity-from-reader [{:keys [db eid]}]
+  (de/entity db eid))
+
+(def ^{:doc "Data readers for EDN readers. In CLJS they’re registered automatically. In CLJ, if `data_readers.clj` do not work, you can always do
+
+             ```
+             (clojure.edn/read-string {:readers data-readers} \"...\")
+             ```"}
+  edn-readers
+  {'datahike/Datom        datahike.readers/datom-from-reader
+   'datahike/DB           datahike.readers/db-from-reader
+   'datahike/HistoricalDB datahike.readers/history-from-reader
+   'datahike/SinceDB      datahike.readers/since-from-reader
+   'datahike/AsOfDB       datahike.readers/as-of-from-reader
+   'datahike/Connection   datahike.readers/connection-from-reader
+   'db/id                 datahike.readers/tempid})
+
+#?(:cljs
+   (doseq [[tag cb] edn-readers] (cljs.reader/register-tag-parser! tag cb)))

package/src/datahike/remote.cljc

@@ -0,0 +1,218 @@
+(ns datahike.remote
+  "Literals that can function as lightweight remote pointers to connections and
+  dbs."
+  (:require [cognitect.transit :as transit]
+            [jsonista.core :as j]
+            [jsonista.tagged :as jt]
+            [clojure.edn :as edn]
+            [datahike.json :refer [json-base-handlers]]
+            [datahike.datom :as dd])
+  #?(:clj
+     (:import [clojure.lang IDeref]
+              [datahike.datom Datom]
+              [com.fasterxml.jackson.core JsonGenerator])))
+
+;; https://github.com/thi-ng/color/issues/10
+;; fixes lein repl / Cloure 1.10.0 
+(prefer-method print-method java.util.Map clojure.lang.IDeref)
+
+;; fixes lein repl / Clojure 1.10.1
+(prefer-method print-method clojure.lang.IPersistentMap clojure.lang.IDeref)
+
+;; fixes CIDER / Clojure 1.9.0 / 1.10.0 / 1.10.1
+(prefer-method clojure.pprint/simple-dispatch clojure.lang.IPersistentMap clojure.lang.IDeref)
+
+;; Remote peer currently operated on. This is used to allow the tagged literal
+;; readers to attach the remote again.
+(def ^:dynamic *remote-peer* nil)
+
+(defmulti remote-deref (fn [{:keys [remote-peer]}] (:backend remote-peer)))
+
+(defprotocol PRemotePeer
+  (-remote-peer [_] "Retrieve remote peer."))
+
+(extend-protocol PRemotePeer
+  Object
+  (-remote-peer [_] nil))
+
+(defn remote-peer [obj] (-remote-peer obj))
+
+(defrecord RemoteConnection [store-id remote-peer]
+  #?@(:clj
+      [IDeref
+       (deref [conn] (remote-deref conn))
+       PRemotePeer
+       (-remote-peer [_] remote-peer)]))
+
+(defn remote-connection [store-id]
+  (RemoteConnection. store-id *remote-peer*))
+
+#?(:clj
+   (defmethod print-method RemoteConnection
+     [^RemoteConnection conn ^java.io.Writer w]
+     (.write w "#datahike/RemoteConnection")
+     (.write w (pr-str (:store-id conn)))))
+
+(defrecord RemoteDB [store-id max-tx max-eid commit-id remote-peer]
+  PRemotePeer
+  (-remote-peer [_] remote-peer))
+
+(defn remote-db [m]
+  (assoc (map->RemoteDB m) :remote-peer *remote-peer*))
+
+#?(:clj
+   (defmethod print-method RemoteDB
+     [^RemoteDB db ^java.io.Writer w]
+     (.write w "#datahike/RemoteDB")
+     (.write w (pr-str  (into {} (dissoc db :remote-peer))))))
+
+(defrecord RemoteHistoricalDB [origin remote-peer]
+  PRemotePeer
+  (-remote-peer [_] remote-peer))
+
+(defn remote-historical-db [m]
+  (assoc (map->RemoteHistoricalDB m) :remote-peer *remote-peer*))
+
+#?(:clj
+   (defmethod print-method RemoteHistoricalDB
+     [^RemoteDB db ^java.io.Writer w]
+     (.write w "#datahike/RemoteHistoricalDB")
+     (.write w (pr-str  (into {} (dissoc db :remote-peer))))))
+
+(defrecord RemoteSinceDB [origin time-point remote-peer]
+  PRemotePeer
+  (-remote-peer [_] remote-peer))
+
+(defn remote-since-db [m]
+  (assoc (map->RemoteSinceDB m) :remote-peer *remote-peer*))
+
+#?(:clj
+   (defmethod print-method RemoteSinceDB
+     [^RemoteDB db ^java.io.Writer w]
+     (.write w "#datahike/RemoteSinceDB")
+     (.write w (pr-str  (into {} (dissoc db :remote-peer))))))
+
+(defrecord RemoteAsOfDB [origin time-point remote-peer]
+  PRemotePeer
+  (-remote-peer [_] remote-peer))
+
+(defn remote-as-of-db [m]
+  (assoc (map->RemoteAsOfDB m) :remote-peer *remote-peer*))
+
+#?(:clj
+   (defmethod print-method RemoteAsOfDB
+     [^RemoteDB db ^java.io.Writer w]
+     (.write w "#datahike/RemoteAsOfDB")
+     (.write w (pr-str  (into {} (dissoc db :remote-peer))))))
+
+(defrecord RemoteEntity [db eid remote-peer]
+  PRemotePeer
+  (-remote-peer [_] remote-peer))
+
+(defn remote-entity [m]
+  (assoc (map->RemoteEntity m) :remote-peer *remote-peer*))
+
+#?(:clj
+   (defmethod print-method RemoteEntity
+     [^RemoteEntity e ^java.io.Writer w]
+     (.write w "#datahike/RemoteEntity")
+     (.write w (pr-str (dissoc (into {} e) :remote-peer)))))
+
+(defn edn-replace-remote-literals [s]
+  (reduce (fn [^String s [^String from ^String to]]
+            (.replace s from to))
+          s
+          [["#datahike/RemoteConnection" "#datahike/Connection"]
+           ["#datahike/RemoteDB" "#datahike/DB"]
+           ["#datahike/RemoteHistoricalDB" "#datahike/HistoricalDB"]
+           ["#datahike/RemoteSinceDB" "#datahike/SinceDB"]
+           ["#datahike/RemoteAsOfDB" "#datahike/AsOfDB"]]))
+
+(def edn-readers {'datahike/Connection   remote-connection
+                  'datahike/DB           remote-db
+                  'datahike/HistoricalDB remote-historical-db
+                  'datahike/AsOfDB       remote-as-of-db
+                  'datahike/SinceDB      remote-since-db
+                  'datahike/Datom        datahike.datom/datom-from-reader
+                  'datahike.db.TxReport  datahike.db/map->TxReport})
+
+(defn map-without-remote [r]
+  (dissoc (into {} r) :remote-peer))
+
+(defn datom-as-vec [^Datom d]
+  [(.-e d) (.-a d) (.-v d) (dd/datom-tx d) (dd/datom-added d)])
+
+(defn datom-from-vec [v] (apply dd/datom v))
+
+(def transit-write-handlers {datahike.remote.RemoteConnection   (transit/write-handler "datahike/Connection" #(:store-id %))
+                             datahike.datom.Datom               (transit/write-handler "datahike/Datom" datom-as-vec)
+                             datahike.remote.RemoteDB           (transit/write-handler "datahike/DB" map-without-remote)
+                             datahike.remote.RemoteHistoricalDB (transit/write-handler "datahike/HistoricalDB" map-without-remote)
+                             datahike.remote.RemoteSinceDB      (transit/write-handler "datahike/SinceDB" map-without-remote)
+                             datahike.remote.RemoteAsOfDB       (transit/write-handler "datahike/AsOfDB" map-without-remote)
+                             datahike.remote.RemoteEntity       (transit/write-handler "datahike/Entity" #(into {} %))})
+
+(def transit-read-handlers {"datahike/Connection"   (transit/read-handler remote-connection)
+                            "datahike/Datom"        (transit/read-handler datom-from-vec)
+                            "datahike/TxReport"     (transit/read-handler datahike.db/map->TxReport)
+                            "datahike/DB"           (transit/read-handler remote-db)
+                            "datahike/HistoricalDB" (transit/read-handler remote-historical-db)
+                            "datahike/SinceDB"      (transit/read-handler remote-since-db)
+                            "datahike/AsOfDB"       (transit/read-handler remote-as-of-db)
+                            "datahike/Entity"       (transit/read-handler remote-entity)})
+
+(declare json-mapper)
+
+(defn write-to-generator [f]
+  (fn [x ^JsonGenerator gen]
+    (let [json-out (j/write-value-as-string (f x) json-mapper)]
+      (.writeRawValue gen json-out))))
+
+(def json-mapper-opts
+  {:encode-key-fn true
+   :decode-key-fn true
+   :modules       [(jt/module
+                    {:handlers
+                     (merge
+                      json-base-handlers
+                      {datahike.remote.RemoteConnection
+                       {:tag    "!datahike/Connection"
+                        :encode (write-to-generator :store-id)
+                        :decode remote-connection}
+
+                       datahike.datom.Datom
+                       {:tag    "!datahike/Datom"
+                        :encode (write-to-generator datom-as-vec)
+                        :decode datom-from-vec}
+
+                       datahike.db.TxReport
+                       {:tag    "!datahike/TxReport"
+                        :encode (write-to-generator #(into {} %))
+                        :decode datahike.db/map->TxReport}
+
+                       datahike.remote.RemoteDB
+                       {:tag    "!datahike/DB"
+                        :encode (write-to-generator map-without-remote)
+                        :decode remote-db}
+
+                       datahike.remote.RemoteHistoricalDB
+                       {:tag    "!datahike/HistoricalDB"
+                        :encode (write-to-generator map-without-remote)
+                        :decode remote-historical-db}
+
+                       datahike.remote.RemoteSinceDB
+                       {:tag    "!datahike/SinceDB"
+                        :encode (write-to-generator map-without-remote)
+                        :decode remote-since-db}
+
+                       datahike.remote.RemoteAsOfDB
+                       {:tag    "!datahike/AsOfDB"
+                        :encode (write-to-generator map-without-remote)
+                        :decode remote-as-of-db}
+
+                       datahike.remote.RemoteEntity
+                       {:tag    "!datahike/Entity"
+                        :encode (write-to-generator #(into {} %))
+                        :decode remote-entity}})})]})
+
+(def json-mapper (j/object-mapper json-mapper-opts))

package/src/datahike/schema.cljc

@@ -0,0 +1,228 @@
+(ns ^:no-doc datahike.schema
+  (:require [clojure.spec.alpha :as s]
+            [datahike.datom])
+  #?(:clj (:import [datahike.datom Datom])))
+
+(s/def :db.type/id #?(:clj #(or (= (class %) java.lang.Long) string?)
+                      :cljs #(or (and (number? %)
+                                      (js/Number.isSafeInteger %))
+                                 string?)))
+
+;; db types
+(s/def :db.type/bigdec #?(:cljs (complement any?) ; feels more appropriate than hiding key -pat
+                          :clj decimal?))
+(s/def :db.type/bigint #?(:clj integer?
+                          :cljs #(or (integer? %)
+                                     (= js/BigInt (type %)))))
+(s/def :db.type/boolean boolean?)
+(s/def :db.type/bytes #?(:clj bytes?
+                         :cljs #(and (some->> (.-buffer %) (instance? js/ArrayBuffer))
+                                     (some->> (.-byteLength %) (number?)))))
+(s/def :db.type/double double?)
+(s/def :db.type/float float?)
+(s/def :db.type/number number?)
+(s/def :db.type/instant #?(:clj #(= (class %) java.util.Date)
+                           :cljs inst?))
+(s/def :db.type/keyword keyword?)
+(s/def :db.type/long #?(:clj #(= (class %) java.lang.Long)
+                        :cljs #(js/Number.isSafeInteger %)))
+(s/def :db.type/ref :db.type/id)
+(s/def :db.type/string string?)
+(s/def :db.type/symbol symbol?)
+(s/def :db.type/uuid uuid?)
+(s/def :db.type/tuple vector?)
+
+(s/def :db.type/value
+  #{:db.type/bigdec
+    :db.type/bigint
+    :db.type/boolean
+    :db.type/bytes
+    :db.type/double
+    :db.type/float
+    :db.type/number
+    :db.type/instant
+    :db.type/keyword
+    :db.type/long
+    :db.type/ref
+    :db.type/string
+    :db.type/symbol
+    :db.type/uuid
+    :db.type/value
+    :db.type/tuple
+    :db.type/cardinality
+    :db.type.install/attribute
+    :db.type/valueType
+    :db.type/unique})
+
+;; TODO: add bytes
+
+(s/def :db.type/cardinality #{:db.cardinality/one :db.cardinality/many})
+(s/def :db.type/unique #{:db.unique/identity :db.unique/value})
+
+;; only for old datomic compliance, will be part of partioning in the future
+(s/def :db.type.install/_attribute #{:db.part/tx :db.part/db :db.part/user})
+
+(s/def ::schema-attribute #{:db/id :db/ident :db/isComponent :db/noHistory :db/valueType :db/cardinality :db/unique :db/index :db.install/_attribute :db/doc :db/tupleAttrs  :db/tupleType :db/tupleTypes})
+
+(s/def ::entity-spec-attribute #{:db/ensure :db.entity/attrs :db.entity/preds})
+(s/def ::meta-attribute #{:db/txInstant :db/retracted :db/noCommit})
+
+(s/def ::schema (s/keys :req [:db/ident :db/valueType :db/cardinality]
+                        :opt [:db/id :db/unique :db/index :db.install/_attribute :db/doc :db/noHistory :db/tupleType :db/tupleTypes]))
+
+(s/def ::entity-spec (s/keys :opt [:db.entity/attrs :db.entity/preds]))
+
+(s/def ::enum (s/keys :req [:db/ident]))
+
+(def required-keys #{:db/ident :db/valueType :db/cardinality})
+
+(def ^:const implicit-schema-spec {:db/ident {:db/valueType   :db.type/keyword
+                                              :db/unique      :db.unique/identity
+                                              :db/cardinality :db.cardinality/one}
+                                   :db/valueType {:db/valueType   :db.type/value
+                                                  :db/unique      :db.unique/identity
+                                                  :db/cardinality :db.cardinality/one}
+                                   :db/id {:db/valueType   :db.type/id
+                                           :db/unique      :db.unique/identity
+                                           :db/cardinality :db.cardinality/one}
+                                   :db/cardinality {:db/valueType   :db.type/cardinality
+                                                    :db/unique      :db.unique/identity
+                                                    :db/cardinality :db.cardinality/one}
+                                   :db/index {:db/valueType   :db.type/boolean
+                                              :db/unique      :db.unique/identity
+                                              :db/cardinality :db.cardinality/one}
+                                   :db/unique {:db/valueType   :db.type/unique
+                                               :db/unique      :db.unique/identity
+                                               :db/cardinality :db.cardinality/one}
+                                   :db/isComponent {:db/valueType :db.type/boolean
+                                                    :db/unique :db.unique/identity
+                                                    :db/cardinality :db.cardinality/one}
+                                   :db/noHistory {:db/valueType :db.type/boolean
+                                                  :db/unique :db.unique/identity
+                                                  :db/cardinality :db.cardinality/one}
+                                   :db/txInstant {:db/valueType :db.type/instant
+                                                  :db/unique :db.unique/identity
+                                                  :db/index true
+                                                  :db/cardinality :db.cardinality/one}
+                                   :db/noCommit  {:db/valueType :db.type/boolean
+                                                  :db/unique :db.unique/identity
+                                                  :db/cardinality :db.cardinality/one}
+                                   :db/retracted {:db/valueType :db.type/long
+                                                  :db/unique :db.unique/identity
+                                                  :db/cardinality :db.cardinality/many}
+                                   :db/ensure {:db/valueType :db.type/keyword
+                                               :db/cardinality :db.cardinality/one}
+                                   :db.entity/attrs {:db/valueType :db.type/keyword
+                                                     :db/cardinality :db.cardinality/many}
+                                   :db.entity/preds {:db/valueType :db.type/symbol
+                                                     :db/cardinality :db.cardinality/many}
+                                   :db/doc {:db/valueType :db.type/string
+                                            :db/index true
+                                            :db/cardinality :db.cardinality/one}
+                                   :db.install/_attribute {:db/valueType   :db.type.install/_attribute
+                                                           :db/unique      :db.unique/identity
+                                                           :db/cardinality :db.cardinality/one}
+                                   :db/tupleType {:db/valueType :db.type/value
+                                                  :db/cardinality :db.cardinality/one}
+                                   :db/tupleTypes {:db/valueType :db.type/tuple
+                                                   :db/cardinality :db.cardinality/one}
+                                   :db/tupleAttrs {:db/valueType :db.type/tuple
+                                                   :db/cardinality :db.cardinality/one}})
+(s/def :db/helpers #{:db.install/attribute :db})
+(s/def :db.part/types #{:db.part/tx :db.part/sys :db.part/user})
+
+(s/def :db.meta/attributes #{:db/txInstant})
+
+(s/def ::sys-idents (s/or :value :db.type/value
+                          :cardinality :db.type/cardinality
+                          :parts :db.part/types
+                          :helpers :db/helpers
+                          :meta :db.meta/attributes
+                          :unique :db.type/unique))
+
+(def schema-keys #{:db/ident :db/isComponent :db/noHistory :db/valueType :db/cardinality :db/unique :db/index :db.install/_attribute :db/doc :db/tupleType :db/tupleTypes :db/tupleAttrs})
+
+(s/def ::old-schema-val (s/keys :req [:db/valueType :db/cardinality]
+                                :opt [:db/ident :db/unique :db/index :db.install/_attribute :db/doc :db/noHistory]))
+
+(s/def ::old-schema-key keyword?)
+
+(s/def ::old-schema (s/nilable (s/map-of ::old-schema-key ::old-schema-val)))
+
+(defn old-schema-valid? [schema]
+  (s/valid? ::old-schema schema))
+
+(defn explain-old-schema [schema]
+  (s/explain-data ::old-schema schema))
+
+(defn meta-attr? [a-ident]
+  (s/valid? ::meta-attribute a-ident))
+
+(defn schema-attr? [a-ident]
+  (s/valid? ::schema-attribute a-ident))
+
+(defn sys-ident? [a-ident]
+  (s/valid? ::sys-idents a-ident))
+
+(defn entity-spec-attr? [a-ident]
+  (s/valid? ::entity-spec-attribute a-ident))
+
+(defn value-valid? [a-ident v-ident schema]
+  (let [schema (if (or (meta-attr? a-ident) (schema-attr? a-ident) (entity-spec-attr? a-ident))
+                 implicit-schema-spec
+                 schema)
+        value-type (get-in schema [a-ident :db/valueType])]
+    (s/valid? value-type v-ident)))
+
+(defn instant? [db ^Datom datom schema]
+  (let [a-ident (if (:attribute-refs? (:config db))
+                  ((:ref-ident-map db) (.-a datom))
+                  (.-a datom))
+        schema (if (or (meta-attr? a-ident) (schema-attr? a-ident))
+                 implicit-schema-spec
+                 schema)]
+    (= (get-in schema [a-ident :db/valueType]) :db.type/instant)))
+
+(defn schema-entity? [entity]
+  (some #(contains? entity %) schema-keys))
+
+(defn schema? [schema]
+  (s/valid? ::schema schema))
+
+(defn describe-type [schema-type]
+  (s/describe schema-type))
+
+(defn find-invalid-schema-updates [entity attr-schema]
+  (reduce-kv
+   (fn [m attr-def new-value]
+     (let [old-value (get-in attr-schema [attr-def])]
+       (when (not= old-value new-value)
+         (case attr-def
+           :db/cardinality
+           ;; Prohibit update from :db.cardinality/one to :db.cardinality/many, if there is a :db/unique constraint.
+           (when (and (= new-value :db.cardinality/many)
+                      (#{:db.unique/value :db.unique/identity} (:db/unique attr-schema)))
+             (assoc m attr-def [old-value new-value]))
+
+           :db/unique
+           (when (or (not (:db/unique attr-schema))
+                     (not= :db.cardinality/one (:db/cardinality attr-schema)))
+             (assoc m attr-def [old-value new-value]))
+
+           ;; Always allow these attributes to be updated. 
+           :db/doc nil
+           :db/noHistory nil
+           :db/isComponent nil
+
+           (assoc m attr-def [old-value new-value])))))
+   {}
+   (dissoc entity :db/id)))
+
+(defn is-system-keyword? [value]
+  (and (or (keyword? value) (string? value))
+       (if-let [ns (namespace (keyword value))]
+         (= "db" (first (clojure.string/split ns #"\.")))
+         false)))
+
+(defn get-user-schema [{:keys [schema] :as db}]
+  (into {} (filter #(not (is-system-keyword? (key %))) schema)))

package/src/datahike/schema_cache.cljc

@@ -0,0 +1,42 @@
+(ns datahike.schema-cache
+  (:require #?(:clj [clojure.core.cache.wrapped :as cw]
+               :cljs [cljs.cache.wrapped :as cw])
+            [datahike.config :as dc]
+            [datahike.store :as ds]))
+
+;; Shared schema read cache across all stores
+(def schema-meta-cache (cw/lru-cache-factory {} :threshold dc/*schema-meta-cache-size*))
+
+;; LRU cache of LRU caches for write operations, one per store
+(def schema-write-caches
+  (cw/lru-cache-factory {} :threshold dc/*schema-write-cache-max-db-count*))
+
+(defn- get-or-create-write-cache [store-config]
+  (let [store-id (ds/store-identity store-config)]
+    (if (cw/has? schema-write-caches store-id)
+      (cw/lookup schema-write-caches store-id)
+      (let [new-cache (cw/lru-cache-factory {} :threshold dc/*schema-meta-cache-size*)]
+        (cw/miss schema-write-caches store-id new-cache)
+        new-cache))))
+
+(defn cache-has? [schema-meta-key]
+  (cw/has? schema-meta-cache schema-meta-key))
+
+(defn cache-lookup [schema-meta-key]
+  (cw/lookup schema-meta-cache schema-meta-key))
+
+(defn cache-miss [schema-meta-key schema-meta]
+  (cw/miss schema-meta-cache schema-meta-key schema-meta))
+
+(defn write-cache-has? [store-config schema-meta-key]
+  (let [write-cache (get-or-create-write-cache store-config)]
+    (cw/has? write-cache schema-meta-key)))
+
+(defn add-to-write-cache [store-config schema-meta-key]
+  (let [write-cache (get-or-create-write-cache store-config)]
+    (cw/miss write-cache schema-meta-key true)))
+
+(defn clear-write-cache [store-config]
+  (let [store-id (ds/store-identity store-config)]
+    (cw/evict schema-write-caches store-id)))
+