LCOV - code coverage report
Current view: top level - pebble - options.go (source / functions) Coverage Total Hit
Test: 2025-08-07 08:18Z 436c169a - meta test only.lcov Lines: 62.1 % 1183 735
Test Date: 2025-08-07 08:19:55 Functions: - 0 0

            Line data    Source code
       1              : // Copyright 2011 The LevelDB-Go and Pebble Authors. All rights reserved. Use
       2              : // of this source code is governed by a BSD-style license that can be found in
       3              : // the LICENSE file.
       4              : 
       5              : package pebble
       6              : 
       7              : import (
       8              :         "bytes"
       9              :         "fmt"
      10              :         "io"
      11              :         "regexp"
      12              :         "runtime"
      13              :         "slices"
      14              :         "sort"
      15              :         "strconv"
      16              :         "strings"
      17              :         "time"
      18              :         "unicode"
      19              : 
      20              :         "github.com/cockroachdb/crlib/fifo"
      21              :         "github.com/cockroachdb/errors"
      22              :         "github.com/cockroachdb/pebble/internal/base"
      23              :         "github.com/cockroachdb/pebble/internal/cache"
      24              :         "github.com/cockroachdb/pebble/internal/humanize"
      25              :         "github.com/cockroachdb/pebble/internal/keyspan"
      26              :         "github.com/cockroachdb/pebble/internal/manifest"
      27              :         "github.com/cockroachdb/pebble/internal/testkeys"
      28              :         "github.com/cockroachdb/pebble/objstorage/objstorageprovider"
      29              :         "github.com/cockroachdb/pebble/objstorage/remote"
      30              :         "github.com/cockroachdb/pebble/rangekey"
      31              :         "github.com/cockroachdb/pebble/sstable"
      32              :         "github.com/cockroachdb/pebble/sstable/blob"
      33              :         "github.com/cockroachdb/pebble/sstable/block"
      34              :         "github.com/cockroachdb/pebble/sstable/colblk"
      35              :         "github.com/cockroachdb/pebble/vfs"
      36              :         "github.com/cockroachdb/pebble/wal"
      37              :         "github.com/cockroachdb/redact"
      38              : )
      39              : 
      40              : const (
      41              :         cacheDefaultSize       = 8 << 20 // 8 MB
      42              :         defaultLevelMultiplier = 10
      43              : )
      44              : 
      45              : // FilterType exports the base.FilterType type.
      46              : type FilterType = base.FilterType
      47              : 
      48              : // Exported TableFilter constants.
      49              : const (
      50              :         TableFilter = base.TableFilter
      51              : )
      52              : 
      53              : // FilterWriter exports the base.FilterWriter type.
      54              : type FilterWriter = base.FilterWriter
      55              : 
      56              : // FilterPolicy exports the base.FilterPolicy type.
      57              : type FilterPolicy = base.FilterPolicy
      58              : 
      59              : var NoFilterPolicy = base.NoFilterPolicy
      60              : 
      61              : // KeySchema exports the colblk.KeySchema type.
      62              : type KeySchema = colblk.KeySchema
      63              : 
      64              : // BlockPropertyCollector exports the sstable.BlockPropertyCollector type.
      65              : type BlockPropertyCollector = sstable.BlockPropertyCollector
      66              : 
      67              : // BlockPropertyFilter exports the sstable.BlockPropertyFilter type.
      68              : type BlockPropertyFilter = base.BlockPropertyFilter
      69              : 
      70              : // ShortAttributeExtractor exports the base.ShortAttributeExtractor type.
      71              : type ShortAttributeExtractor = base.ShortAttributeExtractor
      72              : 
      73              : // UserKeyPrefixBound exports the sstable.UserKeyPrefixBound type.
      74              : type UserKeyPrefixBound = sstable.UserKeyPrefixBound
      75              : 
      76              : // IterKeyType configures which types of keys an iterator should surface.
      77              : type IterKeyType int8
      78              : 
      79              : // DirLock represents a file lock on a directory. It may be passed to Open through
      80              : // Options.Lock to elide lock aquisition during Open.
      81              : type DirLock = base.DirLock
      82              : 
      83              : // LockDirectory acquires the directory lock in the named directory, preventing
      84              : // another process from opening the database. LockDirectory returns a
      85              : // handle to the held lock that may be passed to Open, skipping lock acquisition
      86              : // during Open.
      87              : //
      88              : // LockDirectory may be used to expand the critical section protected by the
      89              : // database lock to include setup before the call to Open.
      90            0 : func LockDirectory(dirname string, fs vfs.FS) (*DirLock, error) {
      91            0 :         return base.LockDirectory(dirname, fs)
      92            0 : }
      93              : 
      94              : const (
      95              :         // IterKeyTypePointsOnly configures an iterator to iterate over point keys
      96              :         // only.
      97              :         IterKeyTypePointsOnly IterKeyType = iota
      98              :         // IterKeyTypeRangesOnly configures an iterator to iterate over range keys
      99              :         // only.
     100              :         IterKeyTypeRangesOnly
     101              :         // IterKeyTypePointsAndRanges configures an iterator iterate over both point
     102              :         // keys and range keys simultaneously.
     103              :         IterKeyTypePointsAndRanges
     104              : )
     105              : 
     106              : // String implements fmt.Stringer.
     107            0 : func (t IterKeyType) String() string {
     108            0 :         switch t {
     109            0 :         case IterKeyTypePointsOnly:
     110            0 :                 return "points-only"
     111            0 :         case IterKeyTypeRangesOnly:
     112            0 :                 return "ranges-only"
     113            0 :         case IterKeyTypePointsAndRanges:
     114            0 :                 return "points-and-ranges"
     115            0 :         default:
     116            0 :                 panic(fmt.Sprintf("unknown key type %d", t))
     117              :         }
     118              : }
     119              : 
     120              : // IterOptions hold the optional per-query parameters for NewIter.
     121              : //
     122              : // Like Options, a nil *IterOptions is valid and means to use the default
     123              : // values.
     124              : type IterOptions struct {
     125              :         // LowerBound specifies the smallest key (inclusive) that the iterator will
     126              :         // return during iteration. If the iterator is seeked or iterated past this
     127              :         // boundary the iterator will return Valid()==false. Setting LowerBound
     128              :         // effectively truncates the key space visible to the iterator.
     129              :         LowerBound []byte
     130              :         // UpperBound specifies the largest key (exclusive) that the iterator will
     131              :         // return during iteration. If the iterator is seeked or iterated past this
     132              :         // boundary the iterator will return Valid()==false. Setting UpperBound
     133              :         // effectively truncates the key space visible to the iterator.
     134              :         UpperBound []byte
     135              :         // SkipPoint may be used to skip over point keys that don't match an
     136              :         // arbitrary predicate during iteration. If set, the Iterator invokes
     137              :         // SkipPoint for keys encountered. If SkipPoint returns true, the iterator
     138              :         // will skip the key without yielding it to the iterator operation in
     139              :         // progress.
     140              :         //
     141              :         // SkipPoint must be a pure function and always return the same result when
     142              :         // provided the same arguments. The iterator may call SkipPoint multiple
     143              :         // times for the same user key.
     144              :         SkipPoint func(userKey []byte) bool
     145              :         // PointKeyFilters can be used to avoid scanning tables and blocks in tables
     146              :         // when iterating over point keys. This slice represents an intersection
     147              :         // across all filters, i.e., all filters must indicate that the block is
     148              :         // relevant.
     149              :         //
     150              :         // Performance note: When len(PointKeyFilters) > 0, the caller should ensure
     151              :         // that cap(PointKeyFilters) is at least len(PointKeyFilters)+1. This helps
     152              :         // avoid allocations in Pebble internal code that mutates the slice.
     153              :         PointKeyFilters []BlockPropertyFilter
     154              :         // RangeKeyFilters can be usefd to avoid scanning tables and blocks in tables
     155              :         // when iterating over range keys. The same requirements that apply to
     156              :         // PointKeyFilters apply here too.
     157              :         RangeKeyFilters []BlockPropertyFilter
     158              :         // KeyTypes configures which types of keys to iterate over: point keys,
     159              :         // range keys, or both.
     160              :         KeyTypes IterKeyType
     161              :         // RangeKeyMasking can be used to enable automatic masking of point keys by
     162              :         // range keys. Range key masking is only supported during combined range key
     163              :         // and point key iteration mode (IterKeyTypePointsAndRanges).
     164              :         RangeKeyMasking RangeKeyMasking
     165              : 
     166              :         // OnlyReadGuaranteedDurable is an advanced option that is only supported by
     167              :         // the Reader implemented by DB. When set to true, only the guaranteed to be
     168              :         // durable state is visible in the iterator.
     169              :         // - This definition is made under the assumption that the FS implementation
     170              :         //   is providing a durability guarantee when data is synced.
     171              :         // - The visible state represents a consistent point in the history of the
     172              :         //   DB.
     173              :         // - The implementation is free to choose a conservative definition of what
     174              :         //   is guaranteed durable. For simplicity, the current implementation
     175              :         //   ignores memtables. A more sophisticated implementation could track the
     176              :         //   highest seqnum that is synced to the WAL and published and use that as
     177              :         //   the visible seqnum for an iterator. Note that the latter approach is
     178              :         //   not strictly better than the former since we can have DBs that are (a)
     179              :         //   synced more rarely than memtable flushes, (b) have no WAL. (a) is
     180              :         //   likely to be true in a future CockroachDB context where the DB
     181              :         //   containing the state machine may be rarely synced.
     182              :         // NB: this current implementation relies on the fact that memtables are
     183              :         // flushed in seqnum order, and any ingested sstables that happen to have a
     184              :         // lower seqnum than a non-flushed memtable don't have any overlapping keys.
     185              :         // This is the fundamental level invariant used in other code too, like when
     186              :         // merging iterators.
     187              :         //
     188              :         // Semantically, using this option provides the caller a "snapshot" as of
     189              :         // the time the most recent memtable was flushed. An alternate interface
     190              :         // would be to add a NewSnapshot variant. Creating a snapshot is heavier
     191              :         // weight than creating an iterator, so we have opted to support this
     192              :         // iterator option.
     193              :         OnlyReadGuaranteedDurable bool
     194              :         // UseL6Filters allows the caller to opt into reading filter blocks for L6
     195              :         // sstables. Helpful if a lot of SeekPrefixGEs are expected in quick
     196              :         // succession, that are also likely to not yield a single key. Filter blocks in
     197              :         // L6 can be relatively large, often larger than data blocks, so the benefit of
     198              :         // loading them in the cache is minimized if the probability of the key
     199              :         // existing is not low or if we just expect a one-time Seek (where loading the
     200              :         // data block directly is better).
     201              :         UseL6Filters bool
     202              :         // Category is used for categorized iterator stats. This should not be
     203              :         // changed by calling SetOptions.
     204              :         Category block.Category
     205              : 
     206              :         DebugRangeKeyStack bool
     207              : 
     208              :         // Internal options.
     209              : 
     210              :         logger Logger
     211              :         // Layer corresponding to this file. Only passed in if constructed by a
     212              :         // levelIter.
     213              :         layer manifest.Layer
     214              :         // disableLazyCombinedIteration is an internal testing option.
     215              :         disableLazyCombinedIteration bool
     216              :         // snapshotForHideObsoletePoints is specified for/by levelIter when opening
     217              :         // files and is used to decide whether to hide obsolete points. A value of 0
     218              :         // implies obsolete points should not be hidden.
     219              :         snapshotForHideObsoletePoints base.SeqNum
     220              : 
     221              :         // NB: If adding new Options, you must account for them in iterator
     222              :         // construction and Iterator.SetOptions.
     223              : }
     224              : 
     225              : // GetLowerBound returns the LowerBound or nil if the receiver is nil.
     226            1 : func (o *IterOptions) GetLowerBound() []byte {
     227            1 :         if o == nil {
     228            1 :                 return nil
     229            1 :         }
     230            1 :         return o.LowerBound
     231              : }
     232              : 
     233              : // GetUpperBound returns the UpperBound or nil if the receiver is nil.
     234            1 : func (o *IterOptions) GetUpperBound() []byte {
     235            1 :         if o == nil {
     236            1 :                 return nil
     237            1 :         }
     238            1 :         return o.UpperBound
     239              : }
     240              : 
     241            1 : func (o *IterOptions) pointKeys() bool {
     242            1 :         if o == nil {
     243            0 :                 return true
     244            0 :         }
     245            1 :         return o.KeyTypes == IterKeyTypePointsOnly || o.KeyTypes == IterKeyTypePointsAndRanges
     246              : }
     247              : 
     248            1 : func (o *IterOptions) rangeKeys() bool {
     249            1 :         if o == nil {
     250            0 :                 return false
     251            0 :         }
     252            1 :         return o.KeyTypes == IterKeyTypeRangesOnly || o.KeyTypes == IterKeyTypePointsAndRanges
     253              : }
     254              : 
     255            1 : func (o *IterOptions) getLogger() Logger {
     256            1 :         if o == nil || o.logger == nil {
     257            1 :                 return DefaultLogger
     258            1 :         }
     259            1 :         return o.logger
     260              : }
     261              : 
     262              : // SpanIterOptions creates a SpanIterOptions from this IterOptions.
     263            1 : func (o *IterOptions) SpanIterOptions() keyspan.SpanIterOptions {
     264            1 :         if o == nil {
     265            1 :                 return keyspan.SpanIterOptions{}
     266            1 :         }
     267            1 :         return keyspan.SpanIterOptions{
     268            1 :                 RangeKeyFilters: o.RangeKeyFilters,
     269            1 :         }
     270              : }
     271              : 
     272              : // scanInternalOptions is similar to IterOptions, meant for use with
     273              : // scanInternalIterator.
     274              : type scanInternalOptions struct {
     275              :         IterOptions
     276              : 
     277              :         category block.Category
     278              : 
     279              :         visitPointKey     func(key *InternalKey, value LazyValue, iterInfo IteratorLevel) error
     280              :         visitRangeDel     func(start, end []byte, seqNum SeqNum) error
     281              :         visitRangeKey     func(start, end []byte, keys []rangekey.Key) error
     282              :         visitSharedFile   func(sst *SharedSSTMeta) error
     283              :         visitExternalFile func(sst *ExternalFile) error
     284              : 
     285              :         // includeObsoleteKeys specifies whether keys shadowed by newer internal keys
     286              :         // are exposed. If false, only one internal key per user key is exposed.
     287              :         includeObsoleteKeys bool
     288              : 
     289              :         // rateLimitFunc is used to limit the amount of bytes read per second.
     290              :         rateLimitFunc func(key *InternalKey, value LazyValue) error
     291              : }
     292              : 
     293              : // RangeKeyMasking configures automatic hiding of point keys by range keys. A
     294              : // non-nil Suffix enables range-key masking. When enabled, range keys with
     295              : // suffixes ≥ Suffix behave as masks. All point keys that are contained within a
     296              : // masking range key's bounds and have suffixes greater than the range key's
     297              : // suffix are automatically skipped.
     298              : //
     299              : // Specifically, when configured with a RangeKeyMasking.Suffix _s_, and there
     300              : // exists a range key with suffix _r_ covering a point key with suffix _p_, and
     301              : //
     302              : //      _s_ ≤ _r_ < _p_
     303              : //
     304              : // then the point key is elided.
     305              : //
     306              : // Range-key masking may only be used when iterating over both point keys and
     307              : // range keys with IterKeyTypePointsAndRanges.
     308              : type RangeKeyMasking struct {
     309              :         // Suffix configures which range keys may mask point keys. Only range keys
     310              :         // that are defined at suffixes greater than or equal to Suffix will mask
     311              :         // point keys.
     312              :         Suffix []byte
     313              :         // Filter is an optional field that may be used to improve performance of
     314              :         // range-key masking through a block-property filter defined over key
     315              :         // suffixes. If non-nil, Filter is called by Pebble to construct a
     316              :         // block-property filter mask at iterator creation. The filter is used to
     317              :         // skip whole point-key blocks containing point keys with suffixes greater
     318              :         // than a covering range-key's suffix.
     319              :         //
     320              :         // To use this functionality, the caller must create and configure (through
     321              :         // Options.BlockPropertyCollectors) a block-property collector that records
     322              :         // the maxmimum suffix contained within a block. The caller then must write
     323              :         // and provide a BlockPropertyFilterMask implementation on that same
     324              :         // property. See the BlockPropertyFilterMask type for more information.
     325              :         Filter func() BlockPropertyFilterMask
     326              : }
     327              : 
     328              : // BlockPropertyFilterMask extends the BlockPropertyFilter interface for use
     329              : // with range-key masking. Unlike an ordinary block property filter, a
     330              : // BlockPropertyFilterMask's filtering criteria is allowed to change when Pebble
     331              : // invokes its SetSuffix method.
     332              : //
     333              : // When a Pebble iterator steps into a range key's bounds and the range key has
     334              : // a suffix greater than or equal to RangeKeyMasking.Suffix, the range key acts
     335              : // as a mask. The masking range key hides all point keys that fall within the
     336              : // range key's bounds and have suffixes > the range key's suffix. Without a
     337              : // filter mask configured, Pebble performs this hiding by stepping through point
     338              : // keys and comparing suffixes. If large numbers of point keys are masked, this
     339              : // requires Pebble to load, iterate through and discard a large number of
     340              : // sstable blocks containing masked point keys.
     341              : //
     342              : // If a block-property collector and a filter mask are configured, Pebble may
     343              : // skip loading some point-key blocks altogether. If a block's keys are known to
     344              : // all fall within the bounds of the masking range key and the block was
     345              : // annotated by a block-property collector with the maximal suffix, Pebble can
     346              : // ask the filter mask to compare the property to the current masking range
     347              : // key's suffix. If the mask reports no intersection, the block may be skipped.
     348              : //
     349              : // If unsuffixed and suffixed keys are written to the database, care must be
     350              : // taken to avoid unintentionally masking un-suffixed keys located in the same
     351              : // block as suffixed keys. One solution is to interpret unsuffixed keys as
     352              : // containing the maximal suffix value, ensuring that blocks containing
     353              : // unsuffixed keys are always loaded.
     354              : type BlockPropertyFilterMask interface {
     355              :         BlockPropertyFilter
     356              : 
     357              :         // SetSuffix configures the mask with the suffix of a range key. The filter
     358              :         // should return false from Intersects whenever it's provided with a
     359              :         // property encoding a block's minimum suffix that's greater (according to
     360              :         // Compare) than the provided suffix.
     361              :         SetSuffix(suffix []byte) error
     362              : }
     363              : 
     364              : // WriteOptions hold the optional per-query parameters for Set and Delete
     365              : // operations.
     366              : //
     367              : // Like Options, a nil *WriteOptions is valid and means to use the default
     368              : // values.
     369              : type WriteOptions struct {
     370              :         // Sync is whether to sync writes through the OS buffer cache and down onto
     371              :         // the actual disk, if applicable. Setting Sync is required for durability of
     372              :         // individual write operations but can result in slower writes.
     373              :         //
     374              :         // If false, and the process or machine crashes, then a recent write may be
     375              :         // lost. This is due to the recently written data being buffered inside the
     376              :         // process running Pebble. This differs from the semantics of a write system
     377              :         // call in which the data is buffered in the OS buffer cache and would thus
     378              :         // survive a process crash.
     379              :         //
     380              :         // The default value is true.
     381              :         Sync bool
     382              : }
     383              : 
     384              : // Sync specifies the default write options for writes which synchronize to
     385              : // disk.
     386              : var Sync = &WriteOptions{Sync: true}
     387              : 
     388              : // NoSync specifies the default write options for writes which do not
     389              : // synchronize to disk.
     390              : var NoSync = &WriteOptions{Sync: false}
     391              : 
     392              : // GetSync returns the Sync value or true if the receiver is nil.
     393            1 : func (o *WriteOptions) GetSync() bool {
     394            1 :         return o == nil || o.Sync
     395            1 : }
     396              : 
     397              : // LevelOptions holds the optional per-level parameters.
     398              : type LevelOptions struct {
     399              :         // BlockRestartInterval is the number of keys between restart points
     400              :         // for delta encoding of keys.
     401              :         //
     402              :         // The default value is 16 for L0, and the value from the previous level for
     403              :         // all other levels.
     404              :         BlockRestartInterval int
     405              : 
     406              :         // BlockSize is the target uncompressed size in bytes of each table block.
     407              :         //
     408              :         // The default value is 4096 for L0, and the value from the previous level for
     409              :         // all other levels.
     410              :         BlockSize int
     411              : 
     412              :         // BlockSizeThreshold finishes a block if the block size is larger than the
     413              :         // specified percentage of the target block size and adding the next entry
     414              :         // would cause the block to be larger than the target block size.
     415              :         //
     416              :         // The default value is 90 for L0, and the value from the previous level for
     417              :         // all other levels.
     418              :         BlockSizeThreshold int
     419              : 
     420              :         // Compression defines the per-block compression to use.
     421              :         //
     422              :         // The default value is Snappy for L0, or the function from the previous level
     423              :         // for all other levels.
     424              :         //
     425              :         // ApplyCompressionSettings can be used to initialize this field for all levels.
     426              :         Compression func() *sstable.CompressionProfile
     427              : 
     428              :         // FilterPolicy defines a filter algorithm (such as a Bloom filter) that can
     429              :         // reduce disk reads for Get calls.
     430              :         //
     431              :         // One such implementation is bloom.FilterPolicy(10) from the pebble/bloom
     432              :         // package.
     433              :         //
     434              :         // The default value for L0 is NoFilterPolicy (no filter), and the value from
     435              :         // the previous level for all other levels.
     436              :         FilterPolicy FilterPolicy
     437              : 
     438              :         // FilterType is a legacy field. The default and only possible value is
     439              :         // TableFilter.
     440              :         FilterType FilterType
     441              : 
     442              :         // IndexBlockSize is the target uncompressed size in bytes of each index
     443              :         // block. When the index block size is larger than this target, two-level
     444              :         // indexes are automatically enabled. Setting this option to a large value
     445              :         // (such as math.MaxInt32) disables the automatic creation of two-level
     446              :         // indexes.
     447              :         //
     448              :         // The default value is the value of BlockSize for L0, or the value from the
     449              :         // previous level for all other levels.
     450              :         IndexBlockSize int
     451              : }
     452              : 
     453              : // EnsureL0Defaults ensures that the L0 default values for the options have been
     454              : // initialized.
     455            1 : func (o *LevelOptions) EnsureL0Defaults() {
     456            1 :         if o.BlockRestartInterval <= 0 {
     457            0 :                 o.BlockRestartInterval = base.DefaultBlockRestartInterval
     458            0 :         }
     459            1 :         if o.BlockSize <= 0 {
     460            0 :                 o.BlockSize = base.DefaultBlockSize
     461            1 :         } else if o.BlockSize > sstable.MaximumRestartOffset {
     462            0 :                 panic(errors.Errorf("BlockSize %d exceeds MaximumRestartOffset", o.BlockSize))
     463              :         }
     464            1 :         if o.BlockSizeThreshold <= 0 {
     465            0 :                 o.BlockSizeThreshold = base.DefaultBlockSizeThreshold
     466            0 :         }
     467            1 :         if o.Compression == nil {
     468            0 :                 o.Compression = func() *sstable.CompressionProfile { return sstable.SnappyCompression }
     469              :         }
     470            1 :         if o.FilterPolicy == nil {
     471            0 :                 o.FilterPolicy = NoFilterPolicy
     472            0 :         }
     473            1 :         if o.IndexBlockSize <= 0 {
     474            0 :                 o.IndexBlockSize = o.BlockSize
     475            0 :         }
     476              : }
     477              : 
     478              : // EnsureL1PlusDefaults ensures that the L1+ default values for the options have
     479              : // been initialized. Requires the fully initialized options for the level above.
     480            1 : func (o *LevelOptions) EnsureL1PlusDefaults(previousLevel *LevelOptions) {
     481            1 :         if o.BlockRestartInterval <= 0 {
     482            0 :                 o.BlockRestartInterval = previousLevel.BlockRestartInterval
     483            0 :         }
     484            1 :         if o.BlockSize <= 0 {
     485            0 :                 o.BlockSize = previousLevel.BlockSize
     486            1 :         } else if o.BlockSize > sstable.MaximumRestartOffset {
     487            0 :                 panic(errors.Errorf("BlockSize %d exceeds MaximumRestartOffset", o.BlockSize))
     488              :         }
     489            1 :         if o.BlockSizeThreshold <= 0 {
     490            0 :                 o.BlockSizeThreshold = previousLevel.BlockSizeThreshold
     491            0 :         }
     492            1 :         if o.Compression == nil {
     493            0 :                 o.Compression = previousLevel.Compression
     494            0 :         }
     495            1 :         if o.FilterPolicy == nil {
     496            0 :                 o.FilterPolicy = previousLevel.FilterPolicy
     497            0 :         }
     498            1 :         if o.IndexBlockSize <= 0 {
     499            0 :                 o.IndexBlockSize = previousLevel.IndexBlockSize
     500            0 :         }
     501              : }
     502              : 
     503              : // Options holds the optional parameters for configuring pebble. These options
     504              : // apply to the DB at large; per-query options are defined by the IterOptions
     505              : // and WriteOptions types.
     506              : type Options struct {
     507              :         // Sync sstables periodically in order to smooth out writes to disk. This
     508              :         // option does not provide any persistency guarantee, but is used to avoid
     509              :         // latency spikes if the OS automatically decides to write out a large chunk
     510              :         // of dirty filesystem buffers. This option only controls SSTable syncs; WAL
     511              :         // syncs are controlled by WALBytesPerSync.
     512              :         //
     513              :         // The default value is 512KB.
     514              :         BytesPerSync int
     515              : 
     516              :         // Cache is used to cache uncompressed blocks from sstables. If it is nil,
     517              :         // a block cache of CacheSize will be created for each DB.
     518              :         Cache *cache.Cache
     519              :         // CacheSize is used when Cache is not set. The default value is 8 MB.
     520              :         CacheSize int64
     521              : 
     522              :         // LoadBlockSema, if set, is used to limit the number of blocks that can be
     523              :         // loaded (i.e. read from the filesystem) in parallel. Each load acquires one
     524              :         // unit from the semaphore for the duration of the read.
     525              :         LoadBlockSema *fifo.Semaphore
     526              : 
     527              :         // Cleaner cleans obsolete files.
     528              :         //
     529              :         // The default cleaner uses the DeleteCleaner.
     530              :         Cleaner Cleaner
     531              : 
     532              :         // Local contains option that pertain to files stored on the local filesystem.
     533              :         Local struct {
     534              :                 // ReadaheadConfig is used to retrieve the current readahead mode; it is
     535              :                 // consulted whenever a read handle is initialized.
     536              :                 ReadaheadConfig *ReadaheadConfig
     537              : 
     538              :                 // TODO(radu): move BytesPerSync, LoadBlockSema, Cleaner here.
     539              :         }
     540              : 
     541              :         // Comparer defines a total ordering over the space of []byte keys: a 'less
     542              :         // than' relationship. The same comparison algorithm must be used for reads
     543              :         // and writes over the lifetime of the DB.
     544              :         //
     545              :         // The default value uses the same ordering as bytes.Compare.
     546              :         Comparer *Comparer
     547              : 
     548              :         // DebugCheck is invoked, if non-nil, whenever a new version is being
     549              :         // installed. Typically, this is set to pebble.DebugCheckLevels in tests
     550              :         // or tools only, to check invariants over all the data in the database.
     551              :         DebugCheck func(*DB) error
     552              : 
     553              :         // Disable the write-ahead log (WAL). Disabling the write-ahead log prohibits
     554              :         // crash recovery, but can improve performance if crash recovery is not
     555              :         // needed (e.g. when only temporary state is being stored in the database).
     556              :         //
     557              :         // TODO(peter): untested
     558              :         DisableWAL bool
     559              : 
     560              :         // ErrorIfExists causes an error on Open if the database already exists.
     561              :         // The error can be checked with errors.Is(err, ErrDBAlreadyExists).
     562              :         //
     563              :         // The default value is false.
     564              :         ErrorIfExists bool
     565              : 
     566              :         // ErrorIfNotExists causes an error on Open if the database does not already
     567              :         // exist. The error can be checked with errors.Is(err, ErrDBDoesNotExist).
     568              :         //
     569              :         // The default value is false which will cause a database to be created if it
     570              :         // does not already exist.
     571              :         ErrorIfNotExists bool
     572              : 
     573              :         // ErrorIfNotPristine causes an error on Open if the database already exists
     574              :         // and any operations have been performed on the database. The error can be
     575              :         // checked with errors.Is(err, ErrDBNotPristine).
     576              :         //
     577              :         // Note that a database that contained keys that were all subsequently deleted
     578              :         // may or may not trigger the error. Currently, we check if there are any live
     579              :         // SSTs or log records to replay.
     580              :         ErrorIfNotPristine bool
     581              : 
     582              :         // EventListener provides hooks to listening to significant DB events such as
     583              :         // flushes, compactions, and table deletion.
     584              :         EventListener *EventListener
     585              : 
     586              :         // Experimental contains experimental options which are off by default.
     587              :         // These options are temporary and will eventually either be deleted, moved
     588              :         // out of the experimental group, or made the non-adjustable default. These
     589              :         // options may change at any time, so do not rely on them.
     590              :         Experimental struct {
     591              :                 // The threshold of L0 read-amplification at which compaction concurrency
     592              :                 // is enabled (if CompactionDebtConcurrency was not already exceeded).
     593              :                 // Every multiple of this value enables another concurrent
     594              :                 // compaction up to CompactionConcurrencyRange.
     595              :                 L0CompactionConcurrency int
     596              : 
     597              :                 // CompactionDebtConcurrency controls the threshold of compaction debt
     598              :                 // at which additional compaction concurrency slots are added. For every
     599              :                 // multiple of this value in compaction debt bytes, an additional
     600              :                 // concurrent compaction is added. This works "on top" of
     601              :                 // L0CompactionConcurrency, so the higher of the count of compaction
     602              :                 // concurrency slots as determined by the two options is chosen.
     603              :                 CompactionDebtConcurrency uint64
     604              : 
     605              :                 // CompactionGarbageFractionForMaxConcurrency is the fraction of garbage
     606              :                 // due to DELs and RANGEDELs that causes MaxConcurrentCompactions to be
     607              :                 // allowed. Concurrent compactions are allowed in a linear manner upto
     608              :                 // this limit being reached. A value <= 0.0 disables adding concurrency
     609              :                 // due to garbage.
     610              :                 CompactionGarbageFractionForMaxConcurrency func() float64
     611              : 
     612              :                 // IngestSplit, if it returns true, allows for ingest-time splitting of
     613              :                 // existing sstables into two virtual sstables to allow ingestion sstables to
     614              :                 // slot into a lower level than they otherwise would have.
     615              :                 IngestSplit func() bool
     616              : 
     617              :                 // ReadCompactionRate controls the frequency of read triggered
     618              :                 // compactions by adjusting `AllowedSeeks` in manifest.TableMetadata:
     619              :                 //
     620              :                 // AllowedSeeks = FileSize / ReadCompactionRate
     621              :                 //
     622              :                 // From LevelDB:
     623              :                 // ```
     624              :                 // We arrange to automatically compact this file after
     625              :                 // a certain number of seeks. Let's assume:
     626              :                 //   (1) One seek costs 10ms
     627              :                 //   (2) Writing or reading 1MB costs 10ms (100MB/s)
     628              :                 //   (3) A compaction of 1MB does 25MB of IO:
     629              :                 //         1MB read from this level
     630              :                 //         10-12MB read from next level (boundaries may be misaligned)
     631              :                 //         10-12MB written to next level
     632              :                 // This implies that 25 seeks cost the same as the compaction
     633              :                 // of 1MB of data.  I.e., one seek costs approximately the
     634              :                 // same as the compaction of 40KB of data.  We are a little
     635              :                 // conservative and allow approximately one seek for every 16KB
     636              :                 // of data before triggering a compaction.
     637              :                 // ```
     638              :                 ReadCompactionRate int64
     639              : 
     640              :                 // ReadSamplingMultiplier is a multiplier for the readSamplingPeriod in
     641              :                 // iterator.maybeSampleRead() to control the frequency of read sampling
     642              :                 // to trigger a read triggered compaction. A value of -1 prevents sampling
     643              :                 // and disables read triggered compactions. The default is 1 << 4. which
     644              :                 // gets multiplied with a constant of 1 << 16 to yield 1 << 20 (1MB).
     645              :                 ReadSamplingMultiplier int64
     646              : 
     647              :                 // NumDeletionsThreshold defines the minimum number of point tombstones
     648              :                 // that must be present in a single data block for that block to be
     649              :                 // considered tombstone-dense for the purposes of triggering a
     650              :                 // tombstone density compaction. Data blocks may also be considered
     651              :                 // tombstone-dense if they meet the criteria defined by
     652              :                 // DeletionSizeRatioThreshold below. Tombstone-dense blocks are identified
     653              :                 // when sstables are written, and so this is effectively an option for
     654              :                 // sstable writers. The default value is 100.
     655              :                 NumDeletionsThreshold int
     656              : 
     657              :                 // DeletionSizeRatioThreshold defines the minimum ratio of the size of
     658              :                 // point tombstones to the size of a data block that must be reached
     659              :                 // for that block to be considered tombstone-dense for the purposes of
     660              :                 // triggering a tombstone density compaction. Data blocks may also be
     661              :                 // considered tombstone-dense if they meet the criteria defined by
     662              :                 // NumDeletionsThreshold above. Tombstone-dense blocks are identified
     663              :                 // when sstables are written, and so this is effectively an option for
     664              :                 // sstable writers. The default value is 0.5.
     665              :                 DeletionSizeRatioThreshold float32
     666              : 
     667              :                 // TombstoneDenseCompactionThreshold is the minimum percent of data
     668              :                 // blocks in a table that must be tombstone-dense for that table to be
     669              :                 // eligible for a tombstone density compaction. It should be defined as a
     670              :                 // ratio out of 1. The default value is 0.10.
     671              :                 //
     672              :                 // If multiple tables are eligible for a tombstone density compaction, then
     673              :                 // tables with a higher percent of tombstone-dense blocks are still
     674              :                 // prioritized for compaction.
     675              :                 //
     676              :                 // A zero or negative value disables tombstone density compactions.
     677              :                 TombstoneDenseCompactionThreshold float64
     678              : 
     679              :                 // FileCacheShards is the number of shards per file cache.
     680              :                 // Reducing the value can reduce the number of idle goroutines per DB
     681              :                 // instance which can be useful in scenarios with a lot of DB instances
     682              :                 // and a large number of CPUs, but doing so can lead to higher contention
     683              :                 // in the file cache and reduced performance.
     684              :                 //
     685              :                 // The default value is the number of logical CPUs, which can be
     686              :                 // limited by runtime.GOMAXPROCS.
     687              :                 FileCacheShards int
     688              : 
     689              :                 // ValidateOnIngest schedules validation of sstables after they have
     690              :                 // been ingested.
     691              :                 //
     692              :                 // By default, this value is false.
     693              :                 ValidateOnIngest bool
     694              : 
     695              :                 // LevelMultiplier configures the size multiplier used to determine the
     696              :                 // desired size of each level of the LSM. Defaults to 10.
     697              :                 LevelMultiplier int
     698              : 
     699              :                 // MultiLevelCompactionHeuristic determines whether to add an additional
     700              :                 // level to a conventional two level compaction.
     701              :                 MultiLevelCompactionHeuristic func() MultiLevelHeuristic
     702              : 
     703              :                 // EnableValueBlocks is used to decide whether to enable writing
     704              :                 // TableFormatPebblev3 sstables. This setting is only respected by a
     705              :                 // specific subset of format major versions: FormatSSTableValueBlocks,
     706              :                 // FormatFlushableIngest and FormatPrePebblev1MarkedCompacted. In lower
     707              :                 // format major versions, value blocks are never enabled. In higher
     708              :                 // format major versions, value blocks are always enabled.
     709              :                 EnableValueBlocks func() bool
     710              : 
     711              :                 // ShortAttributeExtractor is used iff EnableValueBlocks() returns true
     712              :                 // (else ignored). If non-nil, a ShortAttribute can be extracted from the
     713              :                 // value and stored with the key, when the value is stored elsewhere.
     714              :                 ShortAttributeExtractor ShortAttributeExtractor
     715              : 
     716              :                 // DisableIngestAsFlushable disables lazy ingestion of sstables through
     717              :                 // a WAL write and memtable rotation. Only effectual if the format
     718              :                 // major version is at least `FormatFlushableIngest`.
     719              :                 DisableIngestAsFlushable func() bool
     720              : 
     721              :                 // RemoteStorage enables use of remote storage (e.g. S3) for storing
     722              :                 // sstables. Setting this option enables use of CreateOnShared option and
     723              :                 // allows ingestion of external files.
     724              :                 RemoteStorage remote.StorageFactory
     725              : 
     726              :                 // If CreateOnShared is non-zero, new sstables are created on remote storage
     727              :                 // (using CreateOnSharedLocator and with the appropriate
     728              :                 // CreateOnSharedStrategy). These sstables can be shared between different
     729              :                 // Pebble instances; the lifecycle of such objects is managed by the
     730              :                 // remote.Storage constructed by options.RemoteStorage.
     731              :                 //
     732              :                 // Can only be used when RemoteStorage is set (and recognizes
     733              :                 // CreateOnSharedLocator).
     734              :                 CreateOnShared        remote.CreateOnSharedStrategy
     735              :                 CreateOnSharedLocator remote.Locator
     736              : 
     737              :                 // CacheSizeBytesBytes is the size of the on-disk block cache for objects
     738              :                 // on shared storage in bytes. If it is 0, no cache is used.
     739              :                 SecondaryCacheSizeBytes int64
     740              : 
     741              :                 // EnableDeleteOnlyCompactionExcises enables delete-only compactions to also
     742              :                 // apply delete-only compaction hints on sstables that partially overlap
     743              :                 // with it. This application happens through an excise, similar to
     744              :                 // the excise phase of IngestAndExcise.
     745              :                 EnableDeleteOnlyCompactionExcises func() bool
     746              : 
     747              :                 // CompactionScheduler, if set, is used to limit concurrent compactions as
     748              :                 // well as to pace compactions already chosen. If nil, a default scheduler
     749              :                 // is created and used.
     750              :                 CompactionScheduler CompactionScheduler
     751              : 
     752              :                 UserKeyCategories UserKeyCategories
     753              : 
     754              :                 // ValueSeparationPolicy controls the policy for separating values into
     755              :                 // external blob files. If nil, value separation defaults to disabled.
     756              :                 // The value separation policy is ignored if EnableColumnarBlocks() is
     757              :                 // false.
     758              :                 ValueSeparationPolicy func() ValueSeparationPolicy
     759              : 
     760              :                 // SpanPolicyFunc is used to determine the SpanPolicy for a key region.
     761              :                 SpanPolicyFunc SpanPolicyFunc
     762              :         }
     763              : 
     764              :         // Filters is a map from filter policy name to filter policy. It is used for
     765              :         // debugging tools which may be used on multiple databases configured with
     766              :         // different filter policies. It is not necessary to populate this filters
     767              :         // map during normal usage of a DB (it will be done automatically by
     768              :         // EnsureDefaults).
     769              :         Filters map[string]FilterPolicy
     770              : 
     771              :         // FlushDelayDeleteRange configures how long the database should wait before
     772              :         // forcing a flush of a memtable that contains a range deletion. Disk space
     773              :         // cannot be reclaimed until the range deletion is flushed. No automatic
     774              :         // flush occurs if zero.
     775              :         FlushDelayDeleteRange time.Duration
     776              : 
     777              :         // FlushDelayRangeKey configures how long the database should wait before
     778              :         // forcing a flush of a memtable that contains a range key. Range keys in
     779              :         // the memtable prevent lazy combined iteration, so it's desirable to flush
     780              :         // range keys promptly. No automatic flush occurs if zero.
     781              :         FlushDelayRangeKey time.Duration
     782              : 
     783              :         // FlushSplitBytes denotes the target number of bytes per sublevel in
     784              :         // each flush split interval (i.e. range between two flush split keys)
     785              :         // in L0 sstables. When set to zero, only a single sstable is generated
     786              :         // by each flush. When set to a non-zero value, flushes are split at
     787              :         // points to meet L0's TargetFileSize, any grandparent-related overlap
     788              :         // options, and at boundary keys of L0 flush split intervals (which are
     789              :         // targeted to contain around FlushSplitBytes bytes in each sublevel
     790              :         // between pairs of boundary keys). Splitting sstables during flush
     791              :         // allows increased compaction flexibility and concurrency when those
     792              :         // tables are compacted to lower levels.
     793              :         FlushSplitBytes int64
     794              : 
     795              :         // FormatMajorVersion sets the format of on-disk files. It is
     796              :         // recommended to set the format major version to an explicit
     797              :         // version, as the default may change over time.
     798              :         //
     799              :         // At Open if the existing database is formatted using a later
     800              :         // format major version that is known to this version of Pebble,
     801              :         // Pebble will continue to use the later format major version. If
     802              :         // the existing database's version is unknown, the caller may use
     803              :         // FormatMostCompatible and will be able to open the database
     804              :         // regardless of its actual version.
     805              :         //
     806              :         // If the existing database is formatted using a format major
     807              :         // version earlier than the one specified, Open will automatically
     808              :         // ratchet the database to the specified format major version.
     809              :         FormatMajorVersion FormatMajorVersion
     810              : 
     811              :         // FS provides the interface for persistent file storage.
     812              :         //
     813              :         // The default value uses the underlying operating system's file system.
     814              :         FS vfs.FS
     815              : 
     816              :         // KeySchema is the name of the key schema that should be used when writing
     817              :         // new sstables. There must be a key schema with this name defined in
     818              :         // KeySchemas. If not set, colblk.DefaultKeySchema is used to construct a
     819              :         // default key schema.
     820              :         KeySchema string
     821              : 
     822              :         // KeySchemas defines the set of known schemas of user keys. When columnar
     823              :         // blocks are in use (see FormatColumnarBlocks), the user may specify how a
     824              :         // key should be decomposed into columns. Each KeySchema must have a unique
     825              :         // name. The schema named by Options.KeySchema is used while writing
     826              :         // sstables during flushes and compactions.
     827              :         //
     828              :         // Multiple KeySchemas may be used over the lifetime of a database. Once a
     829              :         // KeySchema is used, it must be provided in KeySchemas in subsequent calls
     830              :         // to Open for perpetuity.
     831              :         KeySchemas sstable.KeySchemas
     832              : 
     833              :         // Lock, if set, must be a database lock acquired through LockDirectory for
     834              :         // the same directory passed to Open. If provided, Open will skip locking
     835              :         // the directory. Closing the database will not release the lock, and it's
     836              :         // the responsibility of the caller to release the lock after closing the
     837              :         // database.
     838              :         //
     839              :         // Open will enforce that the Lock passed locks the same directory passed to
     840              :         // Open. Concurrent calls to Open using the same Lock are detected and
     841              :         // prohibited.
     842              :         Lock *base.DirLock
     843              : 
     844              :         // The count of L0 files necessary to trigger an L0 compaction.
     845              :         L0CompactionFileThreshold int
     846              : 
     847              :         // The amount of L0 read-amplification necessary to trigger an L0 compaction.
     848              :         L0CompactionThreshold int
     849              : 
     850              :         // Hard limit on L0 read-amplification, computed as the number of L0
     851              :         // sublevels. Writes are stopped when this threshold is reached.
     852              :         L0StopWritesThreshold int
     853              : 
     854              :         // The maximum number of bytes for LBase. The base level is the level which
     855              :         // L0 is compacted into. The base level is determined dynamically based on
     856              :         // the existing data in the LSM. The maximum number of bytes for other levels
     857              :         // is computed dynamically based on the base level's maximum size. When the
     858              :         // maximum number of bytes for a level is exceeded, compaction is requested.
     859              :         LBaseMaxBytes int64
     860              : 
     861              :         // TargetFileSizes contains the target file size for each level, ignoring
     862              :         // unpopulated levels. Specifically:
     863              :         // - TargetFileSizes[0] is the target file size for L0;
     864              :         // - TargetFileSizes[1] is the target file size for Lbase;
     865              :         // - TargetFileSizes[2] is the target file size for Lbase+1;
     866              :         // and so on.
     867              :         //
     868              :         // The default value for TargetFileSizes[0] is 2MB.
     869              :         // The default value for TargetFileSizes[i] is TargetFileSizes[i-1] * 2.
     870              :         TargetFileSizes [manifest.NumLevels]int64
     871              : 
     872              :         // Per-level options. Levels[i] contains the options for Li (regardless of
     873              :         // what Lbase is).
     874              :         Levels [manifest.NumLevels]LevelOptions
     875              : 
     876              :         // LoggerAndTracer will be used, if non-nil, else Logger will be used and
     877              :         // tracing will be a noop.
     878              : 
     879              :         // Logger used to write log messages.
     880              :         //
     881              :         // The default logger uses the Go standard library log package.
     882              :         Logger Logger
     883              :         // LoggerAndTracer is used for writing log messages and traces.
     884              :         LoggerAndTracer LoggerAndTracer
     885              : 
     886              :         // MaxManifestFileSize is the maximum size the MANIFEST file is allowed to
     887              :         // become. When the MANIFEST exceeds this size it is rolled over and a new
     888              :         // MANIFEST is created.
     889              :         MaxManifestFileSize int64
     890              : 
     891              :         // MaxOpenFiles is a soft limit on the number of open files that can be
     892              :         // used by the DB.
     893              :         //
     894              :         // The default value is 1000.
     895              :         MaxOpenFiles int
     896              : 
     897              :         // The size of a MemTable in steady state. The actual MemTable size starts at
     898              :         // min(256KB, MemTableSize) and doubles for each subsequent MemTable up to
     899              :         // MemTableSize. This reduces the memory pressure caused by MemTables for
     900              :         // short lived (test) DB instances. Note that more than one MemTable can be
     901              :         // in existence since flushing a MemTable involves creating a new one and
     902              :         // writing the contents of the old one in the
     903              :         // background. MemTableStopWritesThreshold places a hard limit on the size of
     904              :         // the queued MemTables.
     905              :         //
     906              :         // The default value is 4MB.
     907              :         MemTableSize uint64
     908              : 
     909              :         // Hard limit on the number of queued of MemTables. Writes are stopped when
     910              :         // the sum of the queued memtable sizes exceeds:
     911              :         //   MemTableStopWritesThreshold * MemTableSize.
     912              :         //
     913              :         // This value should be at least 2 or writes will stop whenever a MemTable is
     914              :         // being flushed.
     915              :         //
     916              :         // The default value is 2.
     917              :         MemTableStopWritesThreshold int
     918              : 
     919              :         // Merger defines the associative merge operation to use for merging values
     920              :         // written with {Batch,DB}.Merge.
     921              :         //
     922              :         // The default merger concatenates values.
     923              :         Merger *Merger
     924              : 
     925              :         // CompactionConcurrencyRange returns a [lower, upper] range for the number of
     926              :         // compactions Pebble runs in parallel (with the caveats below), not including
     927              :         // download compactions (which have a separate limit specified by
     928              :         // MaxConcurrentDownloads).
     929              :         //
     930              :         // The lower value is the concurrency allowed under normal circumstances.
     931              :         // Pebble can dynamically increase the concurrency based on heuristics (like
     932              :         // high read amplification or compaction debt) up to the maximum.
     933              :         //
     934              :         // The upper value is a rough upper bound since delete-only compactions (a) do
     935              :         // not use the CompactionScheduler, and (b) the CompactionScheduler may use
     936              :         // other criteria to decide on how many compactions to permit.
     937              :         //
     938              :         // Elaborating on (b), when the ConcurrencyLimitScheduler is being used, the
     939              :         // value returned by DB.GetAllowedWithoutPermission fully controls how many
     940              :         // compactions get to run. Other CompactionSchedulers may use additional
     941              :         // criteria, like resource availability.
     942              :         //
     943              :         // Elaborating on (a), we don't use the CompactionScheduler to schedule
     944              :         // delete-only compactions since they are expected to be almost free from a
     945              :         // CPU and disk usage perspective. Since the CompactionScheduler does not
     946              :         // know about their existence, the total running count can exceed this
     947              :         // value. For example, consider CompactionConcurrencyRange returns 3, and the
     948              :         // current value returned from DB.GetAllowedWithoutPermission is also 3. Say
     949              :         // 3 delete-only compactions are also running. Then the
     950              :         // ConcurrencyLimitScheduler can also start 3 other compactions, for a total
     951              :         // of 6.
     952              :         //
     953              :         // DB.GetAllowedWithoutPermission returns a value in the interval
     954              :         // [lower, upper]. A value > lower is returned:
     955              :         //  - when L0 read-amplification passes the L0CompactionConcurrency threshold;
     956              :         //  - when compaction debt passes the CompactionDebtConcurrency threshold;
     957              :         //  - when there are multiple manual compactions waiting to run.
     958              :         //
     959              :         // lower and upper must be greater than 0. If lower > upper, then upper is
     960              :         // used for both.
     961              :         //
     962              :         // The default values are 1, 1.
     963              :         CompactionConcurrencyRange func() (lower, upper int)
     964              : 
     965              :         // MaxConcurrentDownloads specifies the maximum number of download
     966              :         // compactions. These are compactions that copy an external file to the local
     967              :         // store.
     968              :         //
     969              :         // This limit is independent of CompactionConcurrencyRange; at any point in
     970              :         // time, we may be running CompactionConcurrencyRange non-download compactions
     971              :         // and MaxConcurrentDownloads download compactions.
     972              :         //
     973              :         // MaxConcurrentDownloads() must be greater than 0.
     974              :         //
     975              :         // The default value is 1.
     976              :         MaxConcurrentDownloads func() int
     977              : 
     978              :         // DisableAutomaticCompactions dictates whether automatic compactions are
     979              :         // scheduled or not. The default is false (enabled). This option is only used
     980              :         // externally when running a manual compaction, and internally for tests.
     981              :         DisableAutomaticCompactions bool
     982              : 
     983              :         // DisableConsistencyCheck disables the consistency check that is performed on
     984              :         // open. Should only be used when a database cannot be opened normally (e.g.
     985              :         // some of the tables don't exist / aren't accessible).
     986              :         DisableConsistencyCheck bool
     987              : 
     988              :         // DisableTableStats dictates whether tables should be loaded asynchronously
     989              :         // to compute statistics that inform compaction heuristics. The collection
     990              :         // of table stats improves compaction of tombstones, reclaiming disk space
     991              :         // more quickly and in some cases reducing write amplification in the
     992              :         // presence of tombstones. Disabling table stats may be useful in tests
     993              :         // that require determinism as the asynchronicity of table stats collection
     994              :         // introduces significant nondeterminism.
     995              :         DisableTableStats bool
     996              : 
     997              :         // NoSyncOnClose decides whether the Pebble instance will enforce a
     998              :         // close-time synchronization (e.g., fdatasync() or sync_file_range())
     999              :         // on files it writes to. Setting this to true removes the guarantee for a
    1000              :         // sync on close. Some implementations can still issue a non-blocking sync.
    1001              :         NoSyncOnClose bool
    1002              : 
    1003              :         // NumPrevManifest is the number of non-current or older manifests which
    1004              :         // we want to keep around for debugging purposes. By default, we're going
    1005              :         // to keep one older manifest.
    1006              :         NumPrevManifest int
    1007              : 
    1008              :         // ReadOnly indicates that the DB should be opened in read-only mode. Writes
    1009              :         // to the DB will return an error, background compactions are disabled, and
    1010              :         // the flush that normally occurs after replaying the WAL at startup is
    1011              :         // disabled.
    1012              :         ReadOnly bool
    1013              : 
    1014              :         // FileCache is an initialized FileCache which should be set as an
    1015              :         // option if the DB needs to be initialized with a pre-existing file cache.
    1016              :         // If FileCache is nil, then a file cache which is unique to the DB instance
    1017              :         // is created. FileCache can be shared between db instances by setting it here.
    1018              :         // The FileCache set here must use the same underlying cache as Options.Cache
    1019              :         // and pebble will panic otherwise.
    1020              :         FileCache *FileCache
    1021              : 
    1022              :         // BlockPropertyCollectors is a list of BlockPropertyCollector creation
    1023              :         // functions. A new BlockPropertyCollector is created for each sstable
    1024              :         // built and lives for the lifetime of writing that table.
    1025              :         BlockPropertyCollectors []func() BlockPropertyCollector
    1026              : 
    1027              :         // WALBytesPerSync sets the number of bytes to write to a WAL before calling
    1028              :         // Sync on it in the background. Just like with BytesPerSync above, this
    1029              :         // helps smooth out disk write latencies, and avoids cases where the OS
    1030              :         // writes a lot of buffered data to disk at once. However, this is less
    1031              :         // necessary with WALs, as many write operations already pass in
    1032              :         // Sync = true.
    1033              :         //
    1034              :         // The default value is 0, i.e. no background syncing. This matches the
    1035              :         // default behaviour in RocksDB.
    1036              :         WALBytesPerSync int
    1037              : 
    1038              :         // WALDir specifies the directory to store write-ahead logs (WALs) in. If
    1039              :         // empty (the default), WALs will be stored in the same directory as sstables
    1040              :         // (i.e. the directory passed to pebble.Open).
    1041              :         WALDir string
    1042              : 
    1043              :         // WALDirLock, if set, must be a directory lock acquired through LockDirectory
    1044              :         // for the same directory set on WALDir passed to Open. If provided, Open will
    1045              :         // skip locking the directory. Closing the database will not release the lock,
    1046              :         // and it's the responsibility of the caller to release the lock after closing the
    1047              :         // database.
    1048              :         //
    1049              :         // Open will enforce that the Lock passed locks the same WAL directory passed to
    1050              :         // Open. Concurrent calls to Open using the same Lock are detected and
    1051              :         // prohibited.
    1052              :         WALDirLock *base.DirLock
    1053              : 
    1054              :         // WALFailover may be set to configure Pebble to monitor writes to its
    1055              :         // write-ahead log and failover to writing write-ahead log entries to a
    1056              :         // secondary location (eg, a separate physical disk). WALFailover may be
    1057              :         // used to improve write availability in the presence of transient disk
    1058              :         // unavailability.
    1059              :         WALFailover *WALFailoverOptions
    1060              : 
    1061              :         // WALRecoveryDirs is a list of additional directories that should be
    1062              :         // scanned for the existence of additional write-ahead logs. WALRecoveryDirs
    1063              :         // is expected to be used when starting Pebble with a new WALDir or a new
    1064              :         // WALFailover configuration. The directories associated with the previous
    1065              :         // configuration may still contain WALs that are required for recovery of
    1066              :         // the current database state.
    1067              :         //
    1068              :         // If a previous WAL configuration may have stored WALs elsewhere but there
    1069              :         // is not a corresponding entry in WALRecoveryDirs, Open will error.
    1070              :         WALRecoveryDirs []wal.Dir
    1071              : 
    1072              :         // WALMinSyncInterval is the minimum duration between syncs of the WAL. If
    1073              :         // WAL syncs are requested faster than this interval, they will be
    1074              :         // artificially delayed. Introducing a small artificial delay (500us) between
    1075              :         // WAL syncs can allow more operations to arrive and reduce IO operations
    1076              :         // while having a minimal impact on throughput. This option is supplied as a
    1077              :         // closure in order to allow the value to be changed dynamically. The default
    1078              :         // value is 0.
    1079              :         //
    1080              :         // TODO(peter): rather than a closure, should there be another mechanism for
    1081              :         // changing options dynamically?
    1082              :         WALMinSyncInterval func() time.Duration
    1083              : 
    1084              :         // The controls below manage deletion pacing, which slows down
    1085              :         // deletions when compactions finish or when readers close and
    1086              :         // obsolete files must be cleaned up. Rapid deletion of many
    1087              :         // files simultaneously can increase disk latency on certain
    1088              :         // SSDs, and this functionality helps protect against that.
    1089              : 
    1090              :         // TargetByteDeletionRate is the rate (in bytes per second) at which sstable file
    1091              :         // deletions are limited to (under normal circumstances).
    1092              :         //
    1093              :         // This value is only a best-effort target; the effective rate can be
    1094              :         // higher if deletions are falling behind or disk space is running low.
    1095              :         //
    1096              :         // Setting this to 0 disables deletion pacing, which is also the default.
    1097              :         TargetByteDeletionRate int
    1098              : 
    1099              :         // FreeSpaceThresholdBytes specifies the minimum amount of free disk space that Pebble
    1100              :         // attempts to maintain. If free disk space drops below this threshold, deletions
    1101              :         // are accelerated above TargetByteDeletionRate until the threshold is restored.
    1102              :         // Default is 16GB.
    1103              :         FreeSpaceThresholdBytes uint64
    1104              : 
    1105              :         // FreeSpaceTimeframe sets the duration (in seconds) within which Pebble attempts
    1106              :         // to restore the free disk space back to FreeSpaceThreshold. A lower value means
    1107              :         // more aggressive deletions. Default is 10s.
    1108              :         FreeSpaceTimeframe time.Duration
    1109              : 
    1110              :         // ObsoleteBytesMaxRatio specifies the maximum allowed ratio of obsolete files to
    1111              :         // live files. If this ratio is exceeded, Pebble speeds up deletions above the
    1112              :         // TargetByteDeletionRate until the ratio is restored. Default is 0.20.
    1113              :         ObsoleteBytesMaxRatio float64
    1114              : 
    1115              :         // ObsoleteBytesTimeframe sets the duration (in seconds) within which Pebble aims
    1116              :         // to restore the obsolete-to-live bytes ratio below ObsoleteBytesMaxRatio. A lower
    1117              :         // value means more aggressive deletions. Default is 300s.
    1118              :         ObsoleteBytesTimeframe time.Duration
    1119              : 
    1120              :         // EnableSQLRowSpillMetrics specifies whether the Pebble instance will only be used
    1121              :         // to temporarily persist data spilled to disk for row-oriented SQL query execution.
    1122              :         EnableSQLRowSpillMetrics bool
    1123              : 
    1124              :         // AllocatorSizeClasses provides a sorted list containing the supported size
    1125              :         // classes of the underlying memory allocator. This provides hints to the
    1126              :         // sstable block writer's flushing policy to select block sizes that
    1127              :         // preemptively reduce internal fragmentation when loaded into the block cache.
    1128              :         AllocatorSizeClasses []int
    1129              : 
    1130              :         // private options are only used by internal tests or are used internally
    1131              :         // for facilitating upgrade paths of unconfigurable functionality.
    1132              :         private struct {
    1133              :                 // disableDeleteOnlyCompactions prevents the scheduling of delete-only
    1134              :                 // compactions that drop sstables wholy covered by range tombstones or
    1135              :                 // range key tombstones.
    1136              :                 disableDeleteOnlyCompactions bool
    1137              : 
    1138              :                 // disableElisionOnlyCompactions prevents the scheduling of elision-only
    1139              :                 // compactions that rewrite sstables in place in order to elide obsolete
    1140              :                 // keys.
    1141              :                 disableElisionOnlyCompactions bool
    1142              : 
    1143              :                 // disableLazyCombinedIteration is a private option used by the
    1144              :                 // metamorphic tests to test equivalence between lazy-combined iteration
    1145              :                 // and constructing the range-key iterator upfront. It's a private
    1146              :                 // option to avoid littering the public interface with options that we
    1147              :                 // do not want to allow users to actually configure.
    1148              :                 disableLazyCombinedIteration bool
    1149              : 
    1150              :                 // testingAlwaysWaitForCleanup is set by some tests to force waiting for
    1151              :                 // obsolete file deletion (to make events deterministic).
    1152              :                 testingAlwaysWaitForCleanup bool
    1153              : 
    1154              :                 // fsCloser holds a closer that should be invoked after a DB using these
    1155              :                 // Options is closed. This is used to automatically stop the
    1156              :                 // long-running goroutine associated with the disk-health-checking FS.
    1157              :                 // See the initialization of FS in EnsureDefaults. Note that care has
    1158              :                 // been taken to ensure that it is still safe to continue using the FS
    1159              :                 // after this closer has been invoked. However, if write operations
    1160              :                 // against the FS are made after the DB is closed, the FS may leak a
    1161              :                 // goroutine indefinitely.
    1162              :                 fsCloser io.Closer
    1163              :         }
    1164              : }
    1165              : 
    1166              : // ValueSeparationPolicy controls the policy for separating values into
    1167              : // external blob files.
    1168              : type ValueSeparationPolicy struct {
    1169              :         // Enabled controls whether value separation is enabled.
    1170              :         Enabled bool
    1171              :         // MinimumSize imposes a lower bound on the size of values that can be
    1172              :         // separated into a blob file. Values smaller than this are always written
    1173              :         // to the sstable (but may still be written to a value block within the
    1174              :         // sstable).
    1175              :         //
    1176              :         // MinimumSize must be > 0.
    1177              :         MinimumSize int
    1178              :         // MaxBlobReferenceDepth limits the number of potentially overlapping (in
    1179              :         // the keyspace) blob files that can be referenced by a single sstable. If a
    1180              :         // compaction may produce an output sstable referencing more than this many
    1181              :         // overlapping blob files, the compaction will instead rewrite referenced
    1182              :         // values into new blob files.
    1183              :         //
    1184              :         // MaxBlobReferenceDepth must be > 0.
    1185              :         MaxBlobReferenceDepth int
    1186              :         // RewriteMinimumAge specifies how old a blob file must be in order for it
    1187              :         // to be eligible for a rewrite that reclaims disk space. Lower values
    1188              :         // reduce space amplification at the cost of write amplification
    1189              :         RewriteMinimumAge time.Duration
    1190              :         // TargetGarbageRatio is a value in the range [0, 1.0] and configures how
    1191              :         // aggressively blob files should be written in order to reduce space
    1192              :         // amplification induced by value separation. As compactions rewrite blob
    1193              :         // files, data may be duplicated.  Older blob files containing the
    1194              :         // duplicated data may need to remain because other sstables are referencing
    1195              :         // other values contained in the same file.
    1196              :         //
    1197              :         // The DB can rewrite these blob files in place in order to reduce this
    1198              :         // space amplification, but this incurs write amplification. This option
    1199              :         // configures how much garbage may accrue before the DB will attempt to
    1200              :         // rewrite blob files to reduce it. A value of 0.20 indicates that once 20%
    1201              :         // of values in blob files are unreferenced, the DB should attempt to
    1202              :         // rewrite blob files to reclaim disk space.
    1203              :         //
    1204              :         // A value of 1.0 indicates that the DB should never attempt to rewrite blob
    1205              :         // files.
    1206              :         TargetGarbageRatio float64
    1207              : }
    1208              : 
    1209              : // SpanPolicy contains policies that can vary by key range. The zero value is
    1210              : // the default value.
    1211              : type SpanPolicy struct {
    1212              :         // Prefer a faster compression algorithm for the keys in this span.
    1213              :         //
    1214              :         // This is useful for keys that are frequently read or written but which don't
    1215              :         // amount to a significant amount of space.
    1216              :         PreferFastCompression bool
    1217              : 
    1218              :         // DisableValueSeparationBySuffix disables discriminating KVs depending on
    1219              :         // suffix.
    1220              :         //
    1221              :         // Among a set of keys with the same prefix, Pebble's default heuristics
    1222              :         // optimize access to the KV with the smallest suffix. This is useful for MVCC
    1223              :         // keys (where the smallest suffix is the latest version), but should be
    1224              :         // disabled for keys where the suffix does not correspond to a version.
    1225              :         DisableValueSeparationBySuffix bool
    1226              : 
    1227              :         // ValueStoragePolicy is a hint used to determine where to store the values
    1228              :         // for KVs.
    1229              :         ValueStoragePolicy ValueStoragePolicy
    1230              : }
    1231              : 
    1232              : // String returns a string representation of the SpanPolicy.
    1233            0 : func (p SpanPolicy) String() string {
    1234            0 :         var sb strings.Builder
    1235            0 :         if p.PreferFastCompression {
    1236            0 :                 sb.WriteString("fast-compression,")
    1237            0 :         }
    1238            0 :         if p.DisableValueSeparationBySuffix {
    1239            0 :                 sb.WriteString("disable-value-separation-by-suffix,")
    1240            0 :         }
    1241            0 :         switch p.ValueStoragePolicy {
    1242            0 :         case ValueStorageLowReadLatency:
    1243            0 :                 sb.WriteString("low-read-latency,")
    1244            0 :         case ValueStorageLatencyTolerant:
    1245            0 :                 sb.WriteString("latency-tolerant,")
    1246              :         }
    1247            0 :         return strings.TrimSuffix(sb.String(), ",")
    1248              : }
    1249              : 
    1250              : // ValueStoragePolicy is a hint used to determine where to store the values for
    1251              : // KVs.
    1252              : type ValueStoragePolicy uint8
    1253              : 
    1254              : const (
    1255              :         // ValueStorageDefault is the default value; Pebble will respect global
    1256              :         // configuration for value blocks and value separation.
    1257              :         ValueStorageDefault ValueStoragePolicy = iota
    1258              : 
    1259              :         // ValueStorageLowReadLatency indicates Pebble should prefer storing values
    1260              :         // in-place.
    1261              :         ValueStorageLowReadLatency
    1262              : 
    1263              :         // ValueStorageLatencyTolerant indicates value retrieval can tolerate
    1264              :         // additional latency, so Pebble should aggressively prefer storing values
    1265              :         // separately if it can reduce write amplification.
    1266              :         //
    1267              :         // If the global Options' enable value separation, Pebble may choose to
    1268              :         // separate values under the LatencyTolerant policy even if they do not meet
    1269              :         // the minimum size threshold of the global Options' ValueSeparationPolicy.
    1270              :         ValueStorageLatencyTolerant
    1271              : )
    1272              : 
    1273              : // SpanPolicyFunc is used to determine the SpanPolicy for a key region.
    1274              : //
    1275              : // The returned policy is valid from the start key until (and not including) the
    1276              : // end key.
    1277              : //
    1278              : // A flush or compaction will call this function once for the first key to be
    1279              : // output. If the compaction reaches the end key, the current output sst is
    1280              : // finished and the function is called again.
    1281              : //
    1282              : // The end key can be empty, in which case the policy is valid for the entire
    1283              : // keyspace after startKey.
    1284              : type SpanPolicyFunc func(startKey []byte) (policy SpanPolicy, endKey []byte, err error)
    1285              : 
    1286              : // SpanAndPolicy defines a key range and the policy to apply to it.
    1287              : type SpanAndPolicy struct {
    1288              :         KeyRange KeyRange
    1289              :         Policy   SpanPolicy
    1290              : }
    1291              : 
    1292              : // MakeStaticSpanPolicyFunc returns a SpanPolicyFunc that applies a given policy
    1293              : // to the given span (and the default policy outside the span). The supplied
    1294              : // policies must be non-overlapping in key range.
    1295            0 : func MakeStaticSpanPolicyFunc(cmp base.Compare, inputPolicies ...SpanAndPolicy) SpanPolicyFunc {
    1296            0 :         // Collect all the boundaries of the input policies, sort and deduplicate them.
    1297            0 :         uniqueKeys := make([][]byte, 0, 2*len(inputPolicies))
    1298            0 :         for i := range inputPolicies {
    1299            0 :                 uniqueKeys = append(uniqueKeys, inputPolicies[i].KeyRange.Start)
    1300            0 :                 uniqueKeys = append(uniqueKeys, inputPolicies[i].KeyRange.End)
    1301            0 :         }
    1302            0 :         slices.SortFunc(uniqueKeys, cmp)
    1303            0 :         uniqueKeys = slices.CompactFunc(uniqueKeys, func(a, b []byte) bool { return cmp(a, b) == 0 })
    1304              : 
    1305              :         // Create a list of policies.
    1306            0 :         policies := make([]SpanPolicy, len(uniqueKeys)-1)
    1307            0 :         for _, p := range inputPolicies {
    1308            0 :                 idx, _ := slices.BinarySearchFunc(uniqueKeys, p.KeyRange.Start, cmp)
    1309            0 :                 policies[idx] = p.Policy
    1310            0 :         }
    1311              : 
    1312            0 :         return func(startKey []byte) (_ SpanPolicy, endKey []byte, _ error) {
    1313            0 :                 // Find the policy that applies to the start key.
    1314            0 :                 idx, eq := slices.BinarySearchFunc(uniqueKeys, startKey, cmp)
    1315            0 :                 switch idx {
    1316            0 :                 case len(uniqueKeys):
    1317            0 :                         // The start key is after the last policy.
    1318            0 :                         return SpanPolicy{}, nil, nil
    1319            0 :                 case len(uniqueKeys) - 1:
    1320            0 :                         if eq {
    1321            0 :                                 // The start key is exactly the start of the last policy.
    1322            0 :                                 return SpanPolicy{}, nil, nil
    1323            0 :                         }
    1324            0 :                 case 0:
    1325            0 :                         if !eq {
    1326            0 :                                 // The start key is before the first policy.
    1327            0 :                                 return SpanPolicy{}, uniqueKeys[0], nil
    1328            0 :                         }
    1329              :                 }
    1330            0 :                 if eq {
    1331            0 :                         // The start key is exactly the start of this policy.
    1332            0 :                         return policies[idx], uniqueKeys[idx+1], nil
    1333            0 :                 }
    1334              :                 // The start key is between two policies.
    1335            0 :                 return policies[idx-1], uniqueKeys[idx], nil
    1336              :         }
    1337              : }
    1338              : 
    1339              : // WALFailoverOptions configures the WAL failover mechanics to use during
    1340              : // transient write unavailability on the primary WAL volume.
    1341              : type WALFailoverOptions struct {
    1342              :         // Secondary indicates the secondary directory and VFS to use in the event a
    1343              :         // write to the primary WAL stalls. The Lock field may be set during setup to
    1344              :         // preacquire the lock on the secondary directory.
    1345              :         Secondary wal.Dir
    1346              : 
    1347              :         // FailoverOptions provides configuration of the thresholds and intervals
    1348              :         // involved in WAL failover. If any of its fields are left unspecified,
    1349              :         // reasonable defaults will be used.
    1350              :         wal.FailoverOptions
    1351              : }
    1352              : 
    1353              : // ReadaheadConfig controls the use of read-ahead.
    1354              : type ReadaheadConfig = objstorageprovider.ReadaheadConfig
    1355              : 
    1356              : // JemallocSizeClasses exports sstable.JemallocSizeClasses.
    1357              : var JemallocSizeClasses = sstable.JemallocSizeClasses
    1358              : 
    1359              : // DebugCheckLevels calls CheckLevels on the provided database.
    1360              : // It may be set in the DebugCheck field of Options to check
    1361              : // level invariants whenever a new version is installed.
    1362            1 : func DebugCheckLevels(db *DB) error {
    1363            1 :         return db.CheckLevels(nil)
    1364            1 : }
    1365              : 
    1366              : // DBCompressionSettings contains compression settings for the entire store. It
    1367              : // defines compression profiles for each LSM level.
    1368              : type DBCompressionSettings struct {
    1369              :         Name   string
    1370              :         Levels [manifest.NumLevels]*block.CompressionProfile
    1371              : }
    1372              : 
    1373              : // Predefined compression settings.
    1374              : var (
    1375              :         DBCompressionNone     = UniformDBCompressionSettings(block.NoCompression)
    1376              :         DBCompressionFastest  = UniformDBCompressionSettings(block.FastestCompression)
    1377            1 :         DBCompressionBalanced = func() DBCompressionSettings {
    1378            1 :                 cs := DBCompressionSettings{Name: "Balanced"}
    1379            1 :                 for i := 0; i < manifest.NumLevels-2; i++ {
    1380            1 :                         cs.Levels[i] = block.FastestCompression
    1381            1 :                 }
    1382            1 :                 cs.Levels[manifest.NumLevels-2] = block.FastCompression     // Zstd1 for value blocks.
    1383            1 :                 cs.Levels[manifest.NumLevels-1] = block.BalancedCompression // Zstd1 for data and value blocks.
    1384            1 :                 return cs
    1385              :         }()
    1386            1 :         DBCompressionGood = func() DBCompressionSettings {
    1387            1 :                 cs := DBCompressionSettings{Name: "Good"}
    1388            1 :                 for i := 0; i < manifest.NumLevels-2; i++ {
    1389            1 :                         cs.Levels[i] = block.FastestCompression
    1390            1 :                 }
    1391            1 :                 cs.Levels[manifest.NumLevels-2] = block.BalancedCompression // Zstd1 for data and value blocks.
    1392            1 :                 cs.Levels[manifest.NumLevels-1] = block.GoodCompression     // Zstd3 for data and value blocks.
    1393            1 :                 return cs
    1394              :         }()
    1395              : )
    1396              : 
    1397              : // UniformDBCompressionSettings returns a DBCompressionSettings which uses the
    1398              : // same compression profile on all LSM levels.
    1399            1 : func UniformDBCompressionSettings(profile *block.CompressionProfile) DBCompressionSettings {
    1400            1 :         cs := DBCompressionSettings{Name: profile.Name}
    1401            1 :         for i := range cs.Levels {
    1402            1 :                 cs.Levels[i] = profile
    1403            1 :         }
    1404            1 :         return cs
    1405              : }
    1406              : 
    1407              : // ApplyCompressionSettings sets the Compression field in each LevelOptions to
    1408              : // call the given function and return the compression profile for that level.
    1409            0 : func (o *Options) ApplyCompressionSettings(csFn func() DBCompressionSettings) {
    1410            0 :         for i := range o.Levels {
    1411            0 :                 levelIdx := i
    1412            0 :                 o.Levels[i].Compression = func() *block.CompressionProfile {
    1413            0 :                         return csFn().Levels[levelIdx]
    1414            0 :                 }
    1415              :         }
    1416              : }
    1417              : 
    1418              : // EnsureDefaults ensures that the default values for all options are set if a
    1419              : // valid value was not already specified.
    1420            1 : func (o *Options) EnsureDefaults() {
    1421            1 :         if o.Cache == nil && o.CacheSize == 0 {
    1422            0 :                 o.CacheSize = cacheDefaultSize
    1423            0 :         }
    1424            1 :         o.Comparer = o.Comparer.EnsureDefaults()
    1425            1 : 
    1426            1 :         if o.BytesPerSync <= 0 {
    1427            0 :                 o.BytesPerSync = 512 << 10 // 512 KB
    1428            0 :         }
    1429            1 :         if o.Cleaner == nil {
    1430            0 :                 o.Cleaner = DeleteCleaner{}
    1431            0 :         }
    1432              : 
    1433            1 :         if o.FreeSpaceThresholdBytes == 0 {
    1434            0 :                 o.FreeSpaceThresholdBytes = 16 << 30 // 16 GB
    1435            0 :         }
    1436              : 
    1437            1 :         if o.FreeSpaceTimeframe == 0 {
    1438            0 :                 o.FreeSpaceTimeframe = 10 * time.Second
    1439            0 :         }
    1440              : 
    1441            1 :         if o.ObsoleteBytesMaxRatio == 0 {
    1442            0 :                 o.ObsoleteBytesMaxRatio = 0.20
    1443            0 :         }
    1444              : 
    1445            1 :         if o.ObsoleteBytesTimeframe == 0 {
    1446            0 :                 o.ObsoleteBytesTimeframe = 300 * time.Second
    1447            0 :         }
    1448              : 
    1449            1 :         if o.Experimental.DisableIngestAsFlushable == nil {
    1450            1 :                 o.Experimental.DisableIngestAsFlushable = func() bool { return false }
    1451              :         }
    1452            1 :         if o.Experimental.L0CompactionConcurrency <= 0 {
    1453            0 :                 o.Experimental.L0CompactionConcurrency = 10
    1454            0 :         }
    1455            1 :         if o.Experimental.CompactionDebtConcurrency <= 0 {
    1456            0 :                 o.Experimental.CompactionDebtConcurrency = 1 << 30 // 1 GB
    1457            0 :         }
    1458            1 :         if o.Experimental.CompactionGarbageFractionForMaxConcurrency == nil {
    1459            0 :                 // When 40% of the DB is garbage, the compaction concurrency is at the
    1460            0 :                 // maximum permitted.
    1461            0 :                 o.Experimental.CompactionGarbageFractionForMaxConcurrency = func() float64 { return 0.4 }
    1462              :         }
    1463            1 :         if o.Experimental.ValueSeparationPolicy == nil {
    1464            0 :                 o.Experimental.ValueSeparationPolicy = func() ValueSeparationPolicy {
    1465            0 :                         return ValueSeparationPolicy{Enabled: false}
    1466            0 :                 }
    1467              :         }
    1468            1 :         if o.KeySchema == "" && len(o.KeySchemas) == 0 {
    1469            0 :                 ks := colblk.DefaultKeySchema(o.Comparer, 16 /* bundleSize */)
    1470            0 :                 o.KeySchema = ks.Name
    1471            0 :                 o.KeySchemas = sstable.MakeKeySchemas(&ks)
    1472            0 :         }
    1473            1 :         if o.L0CompactionThreshold <= 0 {
    1474            0 :                 o.L0CompactionThreshold = 4
    1475            0 :         }
    1476            1 :         if o.L0CompactionFileThreshold <= 0 {
    1477            0 :                 // Some justification for the default of 500:
    1478            0 :                 // Why not smaller?:
    1479            0 :                 // - The default target file size for L0 is 2MB, so 500 files is <= 1GB
    1480            0 :                 //   of data. At observed compaction speeds of > 20MB/s, L0 can be
    1481            0 :                 //   cleared of all files in < 1min, so this backlog is not huge.
    1482            0 :                 // - 500 files is low overhead for instantiating L0 sublevels from
    1483            0 :                 //   scratch.
    1484            0 :                 // - Lower values were observed to cause excessive and inefficient
    1485            0 :                 //   compactions out of L0 in a TPCC import benchmark.
    1486            0 :                 // Why not larger?:
    1487            0 :                 // - More than 1min to compact everything out of L0.
    1488            0 :                 // - CockroachDB's admission control system uses a threshold of 1000
    1489            0 :                 //   files to start throttling writes to Pebble. Using 500 here gives
    1490            0 :                 //   us headroom between when Pebble should start compacting L0 and
    1491            0 :                 //   when the admission control threshold is reached.
    1492            0 :                 //
    1493            0 :                 // We can revisit this default in the future based on better
    1494            0 :                 // experimental understanding.
    1495            0 :                 //
    1496            0 :                 // TODO(jackson): Experiment with slightly lower thresholds [or higher
    1497            0 :                 // admission control thresholds] to see whether a higher L0 score at the
    1498            0 :                 // threshold (currently 2.0) is necessary for some workloads to avoid
    1499            0 :                 // starving L0 in favor of lower-level compactions.
    1500            0 :                 o.L0CompactionFileThreshold = 500
    1501            0 :         }
    1502            1 :         if o.L0StopWritesThreshold <= 0 {
    1503            0 :                 o.L0StopWritesThreshold = 12
    1504            0 :         }
    1505            1 :         if o.LBaseMaxBytes <= 0 {
    1506            0 :                 o.LBaseMaxBytes = 64 << 20 // 64 MB
    1507            0 :         }
    1508            1 :         if o.TargetFileSizes[0] <= 0 {
    1509            0 :                 o.TargetFileSizes[0] = 2 << 20 // 2 MB
    1510            0 :         }
    1511            1 :         for i := 1; i < len(o.TargetFileSizes); i++ {
    1512            1 :                 if o.TargetFileSizes[i] <= 0 {
    1513            0 :                         o.TargetFileSizes[i] = o.TargetFileSizes[i-1] * 2
    1514            0 :                 }
    1515              :         }
    1516            1 :         o.Levels[0].EnsureL0Defaults()
    1517            1 :         for i := 1; i < len(o.Levels); i++ {
    1518            1 :                 o.Levels[i].EnsureL1PlusDefaults(&o.Levels[i-1])
    1519            1 :         }
    1520            1 :         if o.Logger == nil {
    1521            1 :                 o.Logger = DefaultLogger
    1522            1 :         }
    1523            1 :         if o.EventListener == nil {
    1524            1 :                 o.EventListener = &EventListener{}
    1525            1 :         }
    1526            1 :         o.EventListener.EnsureDefaults(o.Logger)
    1527            1 :         if o.MaxManifestFileSize == 0 {
    1528            0 :                 o.MaxManifestFileSize = 128 << 20 // 128 MB
    1529            0 :         }
    1530            1 :         if o.MaxOpenFiles == 0 {
    1531            0 :                 o.MaxOpenFiles = 1000
    1532            0 :         }
    1533            1 :         if o.MemTableSize <= 0 {
    1534            0 :                 o.MemTableSize = 4 << 20 // 4 MB
    1535            0 :         }
    1536            1 :         if o.MemTableStopWritesThreshold <= 0 {
    1537            0 :                 o.MemTableStopWritesThreshold = 2
    1538            0 :         }
    1539            1 :         if o.Merger == nil {
    1540            0 :                 o.Merger = DefaultMerger
    1541            0 :         }
    1542            1 :         if o.CompactionConcurrencyRange == nil {
    1543            0 :                 o.CompactionConcurrencyRange = func() (int, int) { return 1, 1 }
    1544              :         }
    1545            1 :         if o.MaxConcurrentDownloads == nil {
    1546            0 :                 o.MaxConcurrentDownloads = func() int { return 1 }
    1547              :         }
    1548            1 :         if o.NumPrevManifest <= 0 {
    1549            1 :                 o.NumPrevManifest = 1
    1550            1 :         }
    1551              : 
    1552            1 :         if o.FormatMajorVersion == FormatDefault {
    1553            0 :                 o.FormatMajorVersion = FormatMinSupported
    1554            0 :                 if o.Experimental.CreateOnShared != remote.CreateOnSharedNone {
    1555            0 :                         o.FormatMajorVersion = FormatMinForSharedObjects
    1556            0 :                 }
    1557              :         }
    1558              : 
    1559            1 :         if o.FS == nil {
    1560            0 :                 o.WithFSDefaults()
    1561            0 :         }
    1562            1 :         if o.FlushSplitBytes <= 0 {
    1563            0 :                 o.FlushSplitBytes = 2 * o.TargetFileSizes[0]
    1564            0 :         }
    1565            1 :         if o.WALFailover != nil {
    1566            1 :                 o.WALFailover.FailoverOptions.EnsureDefaults()
    1567            1 :         }
    1568            1 :         if o.Experimental.LevelMultiplier <= 0 {
    1569            1 :                 o.Experimental.LevelMultiplier = defaultLevelMultiplier
    1570            1 :         }
    1571            1 :         if o.Experimental.ReadCompactionRate == 0 {
    1572            0 :                 o.Experimental.ReadCompactionRate = 16000
    1573            0 :         }
    1574            1 :         if o.Experimental.ReadSamplingMultiplier == 0 {
    1575            0 :                 o.Experimental.ReadSamplingMultiplier = 1 << 4
    1576            0 :         }
    1577            1 :         if o.Experimental.NumDeletionsThreshold == 0 {
    1578            0 :                 o.Experimental.NumDeletionsThreshold = sstable.DefaultNumDeletionsThreshold
    1579            0 :         }
    1580            1 :         if o.Experimental.DeletionSizeRatioThreshold == 0 {
    1581            0 :                 o.Experimental.DeletionSizeRatioThreshold = sstable.DefaultDeletionSizeRatioThreshold
    1582            0 :         }
    1583            1 :         if o.Experimental.TombstoneDenseCompactionThreshold == 0 {
    1584            0 :                 o.Experimental.TombstoneDenseCompactionThreshold = 0.10
    1585            0 :         }
    1586            1 :         if o.Experimental.FileCacheShards <= 0 {
    1587            0 :                 o.Experimental.FileCacheShards = runtime.GOMAXPROCS(0)
    1588            0 :         }
    1589            1 :         if o.Experimental.MultiLevelCompactionHeuristic == nil {
    1590            0 :                 o.Experimental.MultiLevelCompactionHeuristic = OptionWriteAmpHeuristic
    1591            0 :         }
    1592            1 :         if o.Experimental.SpanPolicyFunc == nil {
    1593            1 :                 o.Experimental.SpanPolicyFunc = func(startKey []byte) (SpanPolicy, []byte, error) { return SpanPolicy{}, nil, nil }
    1594              :         }
    1595              :         // TODO(jackson): Enable value separation by default once we have confidence
    1596              :         // in a default policy.
    1597              : 
    1598            1 :         o.initMaps()
    1599              : }
    1600              : 
    1601              : // TargetFileSize computes the target file size for the given output level.
    1602            1 : func (o *Options) TargetFileSize(outputLevel int, baseLevel int) int64 {
    1603            1 :         if outputLevel == 0 {
    1604            1 :                 return o.TargetFileSizes[0]
    1605            1 :         }
    1606            1 :         if baseLevel > outputLevel {
    1607            0 :                 panic(fmt.Sprintf("invalid base level %d (output level %d)", baseLevel, outputLevel))
    1608              :         }
    1609            1 :         return o.TargetFileSizes[outputLevel-baseLevel+1]
    1610              : }
    1611              : 
    1612              : // DefaultOptions returns a new Options object with the default values set.
    1613            0 : func DefaultOptions() *Options {
    1614            0 :         o := &Options{}
    1615            0 :         o.EnsureDefaults()
    1616            0 :         return o
    1617            0 : }
    1618              : 
    1619              : // WithFSDefaults configures the Options to wrap the configured filesystem with
    1620              : // the default virtual file system middleware, like disk-health checking.
    1621            1 : func (o *Options) WithFSDefaults() {
    1622            1 :         if o.FS == nil {
    1623            0 :                 o.FS = vfs.Default
    1624            0 :         }
    1625            1 :         o.FS, o.private.fsCloser = vfs.WithDiskHealthChecks(o.FS, 5*time.Second, nil,
    1626            1 :                 func(info vfs.DiskSlowInfo) {
    1627            0 :                         o.EventListener.DiskSlow(info)
    1628            0 :                 })
    1629              : }
    1630              : 
    1631              : // AddEventListener adds the provided event listener to the Options, in addition
    1632              : // to any existing event listener.
    1633            0 : func (o *Options) AddEventListener(l EventListener) {
    1634            0 :         if o.EventListener != nil {
    1635            0 :                 l = TeeEventListener(l, *o.EventListener)
    1636            0 :         }
    1637            0 :         o.EventListener = &l
    1638              : }
    1639              : 
    1640              : // initMaps initializes the Comparers, Filters, and Mergers maps.
    1641            1 : func (o *Options) initMaps() {
    1642            1 :         for i := range o.Levels {
    1643            1 :                 l := &o.Levels[i]
    1644            1 :                 if l.FilterPolicy != NoFilterPolicy {
    1645            1 :                         if o.Filters == nil {
    1646            1 :                                 o.Filters = make(map[string]FilterPolicy)
    1647            1 :                         }
    1648            1 :                         name := l.FilterPolicy.Name()
    1649            1 :                         if _, ok := o.Filters[name]; !ok {
    1650            1 :                                 o.Filters[name] = l.FilterPolicy
    1651            1 :                         }
    1652              :                 }
    1653              :         }
    1654              : }
    1655              : 
    1656              : // Clone creates a shallow-copy of the supplied options.
    1657            1 : func (o *Options) Clone() *Options {
    1658            1 :         if o == nil {
    1659            0 :                 return &Options{}
    1660            0 :         }
    1661            1 :         n := *o
    1662            1 :         if o.WALFailover != nil {
    1663            1 :                 c := *o.WALFailover
    1664            1 :                 n.WALFailover = &c
    1665            1 :         }
    1666            1 :         return &n
    1667              : }
    1668              : 
    1669            1 : func (o *Options) String() string {
    1670            1 :         var buf bytes.Buffer
    1671            1 : 
    1672            1 :         cacheSize := o.CacheSize
    1673            1 :         if o.Cache != nil {
    1674            1 :                 cacheSize = o.Cache.MaxSize()
    1675            1 :         }
    1676              : 
    1677            1 :         fmt.Fprintf(&buf, "[Version]\n")
    1678            1 :         fmt.Fprintf(&buf, "  pebble_version=0.1\n")
    1679            1 :         fmt.Fprintf(&buf, "\n")
    1680            1 :         fmt.Fprintf(&buf, "[Options]\n")
    1681            1 :         fmt.Fprintf(&buf, "  bytes_per_sync=%d\n", o.BytesPerSync)
    1682            1 :         fmt.Fprintf(&buf, "  cache_size=%d\n", cacheSize)
    1683            1 :         fmt.Fprintf(&buf, "  cleaner=%s\n", o.Cleaner)
    1684            1 :         fmt.Fprintf(&buf, "  compaction_debt_concurrency=%d\n", o.Experimental.CompactionDebtConcurrency)
    1685            1 :         fmt.Fprintf(&buf, "  compaction_garbage_fraction_for_max_concurrency=%.2f\n",
    1686            1 :                 o.Experimental.CompactionGarbageFractionForMaxConcurrency())
    1687            1 :         fmt.Fprintf(&buf, "  comparer=%s\n", o.Comparer.Name)
    1688            1 :         fmt.Fprintf(&buf, "  disable_wal=%t\n", o.DisableWAL)
    1689            1 :         if o.Experimental.DisableIngestAsFlushable != nil && o.Experimental.DisableIngestAsFlushable() {
    1690            1 :                 fmt.Fprintf(&buf, "  disable_ingest_as_flushable=%t\n", true)
    1691            1 :         }
    1692            1 :         fmt.Fprintf(&buf, "  flush_delay_delete_range=%s\n", o.FlushDelayDeleteRange)
    1693            1 :         fmt.Fprintf(&buf, "  flush_delay_range_key=%s\n", o.FlushDelayRangeKey)
    1694            1 :         fmt.Fprintf(&buf, "  flush_split_bytes=%d\n", o.FlushSplitBytes)
    1695            1 :         fmt.Fprintf(&buf, "  format_major_version=%d\n", o.FormatMajorVersion)
    1696            1 :         fmt.Fprintf(&buf, "  key_schema=%s\n", o.KeySchema)
    1697            1 :         fmt.Fprintf(&buf, "  l0_compaction_concurrency=%d\n", o.Experimental.L0CompactionConcurrency)
    1698            1 :         fmt.Fprintf(&buf, "  l0_compaction_file_threshold=%d\n", o.L0CompactionFileThreshold)
    1699            1 :         fmt.Fprintf(&buf, "  l0_compaction_threshold=%d\n", o.L0CompactionThreshold)
    1700            1 :         fmt.Fprintf(&buf, "  l0_stop_writes_threshold=%d\n", o.L0StopWritesThreshold)
    1701            1 :         fmt.Fprintf(&buf, "  lbase_max_bytes=%d\n", o.LBaseMaxBytes)
    1702            1 :         if o.Experimental.LevelMultiplier != defaultLevelMultiplier {
    1703            1 :                 fmt.Fprintf(&buf, "  level_multiplier=%d\n", o.Experimental.LevelMultiplier)
    1704            1 :         }
    1705            1 :         lower, upper := o.CompactionConcurrencyRange()
    1706            1 :         fmt.Fprintf(&buf, "  concurrent_compactions=%d\n", lower)
    1707            1 :         fmt.Fprintf(&buf, "  max_concurrent_compactions=%d\n", upper)
    1708            1 :         fmt.Fprintf(&buf, "  max_concurrent_downloads=%d\n", o.MaxConcurrentDownloads())
    1709            1 :         fmt.Fprintf(&buf, "  max_manifest_file_size=%d\n", o.MaxManifestFileSize)
    1710            1 :         fmt.Fprintf(&buf, "  max_open_files=%d\n", o.MaxOpenFiles)
    1711            1 :         fmt.Fprintf(&buf, "  mem_table_size=%d\n", o.MemTableSize)
    1712            1 :         fmt.Fprintf(&buf, "  mem_table_stop_writes_threshold=%d\n", o.MemTableStopWritesThreshold)
    1713            1 :         fmt.Fprintf(&buf, "  min_deletion_rate=%d\n", o.TargetByteDeletionRate)
    1714            1 :         fmt.Fprintf(&buf, "  free_space_threshold_bytes=%d\n", o.FreeSpaceThresholdBytes)
    1715            1 :         fmt.Fprintf(&buf, "  free_space_timeframe=%s\n", o.FreeSpaceTimeframe.String())
    1716            1 :         fmt.Fprintf(&buf, "  obsolete_bytes_max_ratio=%f\n", o.ObsoleteBytesMaxRatio)
    1717            1 :         fmt.Fprintf(&buf, "  obsolete_bytes_timeframe=%s\n", o.ObsoleteBytesTimeframe.String())
    1718            1 :         fmt.Fprintf(&buf, "  merger=%s\n", o.Merger.Name)
    1719            1 :         if o.Experimental.MultiLevelCompactionHeuristic != nil {
    1720            1 :                 fmt.Fprintf(&buf, "  multilevel_compaction_heuristic=%s\n", o.Experimental.MultiLevelCompactionHeuristic().String())
    1721            1 :         }
    1722            1 :         fmt.Fprintf(&buf, "  read_compaction_rate=%d\n", o.Experimental.ReadCompactionRate)
    1723            1 :         fmt.Fprintf(&buf, "  read_sampling_multiplier=%d\n", o.Experimental.ReadSamplingMultiplier)
    1724            1 :         fmt.Fprintf(&buf, "  num_deletions_threshold=%d\n", o.Experimental.NumDeletionsThreshold)
    1725            1 :         fmt.Fprintf(&buf, "  deletion_size_ratio_threshold=%f\n", o.Experimental.DeletionSizeRatioThreshold)
    1726            1 :         fmt.Fprintf(&buf, "  tombstone_dense_compaction_threshold=%f\n", o.Experimental.TombstoneDenseCompactionThreshold)
    1727            1 :         // We no longer care about strict_wal_tail, but set it to true in case an
    1728            1 :         // older version reads the options.
    1729            1 :         fmt.Fprintf(&buf, "  strict_wal_tail=%t\n", true)
    1730            1 :         fmt.Fprintf(&buf, "  table_cache_shards=%d\n", o.Experimental.FileCacheShards)
    1731            1 :         fmt.Fprintf(&buf, "  validate_on_ingest=%t\n", o.Experimental.ValidateOnIngest)
    1732            1 :         fmt.Fprintf(&buf, "  wal_dir=%s\n", o.WALDir)
    1733            1 :         fmt.Fprintf(&buf, "  wal_bytes_per_sync=%d\n", o.WALBytesPerSync)
    1734            1 :         fmt.Fprintf(&buf, "  secondary_cache_size_bytes=%d\n", o.Experimental.SecondaryCacheSizeBytes)
    1735            1 :         fmt.Fprintf(&buf, "  create_on_shared=%d\n", o.Experimental.CreateOnShared)
    1736            1 : 
    1737            1 :         // Private options.
    1738            1 :         //
    1739            1 :         // These options are only encoded if true, because we do not want them to
    1740            1 :         // appear in production serialized Options files, since they're testing-only
    1741            1 :         // options. They're only serialized when true, which still ensures that the
    1742            1 :         // metamorphic tests may propagate them to subprocesses.
    1743            1 :         if o.private.disableDeleteOnlyCompactions {
    1744            1 :                 fmt.Fprintln(&buf, "  disable_delete_only_compactions=true")
    1745            1 :         }
    1746            1 :         if o.private.disableElisionOnlyCompactions {
    1747            1 :                 fmt.Fprintln(&buf, "  disable_elision_only_compactions=true")
    1748            1 :         }
    1749            1 :         if o.private.disableLazyCombinedIteration {
    1750            1 :                 fmt.Fprintln(&buf, "  disable_lazy_combined_iteration=true")
    1751            1 :         }
    1752              : 
    1753            1 :         if o.Experimental.ValueSeparationPolicy != nil {
    1754            1 :                 policy := o.Experimental.ValueSeparationPolicy()
    1755            1 :                 if policy.Enabled {
    1756            1 :                         fmt.Fprintln(&buf)
    1757            1 :                         fmt.Fprintln(&buf, "[Value Separation]")
    1758            1 :                         fmt.Fprintf(&buf, "  enabled=%t\n", policy.Enabled)
    1759            1 :                         fmt.Fprintf(&buf, "  minimum_size=%d\n", policy.MinimumSize)
    1760            1 :                         fmt.Fprintf(&buf, "  max_blob_reference_depth=%d\n", policy.MaxBlobReferenceDepth)
    1761            1 :                         fmt.Fprintf(&buf, "  rewrite_minimum_age=%s\n", policy.RewriteMinimumAge)
    1762            1 :                         fmt.Fprintf(&buf, "  target_garbage_ratio=%.2f\n", policy.TargetGarbageRatio)
    1763            1 :                 }
    1764              :         }
    1765              : 
    1766            1 :         if o.WALFailover != nil {
    1767            1 :                 unhealthyThreshold, _ := o.WALFailover.FailoverOptions.UnhealthyOperationLatencyThreshold()
    1768            1 :                 fmt.Fprintf(&buf, "\n")
    1769            1 :                 fmt.Fprintf(&buf, "[WAL Failover]\n")
    1770            1 :                 fmt.Fprintf(&buf, "  secondary_dir=%s\n", o.WALFailover.Secondary.Dirname)
    1771            1 :                 fmt.Fprintf(&buf, "  primary_dir_probe_interval=%s\n", o.WALFailover.FailoverOptions.PrimaryDirProbeInterval)
    1772            1 :                 fmt.Fprintf(&buf, "  healthy_probe_latency_threshold=%s\n", o.WALFailover.FailoverOptions.HealthyProbeLatencyThreshold)
    1773            1 :                 fmt.Fprintf(&buf, "  healthy_interval=%s\n", o.WALFailover.FailoverOptions.HealthyInterval)
    1774            1 :                 fmt.Fprintf(&buf, "  unhealthy_sampling_interval=%s\n", o.WALFailover.FailoverOptions.UnhealthySamplingInterval)
    1775            1 :                 fmt.Fprintf(&buf, "  unhealthy_operation_latency_threshold=%s\n", unhealthyThreshold)
    1776            1 :                 fmt.Fprintf(&buf, "  elevated_write_stall_threshold_lag=%s\n", o.WALFailover.FailoverOptions.ElevatedWriteStallThresholdLag)
    1777            1 :         }
    1778              : 
    1779            1 :         for i := range o.Levels {
    1780            1 :                 l := &o.Levels[i]
    1781            1 :                 fmt.Fprintf(&buf, "\n")
    1782            1 :                 fmt.Fprintf(&buf, "[Level \"%d\"]\n", i)
    1783            1 :                 fmt.Fprintf(&buf, "  block_restart_interval=%d\n", l.BlockRestartInterval)
    1784            1 :                 fmt.Fprintf(&buf, "  block_size=%d\n", l.BlockSize)
    1785            1 :                 fmt.Fprintf(&buf, "  block_size_threshold=%d\n", l.BlockSizeThreshold)
    1786            1 :                 fmt.Fprintf(&buf, "  compression=%s\n", l.Compression().Name)
    1787            1 :                 fmt.Fprintf(&buf, "  filter_policy=%s\n", l.FilterPolicy.Name())
    1788            1 :                 fmt.Fprintf(&buf, "  filter_type=%s\n", l.FilterType)
    1789            1 :                 fmt.Fprintf(&buf, "  index_block_size=%d\n", l.IndexBlockSize)
    1790            1 :                 fmt.Fprintf(&buf, "  target_file_size=%d\n", o.TargetFileSizes[i])
    1791            1 :         }
    1792              : 
    1793            1 :         return buf.String()
    1794              : }
    1795              : 
    1796              : type parseOptionsFuncs struct {
    1797              :         visitNewSection          func(i, j int, section string) error
    1798              :         visitKeyValue            func(i, j int, section, key, value string) error
    1799              :         visitCommentOrWhitespace func(i, j int, whitespace string) error
    1800              : }
    1801              : 
    1802              : // parseOptions takes options serialized by Options.String() and parses them
    1803              : // into keys and values. It calls fns.visitNewSection for the beginning of each
    1804              : // new section, fns.visitKeyValue for each key-value pair, and
    1805              : // visitCommentOrWhitespace for comments and whitespace between key-value pairs.
    1806            1 : func parseOptions(s string, fns parseOptionsFuncs) error {
    1807            1 :         var section, mappedSection string
    1808            1 :         i := 0
    1809            1 :         for i < len(s) {
    1810            1 :                 rem := s[i:]
    1811            1 :                 j := strings.IndexByte(rem, '\n')
    1812            1 :                 if j < 0 {
    1813            0 :                         j = len(rem)
    1814            1 :                 } else {
    1815            1 :                         j += 1 // Include the newline.
    1816            1 :                 }
    1817            1 :                 line := strings.TrimSpace(s[i : i+j])
    1818            1 :                 startOff, endOff := i, i+j
    1819            1 :                 i += j
    1820            1 : 
    1821            1 :                 if len(line) == 0 || line[0] == ';' || line[0] == '#' {
    1822            1 :                         // Skip blank lines and comments.
    1823            1 :                         if fns.visitCommentOrWhitespace != nil {
    1824            1 :                                 if err := fns.visitCommentOrWhitespace(startOff, endOff, line); err != nil {
    1825            0 :                                         return err
    1826            0 :                                 }
    1827              :                         }
    1828            1 :                         continue
    1829              :                 }
    1830            1 :                 n := len(line)
    1831            1 :                 if line[0] == '[' && line[n-1] == ']' {
    1832            1 :                         // Parse section.
    1833            1 :                         section = line[1 : n-1]
    1834            1 :                         // RocksDB uses a similar (INI-style) syntax for the OPTIONS file, but
    1835            1 :                         // different section names and keys. The "CFOptions ..." paths are the
    1836            1 :                         // RocksDB versions which we map to the Pebble paths.
    1837            1 :                         mappedSection = section
    1838            1 :                         if section == `CFOptions "default"` {
    1839            0 :                                 mappedSection = "Options"
    1840            0 :                         }
    1841            1 :                         if fns.visitNewSection != nil {
    1842            1 :                                 if err := fns.visitNewSection(startOff, endOff, mappedSection); err != nil {
    1843            0 :                                         return err
    1844            0 :                                 }
    1845              :                         }
    1846            1 :                         continue
    1847              :                 }
    1848              : 
    1849            1 :                 pos := strings.Index(line, "=")
    1850            1 :                 if pos < 0 {
    1851            0 :                         const maxLen = 50
    1852            0 :                         if len(line) > maxLen {
    1853            0 :                                 line = line[:maxLen-3] + "..."
    1854            0 :                         }
    1855            0 :                         return base.CorruptionErrorf("invalid key=value syntax: %q", errors.Safe(line))
    1856              :                 }
    1857              : 
    1858            1 :                 key := strings.TrimSpace(line[:pos])
    1859            1 :                 value := strings.TrimSpace(line[pos+1:])
    1860            1 : 
    1861            1 :                 if section == `CFOptions "default"` {
    1862            0 :                         switch key {
    1863            0 :                         case "comparator":
    1864            0 :                                 key = "comparer"
    1865            0 :                         case "merge_operator":
    1866            0 :                                 key = "merger"
    1867              :                         }
    1868              :                 }
    1869            1 :                 if fns.visitKeyValue != nil {
    1870            1 :                         if err := fns.visitKeyValue(startOff, endOff, mappedSection, key, value); err != nil {
    1871            0 :                                 return err
    1872            0 :                         }
    1873              :                 }
    1874              :         }
    1875            1 :         return nil
    1876              : }
    1877              : 
    1878              : // ParseHooks contains callbacks to create options fields which can have
    1879              : // user-defined implementations.
    1880              : type ParseHooks struct {
    1881              :         NewCleaner      func(name string) (Cleaner, error)
    1882              :         NewComparer     func(name string) (*Comparer, error)
    1883              :         NewFilterPolicy func(name string) (FilterPolicy, error)
    1884              :         NewKeySchema    func(name string) (KeySchema, error)
    1885              :         NewMerger       func(name string) (*Merger, error)
    1886              :         SkipUnknown     func(name, value string) bool
    1887              : }
    1888              : 
    1889              : // Parse parses the options from the specified string. Note that certain
    1890              : // options cannot be parsed into populated fields. For example, comparer and
    1891              : // merger.
    1892            1 : func (o *Options) Parse(s string, hooks *ParseHooks) error {
    1893            1 :         var valSepPolicy ValueSeparationPolicy
    1894            1 :         var concurrencyLimit struct {
    1895            1 :                 lower    int
    1896            1 :                 lowerSet bool
    1897            1 :                 upper    int
    1898            1 :                 upperSet bool
    1899            1 :         }
    1900            1 : 
    1901            1 :         visitKeyValue := func(i, j int, section, key, value string) error {
    1902            1 :                 // WARNING: DO NOT remove entries from the switches below because doing so
    1903            1 :                 // causes a key previously written to the OPTIONS file to be considered unknown,
    1904            1 :                 // a backwards incompatible change. Instead, leave in support for parsing the
    1905            1 :                 // key but simply don't parse the value.
    1906            1 : 
    1907            1 :                 parseComparer := func(name string) (*Comparer, error) {
    1908            1 :                         switch name {
    1909            0 :                         case DefaultComparer.Name:
    1910            0 :                                 return DefaultComparer, nil
    1911            1 :                         case testkeys.Comparer.Name:
    1912            1 :                                 return testkeys.Comparer, nil
    1913            1 :                         default:
    1914            1 :                                 if hooks != nil && hooks.NewComparer != nil {
    1915            1 :                                         return hooks.NewComparer(name)
    1916            1 :                                 }
    1917            0 :                                 return nil, nil
    1918              :                         }
    1919              :                 }
    1920              : 
    1921            1 :                 switch {
    1922            1 :                 case section == "Version":
    1923            1 :                         switch key {
    1924            1 :                         case "pebble_version":
    1925            0 :                         default:
    1926            0 :                                 if hooks != nil && hooks.SkipUnknown != nil && hooks.SkipUnknown(section+"."+key, value) {
    1927            0 :                                         return nil
    1928            0 :                                 }
    1929            0 :                                 return errors.Errorf("pebble: unknown option: %s.%s",
    1930            0 :                                         errors.Safe(section), errors.Safe(key))
    1931              :                         }
    1932            1 :                         return nil
    1933              : 
    1934            1 :                 case section == "Options":
    1935            1 :                         var err error
    1936            1 :                         switch key {
    1937            1 :                         case "bytes_per_sync":
    1938            1 :                                 o.BytesPerSync, err = strconv.Atoi(value)
    1939            1 :                         case "cache_size":
    1940            1 :                                 o.CacheSize, err = strconv.ParseInt(value, 10, 64)
    1941            1 :                         case "cleaner":
    1942            1 :                                 switch value {
    1943            1 :                                 case "archive":
    1944            1 :                                         o.Cleaner = ArchiveCleaner{}
    1945            0 :                                 case "delete":
    1946            0 :                                         o.Cleaner = DeleteCleaner{}
    1947            0 :                                 default:
    1948            0 :                                         if hooks != nil && hooks.NewCleaner != nil {
    1949            0 :                                                 o.Cleaner, err = hooks.NewCleaner(value)
    1950            0 :                                         }
    1951              :                                 }
    1952            1 :                         case "comparer":
    1953            1 :                                 var comparer *Comparer
    1954            1 :                                 comparer, err = parseComparer(value)
    1955            1 :                                 if comparer != nil {
    1956            1 :                                         o.Comparer = comparer
    1957            1 :                                 }
    1958            1 :                         case "compaction_debt_concurrency":
    1959            1 :                                 o.Experimental.CompactionDebtConcurrency, err = strconv.ParseUint(value, 10, 64)
    1960            1 :                         case "compaction_garbage_fraction_for_max_concurrency":
    1961            1 :                                 var frac float64
    1962            1 :                                 frac, err = strconv.ParseFloat(value, 64)
    1963            1 :                                 if err == nil {
    1964            1 :                                         o.Experimental.CompactionGarbageFractionForMaxConcurrency =
    1965            1 :                                                 func() float64 { return frac }
    1966              :                                 }
    1967            0 :                         case "delete_range_flush_delay":
    1968            0 :                                 // NB: This is a deprecated serialization of the
    1969            0 :                                 // `flush_delay_delete_range`.
    1970            0 :                                 o.FlushDelayDeleteRange, err = time.ParseDuration(value)
    1971            1 :                         case "disable_delete_only_compactions":
    1972            1 :                                 o.private.disableDeleteOnlyCompactions, err = strconv.ParseBool(value)
    1973            1 :                         case "disable_elision_only_compactions":
    1974            1 :                                 o.private.disableElisionOnlyCompactions, err = strconv.ParseBool(value)
    1975            1 :                         case "disable_ingest_as_flushable":
    1976            1 :                                 var v bool
    1977            1 :                                 v, err = strconv.ParseBool(value)
    1978            1 :                                 if err == nil {
    1979            1 :                                         o.Experimental.DisableIngestAsFlushable = func() bool { return v }
    1980              :                                 }
    1981            1 :                         case "disable_lazy_combined_iteration":
    1982            1 :                                 o.private.disableLazyCombinedIteration, err = strconv.ParseBool(value)
    1983            1 :                         case "disable_wal":
    1984            1 :                                 o.DisableWAL, err = strconv.ParseBool(value)
    1985            0 :                         case "enable_columnar_blocks":
    1986              :                                 // Do nothing; option existed in older versions of pebble.
    1987            1 :                         case "flush_delay_delete_range":
    1988            1 :                                 o.FlushDelayDeleteRange, err = time.ParseDuration(value)
    1989            1 :                         case "flush_delay_range_key":
    1990            1 :                                 o.FlushDelayRangeKey, err = time.ParseDuration(value)
    1991            1 :                         case "flush_split_bytes":
    1992            1 :                                 o.FlushSplitBytes, err = strconv.ParseInt(value, 10, 64)
    1993            1 :                         case "format_major_version":
    1994            1 :                                 // NB: The version written here may be stale. Open does
    1995            1 :                                 // not use the format major version encoded in the
    1996            1 :                                 // OPTIONS file other than to validate that the encoded
    1997            1 :                                 // version is valid right here.
    1998            1 :                                 var v uint64
    1999            1 :                                 v, err = strconv.ParseUint(value, 10, 64)
    2000            1 :                                 if vers := FormatMajorVersion(v); vers > internalFormatNewest || vers == FormatDefault {
    2001            0 :                                         err = errors.Newf("unsupported format major version %d", o.FormatMajorVersion)
    2002            0 :                                 }
    2003            1 :                                 if err == nil {
    2004            1 :                                         o.FormatMajorVersion = FormatMajorVersion(v)
    2005            1 :                                 }
    2006            1 :                         case "key_schema":
    2007            1 :                                 o.KeySchema = value
    2008            1 :                                 if o.KeySchemas == nil {
    2009            0 :                                         o.KeySchemas = make(map[string]*KeySchema)
    2010            0 :                                 }
    2011            1 :                                 if _, ok := o.KeySchemas[o.KeySchema]; !ok {
    2012            0 :                                         if strings.HasPrefix(value, "DefaultKeySchema(") && strings.HasSuffix(value, ")") {
    2013            0 :                                                 argsStr := strings.TrimSuffix(strings.TrimPrefix(value, "DefaultKeySchema("), ")")
    2014            0 :                                                 args := strings.FieldsFunc(argsStr, func(r rune) bool {
    2015            0 :                                                         return unicode.IsSpace(r) || r == ','
    2016            0 :                                                 })
    2017            0 :                                                 var comparer *base.Comparer
    2018            0 :                                                 var bundleSize int
    2019            0 :                                                 comparer, err = parseComparer(args[0])
    2020            0 :                                                 if err == nil {
    2021            0 :                                                         bundleSize, err = strconv.Atoi(args[1])
    2022            0 :                                                 }
    2023            0 :                                                 if err == nil {
    2024            0 :                                                         schema := colblk.DefaultKeySchema(comparer, bundleSize)
    2025            0 :                                                         o.KeySchema = schema.Name
    2026            0 :                                                         o.KeySchemas[o.KeySchema] = &schema
    2027            0 :                                                 }
    2028            0 :                                         } else if hooks != nil && hooks.NewKeySchema != nil {
    2029            0 :                                                 var schema KeySchema
    2030            0 :                                                 schema, err = hooks.NewKeySchema(value)
    2031            0 :                                                 if err == nil {
    2032            0 :                                                         o.KeySchemas[value] = &schema
    2033            0 :                                                 }
    2034              :                                         }
    2035              :                                 }
    2036            1 :                         case "l0_compaction_concurrency":
    2037            1 :                                 o.Experimental.L0CompactionConcurrency, err = strconv.Atoi(value)
    2038            1 :                         case "l0_compaction_file_threshold":
    2039            1 :                                 o.L0CompactionFileThreshold, err = strconv.Atoi(value)
    2040            1 :                         case "l0_compaction_threshold":
    2041            1 :                                 o.L0CompactionThreshold, err = strconv.Atoi(value)
    2042            1 :                         case "l0_stop_writes_threshold":
    2043            1 :                                 o.L0StopWritesThreshold, err = strconv.Atoi(value)
    2044            0 :                         case "l0_sublevel_compactions":
    2045              :                                 // Do nothing; option existed in older versions of pebble.
    2046            1 :                         case "lbase_max_bytes":
    2047            1 :                                 o.LBaseMaxBytes, err = strconv.ParseInt(value, 10, 64)
    2048            1 :                         case "level_multiplier":
    2049            1 :                                 o.Experimental.LevelMultiplier, err = strconv.Atoi(value)
    2050            1 :                         case "concurrent_compactions":
    2051            1 :                                 concurrencyLimit.lowerSet = true
    2052            1 :                                 concurrencyLimit.lower, err = strconv.Atoi(value)
    2053            1 :                         case "max_concurrent_compactions":
    2054            1 :                                 concurrencyLimit.upperSet = true
    2055            1 :                                 concurrencyLimit.upper, err = strconv.Atoi(value)
    2056            1 :                         case "max_concurrent_downloads":
    2057            1 :                                 var concurrentDownloads int
    2058            1 :                                 concurrentDownloads, err = strconv.Atoi(value)
    2059            1 :                                 if concurrentDownloads <= 0 {
    2060            0 :                                         err = errors.New("max_concurrent_compactions cannot be <= 0")
    2061            1 :                                 } else {
    2062            1 :                                         o.MaxConcurrentDownloads = func() int { return concurrentDownloads }
    2063              :                                 }
    2064            1 :                         case "max_manifest_file_size":
    2065            1 :                                 o.MaxManifestFileSize, err = strconv.ParseInt(value, 10, 64)
    2066            1 :                         case "max_open_files":
    2067            1 :                                 o.MaxOpenFiles, err = strconv.Atoi(value)
    2068            1 :                         case "mem_table_size":
    2069            1 :                                 o.MemTableSize, err = strconv.ParseUint(value, 10, 64)
    2070            1 :                         case "mem_table_stop_writes_threshold":
    2071            1 :                                 o.MemTableStopWritesThreshold, err = strconv.Atoi(value)
    2072            0 :                         case "min_compaction_rate":
    2073              :                                 // Do nothing; option existed in older versions of pebble, and
    2074              :                                 // may be meaningful again eventually.
    2075            1 :                         case "min_deletion_rate":
    2076            1 :                                 o.TargetByteDeletionRate, err = strconv.Atoi(value)
    2077            1 :                         case "free_space_threshold_bytes":
    2078            1 :                                 o.FreeSpaceThresholdBytes, err = strconv.ParseUint(value, 10, 64)
    2079            1 :                         case "free_space_timeframe":
    2080            1 :                                 o.FreeSpaceTimeframe, err = time.ParseDuration(value)
    2081            1 :                         case "obsolete_bytes_max_ratio":
    2082            1 :                                 o.ObsoleteBytesMaxRatio, err = strconv.ParseFloat(value, 64)
    2083            1 :                         case "obsolete_bytes_timeframe":
    2084            1 :                                 o.ObsoleteBytesTimeframe, err = time.ParseDuration(value)
    2085            0 :                         case "min_flush_rate":
    2086              :                                 // Do nothing; option existed in older versions of pebble, and
    2087              :                                 // may be meaningful again eventually.
    2088            1 :                         case "multilevel_compaction_heuristic":
    2089            1 :                                 switch {
    2090            1 :                                 case value == "none":
    2091            1 :                                         o.Experimental.MultiLevelCompactionHeuristic = OptionNoMultiLevel
    2092            1 :                                 case strings.HasPrefix(value, "wamp"):
    2093            1 :                                         o.Experimental.MultiLevelCompactionHeuristic = OptionWriteAmpHeuristic
    2094            1 :                                         fields := strings.FieldsFunc(strings.TrimPrefix(value, "wamp"), func(r rune) bool {
    2095            1 :                                                 return unicode.IsSpace(r) || r == ',' || r == '(' || r == ')'
    2096            1 :                                         })
    2097            1 :                                         if len(fields) != 2 {
    2098            0 :                                                 err = errors.Newf("require 2 arguments")
    2099            0 :                                         }
    2100            1 :                                         var h WriteAmpHeuristic
    2101            1 :                                         if err == nil {
    2102            1 :                                                 h.AddPropensity, err = strconv.ParseFloat(fields[0], 64)
    2103            1 :                                         }
    2104            1 :                                         if err == nil {
    2105            1 :                                                 h.AllowL0, err = strconv.ParseBool(fields[1])
    2106            1 :                                         }
    2107              : 
    2108            1 :                                         if err == nil {
    2109            1 :                                                 if h.AllowL0 || h.AddPropensity != 0 {
    2110            1 :                                                         o.Experimental.MultiLevelCompactionHeuristic = func() MultiLevelHeuristic {
    2111            1 :                                                                 return &h
    2112            1 :                                                         }
    2113              :                                                 }
    2114            0 :                                         } else {
    2115            0 :                                                 err = errors.Wrapf(err, "unexpected wamp heuristic arguments: %s", value)
    2116            0 :                                         }
    2117            0 :                                 default:
    2118            0 :                                         err = errors.Newf("unrecognized multilevel compaction heuristic: %s", value)
    2119              :                                 }
    2120            0 :                         case "point_tombstone_weight":
    2121              :                                 // Do nothing; deprecated.
    2122            1 :                         case "strict_wal_tail":
    2123            1 :                                 var strictWALTail bool
    2124            1 :                                 strictWALTail, err = strconv.ParseBool(value)
    2125            1 :                                 if err == nil && !strictWALTail {
    2126            0 :                                         err = errors.Newf("reading from versions with strict_wal_tail=false no longer supported")
    2127            0 :                                 }
    2128            1 :                         case "merger":
    2129            1 :                                 switch value {
    2130            0 :                                 case "nullptr":
    2131            0 :                                         o.Merger = nil
    2132            1 :                                 case "pebble.concatenate":
    2133            1 :                                         o.Merger = DefaultMerger
    2134            0 :                                 default:
    2135            0 :                                         if hooks != nil && hooks.NewMerger != nil {
    2136            0 :                                                 o.Merger, err = hooks.NewMerger(value)
    2137            0 :                                         }
    2138              :                                 }
    2139            1 :                         case "read_compaction_rate":
    2140            1 :                                 o.Experimental.ReadCompactionRate, err = strconv.ParseInt(value, 10, 64)
    2141            1 :                         case "read_sampling_multiplier":
    2142            1 :                                 o.Experimental.ReadSamplingMultiplier, err = strconv.ParseInt(value, 10, 64)
    2143            1 :                         case "num_deletions_threshold":
    2144            1 :                                 o.Experimental.NumDeletionsThreshold, err = strconv.Atoi(value)
    2145            1 :                         case "deletion_size_ratio_threshold":
    2146            1 :                                 val, parseErr := strconv.ParseFloat(value, 32)
    2147            1 :                                 o.Experimental.DeletionSizeRatioThreshold = float32(val)
    2148            1 :                                 err = parseErr
    2149            1 :                         case "tombstone_dense_compaction_threshold":
    2150            1 :                                 o.Experimental.TombstoneDenseCompactionThreshold, err = strconv.ParseFloat(value, 64)
    2151            1 :                         case "table_cache_shards":
    2152            1 :                                 o.Experimental.FileCacheShards, err = strconv.Atoi(value)
    2153            0 :                         case "table_format":
    2154            0 :                                 switch value {
    2155            0 :                                 case "leveldb":
    2156            0 :                                 case "rocksdbv2":
    2157            0 :                                 default:
    2158            0 :                                         return errors.Errorf("pebble: unknown table format: %q", errors.Safe(value))
    2159              :                                 }
    2160            0 :                         case "table_property_collectors":
    2161              :                                 // No longer implemented; ignore.
    2162            1 :                         case "validate_on_ingest":
    2163            1 :                                 o.Experimental.ValidateOnIngest, err = strconv.ParseBool(value)
    2164            1 :                         case "wal_dir":
    2165            1 :                                 o.WALDir = value
    2166            1 :                         case "wal_bytes_per_sync":
    2167            1 :                                 o.WALBytesPerSync, err = strconv.Atoi(value)
    2168            0 :                         case "max_writer_concurrency":
    2169              :                                 // No longer implemented; ignore.
    2170            0 :                         case "force_writer_parallelism":
    2171              :                                 // No longer implemented; ignore.
    2172            1 :                         case "secondary_cache_size_bytes":
    2173            1 :                                 o.Experimental.SecondaryCacheSizeBytes, err = strconv.ParseInt(value, 10, 64)
    2174            1 :                         case "create_on_shared":
    2175            1 :                                 var createOnSharedInt int64
    2176            1 :                                 createOnSharedInt, err = strconv.ParseInt(value, 10, 64)
    2177            1 :                                 o.Experimental.CreateOnShared = remote.CreateOnSharedStrategy(createOnSharedInt)
    2178            0 :                         default:
    2179            0 :                                 if hooks != nil && hooks.SkipUnknown != nil && hooks.SkipUnknown(section+"."+key, value) {
    2180            0 :                                         return nil
    2181            0 :                                 }
    2182            0 :                                 return errors.Errorf("pebble: unknown option: %s.%s",
    2183            0 :                                         errors.Safe(section), errors.Safe(key))
    2184              :                         }
    2185            1 :                         return err
    2186              : 
    2187            1 :                 case section == "Value Separation":
    2188            1 :                         var err error
    2189            1 :                         switch key {
    2190            1 :                         case "enabled":
    2191            1 :                                 valSepPolicy.Enabled, err = strconv.ParseBool(value)
    2192            1 :                         case "minimum_size":
    2193            1 :                                 var minimumSize int
    2194            1 :                                 minimumSize, err = strconv.Atoi(value)
    2195            1 :                                 valSepPolicy.MinimumSize = minimumSize
    2196            1 :                         case "max_blob_reference_depth":
    2197            1 :                                 valSepPolicy.MaxBlobReferenceDepth, err = strconv.Atoi(value)
    2198            1 :                         case "rewrite_minimum_age":
    2199            1 :                                 valSepPolicy.RewriteMinimumAge, err = time.ParseDuration(value)
    2200            1 :                         case "target_garbage_ratio":
    2201            1 :                                 valSepPolicy.TargetGarbageRatio, err = strconv.ParseFloat(value, 64)
    2202            0 :                         default:
    2203            0 :                                 if hooks != nil && hooks.SkipUnknown != nil && hooks.SkipUnknown(section+"."+key, value) {
    2204            0 :                                         return nil
    2205            0 :                                 }
    2206            0 :                                 return errors.Errorf("pebble: unknown option: %s.%s", errors.Safe(section), errors.Safe(key))
    2207              :                         }
    2208            1 :                         return err
    2209              : 
    2210            1 :                 case section == "WAL Failover":
    2211            1 :                         if o.WALFailover == nil {
    2212            1 :                                 o.WALFailover = new(WALFailoverOptions)
    2213            1 :                         }
    2214            1 :                         var err error
    2215            1 :                         switch key {
    2216            1 :                         case "secondary_dir":
    2217            1 :                                 o.WALFailover.Secondary = wal.Dir{Dirname: value, FS: vfs.Default}
    2218            1 :                         case "primary_dir_probe_interval":
    2219            1 :                                 o.WALFailover.PrimaryDirProbeInterval, err = time.ParseDuration(value)
    2220            1 :                         case "healthy_probe_latency_threshold":
    2221            1 :                                 o.WALFailover.HealthyProbeLatencyThreshold, err = time.ParseDuration(value)
    2222            1 :                         case "healthy_interval":
    2223            1 :                                 o.WALFailover.HealthyInterval, err = time.ParseDuration(value)
    2224            1 :                         case "unhealthy_sampling_interval":
    2225            1 :                                 o.WALFailover.UnhealthySamplingInterval, err = time.ParseDuration(value)
    2226            1 :                         case "unhealthy_operation_latency_threshold":
    2227            1 :                                 var threshold time.Duration
    2228            1 :                                 threshold, err = time.ParseDuration(value)
    2229            1 :                                 o.WALFailover.UnhealthyOperationLatencyThreshold = func() (time.Duration, bool) {
    2230            1 :                                         return threshold, true
    2231            1 :                                 }
    2232            1 :                         case "elevated_write_stall_threshold_lag":
    2233            1 :                                 o.WALFailover.ElevatedWriteStallThresholdLag, err = time.ParseDuration(value)
    2234            0 :                         default:
    2235            0 :                                 if hooks != nil && hooks.SkipUnknown != nil && hooks.SkipUnknown(section+"."+key, value) {
    2236            0 :                                         return nil
    2237            0 :                                 }
    2238            0 :                                 return errors.Errorf("pebble: unknown option: %s.%s",
    2239            0 :                                         errors.Safe(section), errors.Safe(key))
    2240              :                         }
    2241            1 :                         return err
    2242              : 
    2243            1 :                 case strings.HasPrefix(section, "Level "):
    2244            1 :                         m := regexp.MustCompile(`Level\s*"?(\d+)"?\s*$`).FindStringSubmatch(section)
    2245            1 :                         if m == nil {
    2246            0 :                                 return errors.Errorf("pebble: unknown section: %q", errors.Safe(section))
    2247            0 :                         }
    2248            1 :                         index, _ := strconv.Atoi(m[1])
    2249            1 : 
    2250            1 :                         l := &o.Levels[index]
    2251            1 : 
    2252            1 :                         var err error
    2253            1 :                         switch key {
    2254            1 :                         case "block_restart_interval":
    2255            1 :                                 l.BlockRestartInterval, err = strconv.Atoi(value)
    2256            1 :                         case "block_size":
    2257            1 :                                 l.BlockSize, err = strconv.Atoi(value)
    2258            1 :                         case "block_size_threshold":
    2259            1 :                                 l.BlockSizeThreshold, err = strconv.Atoi(value)
    2260            1 :                         case "compression":
    2261            1 :                                 profile := block.CompressionProfileByName(value)
    2262            1 :                                 if profile == nil {
    2263            0 :                                         return errors.Errorf("pebble: unknown compression: %q", errors.Safe(value))
    2264            0 :                                 }
    2265            1 :                                 l.Compression = func() *sstable.CompressionProfile { return profile }
    2266            1 :                         case "filter_policy":
    2267            1 :                                 if hooks != nil && hooks.NewFilterPolicy != nil {
    2268            1 :                                         l.FilterPolicy, err = hooks.NewFilterPolicy(value)
    2269            1 :                                 } else {
    2270            0 :                                         l.FilterPolicy = NoFilterPolicy
    2271            0 :                                 }
    2272            1 :                         case "filter_type":
    2273            1 :                                 switch value {
    2274            1 :                                 case "table":
    2275            1 :                                         l.FilterType = TableFilter
    2276            0 :                                 default:
    2277            0 :                                         return errors.Errorf("pebble: unknown filter type: %q", errors.Safe(value))
    2278              :                                 }
    2279            1 :                         case "index_block_size":
    2280            1 :                                 l.IndexBlockSize, err = strconv.Atoi(value)
    2281            1 :                         case "target_file_size":
    2282            1 :                                 o.TargetFileSizes[index], err = strconv.ParseInt(value, 10, 64)
    2283            0 :                         default:
    2284            0 :                                 if hooks != nil && hooks.SkipUnknown != nil && hooks.SkipUnknown(section+"."+key, value) {
    2285            0 :                                         return nil
    2286            0 :                                 }
    2287            0 :                                 return errors.Errorf("pebble: unknown option: %s.%s", errors.Safe(section), errors.Safe(key))
    2288              :                         }
    2289            1 :                         return err
    2290              :                 }
    2291            1 :                 if hooks != nil && hooks.SkipUnknown != nil && hooks.SkipUnknown(section+"."+key, value) {
    2292            1 :                         return nil
    2293            1 :                 }
    2294            0 :                 return errors.Errorf("pebble: unknown section %q or key %q", errors.Safe(section), errors.Safe(key))
    2295              :         }
    2296            1 :         err := parseOptions(s, parseOptionsFuncs{
    2297            1 :                 visitKeyValue: visitKeyValue,
    2298            1 :         })
    2299            1 :         if err != nil {
    2300            0 :                 return err
    2301            0 :         }
    2302            1 :         o.Experimental.ValueSeparationPolicy = func() ValueSeparationPolicy { return valSepPolicy }
    2303            1 :         if concurrencyLimit.lowerSet || concurrencyLimit.upperSet {
    2304            1 :                 if !concurrencyLimit.lowerSet {
    2305            0 :                         concurrencyLimit.lower = 1
    2306            1 :                 } else if concurrencyLimit.lower < 1 {
    2307            0 :                         return errors.New("baseline_concurrent_compactions cannot be <= 0")
    2308            0 :                 }
    2309            1 :                 if !concurrencyLimit.upperSet {
    2310            0 :                         concurrencyLimit.upper = concurrencyLimit.lower
    2311            1 :                 } else if concurrencyLimit.upper < concurrencyLimit.lower {
    2312            0 :                         return errors.Newf("max_concurrent_compactions cannot be < %d", concurrencyLimit.lower)
    2313            0 :                 }
    2314            1 :                 o.CompactionConcurrencyRange = func() (int, int) {
    2315            1 :                         return concurrencyLimit.lower, concurrencyLimit.upper
    2316            1 :                 }
    2317              :         }
    2318            1 :         return nil
    2319              : }
    2320              : 
    2321              : // ErrMissingWALRecoveryDir is an error returned when a database is attempted to be
    2322              : // opened without supplying a Options.WALRecoveryDir entry for a directory that
    2323              : // may contain WALs required to recover a consistent database state.
    2324              : type ErrMissingWALRecoveryDir struct {
    2325              :         Dir       string
    2326              :         ExtraInfo string
    2327              : }
    2328              : 
    2329              : // Error implements error.
    2330            0 : func (e ErrMissingWALRecoveryDir) Error() string {
    2331            0 :         return fmt.Sprintf("directory %q may contain relevant WALs but is not in WALRecoveryDirs%s", e.Dir, e.ExtraInfo)
    2332            0 : }
    2333              : 
    2334              : // CheckCompatibility verifies the options are compatible with the previous options
    2335              : // serialized by Options.String(). For example, the Comparer and Merger must be
    2336              : // the same, or data will not be able to be properly read from the DB.
    2337              : //
    2338              : // This function only looks at specific keys and does not error out if the
    2339              : // options are newer and contain unknown keys.
    2340            1 : func (o *Options) CheckCompatibility(storeDir string, previousOptions string) error {
    2341            1 :         previousWALDir := ""
    2342            1 : 
    2343            1 :         visitKeyValue := func(i, j int, section, key, value string) error {
    2344            1 :                 switch section + "." + key {
    2345            1 :                 case "Options.comparer":
    2346            1 :                         if value != o.Comparer.Name {
    2347            0 :                                 return errors.Errorf("pebble: comparer name from file %q != comparer name from options %q",
    2348            0 :                                         errors.Safe(value), errors.Safe(o.Comparer.Name))
    2349            0 :                         }
    2350            1 :                 case "Options.merger":
    2351            1 :                         // RocksDB allows the merge operator to be unspecified, in which case it
    2352            1 :                         // shows up as "nullptr".
    2353            1 :                         if value != "nullptr" && value != o.Merger.Name {
    2354            0 :                                 return errors.Errorf("pebble: merger name from file %q != merger name from options %q",
    2355            0 :                                         errors.Safe(value), errors.Safe(o.Merger.Name))
    2356            0 :                         }
    2357            1 :                 case "Options.wal_dir":
    2358            1 :                         previousWALDir = value
    2359            1 :                 case "WAL Failover.secondary_dir":
    2360            1 :                         previousWALSecondaryDir := value
    2361            1 :                         if err := o.checkWALDir(storeDir, previousWALSecondaryDir, "WALFailover.Secondary changed from previous options"); err != nil {
    2362            0 :                                 return err
    2363            0 :                         }
    2364              :                 }
    2365            1 :                 return nil
    2366              :         }
    2367            1 :         if err := parseOptions(previousOptions, parseOptionsFuncs{visitKeyValue: visitKeyValue}); err != nil {
    2368            0 :                 return err
    2369            0 :         }
    2370            1 :         if err := o.checkWALDir(storeDir, previousWALDir, "WALDir changed from previous options"); err != nil {
    2371            0 :                 return err
    2372            0 :         }
    2373            1 :         return nil
    2374              : }
    2375              : 
    2376              : // checkWALDir verifies that walDir is among o.WALDir, o.WALFailover.Secondary,
    2377              : // or o.WALRecoveryDirs. An empty "walDir" maps to the storeDir.
    2378            1 : func (o *Options) checkWALDir(storeDir, walDir, errContext string) error {
    2379            1 :         walPath := resolveStorePath(storeDir, walDir)
    2380            1 :         if walDir == "" {
    2381            1 :                 walPath = storeDir
    2382            1 :         }
    2383              : 
    2384            1 :         if o.WALDir == "" {
    2385            1 :                 if walPath == storeDir {
    2386            1 :                         return nil
    2387            1 :                 }
    2388            1 :         } else {
    2389            1 :                 if walPath == resolveStorePath(storeDir, o.WALDir) {
    2390            1 :                         return nil
    2391            1 :                 }
    2392              :         }
    2393              : 
    2394            1 :         if o.WALFailover != nil && walPath == resolveStorePath(storeDir, o.WALFailover.Secondary.Dirname) {
    2395            1 :                 return nil
    2396            1 :         }
    2397              : 
    2398            0 :         for _, d := range o.WALRecoveryDirs {
    2399            0 :                 // TODO(radu): should we also check that d.FS is the same as walDir's FS?
    2400            0 :                 if walPath == resolveStorePath(storeDir, d.Dirname) {
    2401            0 :                         return nil
    2402            0 :                 }
    2403              :         }
    2404              : 
    2405            0 :         var buf bytes.Buffer
    2406            0 :         fmt.Fprintf(&buf, "\n  %s\n", errContext)
    2407            0 :         fmt.Fprintf(&buf, "  o.WALDir: %q\n", o.WALDir)
    2408            0 :         if o.WALFailover != nil {
    2409            0 :                 fmt.Fprintf(&buf, "  o.WALFailover.Secondary.Dirname: %q\n", o.WALFailover.Secondary.Dirname)
    2410            0 :         }
    2411            0 :         fmt.Fprintf(&buf, "  o.WALRecoveryDirs: %d", len(o.WALRecoveryDirs))
    2412            0 :         for _, d := range o.WALRecoveryDirs {
    2413            0 :                 fmt.Fprintf(&buf, "\n    %q", d.Dirname)
    2414            0 :         }
    2415            0 :         return ErrMissingWALRecoveryDir{Dir: walPath, ExtraInfo: buf.String()}
    2416              : }
    2417              : 
    2418              : // Validate verifies that the options are mutually consistent. For example,
    2419              : // L0StopWritesThreshold must be >= L0CompactionThreshold, otherwise a write
    2420              : // stall would persist indefinitely.
    2421            1 : func (o *Options) Validate() error {
    2422            1 :         // Note that we can presume Options.EnsureDefaults has been called, so there
    2423            1 :         // is no need to check for zero values.
    2424            1 : 
    2425            1 :         var buf strings.Builder
    2426            1 :         if o.Experimental.L0CompactionConcurrency < 1 {
    2427            0 :                 fmt.Fprintf(&buf, "L0CompactionConcurrency (%d) must be >= 1\n",
    2428            0 :                         o.Experimental.L0CompactionConcurrency)
    2429            0 :         }
    2430            1 :         if o.L0StopWritesThreshold < o.L0CompactionThreshold {
    2431            0 :                 fmt.Fprintf(&buf, "L0StopWritesThreshold (%d) must be >= L0CompactionThreshold (%d)\n",
    2432            0 :                         o.L0StopWritesThreshold, o.L0CompactionThreshold)
    2433            0 :         }
    2434            1 :         if uint64(o.MemTableSize) >= maxMemTableSize {
    2435            0 :                 fmt.Fprintf(&buf, "MemTableSize (%s) must be < %s\n",
    2436            0 :                         humanize.Bytes.Uint64(uint64(o.MemTableSize)), humanize.Bytes.Uint64(maxMemTableSize))
    2437            0 :         }
    2438            1 :         if o.MemTableStopWritesThreshold < 2 {
    2439            0 :                 fmt.Fprintf(&buf, "MemTableStopWritesThreshold (%d) must be >= 2\n",
    2440            0 :                         o.MemTableStopWritesThreshold)
    2441            0 :         }
    2442            1 :         if o.FormatMajorVersion < FormatMinSupported || o.FormatMajorVersion > internalFormatNewest {
    2443            0 :                 fmt.Fprintf(&buf, "FormatMajorVersion (%d) must be between %d and %d\n",
    2444            0 :                         o.FormatMajorVersion, FormatMinSupported, internalFormatNewest)
    2445            0 :         }
    2446            1 :         if o.Experimental.CreateOnShared != remote.CreateOnSharedNone && o.FormatMajorVersion < FormatMinForSharedObjects {
    2447            0 :                 fmt.Fprintf(&buf, "FormatMajorVersion (%d) when CreateOnShared is set must be at least %d\n",
    2448            0 :                         o.FormatMajorVersion, FormatMinForSharedObjects)
    2449            0 :         }
    2450            1 :         if len(o.KeySchemas) > 0 {
    2451            1 :                 if o.KeySchema == "" {
    2452            0 :                         fmt.Fprintf(&buf, "KeySchemas is set but KeySchema is not\n")
    2453            0 :                 }
    2454            1 :                 if _, ok := o.KeySchemas[o.KeySchema]; !ok {
    2455            0 :                         fmt.Fprintf(&buf, "KeySchema %q not found in KeySchemas\n", o.KeySchema)
    2456            0 :                 }
    2457              :         }
    2458            1 :         if policy := o.Experimental.ValueSeparationPolicy(); policy.Enabled {
    2459            1 :                 if policy.MinimumSize <= 0 {
    2460            0 :                         fmt.Fprintf(&buf, "ValueSeparationPolicy.MinimumSize (%d) must be > 0\n", policy.MinimumSize)
    2461            0 :                 }
    2462            1 :                 if policy.MaxBlobReferenceDepth <= 0 {
    2463            0 :                         fmt.Fprintf(&buf, "ValueSeparationPolicy.MaxBlobReferenceDepth (%d) must be > 0\n", policy.MaxBlobReferenceDepth)
    2464            0 :                 }
    2465              :         }
    2466              : 
    2467            1 :         if buf.Len() == 0 {
    2468            1 :                 return nil
    2469            1 :         }
    2470            0 :         return errors.New(buf.String())
    2471              : }
    2472              : 
    2473              : // MakeReaderOptions constructs sstable.ReaderOptions from the corresponding
    2474              : // options in the receiver.
    2475            1 : func (o *Options) MakeReaderOptions() sstable.ReaderOptions {
    2476            1 :         var readerOpts sstable.ReaderOptions
    2477            1 :         if o != nil {
    2478            1 :                 readerOpts.Comparer = o.Comparer
    2479            1 :                 readerOpts.Filters = o.Filters
    2480            1 :                 readerOpts.KeySchemas = o.KeySchemas
    2481            1 :                 readerOpts.LoadBlockSema = o.LoadBlockSema
    2482            1 :                 readerOpts.LoggerAndTracer = o.LoggerAndTracer
    2483            1 :                 readerOpts.Merger = o.Merger
    2484            1 :         }
    2485            1 :         return readerOpts
    2486              : }
    2487              : 
    2488              : // MakeWriterOptions constructs sstable.WriterOptions for the specified level
    2489              : // from the corresponding options in the receiver.
    2490            1 : func (o *Options) MakeWriterOptions(level int, format sstable.TableFormat) sstable.WriterOptions {
    2491            1 :         var writerOpts sstable.WriterOptions
    2492            1 :         writerOpts.TableFormat = format
    2493            1 :         if o != nil {
    2494            1 :                 writerOpts.Comparer = o.Comparer
    2495            1 :                 if o.Merger != nil {
    2496            1 :                         writerOpts.MergerName = o.Merger.Name
    2497            1 :                 }
    2498            1 :                 writerOpts.BlockPropertyCollectors = o.BlockPropertyCollectors
    2499              :         }
    2500            1 :         if format >= sstable.TableFormatPebblev3 {
    2501            1 :                 writerOpts.ShortAttributeExtractor = o.Experimental.ShortAttributeExtractor
    2502            1 :                 if format >= sstable.TableFormatPebblev4 && level == numLevels-1 {
    2503            1 :                         writerOpts.WritingToLowestLevel = true
    2504            1 :                 }
    2505              :         }
    2506            1 :         levelOpts := o.Levels[level]
    2507            1 :         writerOpts.BlockRestartInterval = levelOpts.BlockRestartInterval
    2508            1 :         writerOpts.BlockSize = levelOpts.BlockSize
    2509            1 :         writerOpts.BlockSizeThreshold = levelOpts.BlockSizeThreshold
    2510            1 :         writerOpts.Compression = levelOpts.Compression()
    2511            1 :         writerOpts.FilterPolicy = levelOpts.FilterPolicy
    2512            1 :         writerOpts.FilterType = levelOpts.FilterType
    2513            1 :         writerOpts.IndexBlockSize = levelOpts.IndexBlockSize
    2514            1 :         if o.KeySchema != "" {
    2515            1 :                 var ok bool
    2516            1 :                 writerOpts.KeySchema, ok = o.KeySchemas[o.KeySchema]
    2517            1 :                 if !ok {
    2518            0 :                         panic(fmt.Sprintf("invalid schema %q", redact.Safe(o.KeySchema)))
    2519              :                 }
    2520              :         }
    2521            1 :         writerOpts.AllocatorSizeClasses = o.AllocatorSizeClasses
    2522            1 :         writerOpts.NumDeletionsThreshold = o.Experimental.NumDeletionsThreshold
    2523            1 :         writerOpts.DeletionSizeRatioThreshold = o.Experimental.DeletionSizeRatioThreshold
    2524            1 :         return writerOpts
    2525              : }
    2526              : 
    2527              : // MakeBlobWriterOptions constructs blob.FileWriterOptions from the corresponding
    2528              : // options in the receiver.
    2529            1 : func (o *Options) MakeBlobWriterOptions(level int, format blob.FileFormat) blob.FileWriterOptions {
    2530            1 :         lo := o.Levels[level]
    2531            1 :         return blob.FileWriterOptions{
    2532            1 :                 Format:       format,
    2533            1 :                 Compression:  lo.Compression(),
    2534            1 :                 ChecksumType: block.ChecksumTypeCRC32c,
    2535            1 :                 FlushGovernor: block.MakeFlushGovernor(
    2536            1 :                         lo.BlockSize,
    2537            1 :                         lo.BlockSizeThreshold,
    2538            1 :                         base.SizeClassAwareBlockSizeThreshold,
    2539            1 :                         o.AllocatorSizeClasses,
    2540            1 :                 ),
    2541            1 :         }
    2542            1 : }
    2543              : 
    2544            1 : func (o *Options) MakeObjStorageProviderSettings(dirname string) objstorageprovider.Settings {
    2545            1 :         s := objstorageprovider.Settings{
    2546            1 :                 Logger:        o.Logger,
    2547            1 :                 FS:            o.FS,
    2548            1 :                 FSDirName:     dirname,
    2549            1 :                 FSCleaner:     o.Cleaner,
    2550            1 :                 NoSyncOnClose: o.NoSyncOnClose,
    2551            1 :                 BytesPerSync:  o.BytesPerSync,
    2552            1 :         }
    2553            1 :         s.Local.ReadaheadConfig = o.Local.ReadaheadConfig
    2554            1 :         s.Remote.StorageFactory = o.Experimental.RemoteStorage
    2555            1 :         s.Remote.CreateOnShared = o.Experimental.CreateOnShared
    2556            1 :         s.Remote.CreateOnSharedLocator = o.Experimental.CreateOnSharedLocator
    2557            1 :         s.Remote.CacheSizeBytes = o.Experimental.SecondaryCacheSizeBytes
    2558            1 :         return s
    2559            1 : }
    2560              : 
    2561              : // UserKeyCategories describes a partitioning of the user key space. Each
    2562              : // partition is a category with a name. The categories are used for informative
    2563              : // purposes only (like pprof labels). Pebble does not treat keys differently
    2564              : // based on the UserKeyCategories.
    2565              : //
    2566              : // The partitions are defined by their upper bounds. The last partition is
    2567              : // assumed to go until the end of keyspace; its UpperBound is ignored. The rest
    2568              : // of the partitions are ordered by their UpperBound.
    2569              : type UserKeyCategories struct {
    2570              :         categories []UserKeyCategory
    2571              :         cmp        base.Compare
    2572              :         // rangeNames[i][j] contains the string referring to the categories in the
    2573              :         // range [i, j], with j > i.
    2574              :         rangeNames [][]string
    2575              : }
    2576              : 
    2577              : // UserKeyCategory describes a partition of the user key space.
    2578              : //
    2579              : // User keys >= the previous category's UpperBound and < this category's
    2580              : // UpperBound are part of this category.
    2581              : type UserKeyCategory struct {
    2582              :         Name string
    2583              :         // UpperBound is the exclusive upper bound of the category. All user keys >= the
    2584              :         // previous category's UpperBound and < this UpperBound are part of this
    2585              :         // category.
    2586              :         UpperBound []byte
    2587              : }
    2588              : 
    2589              : // MakeUserKeyCategories creates a UserKeyCategories object with the given
    2590              : // categories. The object is immutable and can be reused across different
    2591              : // stores.
    2592            0 : func MakeUserKeyCategories(cmp base.Compare, categories ...UserKeyCategory) UserKeyCategories {
    2593            0 :         n := len(categories)
    2594            0 :         if n == 0 {
    2595            0 :                 return UserKeyCategories{}
    2596            0 :         }
    2597            0 :         if categories[n-1].UpperBound != nil {
    2598            0 :                 panic("last category UpperBound must be nil")
    2599              :         }
    2600              :         // Verify that the partitions are ordered as expected.
    2601            0 :         for i := 1; i < n-1; i++ {
    2602            0 :                 if cmp(categories[i-1].UpperBound, categories[i].UpperBound) >= 0 {
    2603            0 :                         panic("invalid UserKeyCategories: key prefixes must be sorted")
    2604              :                 }
    2605              :         }
    2606              : 
    2607              :         // Precalculate a table of range names to avoid allocations in the
    2608              :         // categorization path.
    2609            0 :         rangeNamesBuf := make([]string, n*n)
    2610            0 :         rangeNames := make([][]string, n)
    2611            0 :         for i := range rangeNames {
    2612            0 :                 rangeNames[i] = rangeNamesBuf[:n]
    2613            0 :                 rangeNamesBuf = rangeNamesBuf[n:]
    2614            0 :                 for j := i + 1; j < n; j++ {
    2615            0 :                         rangeNames[i][j] = categories[i].Name + "-" + categories[j].Name
    2616            0 :                 }
    2617              :         }
    2618            0 :         return UserKeyCategories{
    2619            0 :                 categories: categories,
    2620            0 :                 cmp:        cmp,
    2621            0 :                 rangeNames: rangeNames,
    2622            0 :         }
    2623              : }
    2624              : 
    2625              : // Len returns the number of categories defined.
    2626            1 : func (kc *UserKeyCategories) Len() int {
    2627            1 :         return len(kc.categories)
    2628            1 : }
    2629              : 
    2630              : // CategorizeKey returns the name of the category containing the key.
    2631            0 : func (kc *UserKeyCategories) CategorizeKey(userKey []byte) string {
    2632            0 :         idx := sort.Search(len(kc.categories)-1, func(i int) bool {
    2633            0 :                 return kc.cmp(userKey, kc.categories[i].UpperBound) < 0
    2634            0 :         })
    2635            0 :         return kc.categories[idx].Name
    2636              : }
    2637              : 
    2638              : // CategorizeKeyRange returns the name of the category containing the key range.
    2639              : // If the key range spans multiple categories, the result shows the first and
    2640              : // last category separated by a dash, e.g. `cat1-cat5`.
    2641            0 : func (kc *UserKeyCategories) CategorizeKeyRange(startUserKey, endUserKey []byte) string {
    2642            0 :         n := len(kc.categories)
    2643            0 :         p := sort.Search(n-1, func(i int) bool {
    2644            0 :                 return kc.cmp(startUserKey, kc.categories[i].UpperBound) < 0
    2645            0 :         })
    2646            0 :         if p == n-1 || kc.cmp(endUserKey, kc.categories[p].UpperBound) < 0 {
    2647            0 :                 // Fast path for a single category.
    2648            0 :                 return kc.categories[p].Name
    2649            0 :         }
    2650              :         // Binary search among the remaining categories.
    2651            0 :         q := p + 1 + sort.Search(n-2-p, func(i int) bool {
    2652            0 :                 return kc.cmp(endUserKey, kc.categories[p+1+i].UpperBound) < 0
    2653            0 :         })
    2654            0 :         return kc.rangeNames[p][q]
    2655              : }
    2656              : 
    2657              : const storePathIdentifier = "{store_path}"
    2658              : 
    2659              : // MakeStoreRelativePath takes a path that is relative to the store directory
    2660              : // and creates a path that can be used for Options.WALDir and wal.Dir.Dirname.
    2661              : //
    2662              : // This is used in metamorphic tests, so that the test run directory can be
    2663              : // copied or moved.
    2664            0 : func MakeStoreRelativePath(fs vfs.FS, relativePath string) string {
    2665            0 :         if relativePath == "" {
    2666            0 :                 return storePathIdentifier
    2667            0 :         }
    2668            0 :         return fs.PathJoin(storePathIdentifier, relativePath)
    2669              : }
    2670              : 
    2671              : // resolveStorePath is the inverse of MakeStoreRelativePath(). It replaces any
    2672              : // storePathIdentifier prefix with the store dir.
    2673            1 : func resolveStorePath(storeDir, path string) string {
    2674            1 :         if remainder, ok := strings.CutPrefix(path, storePathIdentifier); ok {
    2675            1 :                 return storeDir + remainder
    2676            1 :         }
    2677            1 :         return path
    2678              : }
        

Generated by: LCOV version 2.0-1