A transaction monad. This is currently exported with a MonadIO instance, but using it comes with caveats:

• runTransaction will retry your transaction in some cases, which means any IO in your transaction will be repeated. You can disable retries by setting maxRetries in TransactionConfig to 0.
• Transactions have strict time limits, so slow IO operations should be avoided.

Attempts to commit a transaction against the given database. If an unretryable error occurs, throws an Error. Attempts to retry the transaction for retryable errors.

Like runTransaction, but returns a sum instead of throwing an exception on errors.

Contains useful options that are not directly exposed by the C API (for options that are, see setOption).

A config for a non-idempotent transaction, allowing 5 retries, with a time limit of 500 milliseconds.

Attempt to commit a transaction against the given database. If an unretryable error occurs, throws an Error. Attempts to retry the transaction for retryable errors according to the maxRetries setting in the provided TransactionConfig.

Attempt to commit a transaction against the given database. If an unretryable error occurs, returns Left. Attempts to retry the transaction for retryable errors.

Cancel a transaction. The transaction will not be committed, and will throw TransactionCanceled.

Reset the transaction. All operations prior to this will be discarded.

Runs a transaction using snapshot reads, which means that the transaction will see the results of concurrent transactions, removing the default serializable isolation guarantee.

Set one of the transaction options from the underlying C API.

Gets the read version of the current transaction, representing all transactions that were reported committed before this one.

Sets the read version on the current transaction. As the FoundationDB docs state, "this is not needed in simple cases".

Returns a FutureIO that will resolve to the versionstamp of the committed transaction. Most applications won't need this.

Returns a future that will return the size, in bytes, of the transaction so far, as a summation of the estimated size of mutations, read conflict ranges, and write conflict ranges. This can be used to decide how to split a large task into smaller transactions.

Get the value of a key. If the key does not exist, returns Nothing.

Set a bytestring key to a bytestring value.

Delete a key from the DB.

clearRange k l deletes all keys in the half-open range [k,l).

Tells FoundationDB to consider the given range to have been read by this transaction.

Tells FoundationDB to consider the given key to have been read by this transaction.

Tells FoundationDB to consider the given key to have been written by this transaction.

Gets the key specified by the given KeySelector.

Get the public network addresses of all nodes responsible for storing the given key.

Perform an atomic operation of MutationType on the given key. A transaction that performs only atomic operations is guaranteed not to conflict. However, it may cause other concurrent transactions to conflict.

Reads all key-value pairs in the specified Range which are lexicographically greater than or equal to the rangeBegin KeySelector and lexicographically less than the rangeEnd KeySelector. Uses StreamingModeIterator, which assumes that you don't know ahead of time exactly how many pairs in the range you actually need. If you need them all (and they are expected to fit in memory), use getEntireRange. For more advanced usage, use getRange'.

Like getRange, but allows you to specify the streaming mode as desired.

Wrapper around getRange that reads the entire range into memory.

Return True iff the given range is empty.

Specifies a range of keys to be iterated over by getRange.

keyRangeQuery begin end is the range of keys [begin, end).

keyRangeQuery begin end is the range of keys [begin, end].

prefixRange prefix is the range of all keys of which prefix is a prefix. Returns Nothing if prefix is empty or contains only 0xff.

Structure for returning the result of getRange in chunks.

Creates a future that will be fulfilled when the value associated with the given key is changed, relative to the value it had as of the current transaction's read version, or the last value to which the key was previously set within the current transaction. This future is safe to return from the transaction and await in IO. If the transaction in which it was created fails to commit, awaiting it will return the same error as running the transaction did.

The result of a mapped key value query, containing the parent key and value (i.e., the key and value in the secondary index), and the range of key-value pairs retrieved based on the range query generated from the mapper's operation on the parent key and value.

WARNING: FDB's docs warn that the returned KeySelector fields have not yet been tested. Use them at your own risk!

Structure for returning the result of getRange in chunks.

Given a range of keys in a secondary index, fetc the corresponding key/values they refer to by using a mapper. See the docs for more information.

Important: you must have read-your-writes enabled, but you must not read anything you have written in the same transaction. Snapshot isolation is not supported. See the docs linked above.

These functions are only available for FDB >= 7.1

Wrapper around getRange that reads the entire range into memory.

A future result of a FoundationDB call. You can block on a future with await. WARNING: returning a value of this type from runTransaction and then calling await on the value in another transaction will cause a segfault! Future versions of this library may use more sophisticated types to prevent this.

Block until a future is ready. Unfortunately, does not seem to be interruptible by SIGPIPE (the interrupt sent by Control.Conccurent.Async to cancel), even when using InterruptibleFFI.

Polls a future for readiness roughly every millisecond in a loop until it is ready, then returns the value in the future. This is less resource efficient than await, but can be interrupted more easily.

Cancel a future. Attempting to await the future after cancellation will throw OperationCancelled.

Returns True if the future is ready. If so, calling await will not block.

A future that can only be awaited after its transaction has committed. That is, in contrast to Future, this must be returned from runTransaction before it can safely be awaited. Use awaitIO to await it. This future type is not needed frequently.

All FutureIO functions work similarly to their Future counterparts.

IO analogue to await.

IO analogue to awaitInterruptible.

Cancel a future. Attempts to await the future after cancellation will throw OperationCancelled.

Returns True if calling awaitIO will return immediately, without blocking.

Specifies a key in the database. See the official docs for more information. These can be supplied to getKey or used to build a Range.

Increase the offset of the given KeySelector.

The internal state of a transaction as it is being executed by runTransaction.

Execute a transactional action on an existing transaction environment.

Attempts to commit a transaction. If awaiting the returned Future works without errors, the transaction was committed.

Calls the C API's fdb_transaction_on_error function. Re-raises unretryable errors.

Gets the committed version of a transaction. Can only be called after the transaction has committed, so must be used in conjunction with TransactionEnv, since runTransaction and its variants immediately destroy the internal TransactionEnv as soon as they return.