Package pebbleiter exposes a type that selectively wraps a Pebble Iterator only in crdb_test builds.

Attributes configures the engine's attributes.

BallastSize sets the amount reserved by a ballast file for manual out-of-disk recovery.

BallastSizeBytes returns the desired size of the emergency ballast, calculated from the provided store spec and disk usage.

BatchCount provides an efficient way to get the count of mutations in a batch representation.

BlockConcurrencyLimitDivisor sets the divisor used to calculate the block load concurrency limit: the current value of the BlockLoadConcurrencyLimit setting divided by the divisor.

BlockSize sets the engine block size, primarily for testing purposes.

Caches sets the block and file caches.

CacheSize configures the size of the block cache.

CanGCEntireRange checks if a span of keys doesn't contain any live data and all data is covered by range tombstones at or below provided threshold.

CheckSSTConflicts iterates over an SST and a Reader in lockstep and errors out if it finds any conflicts.

ClearRangeWithHeuristic clears the keys from start (inclusive) to end (exclusive), including any range keys, but does not clear intents unless the lock table is targeted explicitly.

CombineOptions combines many options into one.

ComputeStats scans the given key span and computes MVCC stats.

ComputeStatsForIter is like ComputeStats, but scans across the given iterator until exhausted.

ComputeStatsWithVisitors is like ComputeStats, but also takes callbacks that are invoked on each key.

DecodeEngineKey decodes the given bytes as an EngineKey.

DecodeMVCCKey decodes an MVCCKey from its Pebble representation.

DecodeMVCCTimestampSuffix decodes an MVCC timestamp from its Pebble representation, including the length suffix.

DecodeMVCCValue decodes an MVCCKey from its Pebble representation.

DecodeMVCCValueAndErr is a helper that can be called using the ([]byte, error) pair returned from the iterator UnsafeValue(), Value() methods.

DecodeValueFromMVCCValue decodes and MVCCValue and returns the roachpb.Value portion without parsing the MVCCValueHeader.

DefaultPebbleOptions returns the default pebble options.

DisableMetamorphicLockTableItersBeforeSeek disables the metamorphic value for the duration of a test, resetting it at the end.

DisableMetamorphicSimpleValueEncoding disables the disableSimpleValueEncoding metamorphic bool for the duration of a test, resetting it at the end.

DisableOpLogger disables op logging for the given read/writer.

DiskMonitor configures a monitor to track disk stats.

DiskWriteStatsCollector configures an engine to categorically track disk write stats.

EncodedMVCCKeyPrefixLength returns the encoded length of a roachpb.Key prefix including the sentinel byte.

EncodedMVCCTimestampSuffixLength returns the encoded length of the given MVCC timestamp, including the length suffix.

EncodedMVCCValueIsTombstone is faster than decoding a MVCCValue and then calling MVCCValue.IsTombstone.

EncodeMVCCKey encodes an MVCCKey into its Pebble representation.

EncodeMVCCKeyPrefix encodes an MVCC user key (without timestamp) into its Pebble prefix representation.

EncodeMVCCKeyToBuf encodes an MVCCKey into its Pebble representation, reusing the given byte buffer if it has sufficient capacity.

EncodeMVCCTimestampSuffix encodes an MVCC timestamp into its Pebble representation, including the length suffix but excluding the sentinel byte.

EncodeMVCCTimestampSuffixWithSyntheticBitForTesting is a utility to encode the provided timestamp as a MVCC timestamp key suffix with the synthetic bit set.

EncodeMVCCTimestampToBuf encodes an MVCC timestamp into its Pebble representation, excluding the length suffix and sentinel byte, reusing the given byte slice if it has sufficient capacity.

EncodeMVCCValue encodes an MVCCValue into its Pebble representation.

EncodeMVCCValueForExport encodes fields from the MVCCValueHeader that are appropriate for export out of the cluster.

EncodeMVCCValueToBuf encodes an MVCCValue into its Pebble representation.

EngineKeyCompare compares cockroach keys, including the version (which could be MVCC timestamps).

EngineKeyEqual checks for equality of cockroach keys, including the version (which could be MVCC timestamps).

EngineKeySplit implements pebble.Compare.Split.

EnginePointSuffixCompare compares suffixes of Cockroach point keys (which are composed of the version and a trailing version-length byte); the version can be an MVCC timestamp or a lock key.

EngineRangeSuffixCompare implements pebble.Comparer.CompareRangeSuffixes.

FingerprintRangekeys iterates over the provided SSTs, that are expected to contain only rangekeys, and maintains a XOR aggregate of each rangekey's fingerprint.

FuzzEngineKeysInvariants fuzz tests various functions over engine keys, ensuring that invariants over engine keys hold.

GetIntent will look up an intent given a key.

GetKeyPartFromEngineKey is a specialization of DecodeEngineKey which avoids constructing a slice for the version part of the key, since the caller does not need it.

If enables the given option if enable is true.

IncludeStartKeyIntoErr wraps with the given error to include the provided start key of the scan as an additional detail.

IsDiskFull examines the store indicated by spec, determining whether the store's underlying disk is out of disk space.

IsValidSplitKey returns whether the key is a valid split key.

LBaseMaxBytes configures the maximum number of bytes for LBase.

MakeExternalStorageWrapper returns a remote.Storage implementation that wraps cloud.ExternalStorage.

MakeIngestionSSTWriter creates a new SSTWriter tailored for ingestion SSTs.

MakeIngestionSSTWriterWithOverrides creates a new SSTWriter tailored for ingestion SSTs.

MakeIngestionWriterOptions returns writer options suitable for writing SSTs that will subsequently be ingested (e.g.

MakeMVCCMetadataKey creates an MVCCKey from a roachpb.Key.

MakeSingleEngineReplicasStorage constructs a ReplicasStorage where the same Engine contains the the raft log and the state machine.

MakeTransportSSTWriter creates a new SSTWriter tailored for sstables constructed exclusively for transport, which are typically only ever iterated in their entirety and not durably persisted.

MakeValue returns the inline value.

MaxConcurrentCompactions configures the maximum number of concurrent compactions an Engine will execute.

MaxConcurrentDownloads configures the maximum number of concurrent download compactions an Engine will execute.

MaxOpenFiles sets the maximum number of files an engine should open.

MaxSizeBytes ets the intended maximum store size as an absolute byte value.

MaxSizePercent ets the intended maximum store size as the specified percentage of total capacity.

MaxWriterConcurrency sets the concurrency of the sstable Writers.

MergeInternalTimeSeriesData exports the engine's MVCC merge logic for InternalTimeSeriesData to higher level packages.

MinVersionIsAtLeastTargetVersion returns whether the min version recorded on disk is at least the target version.

MVCCAcquireLock attempts to acquire a lock at the specified key and strength by the specified transaction.

MVCCBlindConditionalPut is a fast-path of MVCCConditionalPut.

MVCCBlindInitPut is a fast-path of MVCCInitPut.

MVCCBlindPut is a fast-path of MVCCPut.

MVCCBlindPutInlineWithPrev updates an inline value using a blind put when the previous value is known.

MVCCBlindPutProto sets the given key to the protobuf-serialized byte string of msg and the provided timestamp.

MVCCCheckForAcquireLock scans the replicated lock table to determine whether a lock acquisition at the specified key and strength by the specified transaction[1] would succeed.

MVCCClearTimeRange clears all MVCC versions (point keys and range keys) within the span [key, endKey) which have timestamps in the span (startTime, endTime].

MVCCConditionalPut sets the value for a specified key only if the expected value matches.

MVCCDelete marks the key deleted so that it will not be returned in future get responses.

MVCCDeleteRange deletes the range of key/value pairs specified by start and end keys.

MVCCDeleteRangeUsingTombstone deletes the given MVCC keyspan at the given timestamp using an MVCC range tombstone (rather than MVCC point tombstones).

MVCCExportFingerprint exports a fingerprint for point keys in the keyrange [StartKey, EndKey) over the interval (StartTS, EndTS].

MVCCExportToSST exports changes to the keyrange [StartKey, EndKey) over the interval (StartTS, EndTS] as a Pebble SST.

MVCCFindSplitKey finds a key from the given span such that the left side of the split is roughly targetSize bytes.

MVCCFirstSplitKey returns the first key which is safe to split at and no less than desiredSplitKey in the range which spans [startKey,endKey).

MVCCGarbageCollect creates an iterator on the ReadWriter.

MVCCGarbageCollectPointsWithClearRange removes garbage collected points data within range [start@startTimestamp, endTimestamp).

MVCCGarbageCollectRangeKeys is similar in functionality to MVCCGarbageCollect but operates on range keys.

MVCCGarbageCollectWholeRange removes all the range data and resets counters.

MVCCGet returns a MVCCGetResult.

MVCCGetAsTxn constructs a temporary transaction from the given transaction metadata and calls MVCCGet as that transaction.

MVCCGetForKnownTimestampWithNoIntent returns the value for key@timestamp, which is required to exist as a point (not a rangekey) and not have a corresponding intent.

MVCCGetProto fetches the value at the specified key and unmarshals it into msg if msg is non-nil.

MVCCGetWithValueHeader is like MVCCGet, but in addition returns the MVCCValueHeader for the value.

MVCCIncrement fetches the value for key, and assuming the value is an "integer" type, increments it by inc and stores the new value.

MVCCInitPut sets the value for a specified key if the key doesn't exist.

MVCCIsSpanEmpty returns true if there are no MVCC keys whatsoever in the key span in the requested time interval.

MVCCIterate iterates over the key range [start,end).

MVCCLookupRangeKeyValue reads the value header for a range deletion on [key,endKey) at the specified timestamp.

MVCCMerge implements a merge operation.

MVCCPaginate iteratively invokes f() with the current maxKeys and targetBytes limits.

MVCCPredicateDeleteRange issues MVCC tombstones at endTime to live keys within the span [startKey, endKey) that also have MVCC versions that match the predicate filters.

MVCCPut sets the value for a specified key.

MVCCPutProto sets the given key to the protobuf-serialized byte string of msg and the provided timestamp.

MVCCResolveWriteIntent either commits, aborts (rolls back), or moves forward in time an extant write intent for a given txn according to commit parameter.

MVCCResolveWriteIntentRange commits or aborts (rolls back) the range of write intents specified by start and end keys for a given txn.

MVCCScan scans the key range [key, endKey) in the provided reader up to some maximum number of results in ascending order.

MVCCScanAsTxn constructs a temporary transaction from the given transaction metadata and calls MVCCScan as that transaction.

MVCCScanDecodeKeyValue decodes a key/value pair returned in an MVCCScan "batch" (this is not the RocksDB batch repr format), returning both the key/value and the suffix of data remaining in the batch.

MVCCScanDecodeKeyValues decodes all key/value pairs returned in one or more MVCCScan "batches" (this is not the RocksDB batch repr format).

MVCCScanToBytes is like MVCCScan, but it returns the results in a byte array.

MVCCScanToCols is like MVCCScan, but it returns KVData in a serialized columnar batch suitable for reading by colserde.RecordBatchDeserializer.

MVCCVerifyLock returns true if the supplied transaction holds a lock that offers equal to or greater protection[1] than the supplied lock strength.

NewBackupCompactionIterator creates a new BackupCompactionIterator.

NewBatchReader creates a BatchReader from the given batch repr and verifies the header.

NewDefaultInMemForTesting allocates and returns a new, opened in-memory engine with the default configuration.

NewLockTableIterator creates a new LockTableIterator.

NewMemSSTIterator returns an MVCCIterator for the provided SST data, similarly to NewSSTIterator().

NewMultiMemSSTIterator returns an MVCCIterator for the provided SST data, similarly to NewSSTIterator().

NewMVCCIncrementalIterator creates an MVCCIncrementalIterator with the specified reader and options.

NewOpLoggerBatch creates a new batch that logs logical mvcc operations and wraps the provided batch.

NewPebbleTempEngine creates a new Pebble engine for DistSQL processors to use when the working set is larger than can be stored in memory.

NewReadAsOfIterator constructs a ReadAsOfIterator.

NewSSTEngineIterator is like NewSSTIterator, but returns an EngineIterator.

NewSSTIterator returns an MVCCIterator for the provided "levels" of SST files.

NewTempEngine creates a new engine for DistSQL processors to use when the working set is larger than can be stored in memory.

NoopFinishAbortWritable wraps an io.Writer to make a objstorage.Writable that will ignore Finish and Abort calls.

Open opens a new Pebble storage engine, reading and writing data to the provided fs.Env, configured with the provided options.

PebbleOptions contains Pebble-specific options in the same format as a Pebble OPTIONS file.

PeekRangeKeysLeft peeks for any range keys to the left of the given key.

PeekRangeKeysRight peeks for any range keys to the right of the given key.

RegisterCompressionAlgorithmClusterSetting is a helper to register an enum cluster setting with the given name, description and default value.

RemoteStorageFactory enables use of remote storage (experimental).

ReplacePointTombstonesWithRangeTombstones will replace existing point tombstones with equivalent point-sized range tombstones in the given span, updating stats as needed.

Scan returns up to max point key/value objects from start (inclusive) to end (non-inclusive).

ScanConflictingIntentsForDroppingLatchesEarly scans intents using only the separated intents lock table on behalf of a batch request trying to drop its latches early.

ScanLocks scans locks (shared, exclusive, and intent) using only the lock table keyspace.

SecondaryCache enables use of a secondary cache to store shared objects.

SecondaryCacheBytes returns the desired size of the secondary cache, calculated from the provided store spec and disk usage.

SharedStorage enables use of shared storage (experimental).

ShouldUseEFOS returns true if either of the UseEFOS or UseExciseForSnapshots cluster settings are enabled, and EventuallyFileOnlySnapshots must be used to guarantee snapshot-like semantics.

TargetFileSize sets the target file size across all levels of the LSM, primarily for testing purposes.

UpdateSSTTimestamps replaces all MVCC timestamp in the provided SST to the given timestamp.

UpdateStatsOnRangeKeySplit updates MVCCStats for the split/fragmentation of a range key stack at a given split key.

WALFailover configures automatic failover of the engine's write-ahead log to another volume in the event the WAL becomes blocked on a write that does not complete within a reasonable duration.

WithCompressionFromClusterSetting sets the compression algorithm for an SSTable based on the value of the given cluster setting.

WriteSyncNoop carries out a synchronous no-op write to the engine.

CPutAllowIfMissing is used to indicate a CPut can also succeed when the expected entry does not exist.

CPutFailIfMissing is used to indicate the existing value must match the expected value exactly i.e.

DeletedReplica is a replica with neither raft state or state machine.

GuaranteedDurability is an advanced option (only for raftLogTruncator).

InitializedStateMachine is a replica with both raft state and state machine.

IterKeyTypePointsAndRanges iterates over both point and range keys.

IterKeyTypePointsOnly iterates over point keys only.

IterKeyTypeRangesOnly iterates over only range keys.

MaxArrayLen is a safe maximum length for slices on this architecture.

MaxConflictsPerLockConflictErrorDefault is the default value for maximum number of locks reported by ExportToSST and Scan operations in LockConflictError is set to half of the maximum lock table size.

MinimumMaxOpenFiles is the minimum value that RocksDB's max_open_files option can be set to.

MinimumSupportedFormatVersion is the version that provides features that the Cockroach code relies on unconditionally (like range keys).

MinVersionFilename is the name of the file containing a marshaled roachpb.Version that can be updated during storage-related migrations and checked on startup to determine if we can safely use a backwards-incompatible feature.

MVCCAbortIntentOpType corresponds to the MVCCAbortIntentOp variant.

MVCCCommitIntentOpType corresponds to the MVCCCommitIntentOp variant.

MVCCDecodingNotRequired is used when timestamps aren't needed.

MVCCDecodingRequired is used when timestamps are needed.

MVCCDeleteRangeOpType corresponds to the MVCCDeleteRangeOp variant.

MVCCIncrementalIterIntentPolicyAggregate will not fail on first encountered intent, but will proceed further.

MVCCIncrementalIterIntentPolicyEmit will return intents to the caller if they are inside or outside the time range.

MVCCIncrementalIterIntentPolicyError will immediately return an error for any intent found inside the given time range.

MVCCIncrementalIterIntentPolicyIgnore will not emit intents at all, by disabling intent interleaving and filtering out any encountered intents.

MVCCKeyAndIntentsIterKind specifies that intents must be seen, and appear interleaved with keys, even if they are in a separated lock table.

MVCCKeyIterKind specifies that the caller does not need to see intents.

MVCCUpdateIntentOpType corresponds to the MVCCUpdateIntentOp variant.

MVCCVersionTimestampSize is the size of the timestamp portion of MVCC version keys (used to update stats).

MVCCWriteIntentOpType corresponds to the MVCCWriteIntentOp variant.

MVCCWriteValueOpType corresponds to the MVCCWriteValueOp variant.

RecommendedMaxOpenFiles is the recommended value for RocksDB's max_open_files option.

StandardDurability is what should normally be used.

TargetBytesPerLockConflictErrorDefault is the default value for maximum size of locks reported by ExportToSST and Scan operations in LockConflictError.

UninitializedStateMachine is a replica with raft state but no state machine.

BlockLoadConcurrencyLimit controls the maximum number of outstanding filesystem read operations for loading sstable blocks.

ColumnarBlocksEnabled controls whether columnar-blocks are enabled in Pebble.

CompressionAlgorithmBackupStorage determines the compression algorithm used to compress data blocks when writing sstables that contain backup row data storage.

CompressionAlgorithmBackupTransport determines the compression algorithm used to compress data blocks when writing sstables that will be immediately iterated and will never need to touch disk.

CompressionAlgorithmStorage determines the compression algorithm used to compress data blocks when writing sstables for use in a Pebble store (written directly, or constructed for ingestion on a remote store via AddSSTable).

ConfigureForSharedStorage is used to configure a pebble Options for shared storage.

DefaultKeySchema is the name of the default key schema.

DefaultStorageEngine represents the default storage engine to use.

DisableAutomaticCompactions configures an engine to be opened with disabled automatic compactions.

DisableCheckSSTRangeKeyMasking forcibly disables CheckSSTConflicts range key masking.

EngineComparer is a pebble.Comparer object that implements MVCC-specific comparator settings for use with Pebble.

ForceWriterParallelism configures an engine to be opened with disabled automatic compactions.

ForTesting configures the engine for use in testing.

GetCFetcherWrapper returns a CFetcherWrapper.

IngestAsFlushable controls whether ingested sstables that overlap the memtable may be lazily ingested: written to the WAL and enqueued in the list of flushables (eg, memtables, large batches and now lazily-ingested sstables).

IngestionValueBlocksEnabled controls whether older versions of MVCC keys in the same ingested sstable will have their values written to value blocks.

IngestSplitEnabled controls whether ingest-time splitting is enabled in Pebble.

InMemory re-exports fs.InMemory.

KeySchemas holds the set of KeySchemas understandable by CockroachDB.

LocalTimestampsEnabled controls whether local timestamps are written in MVCC values.

MaxConflictsPerLockConflictError sets maximum number of locks returned in LockConflictError in operations that return multiple locks per error.

MinCapacityForBulkIngest is the fraction of remaining store capacity under which bulk ingestion requests are rejected.

MustExist configures an engine to error on Open if the target directory does not contain an initialized store.

MVCCKeyMax sorts after all other MVCC keys.

MVCCMerger is a pebble.Merger object that implements the merge operator used by Cockroach.

NilKey is the nil MVCCKey.

PebbleBlockPropertyCollectors is the list of functions to construct BlockPropertyCollectors.

TargetBytesPerLockConflictError sets target bytes for collected intents with LockConflictError.

UseEFOS controls whether uses of pebble Snapshots should use EventuallyFileOnlySnapshots instead.

UseExciseForSnapshots controls whether virtual-sstable-based excises should be used instead of range deletions for clearing out replica contents as part of a rebalance/recovery snapshot application.

WithValueBlocksDisabled disables the use of value blocks in an SSTable.

WorkloadCollectorEnabled specifies if the workload collector will be enabled.

AggregatedBatchCommitStats hold cumulative stats summed over all the batches that committed at the engine.

AggregatedIteratorStats holds cumulative stats, collected and summed over all of an engine's iterators.

BackupCompactionIterator wraps a SimpleMVCCIterator and only surfaces the latest valid key of a given MVCC key, including point tombstones, at or below the asOfTimestamp, if set.

BatchReader is used to iterate the entries in a Pebble batch representation.

ClearOptions holds optional parameters to methods that clear keys from the storage engine.

CloneContext is an opaque type encapsulating sufficient context to construct a clone of an existing iterator.

CollectableGCRangeKey is a struct containing range key as well as span boundaries locked for particular range key.

ComputeStatsVisitors holds a set of callbacks that are invoked on each key during stats computation.

ConditionalPutWriteOptions bundles options for the MVCCConditionalPut and MVCCBlindConditionalPut functions.

EngineKey is the general key type that is stored in the engine.

EngineKeyFormatter is a fmt.Formatter for EngineKeys.

EngineKeyRange is a key range composed of EngineKeys.

EngineRangeKeyValue is a raw value for a general range key as stored in the engine.

ExceedMaxSizeError is the error returned when an export request fails due the export size exceeding the budget.

FullReplicaID is a fully-qualified replica ID.

IteratorStats is returned from {MVCCIterator,EngineIterator}.Stats.

IterOptions contains options used to create an {MVCC,Engine}Iterator.

LockTableIterator is an EngineIterator that iterates over locks in the lock table keyspace.

LockTableIteratorOptions contains options used to create a LockTableIterator.

LockTableKey is a key representing a lock in the lock table.

MemObject is an in-memory implementation of objstorage.Writable, intended use with SSTWriter.

Metrics is a set of Engine metrics.

MetricsForInterval is a set of pebble.Metrics that need to be saved in order to compute metrics according to an interval.

MVCCExportOptions contains options for MVCCExportToSST.

MVCCGetOptions bundles options for the MVCCGet family of functions.

MVCCGetResult bundles return values for the MVCCGet family of functions.

MVCCIncrementalIterator iterates over the diff of the key range [startKey,endKey) and time range (startTime,endTime].

MVCCIncrementalIterOptions bundles options for NewMVCCIncrementalIterator.

MVCCIsSpanEmptyOptions configures the MVCCIsSpanEmpty function.

MVCCKey is a versioned key, distinguished from roachpb.Key with the addition of a "version" timestamp.

MVCCKeyValue contains the raw bytes of the value for a key.

MVCCLogicalOpDetails contains details about the occurrence of an MVCC logical operation.

MVCCRangeKey is a versioned key span.

MVCCRangeKeyStack represents a stack of range key fragments as returned by SimpleMVCCIterator.RangeKeys().

MVCCRangeKeyValue contains the raw bytes of the value for a key.

MVCCRangeKeyVersion represents a single range key fragment version.

MVCCResolveWriteIntentOptions bundles options for the MVCCResolveWriteIntent function.

MVCCResolveWriteIntentRangeOptions bundles options for the MVCCResolveWriteIntentRange function.

MVCCScanOptions bundles options for the MVCCScan family of functions.

MVCCScanResult groups the values returned from an MVCCScan operation.

MVCCValue is a versioned value, stored at an associated MVCCKey with a non-zero version timestamp.

MVCCValueMerger implements the `ValueMerger` interface.

MVCCWriteOptions bundles options for the MVCCPut and MVCCDelete families of functions.

OpLoggerBatch records a log of logical MVCC operations.

Pebble is a wrapper around a Pebble database instance.

RaftMutationBatch specifies mutations to the raft log entries and/or HardState.

ReadAsOfIterator wraps a SimpleMVCCIterator and only surfaces the latest valid point key of a given MVCC key that is also below the asOf timestamp, if set.

ReplicaInfo provides the replica ID and state pair.

RowCounter is a helper that counts how many distinct rows appear in the KVs that is shown via `Count`.

SSTWriter writes SSTables.

Batch is the interface for batch specific operations.

CFetcherWrapper is a wrapper around a colfetcher.cFetcher that populates only the needed (according to the fetchpb.IndexFetchSpec) vectors which are returned as coldata.Batch'es (either serialized or as is).

Engine is the interface that wraps the core operations of a key/value store.

EngineIterator is an iterator over key-value pairs where the key is an EngineKey.

EventuallyFileOnlyReader is a specialized Reader that supports a method to wait on a transition to being a file-only reader that does not pin any keys in-memory.

ExportWriter is a trimmed down version of the Writer interface.

InternalWriter is an extension of Writer that supports additional low-level methods to operate on internal keys in Pebble.

LockTableView is a request-bound snapshot into an in-memory collections of key-level locks.

MutationBatch can be committed to the underlying engine.

MVCCIterator is an interface for iterating over key/value pairs in an engine.

NextKVer can fetch a new KV from somewhere.

RangeStorage is a handle for a FullReplicaID that provides the ability to write to the raft state and state machine state.

Reader is the read interface to an engine's data.

ReadWriter is the read/write interface to an engine's data.

ReplicasStorage provides an interface to manage the persistent state of a store that includes the lifecycle of a range replica, its raft log, and the state machine state.

SimpleMVCCIterator is an interface for iterating over key/value pairs in an engine.

WriteBatch is the interface for write batch specific operations.

Writer is the write interface to an engine's data.

A ConfigOption may be passed to Open to configure the storage engine.

CPutMissingBehavior describes the handling a non-existing expected value.

DurabilityRequirement is an advanced option.

FirstKeyOfRowGetter returns the first key included into the last incomplete SQL row by the user of NextKVer.

IterKeyType configures which types of keys an iterator should surface.

MVCCDecodingStrategy controls if and how the fetcher should decode MVCC timestamps from returned KV's.

MVCCIncrementalIterIntentPolicy controls how the MVCCIncrementalIterator will handle intents that it encounters when iterating.

MVCCIterKind is used to inform Reader about the kind of iteration desired by the caller.

MVCCLogicalOpType is an enum with values corresponding to each of the enginepb.MVCCLogicalOp variants.

MVCCRangeKeyVersions represents a stack of range key fragment versions.

ReplicaState represents the current state of a range replica in this store.

SSTWriterOption augments one or more sstable.WriterOptions.