konserve.impl.defaults — org.replikativ/konserve 0.9.347

Default implementation of the high level protocol given a binary backing implementation as defined in the storage-layout namespace.

connect-default-store clj/s

(connect-default-store backing
                       {:keys [default-serializer serializers read-handlers
                               write-handlers buffer-size config opts]
                        :or {default-serializer :FressianSerializer
                             read-handlers (atom {})
                             write-handlers (atom {})
                             buffer-size (* 1024 1024)
                             opts {:sync? false}}})

Create general store in given base of backing store.

delete-blob clj/s

(delete-blob backing env)

Remove/Delete key-value pair of backing store by given key. If success it will return true.

get-lock clj/s

(get-lock this store-key env)

io-operation clj/s

(io-operation {:keys [backing]}
              serializers
              read-handlers
              write-handlers
              {:keys [key-vec operation default-serializer sync? overwrite?
                      config]
               :as env})

Read/Write blob. For better understanding use the flow-chart of konserve.

key->store-key clj/s

(key->store-key key)

list-keys clj/s

(list-keys {:keys [backing]}
           serializers
           read-handlers
           write-handlers
           {:keys [sync? config] :as env})

Return all keys in the store.

max-lock-attempts clj/s

prepare-multi-assoc clj/s

(prepare-multi-assoc backing
                     serializers
                     read-handlers
                     write-handlers
                     {:keys [kvs meta-up-fn default-serializer compressor
                             encryptor version config]
                      :as env})

Prepares multiple key-value pairs for writing to the backing store. Handles serialization, metadata updates, and key translation.

read-blob clj/s

(read-blob blob
           read-handlers
           serializers
           {:keys [sync? operation locked-cb config _store-key] :as env})

Read meta, edn or binary from blob.

read-header clj/s

(read-header ac serializers env)

store-key->uuid-key clj/s

(store-key->uuid-key store-key)

update-blob clj/s

(update-blob backing
             store-key
             serializer
             write-handlers
             {:keys [key-vec compressor encryptor up-fn up-fn-meta config
                     operation input sync? version]
              :as env}
             [old-meta old-value])

This function writes first the meta-size, then the meta-data and then the actual updated data into the underlying backing store.