exoscale.vinyl.store — com.exoscale/vinyl 0.1.6

A component and helper functions to expose access to a specific schema accessible by FDB's record layer.

This is agnostic to the schema which will need to be supplied to the component using the rough DDL exposed in exoscale.vinyl.schema

all-of-range clj

(all-of-range txn-context record-type items)

as-isolation-level clj

(as-isolation-level level)

as-query clj

(as-query q)

as-scan-type clj

(as-scan-type t)

async-store-from-builder clj

(async-store-from-builder builder context)

between clj

(between txn-context record-type items start end)

continuation-traversing-transduce clj

(continuation-traversing-transduce db xform f val continuing-fn)

A transducer over large ranges. Results are reduced into an accumulator with the help of the reducing function f and transformation xform. The accumulator is initiated to init. clojure.core.reduced is honored.

Obviously, this approach does away with any consistency guarantees usually offered by FDB. continuing-fn is called at every step

Results being accumulated in memory, this also means that care must be taken with the accumulator.

DatabaseContext clj protocol

get-metadata clj

(get-metadata this)

Return this context's record metadata

new-runner clj

(new-runner this)

Return a runner to handle retryable logic

run-async clj

(run-async this f)

Run an asynchronous function against an FDBRecordStore. Protocolized so it can be called against the database or the store

run-in-context clj

(run-in-context this f)

Run a function against an FDBRecordStore. Protocolized so it can be called against the database or the store

db-from-instance clj

(db-from-instance)

(db-from-instance cluster-file)

Build a valid FDB database from configuration. Use the standard cluster-file location or a specific one if instructed to do so.

delete-all-records clj

(delete-all-records txn-context)

delete-by-key-component clj

(delete-by-key-component txn-context record-type items)

In cases where composite keys are used, this can be used to clear all records for a specific composite key prefix

delete-by-prefix-scan clj

(delete-by-prefix-scan txn-context record-type items)

Delete all records surfaced by a prefix scan

delete-by-query clj

(delete-by-query txn-context query)

Delete all records surfaced by a query

delete-by-range clj

(delete-by-range txn-context range)

delete-record clj

(delete-record txn-context k)

(delete-record txn-context record-type items)

execute-properties clj

(execute-properties {:exoscale.vinyl.store/keys [fail-on-scan-limit-reached?
                                                 isolation-level skip limit]
                     :as props})

execute-query clj

(execute-query txn-context query)

(execute-query txn-context query opts)

(execute-query txn-context query opts values)

exists? clj

(exists? txn-context k)

(exists? txn-context record-type items)

greater-than-range clj

(greater-than-range txn-context record-type items)

inc-prefix clj

(inc-prefix p)

Given an object path, yield the next semantic one.

initialize clj

(initialize schema-name descriptor schema)

(initialize schema-name descriptor schema opts)

insert-record clj

(insert-record txn-context record)

insert-record-batch clj

(insert-record-batch txn-context batch)

iterator-query clj

(iterator-query txn-context query)

(iterator-query txn-context query opts)

key-for clj

(key-for db record-type & args)

key-for* clj

(key-for* db record-type items)

list-query clj

(list-query txn-context query)

(list-query txn-context query opts)

(list-query txn-context query opts values)

load-record clj

(load-record txn-context k)

(load-record txn-context record-type items)

long-query-reduce clj

(long-query-reduce db f val query)

(long-query-reduce db
                   f
                   val
                   query
                   {:exoscale.vinyl.store/keys [values] :as opts})

(long-query-reduce db f init query opts values)

A reducer over large queries. Accepts queries as per execute-query. Results are reduced into an accumulator with the help of the reducing function f. The accumulator is initiated to init. clojure.core.reduced is honored.

Obviously, this approach does away with any consistency guarantees usually offered by FDB.

Results being accumulated in memory, this also means that care must be taken with the accumulator.

long-range-reduce clj

(long-range-reduce db f val record-type items)

(long-range-reduce db
                   f
                   val
                   record-type
                   items
                   {:exoscale.vinyl.store/keys [marker] :as opts})

A reducer over large ranges. Results are reduced into an accumulator with the help of the reducing function f. The accumulator is initiated to init. clojure.core.reduced is honored.

Obviously, this approach does away with any consistency guarantees usually offered by FDB.

Results being accumulated in memory, this also means that care must be taken with the accumulator.

long-range-transduce clj

(long-range-transduce db xform f val record-type items)

(long-range-transduce db
                      xform
                      f
                      val
                      record-type
                      items
                      {:exoscale.vinyl.store/keys [marker] :as opts})

A transducer over large ranges. Except for the addition of xform behaves like long-range-reducer.

marker-range clj

(marker-range txn-context record-type items marker)

metadata-index clj

(metadata-index metadata index-name)

prefix-range clj

(prefix-range txn-context record-type items)

record-primary-key clj

(record-primary-key r)

record-store-builder clj

(record-store-builder)

Yield a new record store builder

RecordStore clj

runner-opts clj

(runner-opts runner
             {:exoscale.vinyl.store/keys [max-attempts initial-delay max-delay
                                          transaction-timeout]})

save-record clj

(save-record txn-context record)

save-record-batch clj

(save-record-batch txn-context batch)

scan-index clj

(scan-index txn-context index-name scan-type range continuation opts)

scan-prefix clj

(scan-prefix txn-context record-type items opts)

scan-properties clj

(scan-properties {:exoscale.vinyl.store/keys [reverse?] :as props})

(scan-properties props reverse?)

scan-range clj

(scan-range txn-context range opts)

start clj

stop clj

store-from-builder clj

(store-from-builder builder context)

store-query-fn clj

(store-query-fn query
                {:exoscale.vinyl.store/keys [values intercept-plan-fn log-plan?]
                 :as opts})

top-level-keyspace clj

This builds a directory structure of /$environment/$schema

wrapped-runner clj

(wrapped-runner db opts)