me.vedang.clj-fdb.core — me.vedang/clj-fdb 0.3.0

clear clj

(clear tc k)

(clear tc s k)

(clear tc k opts)

(clear tc s k opts)

Takes the following:

• TransactionContext tc
• key to be cleared k
• opts : unused at the moment, will support options like :async? in a later release.

Clears the key from the db. Returns nil.

clear-range clj

(clear-range tc r)

(clear-range tc s t)

(clear-range tc r opts)

(clear-range tc s t opts)

Takes the following:

• TransactionContext tc
• Range of keys to be cleared rg
• opts : unused at the moment, will support options like :async? in a later release.

Clears the range from the db. Returns nil.

default-opts clj

The default options to be passed into any options map

get clj

(get tc k)

(get tc s k)

(get tc k opts)

(get tc s k opts)

Takes the following:

• TransactionContext tc
• key to be fetched k (should be byte-array, or convertible to byte-array)
• Subspace s, if you want to store the key under one.

The opts map supports the following arguments:

• Function valfn for converting the return value from byte-array to something else. Note that the byte-array is always sent through the fimpl/decode function first. (So if you have stored a Tuple in FDB, the valfn will be passed a vector of elements instead of a FDB Tuple Object)

Returns the value stored at k, nil if no value exists.

get-range clj

(get-range tc rnge)

(get-range tc subspace)

(get-range tc k opts)

(get-range tc s k)

(get-range tc s k opts)

Takes the following:

• TransactionContext tc
• Range of keys to fetch rng or a Subspace subspace
• In the case of a subspace, can also accept t, a Tuple within that Subspace

The opts map takes the following option at the moment:

• keyfn :
• valfn : Functions to transform the key/value to the correct format.

Note that the byte-arrays are always sent through the fimpl/decode function first. (So if you have stored a Tuple in FDB, the valfn will be passed a vector of elements instead of a FDB Tuple Object)

Note that this function is greedy and forces the evaluation of the entire iterable. Use with care. If you want to get a lazy iterator, use the underlying get-range functions from ftr or fsub namespaces.

Returns a map of key/value pairs.

mutate! clj

(mutate! tc mut k)

(mutate! tc mut s k)

(mutate! tc mut k byte-op)

(mutate! tc mut s k byte-op)

An atomic operation is a single database command that carries out several logical steps: reading the value of a key, performing a transformation on that value, and writing the result.

range clj

(range arg1)

(range arg1 arg2)

Return a range according to the input arguments.

At the moment, this should be considered as a helper function for get-range and clear-range. You should ideally never need to use it directly, even though it is in the core namespace.

set clj

(set tc k v)

(set tc s k v)

(set tc k v opts)

(set tc s k v opts)

Takes the following:

• TransactionContext tc
• key to be stored k (should be byte-array, or convertible to byte-array)
• value to be stored v (should be byte-array, or convertible to byte-array)
• Subspace s under which the key will be stored
• opts : unused at the moment, will support options like :async? in a later release.

Returns nil.