Clear all keys from the database

Clear a key from the database

(let [fd  (select-api-version 520)
      key "foo"]
(with-open [db (open fd)]
   (tr! db (clear-key tr key))))

Clear a range of keys from the database. When only begin is given then the keys with starting with the tuple are cleared. When begin and end are specified then end is exclusive of the range to be cleared.

(let [fd    (select-api-version 520)
      begin "foo"]
(with-open [db (open fd)]
   (tr! db (clear-range tr begin))))

(let [fd    (select-api-version 520)
      begin "foo"
      end   "foo"]
(with-open [db (open fd)]
   (tr! db (clear-range tr begin end))))

Returns key and value pairs with keys greater than or equal to the given key for the given limit

(let [fd  (select-api-version 520)
      key "foo"]
(with-open [db (open fd)]
   (tr! db (first-greater-or-equal tr key))))

Returns key and value pairs with keys greater than the given key for the given limit

(let [fd  (select-api-version 520)
      key "foo"]
(with-open [db (open fd)]
   (tr! db (first-greater-than tr key))))

Get all key values as a vector

Get a range of key values as a vector

(let [fd    (select-api-version 520)
      begin "foo"
      end   "foo"]
(with-open [db (open fd)]
   (tr! db (get-range tr begin end))))

Get a range of key values as a vector that starts with prefix

(let [fd     (select-api-version 520)
      prefix "f"]
(with-open [db (open fd)]
   (tr! db (get-range-startswith tr key prefix))))

Get the value for the given key. Accepts the below :

:subspace - Subspace to be prefixed :coll - Boolean to indicate if the value needs to be deserialized as collection

(let [fd  (select-api-version 520)
      key "foo"]
(with-open [db (open fd)]
   (tr! db
        (get-val tr key))))

(let [fd    (select-api-version 520)
     key   "foo"
     value [1 2 3]]
(with-open [db (open fd)]
  (tr! db
       (set-val tr key value)
       (get-val tr key) ;; 1
       (get-val tr key :coll true)))) ;; [1 2 3]

Returns key and value pairs with keys less than or equal the given key for the given limit

(let [fd  (select-api-version 520)
      key "foo"]
(with-open [db (open fd)]
   (tr! db (last-less-or-equal tr key))))

Returns key and value pairs with keys less than the given key for the given limit

(let [fd  (select-api-version 520)
      key "foo"]
(with-open [db (open fd)]
   (tr! db (last-less-than tr key))))

Returns a key with name as prefix

(make-subspace ["class" "intro"] ["algebra"]) returns ("class" "intro" "algebra")

Set given keys with the value

(let [fd    (select-api-version 520)
      keys  ["foo" "baz"]
      value "bar"]
(with-open [db (open fd)]
   (tr! db (set-keys tr keys value))))

Set a value for the key. Accepts the below :

:subspace - Subspace to be prefixed

(let [fd    (select-api-version 520)
      key   "foo"
      value "bar"]
(with-open [db (open fd)]
   (tr! db
        (set-val tr key value))))

Transaction macro to perform actions. Always use tr for actions inside each action since the transaction variable is bound to tr in the functions.

(let [fd    (select-api-version 520)
      key   "foo"
      value "bar"]
(with-open [db (open fd)]
   (tr! db
        (set-val tr key value)
        (get-val tr key))))

A key to watch and a callback function to be executed on change. It returns a future object that is realized when there is a change to key. Change in key value or clearing the key is noted as a change. A set statement with the old value is not a change.

(let [fd    (select-api-version 520)
     key    "foo"
     value  "bar"]
(with-open [db (open fd)]
  (tr! db
       (clear-key tr key)
       (watch tr key #(println "key is set"))
       (set-val tr key value)
       (watch tr key #(println "key is changed to 1"))
       (set-val tr key value) ;; Doesn't trigger watch
       (set-val tr key "1")
       (watch tr key #(println "cleared key"))
       (clear-key tr key))))

key is set key is changed to 1 cleared key

Sets and gets the keys with the given subspace key prefixed. This essentially executes with code binding the given prefix to subspace.

(let [fd    (select-api-version 520)
      key   "foo"
      value "bar"]
  (with-open [db (open fd)]
    (tr! db
         (clear-all tr)
         (with-subspace "class"
           (set-val tr key value)
           (get-val tr key))
          (nil? (get-val tr key)))))