Type Parameters:

M - type used to represent stored records

All Superinterfaces:

RecordMetaDataProvider

All Known Implementing Classes:

FDBRecordStore, FDBTypedRecordStore
```
@API(MAINTAINED)
public interface FDBRecordStoreBase<M extends Message>
extends RecordMetaDataProvider
```
Base interface for typed and untyped record stores. This interface is the main front-end for most operations inserting, modifying, or querying data through the Record Layer. A record store combines:
- A Subspace (often specified via a KeySpacePath)
- The RecordMetaData associated with the data stored with the data in that subspace
- An FDBRecordContext which wraps a FoundationDB Transaction
All of the record store's data—including index data—are stored durably within the given subspace. Note that the meta-data is not stored by the record store directly. However, information about the store's current meta-data version is persisted with the store to detect when the meta-data have changed and to know if any action needs to be taken to begin using the new meta-data. (For example, new indexes might need to be built and removed indexes deleted.) The same meta-data may be used for multiple record stores, and separating the meta-data from the data makes updating the shared meta-data simpler as it only needs to be updated in one place. The FDBMetaDataStore may be used if one wishes to persist the meta-data into a FoundationDB cluster.

All operations conducted by a record store are conducted within the lifetime single transaction, and no data is persisted to the database until the transaction is committed by calling FDBRecordContext.commit() or FDBRecordContext.commitAsync(). Record Layer transactions inherit all of the guarantees and limitations of the transactions exposed by FoundationDB, including their durability and consistency guarantees as well as size and duration limits. See the FoundationDB known limitations for more details.

The record store also allows the user to tweak additional parameters such as what the parallelism of pipelined operations should be (through the FDBRecordStoreBase.PipelineSizer) and what serializer should be used to read and write data to the database. See the FDBRecordStoreBase.BaseBuilder interface for more details.
See Also:

FDBRecordStore, FDBTypedRecordStore

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static interface`	`FDBRecordStoreBase.BaseBuilder<M extends Message,R extends FDBRecordStoreBase<M>>`	Builder for `FDBRecordStoreBase`.
`static interface`	`FDBRecordStoreBase.PipelineSizer`	Function for computing the number of elements to allow in the asynchronous pipeline for an operation of the given type.
`static class`	`FDBRecordStoreBase.RecordExistenceCheck`	Action to take if the record being saved does / does not already exist.
`static class`	`FDBRecordStoreBase.StoreExistenceCheck`	Action to take if the record store does / does not already exist.
`static interface`	`FDBRecordStoreBase.UserVersionChecker`	Hook for checking if store state for client changes.
`static class`	`FDBRecordStoreBase.VersionstampSaveBehavior`	Provided during record save (via `saveRecord(Message, FDBRecordVersion, VersionstampSaveBehavior)`), directs the behavior of the save w.r.t.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method	Description
`void`	`addRecordReadConflict(Tuple primaryKey)`	Add a read conflict as if one had read the record with the given primary key.
`void`	`addRecordWriteConflict(Tuple primaryKey)`	Add a write conflict as if one had modified the record with the given primary key.
`default CompletableFuture<Integer>`	`countRecords(Tuple low, Tuple high, EndpointType lowEndpoint, EndpointType highEndpoint)`	Count the number of records in the database in a range.
`CompletableFuture<Integer>`	`countRecords(Tuple low, Tuple high, EndpointType lowEndpoint, EndpointType highEndpoint, byte[] continuation, ScanProperties scanProperties)`	Count the number of records in the database in a range.
`default FDBQueriedRecord<M>`	`coveredIndexQueriedRecord(Index index, IndexEntry indexEntry, RecordType recordType, M partialRecord, boolean hasPrimaryKey)`	Get a query result from a covering index entry.
`void`	`deleteAllRecords()`	Delete all the data in the record store.
`default boolean`	`deleteRecord(Tuple primaryKey)`	Delete the record with the given primary key.
`CompletableFuture<Boolean>`	`deleteRecordAsync(Tuple primaryKey)`	Async version of `deleteRecord(com.apple.foundationdb.tuple.Tuple)`.
`default void`	`deleteRecordsWhere(QueryComponent component)`	Delete records and associated index entries matching a query filter.
`default void`	`deleteRecordsWhere(String recordType, QueryComponent component)`	Delete records and associated index entries matching a query filter.
`CompletableFuture<Void>`	`deleteRecordsWhereAsync(QueryComponent component)`	Async version of `deleteRecordsWhereAsync(com.apple.foundationdb.record.query.expressions.QueryComponent)`.
`default CompletableFuture<Void>`	`deleteRecordsWhereAsync(String recordType, QueryComponent component)`	Async version of `deleteRecordsWhere(String, QueryComponent)`.
`default CompletableFuture<Tuple>`	`evaluateAggregateFunction(EvaluationContext evaluationContext, List<String> recordTypeNames, IndexAggregateFunction aggregateFunction, TupleRange range, IsolationLevel isolationLevel)`	Evaluate an `IndexAggregateFunction` against a range of the store.
`default CompletableFuture<Tuple>`	`evaluateAggregateFunction(List<String> recordTypeNames, IndexAggregateFunction aggregateFunction, Key.Evaluated value, IsolationLevel isolationLevel)`	Evaluate an `IndexAggregateFunction` against a group value.
`CompletableFuture<Tuple>`	`evaluateAggregateFunction(List<String> recordTypeNames, IndexAggregateFunction aggregateFunction, TupleRange range, IsolationLevel isolationLevel)`	Evaluate an `IndexAggregateFunction` against a range of the store.
`<T> CompletableFuture<T>`	`evaluateIndexRecordFunction(EvaluationContext evaluationContext, IndexRecordFunction<T> function, FDBRecord<M> record)`	Evaluate a `IndexRecordFunction` against a record.
`default <T> CompletableFuture<T>`	`evaluateRecordFunction(EvaluationContext evaluationContext, RecordFunction<T> function, FDBRecord<M> record)`	Evaluate a `RecordFunction` against a record.
`default <T> CompletableFuture<T>`	`evaluateRecordFunction(RecordFunction<T> function, FDBRecord<M> record)`	Evaluate a `RecordFunction` against a record.
`<T> CompletableFuture<T>`	`evaluateStoreFunction(EvaluationContext evaluationContext, StoreRecordFunction<T> function, FDBRecord<M> record)`	Evaluate a `StoreRecordFunction` against a record.
`default <T> CompletableFuture<T>`	`evaluateStoreFunction(StoreRecordFunction<T> function, FDBRecord<M> record)`	Evaluate a `StoreRecordFunction` against a record.
`default RecordCursor<FDBQueriedRecord<M>>`	`executeQuery(RecordQueryPlan query)`	Execute a query.
`default RecordCursor<FDBQueriedRecord<M>>`	`executeQuery(RecordQueryPlan query, byte[] continuation, ExecuteProperties executeProperties)`	Execute a query.
`default RecordCursor<FDBQueriedRecord<M>>`	`executeQuery(RecordQuery query)`	Plan and execute a query.
`default RecordCursor<FDBQueriedRecord<M>>`	`executeQuery(RecordQuery query, byte[] continuation, ExecuteProperties executeProperties)`	Plan and execute a query.
`default RecordCursor<FDBIndexedRecord<M>>`	`fetchIndexRecords(Index index, RecordCursor<IndexEntry> indexCursor, IndexOrphanBehavior orphanBehavior)`	Deprecated. use `fetchIndexRecords(RecordCursor, IndexOrphanBehavior)` instead
`default RecordCursor<FDBIndexedRecord<M>>`	`fetchIndexRecords(Index index, RecordCursor<IndexEntry> indexCursor, IndexOrphanBehavior orphanBehavior, ExecuteState executeState)`	Deprecated. use `fetchIndexRecords(RecordCursor, IndexOrphanBehavior, ExecuteState)` instead
`default RecordCursor<FDBIndexedRecord<M>>`	`fetchIndexRecords(RecordCursor<IndexEntry> indexCursor, IndexOrphanBehavior orphanBehavior)`	Given a cursor that iterates over entries in an index, attempts to fetch the associated records for those entries.
`default RecordCursor<FDBIndexedRecord<M>>`	`fetchIndexRecords(RecordCursor<IndexEntry> indexCursor, IndexOrphanBehavior orphanBehavior, ExecuteState executeState)`	Given a cursor that iterates over entries in an index, attempts to fetch the associated records for those entries.
`FDBRecordContext`	`getContext()`	Get the record context (transaction) to use for the record store.
`default Executor`	`getExecutor()`
`default int`	`getPipelineSize(PipelineOperation pipelineOperation)`	Get the number of elements to allow in the asynchronous pipeline for an operation of the given type.
`FDBRecordStoreBase.PipelineSizer`	`getPipelineSizer()`	Get the function for computing the number of elements to allow in the asynchronous pipeline for an operation of the given type.
`RecordSerializer<M>`	`getSerializer()`	Get the serializer used to convert records into byte arrays.
`default CompletableFuture<Long>`	`getSnapshotRecordCount()`	Get the number of records in the record store.
`CompletableFuture<Long>`	`getSnapshotRecordCount(KeyExpression key, Key.Evaluated value)`	Get the number of records in a portion of the record store determined by a group key expression.
`CompletableFuture<Long>`	`getSnapshotRecordCountForRecordType(String recordTypeName)`	Get the number of records in the record store of the given record type.
`default CompletableFuture<Long>`	`getSnapshotRecordUpdateCount()`
`default CompletableFuture<Long>`	`getSnapshotRecordUpdateCount(KeyExpression key, Key.Evaluated value)`
`SubspaceProvider`	`getSubspaceProvider()`	Get the subspace provider.
`default FDBStoreTimer`	`getTimer()`
`default <N extends Message> FDBTypedRecordStore<N>`	`getTypedRecordStore(RecordSerializer<N> serializer)`	Get a typed record store using the given typed serializer.
`FDBRecordStore`	`getUntypedRecordStore()`	Get the untyped record store associated with this possibly typed store.
`default CompletableFuture<Boolean>`	`hasIndexEntryRecord(IndexEntry entry, IsolationLevel isolationLevel)`	Determine if a given index entry points to a record.
`default CompletableFuture<Boolean>`	`hasIndexEntryRecord(Index index, IndexEntry entry, IsolationLevel isolationLevel)`	Deprecated. use `hasIndexEntryRecord(IndexEntry, IsolationLevel)` instead
`static Tuple`	`indexEntryKey(Index index, Tuple valueKey, Tuple primaryKey)`	Return a tuple to be used as the key for an index entry for the given value and primary key.
`static Tuple`	`indexEntryPrimaryKey(Index index, Tuple entry)`	Deprecated. use `Index.getEntryPrimaryKey(Tuple)` instead
`default FDBStoredRecord<M>`	`insertRecord(M record)`	Save the given record and throw an exception if a record already exists with the same primary key.
`default CompletableFuture<FDBStoredRecord<M>>`	`insertRecordAsync(M record)`	Save the given record and throw an exception if a record already exists with the same primary key.
`default CompletableFuture<FDBIndexedRecord<M>>`	`loadIndexEntryRecord(IndexEntry entry, IndexOrphanBehavior orphanBehavior)`	Using the given index entry, resolve the primary key and asynchronously return the referenced record.
`default CompletableFuture<FDBIndexedRecord<M>>`	`loadIndexEntryRecord(IndexEntry entry, IndexOrphanBehavior orphanBehavior, ExecuteState executeState)`	Using the given index entry, resolve the primary key and asynchronously return the referenced record.
`default CompletableFuture<FDBIndexedRecord<M>>`	`loadIndexEntryRecord(Index index, IndexEntry entry, IndexOrphanBehavior orphanBehavior)`	Deprecated. use `loadIndexEntryRecord(IndexEntry, IndexOrphanBehavior)` instead
`default CompletableFuture<FDBIndexedRecord<M>>`	`loadIndexEntryRecord(Index index, IndexEntry entry, IndexOrphanBehavior orphanBehavior, ExecuteState executeState)`	Deprecated. use `loadIndexEntryRecord(IndexEntry, IndexOrphanBehavior, ExecuteState)` instead
`default FDBStoredRecord<M>`	`loadRecord(Tuple primaryKey)`	Load the record with the given primary key.
`default FDBStoredRecord<M>`	`loadRecord(Tuple primaryKey, boolean snapshot)`	Load the record with the given primary key.
`default CompletableFuture<FDBStoredRecord<M>>`	`loadRecordAsync(Tuple primaryKey)`	Asynchronously load a record.
`default CompletableFuture<FDBStoredRecord<M>>`	`loadRecordAsync(Tuple primaryKey, boolean snapshot)`	Asynchronously load a record.
`CompletableFuture<FDBStoredRecord<M>>`	`loadRecordInternal(Tuple primaryKey, ExecuteState executeState, boolean snapshot)`
`RecordQueryPlan`	`planQuery(RecordQuery query)`	Plan a query.
`CompletableFuture<Void>`	`preloadRecordAsync(Tuple primaryKey)`	Get record into FDB RYW cache.
`default FDBQueriedRecord<M>`	`queriedRecord(FDBIndexedRecord<M> indexedRecord)`	Get a query result record from an indexed record.
`default FDBQueriedRecord<M>`	`queriedRecord(FDBStoredRecord<M> storedRecord)`	Get a query result record from a stored record.
`default boolean`	`recordExists(Tuple primaryKey)`	Check if a record exists in the record store with the given primary key.
`default boolean`	`recordExists(Tuple primaryKey, IsolationLevel isolationLevel)`	Check if a record exists in the record store with the given primary key.
`default CompletableFuture<Boolean>`	`recordExistsAsync(Tuple primaryKey)`	Check if a record exists in the record store with the given primary key.
`CompletableFuture<Boolean>`	`recordExistsAsync(Tuple primaryKey, IsolationLevel isolationLevel)`	Check if a record exists in the record store with the given primary key.
`default CompletableFuture<Void>`	`resolveUniquenessViolation(Index index, Key.Evaluated indexKey, Tuple primaryKey)`	Removes all of the records that have the given value set as their index index value (are thus causing a uniqueness violation) except for the one that has the given primary key (if the key is not `null`).
`CompletableFuture<Void>`	`resolveUniquenessViolation(Index index, Tuple valueKey, Tuple primaryKey)`	Removes all of the records that have the given value set as their index value (and are thus causing a uniqueness violation) except for the one that has the given primary key (if the key is not `null`).
`default FDBStoredRecord<M>`	`saveRecord(M record)`	Save the given record.
`default FDBStoredRecord<M>`	`saveRecord(M record, FDBRecordStoreBase.RecordExistenceCheck existenceCheck)`	Save the given record.
`default FDBStoredRecord<M>`	`saveRecord(M record, FDBRecordStoreBase.RecordExistenceCheck existenceCheck, FDBRecordVersion version, FDBRecordStoreBase.VersionstampSaveBehavior behavior)`	Save the given record with a specific version.
`default FDBStoredRecord<M>`	`saveRecord(M record, FDBRecordVersion version)`	Save the given record with a specific version.
`default FDBStoredRecord<M>`	`saveRecord(M record, FDBRecordVersion version, FDBRecordStoreBase.VersionstampSaveBehavior behavior)`	Save the given record with a specific version.
`default CompletableFuture<FDBStoredRecord<M>>`	`saveRecordAsync(M record)`	Async version of `saveRecord(Message)`.
`default CompletableFuture<FDBStoredRecord<M>>`	`saveRecordAsync(M record, FDBRecordStoreBase.RecordExistenceCheck existenceCheck)`	Async version of `saveRecord(Message, RecordExistenceCheck)`.
`CompletableFuture<FDBStoredRecord<M>>`	`saveRecordAsync(M record, FDBRecordStoreBase.RecordExistenceCheck existenceCheck, FDBRecordVersion version, FDBRecordStoreBase.VersionstampSaveBehavior behavior)`	Async version of `saveRecord(Message, RecordExistenceCheck, FDBRecordVersion, VersionstampSaveBehavior)`.
`default CompletableFuture<FDBStoredRecord<M>>`	`saveRecordAsync(M record, FDBRecordVersion version)`	Async version of `saveRecord(Message, FDBRecordVersion)`.
`default CompletableFuture<FDBStoredRecord<M>>`	`saveRecordAsync(M record, FDBRecordVersion version, FDBRecordStoreBase.VersionstampSaveBehavior behavior)`	Async version of `saveRecord(Message, FDBRecordVersion, VersionstampSaveBehavior)`.
`RecordCursor<IndexEntry>`	`scanIndex(Index index, IndexScanType scanType, TupleRange range, byte[] continuation, ScanProperties scanProperties)`	Scan the entries in an index.
`default RecordCursor<IndexEntry>`	`scanIndex(Index index, IndexScanType scanType, TupleRange range, byte[] continuation, ScanProperties scanProperties, RecordScanLimiter recordScanLimiter)`	Deprecated. because the `RecordScanLimiter` should be specified as part of the `ScanProperties` instead
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecords(String indexName)`	Scan the records pointed to by an index.
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecords(String indexName, IndexScanType scanType, TupleRange range, byte[] continuation, IndexOrphanBehavior orphanBehavior, ScanProperties scanProperties)`	Scan the records pointed to by an index.
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecords(String indexName, IndexScanType scanType, TupleRange range, byte[] continuation, IndexOrphanBehavior orphanBehavior, ScanProperties scanProperties, RecordScanLimiter recordScanLimiter)`	Deprecated. because the `RecordScanLimiter` should be specified as part of the `ScanProperties` instead
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecords(String indexName, IndexScanType scanType, TupleRange range, byte[] continuation, ScanProperties scanProperties)`	Scan the records pointed to by an index.
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecords(String indexName, IndexScanType scanType, TupleRange range, byte[] continuation, ScanProperties scanProperties, RecordScanLimiter recordScanLimiter)`	Deprecated. because the `RecordScanLimiter` should be specified as part of the `ScanProperties` instead
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecords(String indexName, IsolationLevel isolationLevel)`	Scan the records pointed to by an index.
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecordsBetween(String indexName, Object low, Object high)`	Scan the records pointed to by an index between two indexed values.
`default RecordCursor<FDBIndexedRecord<M>>`	`scanIndexRecordsEqual(String indexName, Object... values)`	Scan the records pointed to by an index equal to indexed values.
`default RecordCursor<FDBStoredRecord<M>>`	`scanRecords(byte[] continuation, ScanProperties scanProperties)`	Scan the records in the database.
`default RecordCursor<FDBStoredRecord<M>>`	`scanRecords(TupleRange range, byte[] continuation, ScanProperties scanProperties)`	Scan the records in the database in a range.
`RecordCursor<FDBStoredRecord<M>>`	`scanRecords(Tuple low, Tuple high, EndpointType lowEndpoint, EndpointType highEndpoint, byte[] continuation, ScanProperties scanProperties)`	Scan the records in the database in a range.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, byte[] continuation, ScanProperties scanProperties)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, int limit)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, Key.Evaluated indexKey)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, Key.Evaluated indexKey, byte[] continuation, ScanProperties scanProperties)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, TupleRange range, byte[] continuation, ScanProperties scanProperties)`	Scan the list of uniqueness violations identified for an index.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, Tuple valueKey)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`default RecordCursor<RecordIndexUniquenessViolation>`	`scanUniquenessViolations(Index index, Tuple valueKey, byte[] continuation, ScanProperties scanProperties)`	Scan the list of uniqueness violations for an index for violations with a specific value.
`static Tuple`	`uniquenessViolationKey(Tuple valueKey, Tuple primaryKey)`	Return the key portion of `entry`, which should be the key with the index value as a tuple.
`default FDBStoredRecord<M>`	`updateRecord(M record)`	Save the given record and throw an exception if the record does not already exist in the database.
`default CompletableFuture<FDBStoredRecord<M>>`	`updateRecordAsync(M record)`	Save the given record and throw an exception if the record does not already exist in the database.

Methods inherited from interface com.apple.foundationdb.record.RecordMetaDataProvider
getRecordMetaData

Method Detail

getUntypedRecordStore
```
FDBRecordStore getUntypedRecordStore()
```
Get the untyped record store associated with this possibly typed store.

Returns:

an untyped record store

getTypedRecordStore

default <N extends Message> FDBTypedRecordStore<N> getTypedRecordStore(@Nonnull
                                                                       RecordSerializer<N> serializer)

Get a typed record store using the given typed serializer.

Type Parameters:: N - the type for the new record store
Parameters:: serializer - typed serializer to use
Returns:: a new typed record store

getContext
```
@Nonnull
FDBRecordContext getContext()
```
Get the record context (transaction) to use for the record store.

Returns:

context the record context / transaction to use

getExecutor

@Nonnull
default Executor getExecutor()

getTimer

@Nullable
default FDBStoreTimer getTimer()

getSubspaceProvider
```
@Nullable
SubspaceProvider getSubspaceProvider()
```
Get the subspace provider.

Returns:

the subspace provider

getSerializer
```
@Nonnull
RecordSerializer<M> getSerializer()
```
Get the serializer used to convert records into byte arrays.

Returns:

the serializer to use

saveRecordAsync

@Nonnull
default CompletableFuture<FDBStoredRecord<M>> saveRecordAsync(@Nonnull
                                                              M record)

Async version of saveRecord(Message).

Parameters:: record - the record to save
Returns:: a future that completes with the stored record form of the saved record

saveRecordAsync

@Nonnull
default CompletableFuture<FDBStoredRecord<M>> saveRecordAsync(@Nonnull
                                                              M record,
                                                              @Nonnull
                                                              FDBRecordStoreBase.RecordExistenceCheck existenceCheck)

Async version of saveRecord(Message, RecordExistenceCheck).

Parameters:: record - the record to save; existenceCheck - when to throw an exception if a record with the same primary key does or does not already exist
Returns:: a future that completes with the stored record form of the saved record

saveRecordAsync

@Nonnull
default CompletableFuture<FDBStoredRecord<M>> saveRecordAsync(@Nonnull
                                                              M record,
                                                              @Nullable
                                                              FDBRecordVersion version)

Async version of saveRecord(Message, FDBRecordVersion).

Parameters:: record - the record to save; version - the associated record version
Returns:: a future that completes with the stored record form of the saved record

saveRecordAsync

@Nonnull
default CompletableFuture<FDBStoredRecord<M>> saveRecordAsync(@Nonnull
                                                              M record,
                                                              @Nullable
                                                              FDBRecordVersion version,
                                                              @Nonnull
                                                              FDBRecordStoreBase.VersionstampSaveBehavior behavior)

Async version of saveRecord(Message, FDBRecordVersion, VersionstampSaveBehavior).

Parameters:: record - the record to save; version - the associated record version; behavior - the save behavior w.r.t. the given version
Returns:: a future that completes with the stored record form of the saved record

saveRecordAsync

@Nonnull
CompletableFuture<FDBStoredRecord<M>> saveRecordAsync(@Nonnull
                                                      M record,
                                                      @Nonnull
                                                      FDBRecordStoreBase.RecordExistenceCheck existenceCheck,
                                                      @Nullable
                                                      FDBRecordVersion version,
                                                      @Nonnull
                                                      FDBRecordStoreBase.VersionstampSaveBehavior behavior)

Async version of saveRecord(Message, RecordExistenceCheck, FDBRecordVersion, VersionstampSaveBehavior).

Parameters:: record - the record to save; existenceCheck - when to throw an exception if a record with the same primary key does or does not already exist; version - the associated record version; behavior - the save behavior w.r.t. the given version
Returns:: a future that completes with the stored record form of the saved record

saveRecord

@Nonnull
default FDBStoredRecord<M> saveRecord(@Nonnull
                                      M record)

Save the given record.

Parameters:: record - the record to be saved
Returns:: wrapping object containing saved record and metadata

saveRecord

@Nonnull
default FDBStoredRecord<M> saveRecord(@Nonnull
                                      M record,
                                      @Nonnull
                                      FDBRecordStoreBase.RecordExistenceCheck existenceCheck)

Save the given record.

Parameters:: record - the record to be saved; existenceCheck - when to throw an exception if a record with the same primary key does or does not already exist
Returns:: wrapping object containing saved record and metadata

saveRecord

@Nonnull
default FDBStoredRecord<M> saveRecord(@Nonnull
                                      M record,
                                      @Nullable
                                      FDBRecordVersion version)

Save the given record with a specific version. If null is passed for version, then a new version is created that will be unique for this record.

Parameters:: record - the record to be saved; version - the version to associate with the record when saving
Returns:: wrapping object containing saved record and metadata

saveRecord

@Nonnull
default FDBStoredRecord<M> saveRecord(@Nonnull
                                      M record,
                                      @Nullable
                                      FDBRecordVersion version,
                                      @Nonnull
                                      FDBRecordStoreBase.VersionstampSaveBehavior behavior)

Save the given record with a specific version. The version is handled according to the behavior value. If behavior is DEFAULT then the method acts as saveRecord(Message, FDBRecordVersion). If behavior is NO_VERSION then version is ignored and no version is saved. If behavior is WITH_VERSION then the value of version is stored as given by the caller.

Parameters:: record - the record to be saved; version - the version to associate with the record when saving; behavior - the save behavior w.r.t. the given version
Returns:: wrapping object containing saved record and metadata

saveRecord

@Nonnull
default FDBStoredRecord<M> saveRecord(@Nonnull
                                      M record,
                                      @Nonnull
                                      FDBRecordStoreBase.RecordExistenceCheck existenceCheck,
                                      @Nullable
                                      FDBRecordVersion version,
                                      @Nonnull
                                      FDBRecordStoreBase.VersionstampSaveBehavior behavior)

Save the given record with a specific version. The version is handled according to the behavior value. If behavior is DEFAULT then the method acts as saveRecord(Message, FDBRecordVersion). If behavior is NO_VERSION then version is ignored and no version is saved. If behavior is WITH_VERSION then the value of version is stored as given by the caller.

Parameters:: record - the record to be saved; existenceCheck - when to throw an exception if a record with the same primary key does or does not already exist; version - the version to associate with the record when saving; behavior - the save behavior w.r.t. the given version
Returns:: wrapping object containing saved record and metadata

insertRecordAsync
```
@Nonnull
default CompletableFuture<FDBStoredRecord<M>> insertRecordAsync(@Nonnull
                                                                M record)
```
Save the given record and throw an exception if a record already exists with the same primary key.

Parameters:

record - the record to be saved

Returns:

a future that completes with the stored record form of the saved record

insertRecord
```
@Nonnull
default FDBStoredRecord<M> insertRecord(@Nonnull
                                        M record)
```
Save the given record and throw an exception if a record already exists with the same primary key.

Parameters:

record - the record to be saved

Returns:

wrapping object containing saved record and metadata

updateRecordAsync
```
@Nonnull
default CompletableFuture<FDBStoredRecord<M>> updateRecordAsync(@Nonnull
                                                                M record)
```
Save the given record and throw an exception if the record does not already exist in the database.

Parameters:

record - the record to be saved

Returns:

a future that completes with the stored record form of the saved record

updateRecord
```
@Nonnull
default FDBStoredRecord<M> updateRecord(@Nonnull
                                        M record)
```
Save the given record and throw an exception if the record does not already exist in the database.

Parameters:

record - the record to be saved

Returns:

wrapping object containing saved record and metadata

loadRecord

@Nullable
default FDBStoredRecord<M> loadRecord(@Nonnull
                                      Tuple primaryKey)

Load the record with the given primary key.

Parameters:: primaryKey - the primary key for the record
Returns:: a FDBStoredRecord for the record or null.

loadRecord

@Nullable
default FDBStoredRecord<M> loadRecord(@Nonnull
                                      Tuple primaryKey,
                                      boolean snapshot)

Load the record with the given primary key.

Parameters:: primaryKey - the primary key for the record; snapshot - whether to load at snapshot isolation
Returns:: a FDBStoredRecord for the record or null.

loadRecordAsync

@Nonnull
default CompletableFuture<FDBStoredRecord<M>> loadRecordAsync(@Nonnull
                                                              Tuple primaryKey)

Asynchronously load a record.

Parameters:: primaryKey - the key for the record to be loaded
Returns:: a CompletableFuture that will return a message or null if there was no record with that key

loadRecordAsync

@Nonnull
default CompletableFuture<FDBStoredRecord<M>> loadRecordAsync(@Nonnull
                                                              Tuple primaryKey,
                                                              boolean snapshot)

Asynchronously load a record.

Parameters:: primaryKey - the key for the record to be loaded; snapshot - whether to load at snapshot isolation
Returns:: a CompletableFuture that will return a message or null if there was no record with that key

loadRecordInternal

@Nonnull
@API(INTERNAL)
CompletableFuture<FDBStoredRecord<M>> loadRecordInternal(@Nonnull
                                                         Tuple primaryKey,
                                                         @Nonnull
                                                         ExecuteState executeState,
                                                         boolean snapshot)

preloadRecordAsync
```
@Nonnull
CompletableFuture<Void> preloadRecordAsync(@Nonnull
                                           Tuple primaryKey)
```
Get record into FDB RYW cache. Caller needs to hold on to result until ready or else there is a chance it will get GC'ed and cancelled before then.

Parameters:

primaryKey - the primary key for the record to retrieve

Returns:

a future that will return null when the record is preloaded

recordExistsAsync
```
@Nonnull
default CompletableFuture<Boolean> recordExistsAsync(@Nonnull
                                                     Tuple primaryKey)
```
Check if a record exists in the record store with the given primary key. This performs its reads at the IsolationLevel.SERIALIZABLE isolation level.

Parameters:

primaryKey - the primary key of the record

Returns:

a future that will complete to true if some record in record store has that primary key and false otherwise

See Also:

recordExistsAsync(Tuple, IsolationLevel)

recordExistsAsync
```
@Nonnull
CompletableFuture<Boolean> recordExistsAsync(@Nonnull
                                             Tuple primaryKey,
                                             @Nonnull
                                             IsolationLevel isolationLevel)
```
Check if a record exists in the record store with the given primary key. This is slightly more efficient than loading the record and checking if that record is null as it does not have to deserialize the record, though the record's contents are still read from the database and sent over the network.

Parameters:

primaryKey - the primary key of the record

isolationLevel - the isolation level to use when reading

Returns:

a future that will complete to true if some record in record store has that primary key and false otherwise

recordExists
```
default boolean recordExists(@Nonnull
                             Tuple primaryKey)
```
Check if a record exists in the record store with the given primary key. This method is blocking. For the non-blocking version of this method, see recordExistsAsync(Tuple).

Parameters:

primaryKey - the primary key of the record

Returns:

true if some record in record store has that primary key and false otherwise

See Also:

recordExistsAsync(Tuple)

recordExists
```
default boolean recordExists(@Nonnull
                             Tuple primaryKey,
                             @Nonnull
                             IsolationLevel isolationLevel)
```
Check if a record exists in the record store with the given primary key. This method is blocking. For the non-blocking version of this method, see recordExistsAsync(Tuple, IsolationLevel).

Parameters:

primaryKey - the primary key of the record

isolationLevel - the isolation level to use when reading

Returns:

true if some record in record store has that primary key and false otherwise

See Also:

recordExistsAsync(Tuple)

addRecordReadConflict
```
void addRecordReadConflict(@Nonnull
                           Tuple primaryKey)
```
Add a read conflict as if one had read the record with the given primary key. This will cause this transaction to fail (with a FDBExceptions.FDBStoreTransactionConflictException) if a concurrent transaction modifies the record with the provided primary key. This call however does not require performing any reads against the database, so it is faster and cheaper to perform than a real read. Note also that read-only operations are not checked for conflicts, so if this method is called, but the transaction performs no mutations, the transaction will never be failed with the above exception. Note also that this does not check that a record with this primary key actually exists in the database.
One use case is that this can be used to promote a read from IsolationLevel.SNAPSHOT to IsolationLevel.SERIALIZABLE. For example, if one performs a query at IsolationLevel.SNAPSHOT and then uses a subset of the records to determine a few other writes, then one can add conflicts to only the records actually used.

This method should be used with care and is advised only for those users who need extra control over conflict ranges.

Parameters:

primaryKey - the primary key of the record to add a read conflict on

See Also:

Transaction.addReadConflictRange(byte[], byte[])

addRecordWriteConflict
```
void addRecordWriteConflict(@Nonnull
                            Tuple primaryKey)
```
Add a write conflict as if one had modified the record with the given primary key. This will cause any concurrent transactions to fail (with a FDBExceptions.FDBStoreTransactionConflictException) if they read the record with the provided primary key. This call however does not require performing any writes against the database, so it is faster and cheaper to perform than a real write. Note that this does not check if a record with this primary key actually exists in the database, and it does not update any indexes associated with the record. In this way, it is identical (in terms of conflicts) with overwriting the given record with itself, though it will not induce any disk I/O or cause any watches on the modified keys to fire.
This method should be used with care and is advised only for those users who need extra control over conflict ranges.

Parameters:

primaryKey - the primary key of the record to add a write conflict on

See Also:

Transaction.addWriteConflictRange(byte[], byte[])

scanRecords

@Nonnull
default RecordCursor<FDBStoredRecord<M>> scanRecords(@Nullable
                                                     byte[] continuation,
                                                     @Nonnull
                                                     ScanProperties scanProperties)

Scan the records in the database.

Parameters:: continuation - any continuation from a previous scan; scanProperties - skip, limit and other scan properties
Returns:: a cursor that will scan everything in the range, picking up at continuation, and honoring the given scan properties

scanRecords

@Nonnull
default RecordCursor<FDBStoredRecord<M>> scanRecords(@Nonnull
                                                     TupleRange range,
                                                     @Nullable
                                                     byte[] continuation,
                                                     @Nonnull
                                                     ScanProperties scanProperties)

Scan the records in the database in a range.

Parameters:: range - the range to scan; continuation - any continuation from a previous scan; scanProperties - skip, limit and other scan properties
Returns:: a cursor that will scan everything in the range, picking up at continuation, and honoring the given scan properties

scanRecords

@Nonnull
RecordCursor<FDBStoredRecord<M>> scanRecords(@Nullable
                                             Tuple low,
                                             @Nullable
                                             Tuple high,
                                             @Nonnull
                                             EndpointType lowEndpoint,
                                             @Nonnull
                                             EndpointType highEndpoint,
                                             @Nullable
                                             byte[] continuation,
                                             @Nonnull
                                             ScanProperties scanProperties)

Scan the records in the database in a range.

Parameters:: low - low point of scan range; high - high point of scan point; lowEndpoint - whether low point is inclusive or exclusive; highEndpoint - whether high point is inclusive or exclusive; continuation - any continuation from a previous scan; scanProperties - skip, limit and other scan properties
Returns:: a cursor that will scan everything in the range, picking up at continuation, and honoring the given scan properties

countRecords

@Nonnull
default CompletableFuture<Integer> countRecords(@Nullable
                                                Tuple low,
                                                @Nullable
                                                Tuple high,
                                                @Nonnull
                                                EndpointType lowEndpoint,
                                                @Nonnull
                                                EndpointType highEndpoint)

Count the number of records in the database in a range.

Parameters:: low - low point of scan range; high - high point of scan point; lowEndpoint - whether low point is inclusive or exclusive; highEndpoint - whether high point is inclusive or exclusive
Returns:: a future that will complete with the number of records in the range

countRecords

@Nonnull
CompletableFuture<Integer> countRecords(@Nullable
                                        Tuple low,
                                        @Nullable
                                        Tuple high,
                                        @Nonnull
                                        EndpointType lowEndpoint,
                                        @Nonnull
                                        EndpointType highEndpoint,
                                        @Nullable
                                        byte[] continuation,
                                        @Nonnull
                                        ScanProperties scanProperties)

Count the number of records in the database in a range.

Parameters:: low - low point of scan range; high - high point of scan point; lowEndpoint - whether low point is inclusive or exclusive; highEndpoint - whether high point is inclusive or exclusive; continuation - any continuation from a previous scan; scanProperties - skip, limit and other scan properties
Returns:: a future that will complete with the number of records in the range

scanIndex

@Nonnull
RecordCursor<IndexEntry> scanIndex(@Nonnull
                                   Index index,
                                   @Nonnull
                                   IndexScanType scanType,
                                   @Nonnull
                                   TupleRange range,
                                   @Nullable
                                   byte[] continuation,
                                   @Nonnull
                                   ScanProperties scanProperties)

Scan the entries in an index.

Parameters:: index - the index to scan; scanType - the type of scan to perform; range - range to scan; continuation - any continuation from a previous scan; scanProperties - skip, limit and other scan properties
Returns:: a cursor that will scan the index, picking up at continuation, and honoring the given scan properties

scanIndex

@API(DEPRECATED)
@Deprecated
@Nonnull
default RecordCursor<IndexEntry> scanIndex(@Nonnull
                                           Index index,
                                           @Nonnull
                                           IndexScanType scanType,
                                           @Nonnull
                                           TupleRange range,
                                           @Nullable
                                           byte[] continuation,
                                           @Nonnull
                                           ScanProperties scanProperties,
                                           @Nullable
                                           RecordScanLimiter recordScanLimiter)

Deprecated.

because the RecordScanLimiter should be specified as part of the ScanProperties instead

Scan the entries in an index.

Parameters:: index - the index to scan; scanType - the type of scan to perform; range - range to scan; continuation - any continuation from a previous scan; scanProperties - skip, limit and other scan properties; recordScanLimiter - the scan limit to use
Returns:: a cursor that will scan the index, picking up at continuation, and honoring the given scan properties