Involved Source Filesbackup.gobatch.gocompaction.godb.godir_unix.godiscard.go Package badger implements an embeddable, simple and fast key-value database,
written in pure Go. It is designed to be highly performant for both reads and
writes simultaneously. Badger uses Multi-Version Concurrency Control (MVCC), and
supports transactions. It runs transactions concurrently, with serializable
snapshot isolation guarantees.
Badger uses an LSM tree along with a value log to separate keys from values,
hence reducing both write amplification and the size of the LSM tree. This
allows LSM tree to be served entirely from RAM, while the values are served
from SSD.
# Usage
Badger has the following main types: DB, Txn, Item and Iterator. DB contains
keys that are associated with values. It must be opened with the appropriate
options before it can be accessed.
All operations happen inside a Txn. Txn represents a transaction, which can
be read-only or read-write. Read-only transactions can read values for a
given key (which are returned inside an Item), or iterate over a set of
key-value pairs using an Iterator (which are returned as Item type values as
well). Read-write transactions can also update and delete keys from the DB.
See the examples for more usage details.errors.gohistogram.goiterator.gokey_registry.golevel_handler.golevels.gologger.gomanaged_db.gomanifest.gomemtable.gomerge.gooptions.gopublisher.gostream.gostream_writer.gostructs.gotest_extensions.gotxn.goutil.govalue.go
DB provides the various functions required to interact with Badger.
DB is thread-safe. Backup dumps a protobuf-encoded list of all entries in the database into the
given writer, that are newer than or equal to the specified version. It
returns a timestamp (version) indicating the version of last entry that is
dumped, which after incrementing by 1 can be passed into later invocation to
generate incremental backup of entries that have been added/modified since
the last invocation of DB.Backup().
DB.Backup is a wrapper function over Stream.Backup to generate full and
incremental backups of the DB. For more control over how many goroutines are
used to generate the backup, or if you wish to backup only a certain range
of keys, use Stream.Backup directly. BanNamespace bans a namespace. Read/write to keys belonging to any of such namespace is denied. BannedNamespaces returns the list of prefixes banned for DB. BlockCacheMetrics returns the metrics for the underlying block cache. CacheMaxCost updates the max cost of the given cache (either block or index cache).
The call will have an effect only if the DB was created with the cache. Otherwise it is
a no-op. If you pass a negative value, the function will return the current value
without updating it. Close closes a DB. It's crucial to call it to ensure all the pending updates make their way to
disk. Calling DB.Close() multiple times would still only close the DB once. DropAll would drop all the data stored in Badger. It does this in the following way.
- Stop accepting new writes.
- Pause memtable flushes and compactions.
- Pick all tables from all levels, create a changeset to delete all these
tables and apply it to manifest.
- Pick all log files from value log, and delete all of them. Restart value log files from zero.
- Resume memtable flushes and compactions.
NOTE: DropAll is resilient to concurrent writes, but not to reads. It is up to the user to not do
any reads while DropAll is going on, otherwise they may result in panics. Ideally, both reads and
writes are paused before running DropAll, and resumed after it is finished. DropPrefix would drop all the keys with the provided prefix. It does this in the following way:
- Stop accepting new writes.
- Stop memtable flushes before acquiring lock. Because we're acquiring lock here
and memtable flush stalls for lock, which leads to deadlock
- Flush out all memtables, skipping over keys with the given prefix, Kp.
- Write out the value log header to memtables when flushing, so we don't accidentally bring Kp
back after a restart.
- Stop compaction.
- Compact L0->L1, skipping over Kp.
- Compact rest of the levels, Li->Li, picking tables which have Kp.
- Resume memtable flushes, compactions and writes. EstimateSize can be used to get rough estimate of data size for a given prefix. Flatten can be used to force compactions on the LSM tree so all the tables fall on the same
level. This ensures that all the versions of keys are colocated and not split across multiple
levels, which is necessary after a restore from backup. During Flatten, live compactions are
stopped. Ideally, no writes are going on during Flatten. Otherwise, it would create competition
between flattening the tree and new tables being created at level zero. GetMergeOperator creates a new MergeOperator for a given key and returns a
pointer to it. It also fires off a goroutine that performs a compaction using
the merge function that runs periodically, as specified by dur. GetSequence would initiate a new sequence object, generating it from the stored lease, if
available, in the database. Sequence can be used to get a list of monotonically increasing
integers. Multiple sequences can be created by providing different keys. Bandwidth sets the
size of the lease, determining how many Next() requests can be served from memory.
GetSequence is not supported on ManagedDB. Calling this would result in a panic. IndexCacheMetrics returns the metrics for the underlying index cache. IsClosed denotes if the badger DB is closed or not. A DB instance should not
be used after closing it. Levels gets the LevelInfo.(*DB) LevelsToString() string Load reads a protobuf-encoded list of all entries from a reader and writes
them to the database. This can be used to restore the database from a backup
made by calling DB.Backup(). If more complex logic is needed to restore a badger
backup, the KVLoader interface should be used instead.
DB.Load() should be called on a database that is not running any other
concurrent transactions while it is running. MaxBatchCount returns max possible entries in batch MaxBatchSize returns max possible batch size(*DB) MaxVersion() uint64 NewKVLoader returns a new instance of KVLoader.(*DB) NewManagedWriteBatch() *WriteBatch NewStream creates a new Stream. NewStreamAt creates a new Stream at a particular timestamp. Should only be used with managed DB. NewStreamWriter creates a StreamWriter. Right after creating StreamWriter, Prepare must be
called. The memory usage of a StreamWriter is directly proportional to the number of streams
possible. So, efforts must be made to keep the number of streams low. Stream framework would
typically use 16 goroutines and hence create 16 streams. NewTransaction creates a new transaction. Badger supports concurrent execution of transactions,
providing serializable snapshot isolation, avoiding write skews. Badger achieves this by tracking
the keys read and at Commit time, ensuring that these read keys weren't concurrently modified by
another transaction.
For read-only transactions, set update to false. In this mode, we don't track the rows read for
any changes. Thus, any long running iterations done in this mode wouldn't pay this overhead.
Running transactions concurrently is OK. However, a transaction itself isn't thread safe, and
should only be run serially. It doesn't matter if a transaction is created by one goroutine and
passed down to other, as long as the Txn APIs are called serially.
When you create a new transaction, it is absolutely essential to call
Discard(). This should be done irrespective of what the update param is set
to. Commit API internally runs Discard, but running it twice wouldn't cause
any issues.
txn := db.NewTransaction(false)
defer txn.Discard()
// Call various APIs. NewTransactionAt follows the same logic as DB.NewTransaction(), but uses the
provided read timestamp.
This is only useful for databases built on top of Badger (like Dgraph), and
can be ignored by most users. NewWriteBatch creates a new WriteBatch. This provides a way to conveniently do a lot of writes,
batching them up as tightly as possible in a single transaction and using callbacks to avoid
waiting for them to commit, thus achieving good performance. This API hides away the logic of
creating and committing transactions. Due to the nature of SSI guaratees provided by Badger,
blind writes can never encounter transaction conflicts (ErrConflict). NewWriteBatchAt is similar to NewWriteBatch but it allows user to set the commit timestamp.
NewWriteBatchAt is supposed to be used only in the managed mode. Opts returns a copy of the DB options. PrintHistogram builds and displays the key-value size histogram.
When keyPrefix is set, only the keys that have prefix "keyPrefix" are
considered for creating the histogram Ranges can be used to get rough key ranges to divide up iteration over the DB. The ranges here
would consider the prefix, but would not necessarily start or end with the prefix. In fact, the
first range would have nil as left key, and the last range would have nil as the right key. RunValueLogGC triggers a value log garbage collection.
It picks value log files to perform GC based on statistics that are collected
during compactions. If no such statistics are available, then log files are
picked in random order. The process stops as soon as the first log file is
encountered which does not result in garbage collection.
When a log file is picked, it is first sampled. If the sample shows that we
can discard at least discardRatio space of that file, it would be rewritten.
If a call to RunValueLogGC results in no rewrites, then an ErrNoRewrite is
thrown indicating that the call resulted in no file rewrites.
We recommend setting discardRatio to 0.5, thus indicating that a file be
rewritten if half the space can be discarded. This results in a lifetime
value log write amplification of 2 (1 from original write + 0.5 rewrite +
0.25 + 0.125 + ... = 2). Setting it to higher value would result in fewer
space reclaims, while setting it to a lower value would result in more space
reclaims at the cost of increased activity on the LSM tree. discardRatio
must be in the range (0.0, 1.0), both endpoints excluded, otherwise an
ErrInvalidRequest is returned.
Only one GC is allowed at a time. If another value log GC is running, or DB
has been closed, this would return an ErrRejected.
Note: Every time GC is run, it would produce a spike of activity on the LSM
tree. SetDiscardTs sets a timestamp at or below which, any invalid or deleted
versions can be discarded from the LSM tree, and thence from the value log to
reclaim disk space. Can only be used with managed transactions. Size returns the size of lsm and value log files in bytes. It can be used to decide how often to
call RunValueLogGC. Stream the contents of this DB to a new DB with options outOptions that will be
created in outDir. Subscribe can be used to watch key changes for the given key prefixes and the ignore string.
At least one prefix should be passed, or an error will be returned.
You can use an empty prefix to monitor all changes to the DB.
Ignore string is the byte ranges for which prefix matching will be ignored.
For example: ignore = "2-3", and prefix = "abc" will match for keys "abxxc", "abdfc" etc.
This function blocks until the given context is done or an error occurs.
The given function will be called with a new KVList containing the modified keys and the
corresponding values. Sync syncs database content to disk. This function provides
more control to user to sync data whenever required. Tables gets the TableInfo objects from the level controller. If withKeysCount
is true, TableInfo objects also contain counts of keys for the tables. Update executes a function, creating and managing a read-write transaction
for the user. Error returned by the function is relayed by the Update method.
Update cannot be used with managed transactions. VerifyChecksum verifies checksum for all tables on all levels.
This method can be used to verify checksum, if opt.ChecksumVerificationMode is NoVerification. View executes a function creating and managing a read-only transaction for the user. Error
returned by the function is relayed by the View method.
If View is used with managed transactions, it would assume a read timestamp of MaxUint64.
*DB : github.com/polarsignals/frostdb.Sync
*DB : github.com/prometheus/common/expfmt.Closer
*DB : io.Closer
func Open(opt Options) (*DB, error)
func OpenManaged(opts Options) (*DB, error)
func github.com/pancsta/asyncmachine-go/pkg/history/badger.NewDb(name string) (*DB, error)
func github.com/pancsta/asyncmachine-go/pkg/history/badger.GetMachine(db *DB, id string) (*amhist.MachineRecord, error)
func github.com/pancsta/asyncmachine-go/pkg/history/badger.ListMachines(db *DB) ([]*amhist.MachineRecord, error)
func github.com/pancsta/asyncmachine-go/pkg/history/badger.NewMemory(ctx context.Context, db *DB, mach am.Api, cfg badger.Config, onErr func(err error)) (*badger.Memory, error)
Entry provides Key, Value, UserMeta and ExpiresAt. This struct can be used by
the user to set data. // time.UnixKey[]byteUserMetabyteValue[]byte WithDiscard adds a marker to Entry e. This means all the previous versions of the key (of the
Entry) will be eligible for garbage collection.
This method is only useful if you have set a higher limit for options.NumVersionsToKeep. The
default setting is 1, in which case, this function doesn't add any more benefit. If however, you
have a higher setting for NumVersionsToKeep (in Dgraph, we set it to infinity), you can use this
method to indicate that all the older versions can be discarded and removed during compactions. WithMeta adds meta data to Entry e. This byte is stored alongside the key
and can be used as an aid to interpret the value or store other contextual
bits corresponding to the key-value pair of entry. WithTTL adds time to live duration to Entry e. Entry stored with a TTL would automatically expire
after the time has elapsed, and will be eligible for garbage collection.
func NewEntry(key, value []byte) *Entry
func (*Entry).WithDiscard() *Entry
func (*Entry).WithMeta(meta byte) *Entry
func (*Entry).WithTTL(dur time.Duration) *Entry
func (*Txn).SetEntry(e *Entry) error
func (*WriteBatch).SetEntry(e *Entry) error
func (*WriteBatch).SetEntryAt(e *Entry, ts uint64) error
Item is returned during iteration. Both the Key() and Value() output is only valid until
iterator.Next() is called. DiscardEarlierVersions returns whether the item was created with the
option to discard earlier versions of a key when multiple are available. EstimatedSize returns the approximate size of the key-value pair.
This can be called while iterating through a store to quickly estimate the
size of a range of key-value pairs (without fetching the corresponding
values). ExpiresAt returns a Unix time value indicating when the item will be
considered expired. 0 indicates that the item will never expire. IsDeletedOrExpired returns true if item contains deleted or expired value. Key returns the key.
Key is only valid as long as item is valid, or transaction is valid. If you need to use it
outside its validity, please use KeyCopy. KeyCopy returns a copy of the key of the item, writing it to dst slice.
If nil is passed, or capacity of dst isn't sufficient, a new slice would be allocated and
returned. KeySize returns the size of the key.
Exact size of the key is key + 8 bytes of timestamp String returns a string representation of Item UserMeta returns the userMeta set by the user. Typically, this byte, optionally set by the user
is used to interpret the value. Value retrieves the value of the item from the value log.
This method must be called within a transaction. Calling it outside a
transaction is considered undefined behavior. If an iterator is being used,
then Item.Value() is defined in the current iteration only, because items are
reused.
If you need to use a value outside a transaction, please use Item.ValueCopy
instead, or copy it yourself. Value might change once discard or commit is called.
Use ValueCopy if you want to do a Set after Get. ValueCopy returns a copy of the value of the item from the value log, writing it to dst slice.
If nil is passed, or capacity of dst isn't sufficient, a new slice would be allocated and
returned. Tip: It might make sense to reuse the returned slice as dst argument for the next call.
This function is useful in long running iterate/update transactions to avoid a write deadlock.
See Github issue: https://github.com/dgraph-io/badger/issues/315 ValueSize returns the approximate size of the value.
This can be called to quickly estimate the size of a value without fetching
it. Version returns the commit timestamp of the item.
*Item : expvar.Var
*Item : fmt.Stringer
func (*Iterator).Item() *Item
func (*Txn).Get(key []byte) (item *Item, rerr error)
Iterator helps iterating over the KV pairs in a lexicographically sorted order.Alloc*z.Allocator ThreadId is an optional value that can be set to identify which goroutine created
the iterator. It can be used, for example, to uniquely identify each of the
iterators created by the stream interface Close would close the iterator. It is important to call this when you're done with iteration. Item returns pointer to the current key-value pair.
This item is only valid until it.Next() gets called. Next would advance the iterator by one. Always check it.Valid() after a Next()
to ensure you have access to a valid it.Item(). Rewind would rewind the iterator cursor all the way to zero-th position, which would be the
smallest key if iterating forward, and largest if iterating backward. It does not keep track of
whether the cursor started with a Seek(). Seek would seek to the provided key if present. If absent, it would seek to the next
smallest key greater than the provided key if iterating in the forward direction.
Behavior would be reversed if iterating backwards. Valid returns false when iteration is done. ValidForPrefix returns false when iteration is done
or when the current key is not prefixed by the specified prefix.
func (*Txn).NewIterator(opt IteratorOptions) *Iterator
func (*Txn).NewKeyIterator(key []byte, opt IteratorOptions) *Iterator
func (*Stream).ToList(key []byte, itr *Iterator) (*pb.KVList, error)
IteratorOptions is used to set options when iterating over Badger key-value
stores.
This package provides DefaultIteratorOptions which contains options that
should work for most applications. Consider using that as a starting point
before customizing it for your own needs. // Fetch all valid versions of the same key. // Used to allow internal access to badger keys. PrefetchSize is the number of KV pairs to prefetch while iterating.
Valid only if PrefetchValues is true. PrefetchValues Indicates whether we should prefetch values during
iteration and store them. // Only iterate over this given prefix. // Direction of iteration. False is forward, true is backward. // Only read data that has version > SinceTs.
func (*Txn).NewIterator(opt IteratorOptions) *Iterator
func (*Txn).NewKeyIterator(key []byte, opt IteratorOptions) *Iterator
var DefaultIteratorOptions
KeyRegistry used to maintain all the data keys.RWMutexsync.RWMutex Close closes the key registry. DataKey returns datakey of the given key id. LatestDataKey will give you the latest generated datakey based on the rotation
period. If the last generated datakey lifetime exceeds the rotation period.
It'll create new datakey. Lock locks rw for writing.
If the lock is already locked for reading or writing,
Lock blocks until the lock is available. RLock locks rw for reading.
It should not be used for recursive read locking; a blocked Lock
call excludes new readers from acquiring the lock. See the
documentation on the [RWMutex] type. RLocker returns a [Locker] interface that implements
the [Locker.Lock] and [Locker.Unlock] methods by calling rw.RLock and rw.RUnlock. RUnlock undoes a single [RWMutex.RLock] call;
it does not affect other simultaneous readers.
It is a run-time error if rw is not locked for reading
on entry to RUnlock. TryLock tries to lock rw for writing and reports whether it succeeded.
Note that while correct uses of TryLock do exist, they are rare,
and use of TryLock is often a sign of a deeper problem
in a particular use of mutexes. TryRLock tries to lock rw for reading and reports whether it succeeded.
Note that while correct uses of TryRLock do exist, they are rare,
and use of TryRLock is often a sign of a deeper problem
in a particular use of mutexes. Unlock unlocks rw for writing. It is a run-time error if rw is
not locked for writing on entry to Unlock.
As with Mutexes, a locked [RWMutex] is not associated with a particular
goroutine. One goroutine may [RWMutex.RLock] ([RWMutex.Lock]) a RWMutex and then
arrange for another goroutine to [RWMutex.RUnlock] ([RWMutex.Unlock]) it.
*KeyRegistry : github.com/prometheus/common/expfmt.Closer
*KeyRegistry : io.Closer
*KeyRegistry : sync.Locker
func OpenKeyRegistry(opt KeyRegistryOptions) (*KeyRegistry, error)
func WriteKeyRegistry(reg *KeyRegistry, opt KeyRegistryOptions) error
KVLoader is used to write KVList objects in to badger. It can be used to restore a backup. Finish is meant to be called after all the key-value pairs have been loaded. Set writes the key-value pair to the database.
func (*DB).NewKVLoader(maxPendingWrites int) *KVLoader
Manifest represents the contents of the MANIFEST file in a Badger store.
The MANIFEST file describes the startup state of the db -- all LSM files and what level they're
at.
It consists of a sequence of ManifestChangeSet objects. Each of these is treated atomically,
and contains a sequence of ManifestChange's (file creations/deletions) which we use to
reconstruct the manifest at startup. Contains total number of creation and deletion changes in the manifest -- used to compute
whether it'd be useful to rewrite the manifest.DeletionsintLevels[]levelManifestTablesmap[uint64]TableManifest
func ReplayManifestFile(fp *os.File, extMagic uint16, opt Options) (Manifest, int64, error)
MergeFunc accepts two byte slices, one representing an existing value, and
another representing a new value that needs to be ‘merged’ into it. MergeFunc
contains the logic to perform the ‘merge’ and return an updated value.
MergeFunc could perform operations like integer addition, list appends etc.
Note that the ordering of the operands is maintained.
func (*DB).GetMergeOperator(key []byte, f MergeFunc, dur time.Duration) *MergeOperator
MergeOperator represents a Badger merge operator.RWMutexsync.RWMutex Add records a value in Badger which will eventually be merged by a background
routine into the values that were recorded by previous invocations to Add(). Get returns the latest value for the merge operator, which is derived by
applying the merge function to all the values added so far.
If Add has not been called even once, Get will return ErrKeyNotFound. Lock locks rw for writing.
If the lock is already locked for reading or writing,
Lock blocks until the lock is available. RLock locks rw for reading.
It should not be used for recursive read locking; a blocked Lock
call excludes new readers from acquiring the lock. See the
documentation on the [RWMutex] type. RLocker returns a [Locker] interface that implements
the [Locker.Lock] and [Locker.Unlock] methods by calling rw.RLock and rw.RUnlock. RUnlock undoes a single [RWMutex.RLock] call;
it does not affect other simultaneous readers.
It is a run-time error if rw is not locked for reading
on entry to RUnlock. Stop waits for any pending merge to complete and then stops the background
goroutine. TryLock tries to lock rw for writing and reports whether it succeeded.
Note that while correct uses of TryLock do exist, they are rare,
and use of TryLock is often a sign of a deeper problem
in a particular use of mutexes. TryRLock tries to lock rw for reading and reports whether it succeeded.
Note that while correct uses of TryRLock do exist, they are rare,
and use of TryRLock is often a sign of a deeper problem
in a particular use of mutexes. Unlock unlocks rw for writing. It is a run-time error if rw is
not locked for writing on entry to Unlock.
As with Mutexes, a locked [RWMutex] is not associated with a particular
goroutine. One goroutine may [RWMutex.RLock] ([RWMutex.Lock]) a RWMutex and then
arrange for another goroutine to [RWMutex.RUnlock] ([RWMutex.Unlock]) it.
*MergeOperator : sync.Locker
func (*DB).GetMergeOperator(key []byte, f MergeFunc, dur time.Duration) *MergeOperator
Options are params for creating DB object.
This package provides DefaultOptions which contains options that should
work for most applications. Consider using that as a starting point before
customizing it for your own needs.
Each option X is documented on the WithX method.BaseLevelSizeint64BaseTableSizeint64BlockCacheSizeint64 Changing BlockSize across DB runs will not break badger. The block size is
read from the block index stored at the end of the table.BloomFalsePositivefloat64 BypassLockGuard will bypass the lock guard on badger. Bypassing lock
guard can cause data corruption if multiple badger instances are using
the same directory. Use this options with caution. ChecksumVerificationMode decides when db should verify checksums for SSTable blocks.CompactL0OnCloseboolCompressionoptions.CompressionType DetectConflicts determines whether the transactions would be checked for
conflicts. The transactions can be processed at a higher rate when
conflict detection is disabled.Dirstring Encryption related options. // encryption key // key rotation duration Magic version used by the application using badger to ensure that it doesn't open the DB
with incompatible data format.InMemoryboolIndexCacheSizeint64LevelSizeMultiplierintLmaxCompactionboolLoggerLoggerMaxLevelsintMemTableSizeint64MetricsEnabledbool NamespaceOffset specifies the offset from where the next 8 bytes contains the namespace.NumCompactorsint Sets the Stream.numGo fieldNumLevelZeroTablesintNumLevelZeroTablesStallintNumMemtablesintNumVersionsToKeepintReadOnlyboolSyncWritesboolTableSizeMultiplierintVLogPercentilefloat64ValueDirstringValueLogFileSizeint64ValueLogMaxEntriesuint32ValueThresholdint64 When set, checksum will be validated for each entry read from the value log file.ZSTDCompressionLevelint Debugf logs a DEBUG message to the logger specified in opts. Errorf logs an ERROR log message to the logger specified in opts or to the
global logger if no logger is specified in opts. FromSuperFlag fills Options fields for each flag within the superflag. For
example, replacing the default Options.NumGoroutines:
options := FromSuperFlag("numgoroutines=4", DefaultOptions(""))
It's important to note that if you pass an empty Options struct, FromSuperFlag
will not fill it with default values. FromSuperFlag only writes to the fields
present within the superflag string (case insensitive).
It specially handles compression subflag.
Valid options are {none,snappy,zstd:<level>}
Example: compression=zstd:3;
Unsupported: Options.Logger, Options.EncryptionKey Infof logs an INFO message to the logger specified in opts. Warningf logs a WARNING message to the logger specified in opts. WithBaseLevelSize sets the maximum size target for the base level.
The default value is 10MB. WithBaseTableSize returns a new Options value with BaseTableSize set to the given value.
BaseTableSize sets the maximum size in bytes for LSM table or file in the base level.
The default value of BaseTableSize is 2MB. WithBlockCacheSize returns a new Options value with BlockCacheSize set to the given value.
This value specifies how much data cache should hold in memory. A small size
of cache means lower memory consumption and lookups/iterations would take
longer. It is recommended to use a cache if you're using compression or encryption.
If compression and encryption both are disabled, adding a cache will lead to
unnecessary overhead which will affect the read performance. Setting size to
zero disables the cache altogether.
Default value of BlockCacheSize is 256 MB. WithBlockSize returns a new Options value with BlockSize set to the given value.
BlockSize sets the size of any block in SSTable. SSTable is divided into multiple blocks
internally. Each block is compressed using prefix diff encoding.
The default value of BlockSize is 4KB. WithBloomFalsePositive returns a new Options value with BloomFalsePositive set
to the given value.
BloomFalsePositive sets the false positive probability of the bloom filter in any SSTable.
Before reading a key from table, the bloom filter is checked for key existence.
BloomFalsePositive might impact read performance of DB. Lower BloomFalsePositive value might
consume more memory.
The default value of BloomFalsePositive is 0.01.
Setting this to 0 disables the bloom filter completely. WithBypassLockGuard returns a new Options value with BypassLockGuard
set to the given value.
When BypassLockGuard option is set, badger will not acquire a lock on the
directory. This could lead to data corruption if multiple badger instances
write to the same data directory. Use this option with caution.
The default value of BypassLockGuard is false. WithChecksumVerificationMode returns a new Options value with ChecksumVerificationMode set to
the given value.
ChecksumVerificationMode indicates when the db should verify checksums for SSTable blocks.
The default value of VerifyValueChecksum is options.NoVerification. WithCompactL0OnClose determines whether Level 0 should be compacted before closing the DB. This
ensures that both reads and writes are efficient when the DB is opened later.
The default value of CompactL0OnClose is false. WithCompression is used to enable or disable compression. When compression is enabled, every
block will be compressed using the specified algorithm. This option doesn't affect existing
tables. Only the newly created tables will be compressed.
The default compression algorithm used is snappy. Compression is enabled by default. WithDetectConflicts returns a new Options value with DetectConflicts set to the given value.
Detect conflicts options determines if the transactions would be checked for
conflicts before committing them. When this option is set to false
(detectConflicts=false) badger can process transactions at a higher rate.
Setting this options to false might be useful when the user application
deals with conflict detection and resolution.
The default value of Detect conflicts is True. WithDir returns a new Options value with Dir set to the given value.
Dir is the path of the directory where key data will be stored in.
If it doesn't exist, Badger will try to create it for you.
This is set automatically to be the path given to `DefaultOptions`. WithEncryptionKey is used to encrypt the data with AES. Type of AES is used based on the key
size. For example 16 bytes will use AES-128. 24 bytes will use AES-192. 32 bytes will
use AES-256. The default value is set to 10 days. WithExternalMagic returns a new Options value with ExternalMagicVersion set to the given value.
The DB would fail to start if either the internal or the external magic number fails validated. WithInMemory returns a new Options value with Inmemory mode set to the given value.
When badger is running in InMemory mode, everything is stored in memory. No value/sst files are
created. In case of a crash all data will be lost. WithIndexCacheSize returns a new Options value with IndexCacheSize set to
the given value.
This value specifies how much memory should be used by table indices. These
indices include the block offsets and the bloomfilters. Badger uses bloom
filters to speed up lookups. Each table has its own bloom
filter and each bloom filter is approximately of 5 MB.
Zero value for IndexCacheSize means all the indices will be kept in
memory and the cache is disabled.
The default value of IndexCacheSize is 0 which means all indices are kept in
memory. WithLevelSizeMultiplier returns a new Options value with LevelSizeMultiplier set to the given
value.
LevelSizeMultiplier sets the ratio between the maximum sizes of contiguous levels in the LSM.
Once a level grows to be larger than this ratio allowed, the compaction process will be
triggered.
The default value of LevelSizeMultiplier is 10. WithLogger returns a new Options value with Logger set to the given value.
Logger provides a way to configure what logger each value of badger.DB uses.
The default value of Logger writes to stderr using the log package from the Go standard library. WithLoggingLevel returns a new Options value with logging level of the
default logger set to the given value.
LoggingLevel sets the level of logging. It should be one of DEBUG, INFO,
WARNING or ERROR levels.
The default value of LoggingLevel is INFO. WithMaxLevels returns a new Options value with MaxLevels set to the given value.
Maximum number of levels of compaction allowed in the LSM.
The default value of MaxLevels is 7. WithMemTableSize returns a new Options value with MemTableSize set to the given value.
MemTableSize sets the maximum size in bytes for memtable table.
The default value of MemTableSize is 64MB. WithMetricsEnabled returns a new Options value with MetricsEnabled set to the given value.
When MetricsEnabled is set to false, then the DB will be opened and no badger metrics
will be logged. Metrics are defined in metric.go file.
This flag is useful for use cases like in Dgraph where we open temporary badger instances to
index data. In those cases we don't want badger metrics to be polluted with the noise from
those temporary instances.
Default value is set to true WithNamespaceOffset returns a new Options value with NamespaceOffset set to the given value. DB
will expect the namespace in each key at the 8 bytes starting from NamespaceOffset. A negative
value means that namespace is not stored in the key.
The default value for NamespaceOffset is -1. WithNumCompactors sets the number of compaction workers to run concurrently. Setting this to
zero stops compactions, which could eventually cause writes to block forever.
The default value of NumCompactors is 4. One is dedicated just for L0 and L1. WithNumGoroutines sets the number of goroutines to be used in Stream.
The default value of NumGoroutines is 8. WithNumLevelZeroTables sets the maximum number of Level 0 tables before compaction starts.
The default value of NumLevelZeroTables is 5. WithNumLevelZeroTablesStall sets the number of Level 0 tables that once reached causes the DB to
stall until compaction succeeds.
The default value of NumLevelZeroTablesStall is 15. WithNumMemtables returns a new Options value with NumMemtables set to the given value.
NumMemtables sets the maximum number of tables to keep in memory before stalling.
The default value of NumMemtables is 5. WithNumVersionsToKeep returns a new Options value with NumVersionsToKeep set to the given value.
NumVersionsToKeep sets how many versions to keep per key at most.
The default value of NumVersionsToKeep is 1. WithReadOnly returns a new Options value with ReadOnly set to the given value.
When ReadOnly is true the DB will be opened on read-only mode.
Multiple processes can open the same Badger DB.
Note: if the DB being opened had crashed before and has vlog data to be replayed,
ReadOnly will cause Open to fail with an appropriate message.
The default value of ReadOnly is false. WithSyncWrites returns a new Options value with SyncWrites set to the given value.
Badger does all writes via mmap. So, all writes can survive process crashes or k8s environments
with SyncWrites set to false.
When set to true, Badger would call an additional msync after writes to flush mmap buffer over to
disk to survive hard reboots. Most users of Badger should not need to do this.
The default value of SyncWrites is false. WithVLogPercentile returns a new Options value with ValLogPercentile set to given value.
VLogPercentile with 0.0 means no dynamic thresholding is enabled.
MinThreshold value will always act as the value threshold.
VLogPercentile with value 0.99 means 99 percentile of value will be put in LSM tree
and only 1 percent in vlog. The value threshold will be dynamically updated within the range of
[ValueThreshold, Options.maxValueThreshold]
# Say VLogPercentile with 1.0 means threshold will eventually set to Options.maxValueThreshold
The default value of VLogPercentile is 0.0. WithValueDir returns a new Options value with ValueDir set to the given value.
ValueDir is the path of the directory where value data will be stored in.
If it doesn't exist, Badger will try to create it for you.
This is set automatically to be the path given to `DefaultOptions`. WithValueLogFileSize sets the maximum size of a single value log file.
The default value of ValueLogFileSize is 1GB. WithValueLogMaxEntries sets the maximum number of entries a value log file
can hold approximately. A actual size limit of a value log file is the
minimum of ValueLogFileSize and ValueLogMaxEntries.
The default value of ValueLogMaxEntries is one million (1000000). WithValueThreshold returns a new Options value with ValueThreshold set to the given value.
ValueThreshold sets the threshold used to decide whether a value is stored directly in the LSM
tree or separately in the log value files.
The default value of ValueThreshold is 1 MB, and LSMOnlyOptions sets it to maxValueThreshold
which is set to 1 MB too. WithVerifyValueChecksum is used to set VerifyValueChecksum. When VerifyValueChecksum is set to
true, checksum will be verified for every entry read from the value log. If the value is stored
in SST (value size less than value threshold) then the checksum validation will not be done.
The default value of VerifyValueChecksum is False. WithZSTDCompressionLevel returns a new Options value with ZSTDCompressionLevel set
to the given value.
The ZSTD compression algorithm supports 20 compression levels. The higher the compression
level, the better is the compression ratio but lower is the performance. Lower levels
have better performance and higher levels have better compression ratios.
We recommend using level 1 ZSTD Compression Level. Any level higher than 1 seems to
deteriorate badger's performance.
The following benchmarks were done on a 4 KB block size (default block size). The compression is
ratio supposed to increase with increasing compression level but since the input for compression
algorithm is small (4 KB), we don't get significant benefit at level 3. It is advised to write
your own benchmarks before choosing a compression algorithm or level.
NOTE: The benchmarks are with DataDog ZSTD that requires CGO. Hence, no longer valid.
no_compression-16 10 502848865 ns/op 165.46 MB/s -
zstd_compression/level_1-16 7 739037966 ns/op 112.58 MB/s 2.93
zstd_compression/level_3-16 7 756950250 ns/op 109.91 MB/s 2.72
zstd_compression/level_15-16 1 11135686219 ns/op 7.47 MB/s 4.38
Benchmark code can be found in table/builder_test.go file
*Options : Logger
*Options : github.com/mark3labs/mcp-go/util.Logger
*Options : github.com/stretchr/testify/assert.TestingT
func DefaultOptions(path string) Options
func LSMOnlyOptions(path string) Options
func (*DB).Opts() Options
func Options.FromSuperFlag(superflag string) Options
func Options.WithBaseLevelSize(val int64) Options
func Options.WithBaseTableSize(val int64) Options
func Options.WithBlockCacheSize(size int64) Options
func Options.WithBlockSize(val int) Options
func Options.WithBloomFalsePositive(val float64) Options
func Options.WithBypassLockGuard(b bool) Options
func Options.WithChecksumVerificationMode(cvMode options.ChecksumVerificationMode) Options
func Options.WithCompactL0OnClose(val bool) Options
func Options.WithCompression(cType options.CompressionType) Options
func Options.WithDetectConflicts(b bool) Options
func Options.WithDir(val string) Options
func Options.WithEncryptionKey(key []byte) Options
func Options.WithEncryptionKeyRotationDuration(d time.Duration) Options
func Options.WithExternalMagic(magic uint16) Options
func Options.WithIndexCacheSize(size int64) Options
func Options.WithInMemory(b bool) Options
func Options.WithLevelSizeMultiplier(val int) Options
func Options.WithLogger(val Logger) Options
func Options.WithLoggingLevel(val loggingLevel) Options
func Options.WithMaxLevels(val int) Options
func Options.WithMemTableSize(val int64) Options
func Options.WithMetricsEnabled(val bool) Options
func Options.WithNamespaceOffset(offset int) Options
func Options.WithNumCompactors(val int) Options
func Options.WithNumGoroutines(val int) Options
func Options.WithNumLevelZeroTables(val int) Options
func Options.WithNumLevelZeroTablesStall(val int) Options
func Options.WithNumMemtables(val int) Options
func Options.WithNumVersionsToKeep(val int) Options
func Options.WithReadOnly(val bool) Options
func Options.WithSyncWrites(val bool) Options
func Options.WithValueDir(val string) Options
func Options.WithValueLogFileSize(val int64) Options
func Options.WithValueLogMaxEntries(val uint32) Options
func Options.WithValueThreshold(val int64) Options
func Options.WithVerifyValueChecksum(val bool) Options
func Options.WithVLogPercentile(t float64) Options
func Options.WithZSTDCompressionLevel(cLevel int) Options
func InitDiscardStats(opt Options) (*discardStats, error)
func Open(opt Options) (*DB, error)
func OpenManaged(opts Options) (*DB, error)
func ReplayManifestFile(fp *os.File, extMagic uint16, opt Options) (Manifest, int64, error)
func (*DB).StreamDB(outOptions Options) error
Sequence represents a Badger sequence. Next would return the next integer in the sequence, updating the lease by running a transaction
if needed. Release the leased sequence to avoid wasted integers. This should be done right
before closing the associated DB. However it is valid to use the sequence after
it was released, causing a new lease with full bandwidth.
func (*DB).GetSequence(key []byte, bandwidth uint64) (*Sequence, error)
Stream provides a framework to concurrently iterate over a snapshot of Badger, pick up
key-values, batch them up and call Send. Stream does concurrent iteration over many smaller key
ranges. It does NOT send keys in lexicographical sorted order. To get keys in sorted
order, use Iterator. ChooseKey is invoked each time a new key is encountered. Note that this is not called
on every version of the value, only the first encountered version (i.e. the highest version
of the value a key has). ChooseKey can be left nil to select all keys.
Note: Calls to ChooseKey are concurrent.FinishThreadfunc(threadId int) (*pb.KVList, error) KeyToList, similar to ChooseKey, is only invoked on the highest version of the value. It
is upto the caller to iterate over the versions and generate zero, one or more KVs. It
is expected that the user would advance the iterator to go through the versions of the
values. However, the user MUST immediately return from this function on the first encounter
with a mismatching key. See example usage in ToList function. Can be left nil to use ToList
function by default.
KeyToList has access to z.Allocator accessible via stream.Allocator(itr.ThreadId). This
allocator can be used to allocate KVs, to decrease the memory pressure on Go GC. Stream
framework takes care of releasing those resources after calling Send. AllocRef does
NOT need to be set in the returned KVList, as Stream framework would ignore that field,
instead using the allocator assigned to that thread id.
Note: Calls to KeyToList are concurrent.KeyToListWithThreadIdfunc(key []byte, itr *Iterator, threadId int) (*pb.KVList, error) Badger would produce log entries in Infof to indicate the progress of Stream. LogPrefix can
be used to help differentiate them from other activities. Default is "Badger.Stream". MaxSize is the maximum allowed size of a stream batch. This is a soft limit
as a single list that is still over the limit will have to be sent as is since it
cannot be split further. This limit prevents the framework from creating batches
so big that sending them causes issues (e.g running into the max size gRPC limit).
If necessary, set it up before the Stream starts synchronisation
This is not a concurrency-safe setting Number of goroutines to use for iterating over key ranges. Defaults to 8. Prefix to only iterate over certain range of keys. If set to nil (default), Stream would
iterate over the entire DB. This is the method where Stream sends the final output. All calls to Send are done by a
single goroutine, i.e. logic within Send method can expect single threaded execution. Read data above the sinceTs. All keys with version =< sinceTs will be ignored. UseKeyToListWithThreadId is used to indicate that KeyToListWithThreadId should be used
instead of KeyToList. This is a new api that can be used to figure out parallelism
of the stream. Each threadId would be run serially. KeyToList being concurrent makes you
take care of concurrency in KeyToList. Here threadId could be used to do some things serially.
Once a thread finishes FinishThread() would be called. Backup dumps a protobuf-encoded list of all entries in the database into the
given writer, that are newer than or equal to the specified version. It returns a
timestamp(version) indicating the version of last entry that was dumped, which
after incrementing by 1 can be passed into a later invocation to generate an
incremental dump of entries that have been added/modified since the last
invocation of Stream.Backup().
This can be used to backup the data in a database at a given point in time. Orchestrate runs Stream. It picks up ranges from the SSTables, then runs NumGo number of
goroutines to iterate over these ranges and batch up KVs in lists. It concurrently runs a single
goroutine to pick these lists, batch them up further and send to Output.Send. Orchestrate also
spits logs out to Infof, using provided LogPrefix. Note that all calls to Output.Send
are serial. In case any of these steps encounter an error, Orchestrate would stop execution and
return that error. Orchestrate can be called multiple times, but in serial order. SendDoneMarkers when true would send out done markers on the stream. False by default. ToList is a default implementation of KeyToList. It picks up all valid versions of the key,
skipping over deleted or expired keys.
func (*DB).NewStream() *Stream
func (*DB).NewStreamAt(readTs uint64) *Stream
StreamWriter is used to write data coming from multiple streams. The streams must not have any
overlapping key ranges. Within each stream, the keys must be sorted. Badger Stream framework is
capable of generating such an output. So, this StreamWriter can be used at the other end to build
BadgerDB at a much faster pace by writing SSTables (and value logs) directly to LSM tree levels
without causing any compactions at all. This is way faster than using batched writer or using
transactions, but only applicable in situations where the keys are pre-sorted and the DB is being
bootstrapped. Existing data would get deleted when using this writer. So, this is only useful
when restoring from backup or replicating DB across servers.
StreamWriter should not be called on in-use DB instances. It is designed only to bootstrap new
DBs. Cancel signals all goroutines to exit. Calling defer sw.Cancel() immediately after creating a new StreamWriter
ensures that writes are unblocked even upon early return. Note that dropAll() is not called here, so any
partially written data will not be erased until a new StreamWriter is initialized. Flush is called once we are done writing all the entries. It syncs DB directories. It also
updates Oracle with maxVersion found in all entries (if DB is not managed). Prepare should be called before writing any entry to StreamWriter. It deletes all data present in
existing DB, stops compactions and any writes being done by other means. Be very careful when
calling Prepare, because it could result in permanent data loss. Not calling Prepare would result
in a corrupt Badger instance. Use PrepareIncremental to do incremental stream write. PrepareIncremental should be called before writing any entry to StreamWriter incrementally.
In incremental stream write, the tables are written at one level above the current base level. Write writes KVList to DB. Each KV within the list contains the stream id which StreamWriter
would use to demux the writes. Write is thread safe and can be called concurrently by multiple
goroutines.
*StreamWriter : github.com/apache/thrift/lib/go/thrift.Flusher
func (*DB).NewStreamWriter() *StreamWriter
Txn represents a Badger transaction. Commit commits the transaction, following these steps:
1. If there are no writes, return immediately.
2. Check if read rows were updated since txn started. If so, return ErrConflict.
3. If no conflict, generate a commit timestamp and update written rows' commit ts.
4. Batch up all writes, write them to value log and LSM tree.
5. If callback is provided, Badger will return immediately after checking
for conflicts. Writes to the database will happen in the background. If
there is a conflict, an error will be returned and the callback will not
run. If there are no conflicts, the callback will be called in the
background upon successful completion of writes or any error during write.
If error is nil, the transaction is successfully committed. In case of a non-nil error, the LSM
tree won't be updated, so there's no need for any rollback. CommitAt commits the transaction, following the same logic as Commit(), but
at the given commit timestamp. This will panic if not used with managed transactions.
This is only useful for databases built on top of Badger (like Dgraph), and
can be ignored by most users. CommitWith acts like Commit, but takes a callback, which gets run via a
goroutine to avoid blocking this function. The callback is guaranteed to run,
so it is safe to increment sync.WaitGroup before calling CommitWith, and
decrementing it in the callback; to block until all callbacks are run. Delete deletes a key.
This is done by adding a delete marker for the key at commit timestamp. Any
reads happening before this timestamp would be unaffected. Any reads after
this commit would see the deletion.
The current transaction keeps a reference to the key byte slice argument.
Users must not modify the key until the end of the transaction. Discard discards a created transaction. This method is very important and must be called. Commit
method calls this internally, however, calling this multiple times doesn't cause any issues. So,
this can safely be called via a defer right when transaction is created.
NOTE: If any operations are run on a discarded transaction, ErrDiscardedTxn is returned. Get looks for key and returns corresponding Item.
If key is not found, ErrKeyNotFound is returned. NewIterator returns a new iterator. Depending upon the options, either only keys, or both
key-value pairs would be fetched. The keys are returned in lexicographically sorted order.
Using prefetch is recommended if you're doing a long running iteration, for performance.
Multiple Iterators:
For a read-only txn, multiple iterators can be running simultaneously. However, for a read-write
txn, iterators have the nuance of being a snapshot of the writes for the transaction at the time
iterator was created. If writes are performed after an iterator is created, then that iterator
will not be able to see those writes. Only writes performed before an iterator was created can be
viewed. NewKeyIterator is just like NewIterator, but allows the user to iterate over all versions of a
single key. Internally, it sets the Prefix option in provided opt, and uses that prefix to
additionally run bloom filter lookups before picking tables from the LSM tree. ReadTs returns the read timestamp of the transaction. Set adds a key-value pair to the database.
It will return ErrReadOnlyTxn if update flag was set to false when creating the transaction.
The current transaction keeps a reference to the key and val byte slice
arguments. Users must not modify key and val until the end of the transaction. SetEntry takes an Entry struct and adds the key-value pair in the struct,
along with other metadata to the database.
The current transaction keeps a reference to the entry passed in argument.
Users must not modify the entry until the end of the transaction.
func (*DB).NewTransaction(update bool) *Txn
func (*DB).NewTransactionAt(readTs uint64, update bool) *Txn
WriteBatch holds the necessary info to perform batched writes.Mutexsync.Mutex Cancel function must be called if there's a chance that Flush might not get
called. If neither Flush or Cancel is called, the transaction oracle would
never get a chance to clear out the row commit timestamp map, thus causing an
unbounded memory consumption. Typically, you can call Cancel as a defer
statement right after NewWriteBatch is called.
Note that any committed writes would still go through despite calling Cancel. Delete is equivalent of Txn.Delete. DeleteAt is equivalent of Txn.Delete but accepts a delete timestamp. Error returns any errors encountered so far. No commits would be run once an error is detected. Flush must be called at the end to ensure that any pending writes get committed to Badger. Flush
returns any error stored by WriteBatch. Lock locks m.
If the lock is already in use, the calling goroutine
blocks until the mutex is available. Set is equivalent of Txn.Set(). SetEntry is the equivalent of Txn.SetEntry. SetEntryAt is the equivalent of Txn.SetEntry but it also allows setting version for the entry.
SetEntryAt can be used only in managed mode. SetMaxPendingTxns sets a limit on maximum number of pending transactions while writing batches.
This function should be called before using WriteBatch. Default value of MaxPendingTxns is
16 to minimise memory usage. TryLock tries to lock m and reports whether it succeeded.
Note that while correct uses of TryLock do exist, they are rare,
and use of TryLock is often a sign of a deeper problem
in a particular use of mutexes. Unlock unlocks m.
It is a run-time error if m is not locked on entry to Unlock.
A locked [Mutex] is not associated with a particular goroutine.
It is allowed for one goroutine to lock a Mutex and then
arrange for another goroutine to unlock it.(*WriteBatch) Write(buf *z.Buffer) error(*WriteBatch) WriteList(kvList *pb.KVList) error
*WriteBatch : github.com/apache/thrift/lib/go/thrift.Flusher
*WriteBatch : sync.Locker
func (*DB).NewManagedWriteBatch() *WriteBatch
func (*DB).NewWriteBatch() *WriteBatch
func (*DB).NewWriteBatchAt(commitTs uint64) *WriteBatch
LSMOnlyOptions follows from DefaultOptions, but sets a higher ValueThreshold
so values would be collocated with the LSM tree, with value log largely acting
as a write-ahead log only. These options would reduce the disk usage of value
log, and make Badger act more like a typical LSM tree.
NewEntry creates a new entry with key and value passed in args. This newly created entry can be
set in a transaction by calling txn.SetEntry(). All other properties of Entry can be set by
calling WithMeta, WithDiscard, WithTTL methods on it.
This function uses key and value reference, hence users must
not modify key and value until the end of transaction.
Open returns a new DB object.
OpenKeyRegistry opens key registry if it exists, otherwise it'll create key registry
and returns key registry.
OpenManaged returns a new DB, which allows more control over setting
transaction timestamps, aka managed mode.
This is only useful for databases built on top of Badger (like Dgraph), and
can be ignored by most users.
ReplayManifestFile reads the manifest file and constructs two manifest objects. (We need one
immutable copy and one mutable copy of the manifest. Easiest way is to construct two of them.)
Also, returns the last offset after a completely read manifest entry -- the file must be
truncated at that point before further appends are made (if there is a partial entry after
that). In normal conditions, truncOffset is the file size.
WriteKeyRegistry will rewrite the existing key registry file with new one.
It is okay to give closed key registry. Since, it's using only the datakey.
Package-Level Variables (total 28)
DefaultIteratorOptions contains default options when iterating over Badger key-value stores.
ErrBannedKey is returned if the read/write key belongs to any banned namespace.
ErrBlockedWrites is returned if the user called DropAll. During the process of dropping all
data from Badger, we stop accepting new writes, by returning this error.
ErrConflict is returned when a transaction conflicts with another transaction. This can
happen if the read rows had been updated concurrently by another transaction.
ErrDBClosed is returned when a get operation is performed after closing the DB.
ErrDiscardedTxn is returned if a previously discarded transaction is reused.
ErrEmptyKey is returned if an empty key is passed on an update function.
ErrEncryptionKeyMismatch is returned when the storage key is not
matched with the key previously given.
ErrGCInMemoryMode is returned when db.RunValueLogGC is called in in-memory mode.
ErrInvalidDataKeyID is returned if the datakey id is invalid.
ErrInvalidDump if a data dump made previously cannot be loaded into the database.
ErrInvalidEncryptionKey is returned if length of encryption keys is invalid.
ErrInvalidKey is returned if the key has a special !badger! prefix,
reserved for internal usage.
ErrInvalidRequest is returned if the user request is invalid.
ErrKeyNotFound is returned when key isn't found on a txn.Get.
ErrManagedTxn is returned if the user tries to use an API which isn't
allowed due to external management of transactions, when using ManagedDB.
ErrNamespaceMode is returned if the user tries to use an API which is allowed only when
NamespaceOffset is non-negative.
ErrNilCallback is returned when subscriber's callback is nil.
ErrNoRewrite is returned if a call for value log GC doesn't result in a log file rewrite.
ErrPlan9NotSupported is returned when opt.ReadOnly is used on Plan 9
ErrReadOnlyTxn is returned if an update function is called on a read-only transaction.
ErrRejected is returned if a value log GC is called either while another GC is running, or
after DB::Close has been called.
ErrThresholdZero is returned if threshold is set to zero, and value log GC is called.
In such a case, GC can't be run.
ErrTruncateNeeded is returned when the value log gets corrupt, and requires truncation of
corrupt data to allow Badger to run properly.
ErrTxnTooBig is returned if too many writes are fit into a single transaction.
ErrValueLogSize is returned when opt.ValueLogFileSize option is not within the valid
range.
ErrWindowsNotSupported is returned when opt.ReadOnly is used on Windows
ErrZeroBandwidth is returned if the user passes in zero bandwidth for sequence.
The pages are generated with Goldsv0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.
