@API(value=STABLE) public class FDBRecordStore extends FDBStoreBase implements FDBRecordStoreBase<Message>
RecordSerializer
such as a MessageBuilderRecordSerializer
or a TransformedRecordSerializer
to use
as an alternative. Unlike the serializers used by an FDBTypedRecordStore
which only need to be able to process records
of the appropriate record type, the provided serializer must be able to serialize and deseralize all record types specified by
the record store's RecordMetaData
.
Warning: It is unsafe to create and use two FDBRecordStore
s concurrently over the same Subspace
within the context of a single transaction, i.e., with the same FDBRecordContext
. This is because the FDBRecordStore
object maintains state about certain uncommitted operations, and concurrent access through two objects will not see
changes to this in-memory state. See Issue #489
for more details. Note also that the record stores returned by FDBRecordStoreBase.getTypedRecordStore(RecordSerializer)
and
getUntypedRecordStore()
will share an FDBRecordStore
with the record store on which they are called,
so it is safe to have a typed- and untyped-record store open over the same Subspace
within the context
of the same transaction if one uses one of those methods.
FDBRecordStoreBase
Modifier and Type | Class and Description |
---|---|
static class |
FDBRecordStore.Builder
A builder for
FDBRecordStore . |
static class |
FDBRecordStore.IndexNotBuiltException
Exception that can be thrown if one attempts to mark an index as readable
if it is not yet readable.
|
static class |
FDBRecordStore.RebuildIndexReason
Reason that an index is being rebuilt now.
|
FDBRecordStoreBase.BaseBuilder<M extends Message,R extends FDBRecordStoreBase<M>>, FDBRecordStoreBase.PipelineSizer, FDBRecordStoreBase.RecordExistenceCheck, FDBRecordStoreBase.StoreExistenceCheck, FDBRecordStoreBase.UserVersionChecker, FDBRecordStoreBase.VersionstampSaveBehavior
context, subspaceProvider
Modifier | Constructor and Description |
---|---|
protected |
FDBRecordStore(FDBRecordContext context,
SubspaceProvider subspaceProvider,
int formatVersion,
RecordMetaDataProvider metaDataProvider,
RecordSerializer<Message> serializer,
IndexMaintainerRegistry indexMaintainerRegistry,
IndexMaintenanceFilter indexMaintenanceFilter,
FDBRecordStoreBase.PipelineSizer pipelineSizer,
FDBRecordStoreStateCache storeStateCache) |
Modifier and Type | Method and Description |
---|---|
void |
addRebuildRecordCountsJob(List<CompletableFuture<Void>> work) |
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.
|
void |
addUniquenessCheck(AsyncIterable<KeyValue> kvs,
Index index,
IndexEntry indexEntry,
Tuple primaryKey) |
FDBRecordStore.Builder |
asBuilder() |
protected boolean |
checkPossiblyRebuildRecordCounts(RecordMetaData metaData,
RecordMetaDataProto.DataStoreInfo.Builder info,
List<CompletableFuture<Void>> work,
int oldFormatVersion) |
static CompletableFuture<Void> |
checkStoreHeader(RecordMetaDataProto.DataStoreInfo storeHeader,
FDBRecordContext context,
SubspaceProvider subspaceProvider,
Subspace subspace,
FDBRecordStoreBase.StoreExistenceCheck existenceCheck) |
CompletableFuture<Boolean> |
checkVersion(FDBRecordStoreBase.UserVersionChecker userVersionChecker,
FDBRecordStoreBase.StoreExistenceCheck existenceCheck)
Checks the meta-data version key of the record store and compares it to the version
of the local meta-data object.
|
CompletableFuture<Void> |
clearAndMarkIndexWriteOnly(Index index)
Prepare an index for rebuilding by clearing any existing data and marking the index as write-only.
|
CompletableFuture<Void> |
clearAndMarkIndexWriteOnly(String indexName) |
void |
clearHeaderUserField(String userField)
Clear the value of a user-settable field in the store header.
|
CompletableFuture<Void> |
clearHeaderUserFieldAsync(String userField)
Clear the value of a user-settable field in the store header.
|
protected void |
countKeysAndValues(StoreTimer.Count key,
StoreTimer.Count keyBytes,
StoreTimer.Count valueBytes,
FDBStoredSizes sizeInfo) |
void |
countKeyValue(StoreTimer.Count key,
StoreTimer.Count keyBytes,
StoreTimer.Count valueBytes,
byte[] k,
byte[] v) |
void |
countKeyValue(StoreTimer.Count key,
StoreTimer.Count keyBytes,
StoreTimer.Count valueBytes,
KeyValue keyValue) |
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.
|
static long |
decodeRecordCount(byte[] bytes) |
void |
deleteAllRecords()
Delete all the data in the record store.
|
CompletableFuture<Boolean> |
deleteRecordAsync(Tuple primaryKey)
Async version of
FDBRecordStoreBase.deleteRecord(com.apple.foundationdb.tuple.Tuple) . |
CompletableFuture<Void> |
deleteRecordsWhereAsync(QueryComponent component)
|
static void |
deleteStore(FDBRecordContext context,
KeySpacePath path)
Delete the record store at the given
KeySpacePath . |
static void |
deleteStore(FDBRecordContext context,
Subspace subspace)
Delete the record store at the given
Subspace . |
protected <M extends Message> |
deleteTypedRecord(RecordSerializer<M> typedSerializer,
Tuple primaryKey) |
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<Message> record)
Evaluate a
IndexRecordFunction against a record. |
<T> CompletableFuture<T> |
evaluateStoreFunction(EvaluationContext evaluationContext,
StoreRecordFunction<T> function,
FDBRecord<Message> record)
Evaluate a
StoreRecordFunction against a record. |
protected <T,M extends Message> |
evaluateTypedIndexRecordFunction(EvaluationContext evaluationContext,
IndexRecordFunction<T> indexRecordFunction,
FDBRecord<M> record) |
<T,M extends Message> |
evaluateTypedStoreFunction(EvaluationContext evaluationContext,
StoreRecordFunction<T> function,
FDBRecord<M> record) |
CompletableFuture<Optional<Range>> |
firstUnbuiltRange(Index index)
Returns the first unbuilt range of an index that is currently being bulit.
|
Map<Index,IndexState> |
getAllIndexStates()
Gets a map from
Index to IndexState for all the indexes in the meta-data. |
FDBRecordContext |
getContext()
Get the record context (transaction) to use for the record store.
|
List<Index> |
getEnabledIndexes(RecordTypeOrBuilder recordType)
Gets the list of enabled indexes that are on the given record type.
|
List<Index> |
getEnabledMultiTypeIndexes(RecordTypeOrBuilder recordType)
Gets the list of enabled indexes that are on multiple record types one of which is the
given type.
|
List<Index> |
getEnabledUniversalIndexes()
Gets the list of enabled universal indexes, i.e., the indexes on all record types.
|
int |
getFormatVersion()
Get the storage format version currently in use for this record store.
|
ByteString |
getHeaderUserField(String userField)
Get the value of a user-settable field from the store header.
|
CompletableFuture<IndexBuildState> |
getIndexBuildStateAsync(Index index)
Get the progress of building the given index.
|
IndexMaintainer |
getIndexMaintainer(Index index)
Get the maintainer for a given index.
|
IndexMaintainerRegistry |
getIndexMaintainerRegistry() |
IndexMaintenanceFilter |
getIndexMaintenanceFilter() |
IndexState |
getIndexState(Index index)
Get the state of the index for this record store.
|
IndexState |
getIndexState(String indexName)
Get the state of the index with the given name for this record store.
|
int |
getKeySizeLimit() |
RecordMetaDataProvider |
getMetaDataProvider()
Get the provider for the record store's meta-data.
|
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.
|
RecordCursor<Tuple> |
getPrimaryKeyBoundaries(Tuple low,
Tuple high)
Return a cursor of boundaries separating the key ranges maintained by each FDB server.
|
List<Index> |
getReadableIndexes(RecordTypeOrBuilder recordType)
Gets the list of readable indexes that are on the given record type.
|
List<Index> |
getReadableMultiTypeIndexes(RecordTypeOrBuilder recordType)
Gets the list of readable indexes that are on multiple record types one of which is the
given type.
|
List<Index> |
getReadableUniversalIndexes()
Gets the list of readable universal indexes, i.e., the indexes on all record types.
|
protected org.apache.commons.lang3.tuple.Pair<CompletableFuture<Long>,Boolean> |
getRecordCountForRebuildIndexes(boolean newStore,
boolean rebuildRecordCounts,
Map<Index,List<RecordType>> indexes)
Get count of records to pass to checker to decide whether to build right away.
|
RecordMetaData |
getRecordMetaData()
Get the
RecordMetaData used by this store. |
RecordStoreState |
getRecordStoreState()
Get the
RecordStoreState for this store. |
RecordSerializer<Message> |
getSerializer()
Get the serializer used to convert records into byte arrays.
|
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.
|
protected Map<Index,IndexState> |
getStatesForRebuildIndexes(FDBRecordStoreBase.UserVersionChecker userVersionChecker,
Map<Index,List<RecordType>> indexes,
long recordCount,
boolean newStore,
boolean rebuildRecordCounts,
int oldMetaDataVersion,
int oldFormatVersion) |
FDBRecordStore |
getUntypedRecordStore()
Get the untyped record store associated with this possibly typed store.
|
int |
getUserVersion()
Get the user version currently in use for this record store.
|
int |
getValueSizeLimit() |
Subspace |
indexRangeSubspace(Index index)
Subspace for index in which to place a
RangeSet . |
Subspace |
indexSecondarySubspace(Index index) |
Subspace |
indexStateSubspace() |
Subspace |
indexSubspace(Index index) |
Subspace |
indexSubspaceFromMaintainer(Index index) |
Subspace |
indexUniquenessViolationsSubspace(Index index)
Subspace for index in which to place a record in uniqueness violations.
|
boolean |
isIndexDisabled(Index index)
Determine if the index is disabled for this record store.
|
boolean |
isIndexDisabled(String indexName)
Determine if the index with the given name is disabled for this record store.
|
boolean |
isIndexReadable(Index index)
Determine if the index is readable for this record store.
|
boolean |
isIndexReadable(String indexName)
Determine if the index with the given name is readable for this record store.
|
boolean |
isIndexWriteOnly(Index index)
Determine if the index is write-only for this record store.
|
boolean |
isIndexWriteOnly(String indexName)
Determine if the index with the given name is write-only for this record store.
|
CompletableFuture<FDBStoredRecord<Message>> |
loadRecordInternal(Tuple primaryKey,
ExecuteState executeState,
boolean snapshot) |
CompletableFuture<RecordStoreState> |
loadRecordStoreStateAsync(FDBRecordStoreBase.StoreExistenceCheck existenceCheck)
Loads the current state of the record store within the given subspace asynchronously.
|
Optional<FDBRecordVersion> |
loadRecordVersion(Tuple primaryKey)
Load the version of the last time a record with the
given primary key was saved.
|
Optional<FDBRecordVersion> |
loadRecordVersion(Tuple primaryKey,
boolean snapshot)
Overload of
loadRecordVersion(Tuple) that supports snapshot
reads. |
Optional<CompletableFuture<FDBRecordVersion>> |
loadRecordVersionAsync(Tuple primaryKey)
Async version of
loadRecordVersion(Tuple) . |
Optional<CompletableFuture<FDBRecordVersion>> |
loadRecordVersionAsync(Tuple primaryKey,
boolean snapshot)
Async version of
loadRecordVersion(Tuple, boolean) . |
CompletableFuture<FDBSyntheticRecord> |
loadSyntheticRecord(Tuple primaryKey)
Load a
synthetic record by loading its stored constituent records and synthesizing it from them. |
protected <M extends Message> |
loadTypedRecord(RecordSerializer<M> typedSerializer,
Tuple primaryKey,
boolean snapshot) |
protected <M extends Message> |
loadTypedRecord(RecordSerializer<M> typedSerializer,
Tuple primaryKey,
ExecuteState executeState,
boolean snapshot) |
CompletableFuture<Boolean> |
markIndexDisabled(Index index)
Adds the index to the list of disabled indexes stored within the store.
|
CompletableFuture<Boolean> |
markIndexDisabled(String indexName)
Adds the index of the given name to the list of disabled indexes stored
within the store.
|
CompletableFuture<Boolean> |
markIndexReadable(Index index)
Marks an index as readable.
|
CompletableFuture<Boolean> |
markIndexReadable(String indexName)
Marks the index with the given name as readable.
|
CompletableFuture<Boolean> |
markIndexWriteOnly(Index index)
Adds the given index to the list of write-only indexes stored within the store.
|
CompletableFuture<Boolean> |
markIndexWriteOnly(String indexName)
Adds the index of the given name to the list of write-only indexes stored within the store.
|
protected static QueryComponent |
mergeRecordTypeAndComponent(String recordType,
QueryComponent component) |
static FDBRecordStore.Builder |
newBuilder() |
IndexOperationResult |
performIndexOperation(String indexName,
IndexOperation operation) |
CompletableFuture<IndexOperationResult> |
performIndexOperationAsync(String indexName,
IndexOperation operation) |
RecordQueryPlan |
planQuery(RecordQuery query)
Plan a query.
|
CompletableFuture<Void> |
preloadRecordAsync(Tuple primaryKey)
Get record into FDB RYW cache.
|
protected CompletableFuture<Void> |
preloadRecordStoreStateAsync()
Loads the current state of the record store asynchronously and caches it in memory so that
getRecordStoreState() requires no i/o. |
protected CompletableFuture<Void> |
preloadRecordStoreStateAsync(FDBRecordStoreBase.StoreExistenceCheck existenceCheck,
IsolationLevel storeHeaderIsolationLevel,
IsolationLevel indexStateIsolationLevel)
Loads the current state of the record store asynchronously and sets
recordStoreStateRef . |
protected CompletableFuture<Void> |
preloadSubspaceAsync()
Ensure that subspace provider has cached
Subspace so that calling FDBStoreBase.getSubspace() will not block. |
CompletableFuture<Void> |
rebuildAllIndexes()
Rebuild all of this store's indexes.
|
CompletableFuture<Void> |
rebuildIndex(Index index)
Rebuild an index.
|
CompletableFuture<Void> |
rebuildIndex(Index index,
Collection<RecordType> recordTypes,
FDBRecordStore.RebuildIndexReason reason) |
protected CompletableFuture<Void> |
rebuildIndexes(Map<Index,List<RecordType>> indexes,
Map<Index,IndexState> newStates,
List<CompletableFuture<Void>> work,
FDBRecordStore.RebuildIndexReason reason,
Integer oldMetaDataVersion) |
protected CompletableFuture<Void> |
rebuildOrMarkIndex(Index index,
IndexState indexState,
List<RecordType> recordTypes,
FDBRecordStore.RebuildIndexReason reason,
Integer oldMetaDataVersion) |
CompletableFuture<Boolean> |
recordExistsAsync(Tuple primaryKey,
IsolationLevel isolationLevel)
Check if a record exists in the record store with the given primary key.
|
Subspace |
recordsSubspace() |
void |
removeFormerIndex(FormerIndex formerIndex) |
CompletableFuture<byte[]> |
repairRecordKeys(byte[] continuation,
ScanProperties scanProperties) |
CompletableFuture<byte[]> |
repairRecordKeys(byte[] continuation,
ScanProperties scanProperties,
boolean isDryRun)
Validate and repair known potential issues with record keys.
|
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 ). |
CompletableFuture<FDBStoredRecord<Message>> |
saveRecordAsync(Message record,
FDBRecordStoreBase.RecordExistenceCheck existenceCheck,
FDBRecordVersion version,
FDBRecordStoreBase.VersionstampSaveBehavior behavior)
|
protected void |
saveStoreHeader(RecordMetaDataProto.DataStoreInfo storeHeader) |
protected <M extends Message> |
saveTypedRecord(RecordSerializer<M> typedSerializer,
M record,
FDBRecordStoreBase.RecordExistenceCheck existenceCheck,
FDBRecordVersion version,
FDBRecordStoreBase.VersionstampSaveBehavior behavior) |
RecordCursor<IndexEntry> |
scanIndex(Index index,
IndexScanType scanType,
TupleRange range,
byte[] continuation,
ScanProperties scanProperties)
Scan the entries in an index.
|
RecordCursor<FDBStoredRecord<Message>> |
scanRecords(Tuple low,
Tuple high,
EndpointType lowEndpoint,
EndpointType highEndpoint,
byte[] continuation,
ScanProperties scanProperties)
Scan the records in the database in a range.
|
<M extends Message> |
scanTypedRecords(RecordSerializer<M> typedSerializer,
Tuple low,
Tuple high,
EndpointType lowEndpoint,
EndpointType highEndpoint,
byte[] continuation,
ScanProperties scanProperties) |
RecordCursor<RecordIndexUniquenessViolation> |
scanUniquenessViolations(Index index,
TupleRange range,
byte[] continuation,
ScanProperties scanProperties)
Scan the list of uniqueness violations identified for an index.
|
void |
setHeaderUserField(String userField,
byte[] value)
Set the value of a user-settable field in the store header.
|
void |
setHeaderUserField(String userField,
ByteString value)
Set the value of a user-settable field in the store header.
|
CompletableFuture<Void> |
setHeaderUserFieldAsync(String userField,
byte[] value)
Set the value of a user-settable field in the store header.
|
CompletableFuture<Void> |
setHeaderUserFieldAsync(String userField,
ByteString value)
Set the value of a user-settable field in the store header.
|
boolean |
setStateCacheability(boolean cacheable)
Set whether the store state is cacheable.
|
CompletableFuture<Boolean> |
setStateCacheabilityAsync(boolean cacheable)
Set whether the store state is cacheable.
|
protected RecordType |
singleRecordTypeWithPrefixKey(Map<Index,List<RecordType>> indexes) |
CompletableFuture<Boolean> |
uncheckedMarkIndexReadable(String indexName)
Marks the index with the given name as readable without checking to see if it is
ready.
|
void |
validateMetaData()
Deprecated.
validation is done by
RecordMetaDataBuilder |
static IndexState |
writeOnlyIfTooManyRecordsForRebuild(long recordCount,
boolean indexOnNewRecordTypes) |
addConflictForSubspace, ensureContextActive, getExecutor, getRecordContext, getSubspace, getSubspaceAsync, getSubspaceProvider, getTimer, increment, increment, instrument, instrument, instrument, record, record
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
countRecords, coveredIndexQueriedRecord, deleteRecord, deleteRecordsWhere, deleteRecordsWhere, deleteRecordsWhereAsync, evaluateAggregateFunction, evaluateAggregateFunction, evaluateRecordFunction, evaluateRecordFunction, evaluateStoreFunction, executeQuery, executeQuery, executeQuery, executeQuery, fetchIndexRecords, fetchIndexRecords, fetchIndexRecords, fetchIndexRecords, getExecutor, getPipelineSize, getSnapshotRecordCount, getSnapshotRecordUpdateCount, getSnapshotRecordUpdateCount, getSubspaceProvider, getTimer, getTypedRecordStore, hasIndexEntryRecord, hasIndexEntryRecord, indexEntryKey, indexEntryPrimaryKey, insertRecord, insertRecordAsync, loadIndexEntryRecord, loadIndexEntryRecord, loadIndexEntryRecord, loadIndexEntryRecord, loadRecord, loadRecord, loadRecordAsync, loadRecordAsync, queriedRecord, queriedRecord, recordExists, recordExists, recordExistsAsync, resolveUniquenessViolation, saveRecord, saveRecord, saveRecord, saveRecord, saveRecord, saveRecordAsync, saveRecordAsync, saveRecordAsync, saveRecordAsync, scanIndex, scanIndexRecords, scanIndexRecords, scanIndexRecords, scanIndexRecords, scanIndexRecords, scanIndexRecords, scanIndexRecordsBetween, scanIndexRecordsEqual, scanRecords, scanRecords, scanUniquenessViolations, scanUniquenessViolations, scanUniquenessViolations, scanUniquenessViolations, scanUniquenessViolations, scanUniquenessViolations, scanUniquenessViolations, uniquenessViolationKey, updateRecord, updateRecordAsync
public static final int DEFAULT_PIPELINE_SIZE
public static final FDBRecordStoreBase.PipelineSizer DEFAULT_PIPELINE_SIZER
public static final int MAX_RECORDS_FOR_REBUILD
public static final int MAX_PARALLEL_INDEX_REBUILD
public static final int INFO_ADDED_FORMAT_VERSION
public static final int RECORD_COUNT_ADDED_FORMAT_VERSION
public static final int RECORD_COUNT_KEY_ADDED_FORMAT_VERSION
public static final int FORMAT_CONTROL_FORMAT_VERSION
public static final int SAVE_UNSPLIT_WITH_SUFFIX_FORMAT_VERSION
public static final int SAVE_VERSION_WITH_RECORD_FORMAT_VERSION
public static final int CACHEABLE_STATE_FORMAT_VERSION
public static final int HEADER_USER_FIELDS_FORMAT_VERSION
public static final int MAX_SUPPORTED_FORMAT_VERSION
public static final int DEFAULT_FORMAT_VERSION
public static final int KEY_SIZE_LIMIT
public static final int VALUE_SIZE_LIMIT
protected static final Object STORE_INFO_KEY
protected static final Object RECORD_KEY
protected static final Object INDEX_KEY
protected static final Object INDEX_SECONDARY_SPACE_KEY
protected static final Object RECORD_COUNT_KEY
protected static final Object INDEX_STATE_SPACE_KEY
protected static final Object INDEX_RANGE_SPACE_KEY
protected static final Object INDEX_UNIQUENESS_VIOLATIONS_KEY
protected static final Object RECORD_VERSION_KEY
protected static final Object INDEX_BUILD_SPACE_KEY
public static final byte[] LITTLE_ENDIAN_INT64_ONE
public static final byte[] LITTLE_ENDIAN_INT64_MINUS_ONE
protected int formatVersion
protected int userVersion
@Nonnull protected final RecordMetaDataProvider metaDataProvider
@Nonnull protected final AtomicReference<MutableRecordStoreState> recordStoreStateRef
@Nonnull protected final RecordSerializer<Message> serializer
@Nonnull protected final IndexMaintainerRegistry indexMaintainerRegistry
@Nonnull protected final IndexMaintenanceFilter indexMaintenanceFilter
@Nonnull protected final FDBRecordStoreBase.PipelineSizer pipelineSizer
@Nullable protected final FDBRecordStoreStateCache storeStateCache
protected FDBRecordStore(@Nonnull FDBRecordContext context, @Nonnull SubspaceProvider subspaceProvider, int formatVersion, @Nonnull RecordMetaDataProvider metaDataProvider, @Nonnull RecordSerializer<Message> serializer, @Nonnull IndexMaintainerRegistry indexMaintainerRegistry, @Nonnull IndexMaintenanceFilter indexMaintenanceFilter, @Nonnull FDBRecordStoreBase.PipelineSizer pipelineSizer, @Nullable FDBRecordStoreStateCache storeStateCache)
public FDBRecordStore getUntypedRecordStore()
FDBRecordStoreBase
getUntypedRecordStore
in interface FDBRecordStoreBase<Message>
@Nonnull public FDBRecordContext getContext()
FDBRecordStoreBase
getContext
in interface FDBRecordStoreBase<Message>
public int getFormatVersion()
FDBRecordStoreBase.BaseBuilder.open()
or checkVersion(com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase.UserVersionChecker, com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase.StoreExistenceCheck)
directly, this will be the format stored in the store's info header.
Index maintainers can use this to determine what format to expect / produce.public int getUserVersion()
FDBRecordStoreBase.BaseBuilder.open()
or checkVersion(com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase.UserVersionChecker, com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase.StoreExistenceCheck)
directly, this will be the value stored in the store's info header.
This version is returned from UserVersionChecker#checkUserVersion
and does not have any meaning within the Record Layer core.@Nullable public RecordMetaDataProvider getMetaDataProvider()
@Nonnull public RecordMetaData getRecordMetaData()
RecordMetaData
used by this store.getRecordMetaData
in interface RecordMetaDataProvider
@Nonnull public RecordStoreState getRecordStoreState()
RecordStoreState
for this store.
This represents the indexes that are disabled or in the process of being rebuilt.
If the state is not already loaded, it is loaded synchronously.@Nonnull public RecordSerializer<Message> getSerializer()
FDBRecordStoreBase
getSerializer
in interface FDBRecordStoreBase<Message>
@Nonnull public IndexMaintainerRegistry getIndexMaintainerRegistry()
@Nonnull public IndexMaintenanceFilter getIndexMaintenanceFilter()
@Nonnull public CompletableFuture<FDBStoredRecord<Message>> saveRecordAsync(@Nonnull Message record, @Nonnull FDBRecordStoreBase.RecordExistenceCheck existenceCheck, @Nullable FDBRecordVersion version, @Nonnull FDBRecordStoreBase.VersionstampSaveBehavior behavior)
FDBRecordStoreBase.saveRecord(Message, RecordExistenceCheck, FDBRecordVersion, VersionstampSaveBehavior)
.saveRecordAsync
in interface FDBRecordStoreBase<Message>
record
- the record to saveexistenceCheck
- when to throw an exception if a record with the same primary key does or does not already existversion
- the associated record versionbehavior
- the save behavior w.r.t. the given version
@Nonnull @API(value=INTERNAL) protected <M extends Message> CompletableFuture<FDBStoredRecord<M>> saveTypedRecord(@Nonnull RecordSerializer<M> typedSerializer, @Nonnull M record, @Nonnull FDBRecordStoreBase.RecordExistenceCheck existenceCheck, @Nullable FDBRecordVersion version, @Nonnull FDBRecordStoreBase.VersionstampSaveBehavior behavior)
@Nonnull @API(value=EXPERIMENTAL) public CompletableFuture<FDBSyntheticRecord> loadSyntheticRecord(@Nonnull Tuple primaryKey)
synthetic record
by loading its stored constituent records and synthesizing it from them.primaryKey
- the primary key of the synthetic record, which includes the primary keys of the constituents@Nonnull public Subspace indexSubspaceFromMaintainer(@Nonnull Index index)
@Nonnull public Subspace indexRangeSubspace(@Nonnull Index index)
RangeSet
.
This is used for determining how much progress has been made on building the index in the
case that one is building the index offline.index
- the index to retrieve the range subspace forRangeSet
for the given index@Nonnull public Subspace indexUniquenessViolationsSubspace(@Nonnull Index index)
index
- the index to retrieve the uniqueness violation subspace forpublic IndexMaintainer getIndexMaintainer(@Nonnull Index index)
index
- the required indexpublic int getKeySizeLimit()
public int getValueSizeLimit()
public void addUniquenessCheck(@Nonnull AsyncIterable<KeyValue> kvs, @Nonnull Index index, @Nonnull IndexEntry indexEntry, @Nonnull Tuple primaryKey)
public CompletableFuture<IndexOperationResult> performIndexOperationAsync(@Nonnull String indexName, @Nonnull IndexOperation operation)
public IndexOperationResult performIndexOperation(@Nonnull String indexName, @Nonnull IndexOperation operation)
@Nonnull public CompletableFuture<FDBStoredRecord<Message>> loadRecordInternal(@Nonnull Tuple primaryKey, @Nonnull ExecuteState executeState, boolean snapshot)
loadRecordInternal
in interface FDBRecordStoreBase<Message>
@Nonnull protected <M extends Message> CompletableFuture<FDBStoredRecord<M>> loadTypedRecord(@Nonnull RecordSerializer<M> typedSerializer, @Nonnull Tuple primaryKey, boolean snapshot)
@Nonnull protected <M extends Message> CompletableFuture<FDBStoredRecord<M>> loadTypedRecord(@Nonnull RecordSerializer<M> typedSerializer, @Nonnull Tuple primaryKey, @Nonnull ExecuteState executeState, boolean snapshot)
@Nonnull public Optional<CompletableFuture<FDBRecordVersion>> loadRecordVersionAsync(@Nonnull Tuple primaryKey)
loadRecordVersion(Tuple)
. If the
record does not have a version, but that cannot be determined
before making a call to the database, this might return a
completable future that wraps null
.primaryKey
- the primary key of the recordOptional.empty()
if versions are not enabled for this store@Nonnull public Optional<CompletableFuture<FDBRecordVersion>> loadRecordVersionAsync(@Nonnull Tuple primaryKey, boolean snapshot)
loadRecordVersion(Tuple, boolean)
.primaryKey
- the primary key of the recordsnapshot
- whether to snapshot readOptional.empty()
if versions are not enabled for this store@Nonnull public Optional<FDBRecordVersion> loadRecordVersion(@Nonnull Tuple primaryKey)
Optional
.primaryKey
- the primary key for the recordOptional
that, if not empty, contains record's version@Nonnull public Optional<FDBRecordVersion> loadRecordVersion(@Nonnull Tuple primaryKey, boolean snapshot)
loadRecordVersion(Tuple)
that supports snapshot
reads. If snapshot
is set to true
,
reading the record's version does not add a read conflict to the
store's transaction.primaryKey
- the primary key for the recordsnapshot
- whether this operation should be done with a snapshot
Optional
that, if not empty, contain's the record versionprotected void countKeysAndValues(@Nonnull StoreTimer.Count key, @Nonnull StoreTimer.Count keyBytes, @Nonnull StoreTimer.Count valueBytes, @Nonnull FDBStoredSizes sizeInfo)
public void countKeyValue(@Nonnull StoreTimer.Count key, @Nonnull StoreTimer.Count keyBytes, @Nonnull StoreTimer.Count valueBytes, @Nonnull KeyValue keyValue)
public void countKeyValue(@Nonnull StoreTimer.Count key, @Nonnull StoreTimer.Count keyBytes, @Nonnull StoreTimer.Count valueBytes, @Nonnull byte[] k, @Nonnull byte[] v)
@Nonnull public CompletableFuture<Void> preloadRecordAsync(@Nonnull Tuple primaryKey)
FDBRecordStoreBase
preloadRecordAsync
in interface FDBRecordStoreBase<Message>
primaryKey
- the primary key for the record to retrievenull
when the record is preloaded@Nonnull public CompletableFuture<Boolean> recordExistsAsync(@Nonnull Tuple primaryKey, @Nonnull IsolationLevel isolationLevel)
FDBRecordStoreBase
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.recordExistsAsync
in interface FDBRecordStoreBase<Message>
primaryKey
- the primary key of the recordisolationLevel
- the isolation level to use when readingtrue
if some record in record store has that primary key and
false
otherwisepublic void addRecordReadConflict(@Nonnull Tuple primaryKey)
FDBRecordStoreBase
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.
addRecordReadConflict
in interface FDBRecordStoreBase<Message>
primaryKey
- the primary key of the record to add a read conflict onTransaction.addReadConflictRange(byte[], byte[])
public void addRecordWriteConflict(@Nonnull Tuple primaryKey)
FDBRecordStoreBase
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.
addRecordWriteConflict
in interface FDBRecordStoreBase<Message>
primaryKey
- the primary key of the record to add a write conflict onTransaction.addWriteConflictRange(byte[], byte[])
@Nonnull public RecordCursor<FDBStoredRecord<Message>> scanRecords(@Nullable Tuple low, @Nullable Tuple high, @Nonnull EndpointType lowEndpoint, @Nonnull EndpointType highEndpoint, @Nullable byte[] continuation, @Nonnull ScanProperties scanProperties)
FDBRecordStoreBase
scanRecords
in interface FDBRecordStoreBase<Message>
low
- low point of scan rangehigh
- high point of scan pointlowEndpoint
- whether low point is inclusive or exclusivehighEndpoint
- whether high point is inclusive or exclusivecontinuation
- any continuation from a previous scanscanProperties
- skip, limit and other scan properties@Nonnull public <M extends Message> RecordCursor<FDBStoredRecord<M>> scanTypedRecords(@Nonnull RecordSerializer<M> typedSerializer, @Nullable Tuple low, @Nullable Tuple high, @Nonnull EndpointType lowEndpoint, @Nonnull EndpointType highEndpoint, @Nullable byte[] continuation, @Nonnull ScanProperties scanProperties)
@Nonnull public CompletableFuture<Integer> countRecords(@Nullable Tuple low, @Nullable Tuple high, @Nonnull EndpointType lowEndpoint, @Nonnull EndpointType highEndpoint, @Nullable byte[] continuation, @Nonnull ScanProperties scanProperties)
FDBRecordStoreBase
countRecords
in interface FDBRecordStoreBase<Message>
low
- low point of scan rangehigh
- high point of scan pointlowEndpoint
- whether low point is inclusive or exclusivehighEndpoint
- whether high point is inclusive or exclusivecontinuation
- any continuation from a previous scanscanProperties
- skip, limit and other scan properties@Nonnull public RecordCursor<IndexEntry> scanIndex(@Nonnull Index index, @Nonnull IndexScanType scanType, @Nonnull TupleRange range, @Nullable byte[] continuation, @Nonnull ScanProperties scanProperties)
FDBRecordStoreBase
scanIndex
in interface FDBRecordStoreBase<Message>
index
- the index to scanscanType
- the type of scan to performrange
- range to scancontinuation
- any continuation from a previous scanscanProperties
- skip, limit and other scan properties@Nonnull public RecordCursor<RecordIndexUniquenessViolation> scanUniquenessViolations(@Nonnull Index index, @Nonnull TupleRange range, @Nullable byte[] continuation, @Nonnull ScanProperties scanProperties)
FDBRecordStoreBase
Because of how the data are stored, each primary key that is part of a uniqueness violation will appear at most once for each index key that is causing a violation. The associated existing key is going to be one of the other keys, but it might not be the only one. This means that the total number of violations per index key is capped at the number of records in the store (rather than the square), but it also means that the existing key data is of limited help.
scanUniquenessViolations
in interface FDBRecordStoreBase<Message>
index
- the index to scan the uniqueness violations ofrange
- the range of tuples to include in the scancontinuation
- any continuation from a previous scanscanProperties
- skip, limit and other scan properties@Nonnull public CompletableFuture<Void> resolveUniquenessViolation(@Nonnull Index index, @Nonnull Tuple valueKey, @Nullable Tuple primaryKey)
FDBRecordStoreBase
null
).
It also cleans up the set of uniqueness violations so that none of the remaining entries will
be associated with the given value key.resolveUniquenessViolation
in interface FDBRecordStoreBase<Message>
index
- the index to resolve uniqueness violations forvalueKey
- the value of the index that is being removedprimaryKey
- the primary key of the record that should remain (or null
to remove all of them)@Nonnull public CompletableFuture<Boolean> deleteRecordAsync(@Nonnull Tuple primaryKey)
FDBRecordStoreBase
FDBRecordStoreBase.deleteRecord(com.apple.foundationdb.tuple.Tuple)
.deleteRecordAsync
in interface FDBRecordStoreBase<Message>
primaryKey
- the primary key of the record to deletetrue
if the record was present to be deleted@Nonnull protected <M extends Message> CompletableFuture<Boolean> deleteTypedRecord(@Nonnull RecordSerializer<M> typedSerializer, @Nonnull Tuple primaryKey)
public static void deleteStore(FDBRecordContext context, KeySpacePath path)
KeySpacePath
. This behaves like
deleteStore(FDBRecordContext, Subspace)
on the record store saved
at KeySpacePath.toSubspace(FDBRecordContext)
.context
- the transactional context in which to delete the record storepath
- the path to the record storedeleteStore(FDBRecordContext, Subspace)
public static void deleteStore(FDBRecordContext context, Subspace subspace)
Subspace
. In addition to the store's
data this will delete the store's header and therefore will remove any evidence that
the store existed.
This method does not read the underlying record store, so it does not validate
that a record store exists in the given subspace. As it might be the case that
this record store has a cacheable store state (see setStateCacheability(boolean)
),
this method resets the database's
meta-data version-stamp.
As a result, calling this method may cause other clients to invalidate their caches needlessly.
context
- the transactional context in which to delete the record storesubspace
- the subspace containing the record storepublic void deleteAllRecords()
FDBRecordStoreBase
Everything except the store header and index state information is cleared from the database.
This is is an efficient operation as all data are contiguous.
This means that any disabled or write-only
index will remain in its disabled or write-only state after all of the data are cleared. If one also wants
to reset all index states, one can call rebuildAllIndexes()
, which should complete
quickly on an empty record store. If one wants to remove the record store entirely (including the store
header and all index states), one should call deleteStore(FDBRecordContext, KeySpacePath)
instead of this method.
Note that, at the moment, this operation also has the side effect of resetting
MAX_EVER
and
MIN_EVER
indexes.
See: Issue #398.
deleteAllRecords
in interface FDBRecordStoreBase<Message>
deleteStore(FDBRecordContext, KeySpacePath)
,
deleteStore(FDBRecordContext, Subspace)
public CompletableFuture<Void> deleteRecordsWhereAsync(@Nonnull QueryComponent component)
FDBRecordStoreBase
FDBRecordStoreBase.deleteRecordsWhereAsync(com.apple.foundationdb.record.query.expressions.QueryComponent)
.deleteRecordsWhereAsync
in interface FDBRecordStoreBase<Message>
component
- the query filter for records to delete efficiently@Nonnull protected static QueryComponent mergeRecordTypeAndComponent(@Nonnull String recordType, @Nullable QueryComponent component)
public FDBRecordStoreBase.PipelineSizer getPipelineSizer()
FDBRecordStoreBase
getPipelineSizer
in interface FDBRecordStoreBase<Message>
public CompletableFuture<Long> getSnapshotRecordCount(@Nonnull KeyExpression key, @Nonnull Key.Evaluated value)
FDBRecordStoreBase
COUNT
type index defined.getSnapshotRecordCount
in interface FDBRecordStoreBase<Message>
key
- the grouping key expressionvalue
- the value of key
to matchpublic CompletableFuture<Long> getSnapshotRecordCountForRecordType(@Nonnull String recordTypeName)
FDBRecordStoreBase
COUNT
index defined for it.getSnapshotRecordCountForRecordType
in interface FDBRecordStoreBase<Message>
recordTypeName
- record type for which to count recordspublic static long decodeRecordCount(@Nullable byte[] bytes)
@Nonnull public <T> CompletableFuture<T> evaluateIndexRecordFunction(@Nonnull EvaluationContext evaluationContext, @Nonnull IndexRecordFunction<T> function, @Nonnull FDBRecord<Message> record)
FDBRecordStoreBase
IndexRecordFunction
against a record.evaluateIndexRecordFunction
in interface FDBRecordStoreBase<Message>
T
- the type of the resultevaluationContext
- evaluation context containing parameter bindingsfunction
- the function to evaluaterecord
- the record to evaluate against@Nonnull protected <T,M extends Message> CompletableFuture<T> evaluateTypedIndexRecordFunction(@Nonnull EvaluationContext evaluationContext, @Nonnull IndexRecordFunction<T> indexRecordFunction, @Nonnull FDBRecord<M> record)
@Nonnull public <T> CompletableFuture<T> evaluateStoreFunction(@Nonnull EvaluationContext evaluationContext, @Nonnull StoreRecordFunction<T> function, @Nonnull FDBRecord<Message> record)
FDBRecordStoreBase
StoreRecordFunction
against a record.evaluateStoreFunction
in interface FDBRecordStoreBase<Message>
T
- the type of the resultevaluationContext
- evaluation context containing parameter bindingsfunction
- the function to evaluaterecord
- the record to evaluate against@Nonnull public <T,M extends Message> CompletableFuture<T> evaluateTypedStoreFunction(@Nonnull EvaluationContext evaluationContext, @Nonnull StoreRecordFunction<T> function, @Nonnull FDBRecord<M> record)
@Nonnull public CompletableFuture<Tuple> evaluateAggregateFunction(@Nonnull List<String> recordTypeNames, @Nonnull IndexAggregateFunction aggregateFunction, @Nonnull TupleRange range, @Nonnull IsolationLevel isolationLevel)
FDBRecordStoreBase
IndexAggregateFunction
against a range of the store.evaluateAggregateFunction
in interface FDBRecordStoreBase<Message>
recordTypeNames
- record types for which to find a matching indexaggregateFunction
- the function to evaluaterange
- the range of records (group) for which to evaluateisolationLevel
- whether to use snapshot reads@Nonnull public RecordQueryPlan planQuery(@Nonnull RecordQuery query)
FDBRecordStoreBase
planQuery
in interface FDBRecordStoreBase<Message>
query
- the query to planRecordQueryPlanner.plan(com.apple.foundationdb.record.query.RecordQuery)
@Nonnull public static IndexState writeOnlyIfTooManyRecordsForRebuild(long recordCount, boolean indexOnNewRecordTypes)
@Nonnull public CompletableFuture<Boolean> checkVersion(@Nullable FDBRecordStoreBase.UserVersionChecker userVersionChecker, @Nonnull FDBRecordStoreBase.StoreExistenceCheck existenceCheck)
FDBExceptions.FDBStoreException
indicating
that the meta-data is stale; (2) if the stored version is older than the local version, this
will update the store to include the changes that have happened since the last meta-data
version; and (3) if the versions are the same, it will do nothing. If branch (2) is followed,
then the process of updating the store based on the meta-data will do the following: (a) if
the number of records is small, it will build all of the indexes that have been added
between the two meta-data checks, or (b) if the number of records is large, it will
mark the new indexes as write-only. It is then up to the client to start online index
build jobs to build those indexes.
This will also apply the passed UserVersionChecker
instance to check the user-defined
version. The result of this check will be handled the same as with meta-data version changes, i.e.,
if the user version is newer than the stored version, then version is updated. If the user
version is older than the stored version, it will throw an exception about the stale user
version. If the two versions are the same, it will do nothing.
This will return a future that will either complete exceptionally (in the case of a stale
user or meta-data) or will complete with true
if the version was changed
because the record store had an old version or false
if no change to the
store was done.userVersionChecker
- hook for checking if store state for client must changeexistenceCheck
- when to throw an exception if the record store does or does not already exist@API(value=INTERNAL) @Nonnull public static CompletableFuture<Void> checkStoreHeader(@Nonnull RecordMetaDataProto.DataStoreInfo storeHeader, @Nonnull FDBRecordContext context, @Nonnull SubspaceProvider subspaceProvider, @Nonnull Subspace subspace, @Nonnull FDBRecordStoreBase.StoreExistenceCheck existenceCheck)
protected void saveStoreHeader(@Nonnull RecordMetaDataProto.DataStoreInfo storeHeader)
@Nonnull public CompletableFuture<Void> rebuildAllIndexes()
OnlineIndexer
to build
each index instead.@Nonnull public CompletableFuture<Void> clearAndMarkIndexWriteOnly(@Nonnull String indexName)
@Nonnull public CompletableFuture<Void> clearAndMarkIndexWriteOnly(@Nonnull Index index)
index
- the index to build@Nonnull public CompletableFuture<Boolean> setStateCacheabilityAsync(boolean cacheable)
RecordStoreState
is changed. By default, record store state information is
not cacheable. This is because for deployments in which there are many record stores sharing the same
cluster, updating the meta-data version key every time any store changes its state could lead to performance
problems, so (at least for now), this is a feature the user must opt-in to on each record store.cacheable
- whether the meta-data version-stamp should be invalidated upon store state changetrue
if the store state's cacheability has changedpublic boolean setStateCacheability(boolean cacheable)
setStateCacheabilityAsync(boolean)
in asynchronous contexts.cacheable
- whether this store's state should be cacheablesetStateCacheabilityAsync(boolean)
@Nullable public ByteString getHeaderUserField(@Nonnull String userField)
FDBRecordStoreBase.BaseBuilder.createOrOpenAsync()
or one of its variants. This means that reading this
information from the header does not require any additional communication with database assuming that
the record store has already been initialized. As a result, this is not a blocking call.
Using this feature also requires that the record store be on format version HEADER_USER_FIELDS_FORMAT_VERSION
or higher. There is no change to the on-disk format version from the previous format version except that
extra fields in the store header were added. No data migration is necessary to upgrade to that version if
an existing store is on the previous format version, but the new version is used to prevent the user from serializing
data and then not being able to read it from instances running an older version of the Record Layer.
userField
- the name of the user-settable field to readnull
if it is unsetsetHeaderUserFieldAsync(String, ByteString)
@Nonnull public CompletableFuture<Void> setHeaderUserFieldAsync(@Nonnull String userField, @Nonnull ByteString value)
FDBRecordStoreBase.BaseBuilder.createOrOpenAsync()
or one of its variants. The user may also elect
to set fields to custom values that might be meaningful for their application. For example, if the user wishes
to migrate from one record type to another, the user might include a field with a value that indicates whether
that migration has completed.
Note that there are a few potential pitfalls that adopters of this API should be aware of:
FDBStoreTransactionConflictException
.
Therefore, this should only ever be used for data that are mutated at a very low rate.
The value of these fields are simple byte arrays, so the user is free to choose their own serialization format for the value included in this field. One recommended strategy is for the user to use Protobuf to serialize a message with possibly multiple keys and values, each with meaning to the user, and then to write it to a single user field (or a small number if appropriate). This decreases the total size of the user fields when compared to something like storing one user-field for each field (as the Protobuf serialization format is more compact), and it allows the user to follow standard Protobuf evolution guidelines as these fields evolve.
Once set, the value of these fields can be retrieved by calling getHeaderUserField(String)
. They
can be cleared by calling clearHeaderUserFieldAsync(String)
. Within a given transaction, updates
to the header fields should be visible through getHeaderUserField()
(that is, the header user fields
support read-your-writes within a transaction), but the context associated with this store must be committed
for other transactions to see the update.
Using this feature also requires that the record store be on format version HEADER_USER_FIELDS_FORMAT_VERSION
or higher. There is no change to the on-disk format version from the previous format version except that
extra fields in the store header were added. No data migration is necessary to upgrade to that version if
an existing store is on the previous format version, but the new version is used to prevent the user from serializing
data and then not being able to read it from instances running an older version of the Record Layer.
userField
- the name of the user-settable field to writevalue
- the value to set the field togetHeaderUserField(String)
@Nonnull public CompletableFuture<Void> setHeaderUserFieldAsync(@Nonnull String userField, @Nonnull byte[] value)
ByteString
and then passed to setHeaderUserFieldAsync(String, ByteString)
. See that
function for more details and for a list of caveats on using this function.userField
- the name of the user-settable field to writevalue
- the value to set the field tosetHeaderUserFieldAsync(String, ByteString)
public void setHeaderUserField(@Nonnull String userField, @Nonnull ByteString value)
setHeaderUserFieldAsync(String, ByteString)
. In most circumstances, this function should not be blocking,
but it might if either the store header has not yet been loaded or in some circumstances if the meta-data
is cacheable. It should therefore generally be avoided in asynchronous contexts to be safe.userField
- the name of the user-settable field to writevalue
- the value to set the field tosetHeaderUserFieldAsync(String, ByteString)
,
setStateCacheabilityAsync(boolean)
public void setHeaderUserField(@Nonnull String userField, @Nonnull byte[] value)
setHeaderUserFieldAsync(String, byte[])
. In most circumstances, this function should not be blocking,
but it might if either the store header has not yet been loaded or in some circumstances if the meta-data
is cacheable. It should therefore generally be avoided in asynchronous contexts to be safe.userField
- the name of the user-settable field to writevalue
- the value to set the field tosetHeaderUserFieldAsync(String, ByteString)
,
setStateCacheabilityAsync(boolean)
@Nonnull public CompletableFuture<Void> clearHeaderUserFieldAsync(@Nonnull String userField)
setHeaderUserFieldAsync(String, ByteString)
. This has the same caveats
as that function. In particular, whenever this is called, all concurrent operations to the same record store
will also fail with an
FDBStoreTransactionConflictException
.
As a result, one should avoid clearing these fields too often.userField
- the name of the user-settable field to clearsetHeaderUserFieldAsync(String, ByteString)
public void clearHeaderUserField(@Nonnull String userField)
clearHeaderUserFieldAsync(String)
. In most circumstances, this function should not be blocking,
but it might if either the store header has not yet been loaded or in some circumstances if the meta-data
is cacheable. It should therefore generally be avoided in asynchronous contexts to be safe.userField
- the name of user-settable field to clearclearHeaderUserFieldAsync(String)
,
setStateCacheabilityAsync(boolean)
@Nonnull public CompletableFuture<Boolean> markIndexWriteOnly(@Nonnull String indexName)
true
if the store had to
be modified in order to mark the index as write only (i.e., the index
was not already write-only) and false
otherwise.indexName
- the name of the index to mark as write-onlytrue
if the store was modified and false
otherwiseIllegalArgumentException
- if the index is not present in the meta-data@Nonnull public CompletableFuture<Boolean> markIndexWriteOnly(@Nonnull Index index)
markIndexWriteOnly()
that takes a String
for more details.index
- the index to mark as write onlytrue
if the store was modified and
false
otherwise@Nonnull public CompletableFuture<Boolean> markIndexDisabled(@Nonnull String indexName)
true
if the store had to be modified to mark the index as diabled (i.e., the
index was not already disabled) and false
otherwise.indexName
- the name of the index to mark as disabledtrue
if the store was modified and
false
otherwiseIllegalArgumentException
- if the index is not present in the meta-data@Nonnull public CompletableFuture<Boolean> markIndexDisabled(@Nonnull Index index)
markIndexDisabled(Index)
markIndexDisabled()}
that takes a String
for more details.index
- the index to mark as disabledtrue
if the store was modified and
false
otherwise@Nonnull public CompletableFuture<Optional<Range>> firstUnbuiltRange(@Nonnull Index index)
Optional
. If there is one, it will return an Optional
set to the first unbuilt range it finds.index
- the index to check built state@Nonnull public CompletableFuture<Boolean> markIndexReadable(@Nonnull Index index)
markIndexReadable()
that takes a String
as a parameter for more details.index
- the index to mark readabletrue
if the store was modified
and false
otherwise@Nonnull public CompletableFuture<Boolean> markIndexReadable(@Nonnull String indexName)
RecordStoreState
) will
be able to use that index. This will check to make sure that the index is actually
built and ready to go before making it readable. If it is not, the future
will complete exceptionally with an FDBRecordStore.IndexNotBuiltException
. If the
store is modified when marking the index as readable (i.e., if it was previously
write-only), then this will return true
. Otherwise, it will
return false
.indexName
- the name of the index to mark readabletrue
if the store was modified
and false
otherwise@Nonnull public CompletableFuture<Boolean> uncheckedMarkIndexReadable(@Nonnull String indexName)
indexName
- the name of the index to mark readabletrue
if the store was modified
and false
otherwise@Nonnull @API(value=INTERNAL) protected CompletableFuture<Void> preloadSubspaceAsync()
Subspace
so that calling FDBStoreBase.getSubspace()
will not block.@Nonnull @API(value=INTERNAL) protected CompletableFuture<Void> preloadRecordStoreStateAsync()
getRecordStoreState()
requires no i/o.@Nonnull @API(value=INTERNAL) protected CompletableFuture<Void> preloadRecordStoreStateAsync(@Nonnull FDBRecordStoreBase.StoreExistenceCheck existenceCheck, @Nonnull IsolationLevel storeHeaderIsolationLevel, @Nonnull IsolationLevel indexStateIsolationLevel)
recordStoreStateRef
.existenceCheck
- the action to be taken when the record store already exists (or does not exist yet)storeHeaderIsolationLevel
- the isolation level for loading the store headerindexStateIsolationLevel
- the isolation level for loading index state@API(value=INTERNAL) @Nonnull public CompletableFuture<RecordStoreState> loadRecordStoreStateAsync(@Nonnull FDBRecordStoreBase.StoreExistenceCheck existenceCheck)
existenceCheck
- the action to be taken when the record store already exists (or does not exist yet)@Nonnull public IndexState getIndexState(@Nonnull Index index)
FDBRecordContext
as this record store will fail to commit due to conflicts.index
- the index to check for the stateIllegalArgumentException
- if no index in the metadata has the same name as this index@Nonnull public IndexState getIndexState(@Nonnull String indexName)
indexName
- the name of the index to check for the stateIllegalArgumentException
- if no index in the metadata has the given namepublic boolean isIndexReadable(@Nonnull Index index)
FDBRecordContext
as this record store will fail to commit due to conflicts.index
- the index to check for readabilitytrue
if the index is readable and false
otherwiseIllegalArgumentException
- if no index in the metadata has the same name as this indexpublic boolean isIndexReadable(@Nonnull String indexName)
indexName
- the name of the index to check for readabilitytrue
if the named index is readable and false
otherwiseIllegalArgumentException
- if no index in the metadata has the given namepublic boolean isIndexWriteOnly(@Nonnull Index index)
FDBRecordContext
as this record store will fail to commit due to conflicts.index
- the index to check if write-onlytrue
if the index is write-only and false
otherwiseIllegalArgumentException
- if no index in the metadata has the same name as this indexpublic boolean isIndexWriteOnly(@Nonnull String indexName)
indexName
- the name of the index to check if write-onlytrue
if the named index is write-only and false
otherwiseIllegalArgumentException
- if no index in the metadata has the given namepublic boolean isIndexDisabled(@Nonnull Index index)
FDBRecordContext
as this record store will fail to commit due to conflicts.index
- the index to check if write-onlytrue
if the index is disabled and false
otherwiseIllegalArgumentException
- if no index in the metadata has the same name as this indexpublic boolean isIndexDisabled(@Nonnull String indexName)
indexName
- the name of the index to check if disabledtrue
if the named index is disabled and false
otherwiseIllegalArgumentException
- if no index in the metadata has the given namepublic CompletableFuture<IndexBuildState> getIndexBuildStateAsync(Index index)
index
- the index to check the index build stateIndexBuildState
@Nonnull public List<Index> getReadableIndexes(@Nonnull RecordTypeOrBuilder recordType)
Index
es that are readable, i.e., the index name is not
within the RecordStoreState
's list of write-only indexes or its list of disabled indexes.recordType
- type of record to get the readable indexes of@Nonnull public List<Index> getEnabledIndexes(@Nonnull RecordTypeOrBuilder recordType)
Index
es that are enabled, i.e., the index name is not
within the RecordStoreState
's list of disabled indexes.recordType
- type of record to get the enabled indexes of@Nonnull public List<Index> getReadableMultiTypeIndexes(@Nonnull RecordTypeOrBuilder recordType)
Index
es that are readable, i.e., the index name is not
within the RecordStoreState
's list of write-only indexes or its list of disabled indexes.recordType
- type of record to get the readable multi-type indexes of@Nonnull public List<Index> getEnabledMultiTypeIndexes(@Nonnull RecordTypeOrBuilder recordType)
Index
es that are enabled, i.e., the index name is not
within the RecordStoreState
's list of disabled indexes.recordType
- type of record to get the enabled multi-type indexes of@Nonnull public List<Index> getReadableUniversalIndexes()
Index
es that are readable, i.e., the index name is not
within the RecordStoreState
's list of write-only indexes or its list of disabled indexes.@Nonnull public List<Index> getEnabledUniversalIndexes()
Index
es that are enabled, i.e., the index name is not
within the RecordStoreState
's list of disabled indexes.@Nonnull public Map<Index,IndexState> getAllIndexStates()
Index
to IndexState
for all the indexes in the meta-data.
This method will not perform any queries to the underlying database and instead satisfies the answer based on the
in-memory cache of store state. However, if another operation in a different transaction
happens concurrently that changes the index's state, operations using the same FDBRecordContext
as this record store will fail to commit due to conflicts.@Nonnull protected CompletableFuture<Void> rebuildIndexes(@Nonnull Map<Index,List<RecordType>> indexes, @Nonnull Map<Index,IndexState> newStates, @Nonnull List<CompletableFuture<Void>> work, @Nonnull FDBRecordStore.RebuildIndexReason reason, @Nullable Integer oldMetaDataVersion)
protected CompletableFuture<Void> rebuildOrMarkIndex(@Nonnull Index index, @Nonnull IndexState indexState, @Nullable List<RecordType> recordTypes, @Nonnull FDBRecordStore.RebuildIndexReason reason, @Nullable Integer oldMetaDataVersion)
@Nonnull public CompletableFuture<Void> rebuildIndex(@Nonnull Index index)
Because the operations all occur within a single transaction, for larger record stores,
this operation can run into transaction size and time limits. (See:
FoundationDB Known Limitations.)
To build an index on such a record store, the user should use the OnlineIndexer
, which
breaks up work across multiple transactions to avoid those limits.
index
- the index to rebuildOnlineIndexer
@Nonnull public CompletableFuture<Void> rebuildIndex(@Nonnull Index index, @Nullable Collection<RecordType> recordTypes, @Nonnull FDBRecordStore.RebuildIndexReason reason)
@Nonnull protected org.apache.commons.lang3.tuple.Pair<CompletableFuture<Long>,Boolean> getRecordCountForRebuildIndexes(boolean newStore, boolean rebuildRecordCounts, @Nonnull Map<Index,List<RecordType>> indexes)
newStore
- true
if this is a brand new storerebuildRecordCounts
- true
if there is a record count key that needs to be rebuiltindexes
- indexes that need to be builttrue
if this count is in fact for all record types@Nullable protected RecordType singleRecordTypeWithPrefixKey(@Nonnull Map<Index,List<RecordType>> indexes)
@Nonnull protected Map<Index,IndexState> getStatesForRebuildIndexes(@Nullable FDBRecordStoreBase.UserVersionChecker userVersionChecker, @Nonnull Map<Index,List<RecordType>> indexes, long recordCount, boolean newStore, boolean rebuildRecordCounts, int oldMetaDataVersion, int oldFormatVersion)
public void removeFormerIndex(FormerIndex formerIndex)
protected boolean checkPossiblyRebuildRecordCounts(@Nonnull RecordMetaData metaData, @Nonnull RecordMetaDataProto.DataStoreInfo.Builder info, @Nonnull List<CompletableFuture<Void>> work, int oldFormatVersion)
public void addRebuildRecordCountsJob(List<CompletableFuture<Void>> work)
@API(value=EXPERIMENTAL) @Nonnull public RecordCursor<Tuple> getPrimaryKeyBoundaries(@Nonnull Tuple low, @Nonnull Tuple high)
The boundaries are returned as a cursor which is sorted and does not contain any duplicates. The first element of
the list is greater than or equal to low
, and the last element is less than or equal to
high
.
This implementation may not work when there are too many shard boundaries to complete in a single transaction.
Note: the returned cursor is blocking and must not be used in an asynchronous context
low
- low endpoint of primary key range (inclusive)high
- high endpoint of primary key range (exclusive)@Deprecated public void validateMetaData()
RecordMetaDataBuilder
@Nonnull public CompletableFuture<byte[]> repairRecordKeys(@Nullable byte[] continuation, @Nonnull ScanProperties scanProperties)
@Nonnull public CompletableFuture<byte[]> repairRecordKeys(@Nullable byte[] continuation, @Nonnull ScanProperties scanProperties, boolean isDryRun)
omitUnsplitRecordSuffix
flag
is true
, keys found missing the SplitHelper.UNSPLIT_RECORD
suffix will be repaired.SplitHelper.UNSPLIT_RECORD
, the FDBStoreTimer.Counts.INVALID_SPLIT_SUFFIX
counter will be incremented.
FDBStoreTimer.Counts.INVALID_KEY_LENGTH
counter will be incremented.
continuation
- continuation from a previous repair attempt or null
to start from the beginningscanProperties
- properties to provide scan limits on the repair process
record keys should be loggedisDryRun
- if true, no repairs are made, however counters involving irregular keys or keys that would
would have been repaired are incrementednull
if the repair has been completed@Nonnull public static FDBRecordStore.Builder newBuilder()
@Nonnull public FDBRecordStore.Builder asBuilder()