From da2f9c7a3dcc927823392048bcf68767dbe3a1b3 Mon Sep 17 00:00:00 2001 From: Jackson Owens Date: Tue, 11 Feb 2025 18:04:52 -0500 Subject: [PATCH] internal/manifest: rename uses of 'file' to refer to sstable With the introduction of blob files, the manifest and version edits will need to account for the addition and removal of blob files. The term 'file' when referring to a 'sstable' is vague and potentially confusing. --- checkpoint.go | 12 +- compaction.go | 96 +++++++------- compaction_test.go | 22 ++-- data_test.go | 10 +- db.go | 4 +- file_cache_test.go | 20 +-- ingest.go | 64 ++++----- ingest_test.go | 14 +- .../keyspan/keyspanimpl/level_iter_test.go | 2 +- internal/manifest/l0_sublevels_test.go | 2 +- internal/manifest/manifest_test.go | 2 +- internal/manifest/version_edit.go | 124 +++++++++--------- internal/manifest/version_edit_test.go | 10 +- replay/replay.go | 10 +- table_stats.go | 8 +- tool/db.go | 2 +- tool/find.go | 14 +- tool/lsm.go | 36 ++--- tool/manifest.go | 36 ++--- version_set.go | 24 ++-- version_set_test.go | 10 +- 21 files changed, 261 insertions(+), 261 deletions(-) diff --git a/checkpoint.go b/checkpoint.go index cef9b8f1f5..cf8809794a 100644 --- a/checkpoint.go +++ b/checkpoint.go @@ -262,7 +262,7 @@ func (d *DB) Checkpoint( } } - var excludedFiles map[deletedFileEntry]*fileMetadata + var excludedTables map[deletedFileEntry]*fileMetadata var remoteFiles []base.DiskFileNum // Set of FileBacking.DiskFileNum which will be required by virtual sstables // in the checkpoint. @@ -272,10 +272,10 @@ func (d *DB) Checkpoint( iter := current.Levels[l].Iter() for f := iter.First(); f != nil; f = iter.Next() { if excludeFromCheckpoint(f, opt, d.cmp) { - if excludedFiles == nil { - excludedFiles = make(map[deletedFileEntry]*fileMetadata) + if excludedTables == nil { + excludedTables = make(map[deletedFileEntry]*fileMetadata) } - excludedFiles[deletedFileEntry{ + excludedTables[deletedFileEntry{ Level: l, FileNum: f.FileNum, }] = f @@ -325,7 +325,7 @@ func (d *DB) Checkpoint( ckErr = d.writeCheckpointManifest( fs, formatVers, destDir, dir, manifestFileNum, manifestSize, - excludedFiles, removeBackingTables, + excludedTables, removeBackingTables, ) if ckErr != nil { return ckErr @@ -480,7 +480,7 @@ func (d *DB) writeCheckpointManifest( if len(excludedFiles) > 0 { // Write out an additional VersionEdit that deletes the excluded SST files. ve := versionEdit{ - DeletedFiles: excludedFiles, + DeletedTables: excludedFiles, RemovedBackingTables: removeBackingTables, } diff --git a/compaction.go b/compaction.go index 8e1562c048..36f630e499 100644 --- a/compaction.go +++ b/compaction.go @@ -657,9 +657,9 @@ func (c *compaction) hasExtraLevelData() bool { // this compaction have revisions of the same user key present in both sstables, // when it shouldn't (eg. when splitting flushes). func (c *compaction) errorOnUserKeyOverlap(ve *versionEdit) error { - if n := len(ve.NewFiles); n > 1 { - meta := ve.NewFiles[n-1].Meta - prevMeta := ve.NewFiles[n-2].Meta + if n := len(ve.NewTables); n > 1 { + meta := ve.NewTables[n-1].Meta + prevMeta := ve.NewTables[n-2].Meta if !prevMeta.Largest.IsExclusiveSentinel() && c.cmp(prevMeta.Largest.UserKey, meta.Smallest.UserKey) >= 0 { return errors.Errorf("pebble: compaction split user key across two sstables: %s in %s and %s", @@ -1255,7 +1255,7 @@ func (d *DB) runIngestFlush(c *compaction) (*manifest.VersionEdit, error) { var ingestSplitFiles []ingestSplitFile ingestFlushable := c.flushing[0].flushable.(*ingestedFlushable) - updateLevelMetricsOnExcise := func(m *fileMetadata, level int, added []newFileEntry) { + updateLevelMetricsOnExcise := func(m *fileMetadata, level int, added []newTableEntry) { levelMetrics := c.metrics[level] if levelMetrics == nil { levelMetrics = &LevelMetrics{} @@ -1274,7 +1274,7 @@ func (d *DB) runIngestFlush(c *compaction) (*manifest.VersionEdit, error) { if suggestSplit || ingestFlushable.exciseSpan.Valid() { // We could add deleted files to ve. - ve.DeletedFiles = make(map[manifest.DeletedFileEntry]*manifest.FileMetadata) + ve.DeletedTables = make(map[manifest.DeletedTableEntry]*manifest.FileMetadata) } ctx := context.Background() @@ -1287,7 +1287,7 @@ func (d *DB) runIngestFlush(c *compaction) (*manifest.VersionEdit, error) { }, v: c.version, } - replacedFiles := make(map[base.FileNum][]newFileEntry) + replacedFiles := make(map[base.FileNum][]newTableEntry) for _, file := range ingestFlushable.files { var fileToSplit *fileMetadata var level int @@ -1312,7 +1312,7 @@ func (d *DB) runIngestFlush(c *compaction) (*manifest.VersionEdit, error) { } // Add the current flushableIngest file to the version. - ve.NewFiles = append(ve.NewFiles, newFileEntry{Level: level, Meta: file.FileMetadata}) + ve.NewTables = append(ve.NewTables, newTableEntry{Level: level, Meta: file.FileMetadata}) if fileToSplit != nil { ingestSplitFiles = append(ingestSplitFiles, ingestSplitFile{ ingestFile: file.FileMetadata, @@ -1340,7 +1340,7 @@ func (d *DB) runIngestFlush(c *compaction) (*manifest.VersionEdit, error) { return nil, err } - if _, ok := ve.DeletedFiles[deletedFileEntry{ + if _, ok := ve.DeletedTables[deletedFileEntry{ Level: l, FileNum: m.FileNum, }]; !ok { @@ -1500,8 +1500,8 @@ func (d *DB) flush1() (bytesFlushed uint64, err error) { } if err == nil { validateVersionEdit(ve, d.opts.Comparer.ValidateKey, d.opts.Comparer.FormatKey, d.opts.Logger) - for i := range ve.NewFiles { - e := &ve.NewFiles[i] + for i := range ve.NewTables { + e := &ve.NewTables[i] info.Output = append(info.Output, e.Meta.TableInfo()) // Ingested tables are not necessarily flushed to L0. Record the level of // each ingested file explicitly. @@ -1509,7 +1509,7 @@ func (d *DB) flush1() (bytesFlushed uint64, err error) { info.IngestLevels = append(info.IngestLevels, e.Level) } } - if len(ve.NewFiles) == 0 { + if len(ve.NewTables) == 0 { info.Err = errEmptyTable } @@ -1548,7 +1548,7 @@ func (d *DB) flush1() (bytesFlushed uint64, err error) { } } - if len(ve.DeletedFiles) > 0 { + if len(ve.DeletedTables) > 0 { // Iterate through all other compactions, and check if their inputs have // been replaced due to an ingest-time split or excise. In that case, // cancel the compaction. @@ -1556,7 +1556,7 @@ func (d *DB) flush1() (bytesFlushed uint64, err error) { for i := range c2.inputs { iter := c2.inputs[i].files.Iter() for f := iter.First(); f != nil; f = iter.Next() { - if _, ok := ve.DeletedFiles[deletedFileEntry{FileNum: f.FileNum, Level: c2.inputs[i].level}]; ok { + if _, ok := ve.DeletedTables[deletedFileEntry{FileNum: f.FileNum, Level: c2.inputs[i].level}]; ok { c2.cancel.Store(true) break } @@ -1593,7 +1593,7 @@ func (d *DB) flush1() (bytesFlushed uint64, err error) { flushed = d.mu.mem.queue[:n] d.mu.mem.queue = d.mu.mem.queue[n:] d.updateReadStateLocked(d.opts.DebugCheck) - d.updateTableStatsLocked(ve.NewFiles) + d.updateTableStatsLocked(ve.NewTables) if ingest { d.mu.versions.metrics.Flush.AsIngestCount++ for _, l := range c.metrics { @@ -2293,22 +2293,22 @@ func (d *DB) compact(c *compaction, errChannel chan error) { // // d.mu must be held when calling this method. func (d *DB) cleanupVersionEdit(ve *versionEdit) { - obsoleteFiles := make([]*fileBacking, 0, len(ve.NewFiles)) + obsoleteFiles := make([]*fileBacking, 0, len(ve.NewTables)) deletedFiles := make(map[base.FileNum]struct{}) - for key := range ve.DeletedFiles { + for key := range ve.DeletedTables { deletedFiles[key.FileNum] = struct{}{} } - for i := range ve.NewFiles { - if ve.NewFiles[i].Meta.Virtual { + for i := range ve.NewTables { + if ve.NewTables[i].Meta.Virtual { // We handle backing files separately. continue } - if _, ok := deletedFiles[ve.NewFiles[i].Meta.FileNum]; ok { + if _, ok := deletedFiles[ve.NewTables[i].Meta.FileNum]; ok { // This file is being moved in this ve to a different level. // Don't mark it as obsolete. continue } - obsoleteFiles = append(obsoleteFiles, ve.NewFiles[i].Meta.PhysicalMeta().FileBacking) + obsoleteFiles = append(obsoleteFiles, ve.NewTables[i].Meta.PhysicalMeta().FileBacking) } for i := range ve.CreatedBackingTables { if ve.CreatedBackingTables[i].IsUnused() { @@ -2387,8 +2387,8 @@ func (d *DB) compact1(c *compaction, errChannel chan error) (err error) { info.Done = true info.Err = err if err == nil { - for i := range ve.NewFiles { - e := &ve.NewFiles[i] + for i := range ve.NewTables { + e := &ve.NewTables[i] info.Output.Tables = append(info.Output.Tables, e.Meta.TableInfo()) } d.mu.snapshots.cumulativePinnedCount += stats.CumulativePinnedKeys @@ -2415,7 +2415,7 @@ func (d *DB) compact1(c *compaction, errChannel chan error) (err error) { // table list. if err == nil { d.updateReadStateLocked(d.opts.DebugCheck) - d.updateTableStatsLocked(ve.NewFiles) + d.updateTableStatsLocked(ve.NewTables) } d.deleteObsoleteFiles(jobID) @@ -2444,7 +2444,7 @@ func (d *DB) runCopyCompaction( return nil, compact.Stats{}, ErrCancelledCompaction } ve = &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{ + DeletedTables: map[deletedFileEntry]*fileMetadata{ {Level: c.startLevel.level, FileNum: inputMeta.FileNum}: inputMeta, }, } @@ -2592,7 +2592,7 @@ func (d *DB) runCopyCompaction( } deleteOnExit = true } - ve.NewFiles = []newFileEntry{{ + ve.NewTables = []newTableEntry{{ Level: c.outputLevel.level, Meta: newMeta, }} @@ -2626,7 +2626,7 @@ func (d *DB) applyHintOnFile( levelMetrics *LevelMetrics, ve *versionEdit, hintOverlap deletionHintOverlap, -) (newFiles []manifest.NewFileEntry, err error) { +) (newFiles []manifest.NewTableEntry, err error) { if hintOverlap == hintDoesNotApply { return nil, nil } @@ -2634,7 +2634,7 @@ func (d *DB) applyHintOnFile( // The hint overlaps with at least part of the file. if hintOverlap == hintDeletesFile { // The hint deletes the entirety of this file. - ve.DeletedFiles[deletedFileEntry{ + ve.DeletedTables[deletedFileEntry{ Level: level, FileNum: f.FileNum, }] = f @@ -2652,7 +2652,7 @@ func (d *DB) applyHintOnFile( if err != nil { return nil, errors.Wrap(err, "error when running excise for delete-only compaction") } - if _, ok := ve.DeletedFiles[deletedFileEntry{ + if _, ok := ve.DeletedTables[deletedFileEntry{ Level: level, FileNum: f.FileNum, }]; !ok { @@ -2712,7 +2712,7 @@ func (d *DB) runDeleteOnlyCompactionForLevel( if err != nil { return err } - if _, ok := ve.DeletedFiles[manifest.DeletedFileEntry{Level: cl.level, FileNum: curFile.FileNum}]; ok { + if _, ok := ve.DeletedTables[manifest.DeletedTableEntry{Level: cl.level, FileNum: curFile.FileNum}]; ok { curFile = nil } if len(newFiles) > 0 { @@ -2727,7 +2727,7 @@ func (d *DB) runDeleteOnlyCompactionForLevel( break } } - if _, ok := ve.DeletedFiles[deletedFileEntry{ + if _, ok := ve.DeletedTables[deletedFileEntry{ Level: cl.level, FileNum: f.FileNum, }]; !ok { @@ -2787,7 +2787,7 @@ func (d *DB) runDeleteOnlyCompaction( c.metrics = make(map[int]*LevelMetrics, len(c.inputs)) fragments := fragmentDeleteCompactionHints(d.cmp, c.deletionHints) ve = &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{}, + DeletedTables: map[deletedFileEntry]*fileMetadata{}, } for _, cl := range c.inputs { levelMetrics := &LevelMetrics{} @@ -2797,10 +2797,10 @@ func (d *DB) runDeleteOnlyCompaction( c.metrics[cl.level] = levelMetrics } // Remove any files that were added and deleted in the same versionEdit. - ve.NewFiles = slices.DeleteFunc(ve.NewFiles, func(e manifest.NewFileEntry) bool { - deletedFileEntry := manifest.DeletedFileEntry{Level: e.Level, FileNum: e.Meta.FileNum} - if _, deleted := ve.DeletedFiles[deletedFileEntry]; deleted { - delete(ve.DeletedFiles, deletedFileEntry) + ve.NewTables = slices.DeleteFunc(ve.NewTables, func(e manifest.NewTableEntry) bool { + deletedFileEntry := manifest.DeletedTableEntry{Level: e.Level, FileNum: e.Meta.FileNum} + if _, deleted := ve.DeletedTables[deletedFileEntry]; deleted { + delete(ve.DeletedTables, deletedFileEntry) return true } return false @@ -2808,7 +2808,7 @@ func (d *DB) runDeleteOnlyCompaction( // Remove any entries from CreatedBackingTables that are not used in any // NewFiles. usedBackingFiles := make(map[base.DiskFileNum]struct{}) - for _, e := range ve.NewFiles { + for _, e := range ve.NewTables { if e.Meta.Virtual { usedBackingFiles[e.Meta.FileBacking.DiskFileNum] = struct{}{} } @@ -2841,10 +2841,10 @@ func (d *DB) runMoveCompaction( }, } ve = &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{ + DeletedTables: map[deletedFileEntry]*fileMetadata{ {Level: c.startLevel.level, FileNum: meta.FileNum}: meta, }, - NewFiles: []newFileEntry{ + NewTables: []newTableEntry{ {Level: c.outputLevel.level, Meta: meta}, }, } @@ -3060,12 +3060,12 @@ func (d *DB) compactAndWrite( // tables in compact.Result. func (c *compaction) makeVersionEdit(result compact.Result) (*versionEdit, error) { ve := &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{}, + DeletedTables: map[deletedFileEntry]*fileMetadata{}, } for _, cl := range c.inputs { iter := cl.files.Iter() for f := iter.First(); f != nil; f = iter.Next() { - ve.DeletedFiles[deletedFileEntry{ + ve.DeletedTables[deletedFileEntry{ Level: cl.level, FileNum: f.FileNum, }] = f @@ -3096,7 +3096,7 @@ func (c *compaction) makeVersionEdit(result compact.Result) (*versionEdit, error } inputLargestSeqNumAbsolute := c.inputLargestSeqNumAbsolute() - ve.NewFiles = make([]newFileEntry, len(result.Tables)) + ve.NewTables = make([]newTableEntry, len(result.Tables)) for i := range result.Tables { t := &result.Tables[i] @@ -3134,7 +3134,7 @@ func (c *compaction) makeVersionEdit(result compact.Result) (*versionEdit, error fileMeta.ExtendRangeKeyBounds(c.cmp, t.WriterMeta.SmallestRangeKey, t.WriterMeta.LargestRangeKey) } - ve.NewFiles[i] = newFileEntry{ + ve.NewTables[i] = newTableEntry{ Level: c.outputLevel.level, Meta: fileMeta, } @@ -3154,11 +3154,11 @@ func (c *compaction) makeVersionEdit(result compact.Result) (*versionEdit, error } // Sanity check that the tables are ordered and don't overlap. - for i := 1; i < len(ve.NewFiles); i++ { - if ve.NewFiles[i-1].Meta.UserKeyBounds().End.IsUpperBoundFor(c.cmp, ve.NewFiles[i].Meta.Smallest.UserKey) { + for i := 1; i < len(ve.NewTables); i++ { + if ve.NewTables[i-1].Meta.UserKeyBounds().End.IsUpperBoundFor(c.cmp, ve.NewTables[i].Meta.Smallest.UserKey) { return nil, base.AssertionFailedf("pebble: compaction output tables overlap: %s and %s", - ve.NewFiles[i-1].Meta.DebugString(c.formatKey, true), - ve.NewFiles[i].Meta.DebugString(c.formatKey, true), + ve.NewTables[i-1].Meta.DebugString(c.formatKey, true), + ve.NewTables[i].Meta.DebugString(c.formatKey, true), ) } } @@ -3259,11 +3259,11 @@ func validateVersionEdit( } // Validate both new and deleted files. - for _, f := range ve.NewFiles { + for _, f := range ve.NewTables { validateKey(f.Meta, f.Meta.Smallest.UserKey) validateKey(f.Meta, f.Meta.Largest.UserKey) } - for _, m := range ve.DeletedFiles { + for _, m := range ve.DeletedTables { validateKey(m, m.Smallest.UserKey) validateKey(m, m.Largest.UserKey) } diff --git a/compaction_test.go b/compaction_test.go index 73440b3371..57c8a940c1 100644 --- a/compaction_test.go +++ b/compaction_test.go @@ -768,7 +768,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "single new file; start key", ve: &versionEdit{ - NewFiles: []manifest.NewFileEntry{ + NewTables: []manifest.NewTableEntry{ { Meta: newFileMeta( manifest.InternalKey{UserKey: []byte(badKey)}, @@ -783,7 +783,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "single new file; end key", ve: &versionEdit{ - NewFiles: []manifest.NewFileEntry{ + NewTables: []manifest.NewTableEntry{ { Meta: newFileMeta( manifest.InternalKey{UserKey: []byte("a")}, @@ -798,7 +798,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "multiple new files", ve: &versionEdit{ - NewFiles: []manifest.NewFileEntry{ + NewTables: []manifest.NewTableEntry{ { Meta: newFileMeta( manifest.InternalKey{UserKey: []byte("a")}, @@ -819,7 +819,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "single deleted file; start key", ve: &versionEdit{ - DeletedFiles: map[manifest.DeletedFileEntry]*manifest.FileMetadata{ + DeletedTables: map[manifest.DeletedTableEntry]*manifest.FileMetadata{ deletedFileEntry{Level: 0, FileNum: 0}: newFileMeta( manifest.InternalKey{UserKey: []byte(badKey)}, manifest.InternalKey{UserKey: []byte("z")}, @@ -832,7 +832,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "single deleted file; end key", ve: &versionEdit{ - DeletedFiles: map[manifest.DeletedFileEntry]*manifest.FileMetadata{ + DeletedTables: map[manifest.DeletedTableEntry]*manifest.FileMetadata{ deletedFileEntry{Level: 0, FileNum: 0}: newFileMeta( manifest.InternalKey{UserKey: []byte("a")}, manifest.InternalKey{UserKey: []byte(badKey)}, @@ -845,7 +845,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "multiple deleted files", ve: &versionEdit{ - DeletedFiles: map[manifest.DeletedFileEntry]*manifest.FileMetadata{ + DeletedTables: map[manifest.DeletedTableEntry]*manifest.FileMetadata{ deletedFileEntry{Level: 0, FileNum: 0}: newFileMeta( manifest.InternalKey{UserKey: []byte("a")}, manifest.InternalKey{UserKey: []byte("c")}, @@ -862,7 +862,7 @@ func TestValidateVersionEdit(t *testing.T) { { desc: "no errors", ve: &versionEdit{ - NewFiles: []manifest.NewFileEntry{ + NewTables: []manifest.NewTableEntry{ { Level: 0, Meta: newFileMeta( @@ -878,7 +878,7 @@ func TestValidateVersionEdit(t *testing.T) { ), }, }, - DeletedFiles: map[manifest.DeletedFileEntry]*manifest.FileMetadata{ + DeletedTables: map[manifest.DeletedTableEntry]*manifest.FileMetadata{ deletedFileEntry{Level: 6, FileNum: 0}: newFileMeta( manifest.InternalKey{UserKey: []byte("a")}, manifest.InternalKey{UserKey: []byte("d")}, @@ -2043,19 +2043,19 @@ func TestCompactionErrorOnUserKeyOverlap(t *testing.T) { comparer: DefaultComparer, formatKey: DefaultComparer.FormatKey, } - var files []manifest.NewFileEntry + var files []manifest.NewTableEntry fileNum := base.FileNum(1) for _, data := range strings.Split(d.Input, "\n") { meta := parseMeta(data) meta.FileNum = fileNum fileNum++ - files = append(files, manifest.NewFileEntry{Level: 1, Meta: meta}) + files = append(files, manifest.NewTableEntry{Level: 1, Meta: meta}) } result := "OK" ve := &versionEdit{ - NewFiles: files, + NewTables: files, } if err := c.errorOnUserKeyOverlap(ve); err != nil { result = fmt.Sprint(err) diff --git a/data_test.go b/data_test.go index 10d803f9c2..305c7fb534 100644 --- a/data_test.go +++ b/data_test.go @@ -886,7 +886,7 @@ func runDBDefineCmdReuseFS(td *datadriven.TestData, opts *Options) (*DB, error) return err } largestSeqNum := d.mu.versions.logSeqNum.Load() - for _, f := range newVE.NewFiles { + for _, f := range newVE.NewTables { if start != nil { f.Meta.SmallestPointKey = *start f.Meta.Smallest = *start @@ -898,7 +898,7 @@ func runDBDefineCmdReuseFS(td *datadriven.TestData, opts *Options) (*DB, error) if largestSeqNum <= f.Meta.LargestSeqNum { largestSeqNum = f.Meta.LargestSeqNum + 1 } - ve.NewFiles = append(ve.NewFiles, newFileEntry{ + ve.NewTables = append(ve.NewTables, newTableEntry{ Level: level, Meta: f.Meta, }) @@ -1043,16 +1043,16 @@ func runDBDefineCmdReuseFS(td *datadriven.TestData, opts *Options) (*DB, error) return nil, err } - if len(ve.NewFiles) > 0 { + if len(ve.NewTables) > 0 { jobID := d.newJobIDLocked() d.mu.versions.logLock() - if err := d.mu.versions.logAndApply(jobID, ve, newFileMetrics(ve.NewFiles), false, func() []compactionInfo { + if err := d.mu.versions.logAndApply(jobID, ve, newFileMetrics(ve.NewTables), false, func() []compactionInfo { return nil }); err != nil { return nil, err } d.updateReadStateLocked(nil) - d.updateTableStatsLocked(ve.NewFiles) + d.updateTableStatsLocked(ve.NewTables) } return d, nil diff --git a/db.go b/db.go index 342604cb11..d37d6d6c50 100644 --- a/db.go +++ b/db.go @@ -492,7 +492,7 @@ type DB struct { // Compactions, ingests, flushes append files to be processed. An // active stat collection goroutine clears the list and processes // them. - pending []manifest.NewFileEntry + pending []manifest.NewTableEntry } tableValidation struct { @@ -502,7 +502,7 @@ type DB struct { // pending is a slice of metadata for sstables waiting to be // validated. Only physical sstables should be added to the pending // queue. - pending []newFileEntry + pending []newTableEntry // validating is set to true when validation is running. validating bool } diff --git a/file_cache_test.go b/file_cache_test.go index dd15e020ce..b36e86546c 100644 --- a/file_cache_test.go +++ b/file_cache_test.go @@ -372,8 +372,8 @@ func TestVirtualReadsWiring(t *testing.T) { // Write the version edit. fileMetrics := func(ve *versionEdit) map[int]*LevelMetrics { - metrics := newFileMetrics(ve.NewFiles) - for de, f := range ve.DeletedFiles { + metrics := newFileMetrics(ve.NewTables) + for de, f := range ve.DeletedTables { lm := metrics[de.Level] if lm == nil { lm = &LevelMetrics{} @@ -397,14 +397,14 @@ func TestVirtualReadsWiring(t *testing.T) { } ve := manifest.VersionEdit{} - d1 := manifest.DeletedFileEntry{Level: 6, FileNum: parentFile.FileNum} - n1 := manifest.NewFileEntry{Level: 6, Meta: v1} - n2 := manifest.NewFileEntry{Level: 6, Meta: v2} - - ve.DeletedFiles = make(map[manifest.DeletedFileEntry]*manifest.FileMetadata) - ve.DeletedFiles[d1] = parentFile - ve.NewFiles = append(ve.NewFiles, n1) - ve.NewFiles = append(ve.NewFiles, n2) + d1 := manifest.DeletedTableEntry{Level: 6, FileNum: parentFile.FileNum} + n1 := manifest.NewTableEntry{Level: 6, Meta: v1} + n2 := manifest.NewTableEntry{Level: 6, Meta: v2} + + ve.DeletedTables = make(map[manifest.DeletedTableEntry]*manifest.FileMetadata) + ve.DeletedTables[d1] = parentFile + ve.NewTables = append(ve.NewTables, n1) + ve.NewTables = append(ve.NewTables, n2) ve.CreatedBackingTables = append(ve.CreatedBackingTables, parentFile.FileBacking) require.NoError(t, applyVE(&ve)) diff --git a/ingest.go b/ingest.go index ac4efb9dec..fbc399d733 100644 --- a/ingest.go +++ b/ingest.go @@ -1767,9 +1767,9 @@ func (d *DB) ingest( info.Tables = make([]struct { TableInfo Level int - }, len(ve.NewFiles)) - for i := range ve.NewFiles { - e := &ve.NewFiles[i] + }, len(ve.NewTables)) + for i := range ve.NewTables { + e := &ve.NewTables[i] info.Tables[i].Level = e.Level info.Tables[i].TableInfo = e.Meta.TableInfo() stats.Bytes += e.Meta.Size @@ -1819,14 +1819,14 @@ func (d *DB) ingest( // the mutex is not held. func (d *DB) excise( ctx context.Context, exciseSpan base.UserKeyBounds, m *fileMetadata, ve *versionEdit, level int, -) ([]manifest.NewFileEntry, error) { +) ([]manifest.NewTableEntry, error) { numCreatedFiles := 0 // Check if there's actually an overlap between m and exciseSpan. mBounds := base.UserKeyBoundsFromInternal(m.Smallest, m.Largest) if !exciseSpan.Overlaps(d.cmp, &mBounds) { return nil, nil } - ve.DeletedFiles[deletedFileEntry{ + ve.DeletedTables[deletedFileEntry{ Level: level, FileNum: m.FileNum, }] = m @@ -1950,7 +1950,7 @@ func (d *DB) excise( return nil, err } leftFile.ValidateVirtual(m) - ve.NewFiles = append(ve.NewFiles, newFileEntry{Level: level, Meta: leftFile}) + ve.NewTables = append(ve.NewTables, newTableEntry{Level: level, Meta: leftFile}) needsBacking = true numCreatedFiles++ } @@ -1965,7 +1965,7 @@ func (d *DB) excise( // indicated by the VersionEdit.CreatedBackingTables invariant. ve.CreatedBackingTables = append(ve.CreatedBackingTables, m.FileBacking) } - return ve.NewFiles[len(ve.NewFiles)-numCreatedFiles:], nil + return ve.NewTables[len(ve.NewTables)-numCreatedFiles:], nil } // Create a new file, rightFile, between [firstKeyAfter(exciseSpan.End), m.Largest]. // @@ -2064,7 +2064,7 @@ func (d *DB) excise( return nil, err } rightFile.ValidateVirtual(m) - ve.NewFiles = append(ve.NewFiles, newFileEntry{Level: level, Meta: rightFile}) + ve.NewTables = append(ve.NewTables, newTableEntry{Level: level, Meta: rightFile}) needsBacking = true numCreatedFiles++ } @@ -2077,7 +2077,7 @@ func (d *DB) excise( ve.CreatedBackingTables = append(ve.CreatedBackingTables, m.FileBacking) } - return ve.NewFiles[len(ve.NewFiles)-numCreatedFiles:], nil + return ve.NewTables[len(ve.NewTables)-numCreatedFiles:], nil } type ingestSplitFile struct { @@ -2100,9 +2100,9 @@ type ingestSplitFile struct { func (d *DB) ingestSplit( ctx context.Context, ve *versionEdit, - updateMetrics func(*fileMetadata, int, []newFileEntry), + updateMetrics func(*fileMetadata, int, []newTableEntry), files []ingestSplitFile, - replacedFiles map[base.FileNum][]newFileEntry, + replacedFiles map[base.FileNum][]newTableEntry, ) error { for _, s := range files { ingestFileBounds := s.ingestFile.UserKeyBounds() @@ -2168,7 +2168,7 @@ func (d *DB) ingestSplit( if err != nil { return err } - if _, ok := ve.DeletedFiles[deletedFileEntry{ + if _, ok := ve.DeletedTables[deletedFileEntry{ Level: s.level, FileNum: splitFile.FileNum, }]; !ok { @@ -2185,17 +2185,17 @@ func (d *DB) ingestSplit( } // Flatten the version edit by removing any entries from ve.NewFiles that // are also in ve.DeletedFiles. - newNewFiles := ve.NewFiles[:0] - for i := range ve.NewFiles { - fn := ve.NewFiles[i].Meta.FileNum - deEntry := deletedFileEntry{Level: ve.NewFiles[i].Level, FileNum: fn} - if _, ok := ve.DeletedFiles[deEntry]; ok { - delete(ve.DeletedFiles, deEntry) + newNewFiles := ve.NewTables[:0] + for i := range ve.NewTables { + fn := ve.NewTables[i].Meta.FileNum + deEntry := deletedFileEntry{Level: ve.NewTables[i].Level, FileNum: fn} + if _, ok := ve.DeletedTables[deEntry]; ok { + delete(ve.DeletedTables, deEntry) } else { - newNewFiles = append(newNewFiles, ve.NewFiles[i]) + newNewFiles = append(newNewFiles, ve.NewTables[i]) } } - ve.NewFiles = newNewFiles + ve.NewTables = newNewFiles return nil } @@ -2211,10 +2211,10 @@ func (d *DB) ingestApply( defer d.mu.Unlock() ve := &versionEdit{ - NewFiles: make([]newFileEntry, lr.fileCount()), + NewTables: make([]newTableEntry, lr.fileCount()), } if exciseSpan.Valid() || (d.opts.Experimental.IngestSplit != nil && d.opts.Experimental.IngestSplit()) { - ve.DeletedFiles = map[manifest.DeletedFileEntry]*manifest.FileMetadata{} + ve.DeletedTables = map[manifest.DeletedTableEntry]*manifest.FileMetadata{} } metrics := make(map[int]*LevelMetrics) @@ -2291,7 +2291,7 @@ func (d *DB) ingestApply( ve.CreatedBackingTables = append(ve.CreatedBackingTables, m.FileBacking) } - f := &ve.NewFiles[i] + f := &ve.NewTables[i] var err error if specifiedLevel != -1 { f.Level = specifiedLevel @@ -2367,8 +2367,8 @@ func (d *DB) ingestApply( // possible for a file that we want to split to no longer exist or have a // newer fileMetadata due to a split induced by another ingestion file, or an // excise. - replacedFiles := make(map[base.FileNum][]newFileEntry) - updateLevelMetricsOnExcise := func(m *fileMetadata, level int, added []newFileEntry) { + replacedFiles := make(map[base.FileNum][]newTableEntry) + updateLevelMetricsOnExcise := func(m *fileMetadata, level int, added []newTableEntry) { levelMetrics := metrics[level] if levelMetrics == nil { levelMetrics = &LevelMetrics{} @@ -2407,7 +2407,7 @@ func (d *DB) ingestApply( return nil, err } - if _, ok := ve.DeletedFiles[deletedFileEntry{ + if _, ok := ve.DeletedTables[deletedFileEntry{ Level: level, FileNum: m.FileNum, }]; !ok { @@ -2499,13 +2499,13 @@ func (d *DB) ingestApply( // updateReadStateLocked could have generated obsolete tables, schedule a // cleanup job if necessary. d.deleteObsoleteFiles(jobID) - d.updateTableStatsLocked(ve.NewFiles) + d.updateTableStatsLocked(ve.NewTables) // The ingestion may have pushed a level over the threshold for compaction, // so check to see if one is necessary and schedule it. d.maybeScheduleCompaction() - var toValidate []manifest.NewFileEntry + var toValidate []manifest.NewTableEntry dedup := make(map[base.DiskFileNum]struct{}) - for _, entry := range ve.NewFiles { + for _, entry := range ve.NewTables { if _, ok := dedup[entry.Meta.FileBacking.DiskFileNum]; !ok { toValidate = append(toValidate, entry) dedup[entry.Meta.FileBacking.DiskFileNum] = struct{}{} @@ -2515,14 +2515,14 @@ func (d *DB) ingestApply( return ve, nil } -// maybeValidateSSTablesLocked adds the slice of newFileEntrys to the pending +// maybeValidateSSTablesLocked adds the slice of newTableEntrys to the pending // queue of files to be validated, when the feature is enabled. // // Note that if two entries with the same backing file are added twice, then the // block checksums for the backing file will be validated twice. // // DB.mu must be locked when calling. -func (d *DB) maybeValidateSSTablesLocked(newFiles []newFileEntry) { +func (d *DB) maybeValidateSSTablesLocked(newFiles []newTableEntry) { // Only add to the validation queue when the feature is enabled. if !d.opts.Experimental.ValidateOnIngest { return @@ -2568,7 +2568,7 @@ func (d *DB) validateSSTables() { // If we fail to validate any files due to reasons other than uncovered // corruption, accumulate them and re-queue them for another attempt. - var retry []manifest.NewFileEntry + var retry []manifest.NewTableEntry for _, f := range pending { // The file may have been moved or deleted since it was ingested, in diff --git a/ingest_test.go b/ingest_test.go index 93ab1bced4..f4176cff83 100644 --- a/ingest_test.go +++ b/ingest_test.go @@ -867,7 +867,7 @@ func TestExcise(t *testing.T) { case "excise": ve := &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{}, + DeletedTables: map[deletedFileEntry]*fileMetadata{}, } var exciseSpan KeyRange if len(td.CmdArgs) != 2 { @@ -893,7 +893,7 @@ func TestExcise(t *testing.T) { d.mu.Lock() d.mu.versions.logUnlock() d.mu.Unlock() - return fmt.Sprintf("would excise %d files, use ingest-and-excise to excise.\n%s", len(ve.DeletedFiles), ve.DebugString(base.DefaultFormatter)) + return fmt.Sprintf("would excise %d files, use ingest-and-excise to excise.\n%s", len(ve.DeletedTables), ve.DebugString(base.DefaultFormatter)) case "confirm-backing": // Confirms that the files have the same FileBacking. @@ -1219,7 +1219,7 @@ func testIngestSharedImpl( case "excise": ve := &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{}, + DeletedTables: map[deletedFileEntry]*fileMetadata{}, } var exciseSpan KeyRange if len(td.CmdArgs) != 2 { @@ -1247,7 +1247,7 @@ func testIngestSharedImpl( d.mu.Lock() d.mu.versions.logUnlock() d.mu.Unlock() - return fmt.Sprintf("would excise %d files, use ingest-and-excise to excise.\n%s", len(ve.DeletedFiles), ve.String()) + return fmt.Sprintf("would excise %d files, use ingest-and-excise to excise.\n%s", len(ve.DeletedTables), ve.String()) case "file-only-snapshot": if len(td.CmdArgs) != 1 { @@ -1721,7 +1721,7 @@ func TestConcurrentExcise(t *testing.T) { case "excise": ve := &versionEdit{ - DeletedFiles: map[deletedFileEntry]*fileMetadata{}, + DeletedTables: map[deletedFileEntry]*fileMetadata{}, } var exciseSpan KeyRange if len(td.CmdArgs) != 2 { @@ -1749,7 +1749,7 @@ func TestConcurrentExcise(t *testing.T) { d.mu.Lock() d.mu.versions.logUnlock() d.mu.Unlock() - return fmt.Sprintf("would excise %d files, use ingest-and-excise to excise.\n%s", len(ve.DeletedFiles), ve.String()) + return fmt.Sprintf("would excise %d files, use ingest-and-excise to excise.\n%s", len(ve.DeletedTables), ve.String()) case "file-only-snapshot": if len(td.CmdArgs) != 1 { @@ -3156,7 +3156,7 @@ func TestIngestMemtableOverlapRace(t *testing.T) { var ve manifest.VersionEdit require.NoError(t, ve.Decode(r)) t.Log(ve.String()) - for _, f := range ve.NewFiles { + for _, f := range ve.NewTables { if largest != nil { require.Equal(t, 0, f.Level) if largest.LargestSeqNum > f.Meta.LargestSeqNum { diff --git a/internal/keyspan/keyspanimpl/level_iter_test.go b/internal/keyspan/keyspanimpl/level_iter_test.go index decff7ca91..0239f0ee44 100644 --- a/internal/keyspan/keyspanimpl/level_iter_test.go +++ b/internal/keyspan/keyspanimpl/level_iter_test.go @@ -311,7 +311,7 @@ func TestLevelIterEquivalence(t *testing.T) { for i := range metas { amap[metas[i].FileNum] = metas[i] } - b.Added[6] = amap + b.AddedTables[6] = amap v, err := b.Apply(nil, base.DefaultComparer, 0, 0) require.NoError(t, err) levelIter.Init( diff --git a/internal/manifest/l0_sublevels_test.go b/internal/manifest/l0_sublevels_test.go index 8cdf199bbb..13e23d7f69 100644 --- a/internal/manifest/l0_sublevels_test.go +++ b/internal/manifest/l0_sublevels_test.go @@ -47,7 +47,7 @@ func readManifest(filename string) (*Version, error) { return nil, err } var bve BulkVersionEdit - bve.AddedByFileNum = addedByFileNum + bve.AddedTablesByFileNum = addedByFileNum if err := bve.Accumulate(&ve); err != nil { return nil, err } diff --git a/internal/manifest/manifest_test.go b/internal/manifest/manifest_test.go index cbca5f80ce..0a89b8a7b0 100644 --- a/internal/manifest/manifest_test.go +++ b/internal/manifest/manifest_test.go @@ -114,7 +114,7 @@ func replayManifest(t *testing.T, opts *pebble.Options, dirname string) *manifes cmp := opts.Comparer var bve manifest.BulkVersionEdit - bve.AddedByFileNum = make(map[base.FileNum]*manifest.FileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*manifest.FileMetadata) rr := record.NewReader(f, 0 /* logNum */) for { r, err := rr.Next() diff --git a/internal/manifest/version_edit.go b/internal/manifest/version_edit.go index 79e7ee5891..71d971026e 100644 --- a/internal/manifest/version_edit.go +++ b/internal/manifest/version_edit.go @@ -74,16 +74,16 @@ const ( customTagBlobReferences = 69 ) -// DeletedFileEntry holds the state for a file deletion from a level. The file -// itself might still be referenced by another level. -type DeletedFileEntry struct { +// DeletedTableEntry holds the state for a sstable deletion from a level. The +// table itself might still be referenced by another level. +type DeletedTableEntry struct { Level int FileNum base.FileNum } -// NewFileEntry holds the state for a new file or one moved from a different +// NewTableEntry holds the state for a new sstable or one moved from a different // level. -type NewFileEntry struct { +type NewTableEntry struct { Level int Meta *FileMetadata // BackingFileNum is only set during manifest replay, and only for virtual @@ -124,8 +124,8 @@ type VersionEdit struct { // A file num may be present in both deleted files and new files when it // is moved from a lower level to a higher level (when the compaction // found that there was no overlapping file at the higher level). - DeletedFiles map[DeletedFileEntry]*FileMetadata - NewFiles []NewFileEntry + DeletedTables map[DeletedTableEntry]*FileMetadata + NewTables []NewTableEntry // CreatedBackingTables can be used to preserve the FileBacking associated // with a physical sstable. This is useful when virtual sstables in the // latest version are reconstructed during manifest replay, and we also need @@ -252,10 +252,10 @@ func (v *VersionEdit) Decode(r io.Reader) error { if err != nil { return err } - if v.DeletedFiles == nil { - v.DeletedFiles = make(map[DeletedFileEntry]*FileMetadata) + if v.DeletedTables == nil { + v.DeletedTables = make(map[DeletedTableEntry]*FileMetadata) } - v.DeletedFiles[DeletedFileEntry{level, fileNum}] = nil + v.DeletedTables[DeletedTableEntry{level, fileNum}] = nil case tagNewFile, tagNewFile2, tagNewFile3, tagNewFile4, tagNewFile5: level, err := d.readLevel() @@ -487,14 +487,14 @@ func (v *VersionEdit) Decode(r io.Reader) error { m.InitPhysicalBacking() } - nfe := NewFileEntry{ + nfe := NewTableEntry{ Level: level, Meta: m, } if virtualState.virtual { nfe.BackingFileNum = base.DiskFileNum(virtualState.backingFileNum) } - v.NewFiles = append(v.NewFiles, nfe) + v.NewTables = append(v.NewTables, nfe) case tagNewBlobFile: fileNum, err := d.readFileNum() @@ -561,11 +561,11 @@ func (v *VersionEdit) string(verbose bool, fmtKey base.FormatKey) string { if v.LastSeqNum != 0 { fmt.Fprintf(&buf, " last-seq-num: %d\n", v.LastSeqNum) } - entries := make([]DeletedFileEntry, 0, len(v.DeletedFiles)) - for df := range v.DeletedFiles { + entries := make([]DeletedTableEntry, 0, len(v.DeletedTables)) + for df := range v.DeletedTables { entries = append(entries, df) } - slices.SortFunc(entries, func(a, b DeletedFileEntry) int { + slices.SortFunc(entries, func(a, b DeletedTableEntry) int { if v := stdcmp.Compare(a.Level, b.Level); v != 0 { return v } @@ -574,7 +574,7 @@ func (v *VersionEdit) string(verbose bool, fmtKey base.FormatKey) string { for _, df := range entries { fmt.Fprintf(&buf, " del-table: L%d %s\n", df.Level, df.FileNum) } - for _, nf := range v.NewFiles { + for _, nf := range v.NewTables { fmt.Fprintf(&buf, " add-table: L%d", nf.Level) fmt.Fprintf(&buf, " %s", nf.Meta.DebugString(fmtKey, verbose)) if nf.Meta.CreationTime != 0 { @@ -640,7 +640,7 @@ func ParseVersionEditDebug(s string) (_ *VersionEdit, err error) { if err != nil { return nil, err } - ve.NewFiles = append(ve.NewFiles, NewFileEntry{ + ve.NewTables = append(ve.NewTables, NewTableEntry{ Level: level, Meta: meta, }) @@ -648,10 +648,10 @@ func ParseVersionEditDebug(s string) (_ *VersionEdit, err error) { case "del-table": level := p.Level() num := p.FileNum() - if ve.DeletedFiles == nil { - ve.DeletedFiles = make(map[DeletedFileEntry]*FileMetadata) + if ve.DeletedTables == nil { + ve.DeletedTables = make(map[DeletedTableEntry]*FileMetadata) } - ve.DeletedFiles[DeletedFileEntry{ + ve.DeletedTables[DeletedTableEntry{ Level: level, FileNum: num, }] = nil @@ -720,12 +720,12 @@ func (v *VersionEdit) Encode(w io.Writer) error { e.writeUvarint(tagLastSequence) e.writeUvarint(uint64(v.LastSeqNum)) } - for x := range v.DeletedFiles { + for x := range v.DeletedTables { e.writeUvarint(tagDeletedFile) e.writeUvarint(uint64(x.Level)) e.writeUvarint(uint64(x.FileNum)) } - for _, x := range v.NewFiles { + for _, x := range v.NewTables { customFields := x.Meta.MarkedForCompaction || x.Meta.CreationTime != 0 || x.Meta.Virtual || len(x.Meta.BlobReferences) > 0 var tag uint64 switch { @@ -913,24 +913,24 @@ func (e versionEditEncoder) writeUvarint(u uint64) { // before (in a prior version edit). Note that a given file can be deleted from // a level and added to another level in a single version edit type BulkVersionEdit struct { - Added [NumLevels]map[base.FileNum]*FileMetadata - Deleted [NumLevels]map[base.FileNum]*FileMetadata + AddedTables [NumLevels]map[base.FileNum]*FileMetadata + DeletedTables [NumLevels]map[base.FileNum]*FileMetadata // AddedFileBacking is a map to support lookup so that we can populate the // FileBacking of virtual sstables during manifest replay. AddedFileBacking map[base.DiskFileNum]*FileBacking RemovedFileBacking []base.DiskFileNum - // AddedByFileNum maps file number to file metadata for all added files - // from accumulated version edits. AddedByFileNum is only populated if set - // to non-nil by a caller. It must be set to non-nil when replaying - // version edits read from a MANIFEST (as opposed to VersionEdits + // AddedTablesByFileNum maps file number to file metadata for all added + // files from accumulated version edits. AddedTablesByFileNum is only + // populated if set to non-nil by a caller. It must be set to non-nil when + // replaying version edits read from a MANIFEST (as opposed to VersionEdits // constructed in-memory). While replaying a MANIFEST file, - // VersionEdit.DeletedFiles map entries have nil values, because the - // on-disk deletion record encodes only the file number. Accumulate - // uses AddedByFileNum to correctly populate the BulkVersionEdit's Deleted + // VersionEdit.DeletedFiles map entries have nil values, because the on-disk + // deletion record encodes only the file number. Accumulate uses + // AddedTablesByFileNum to correctly populate the BulkVersionEdit's Deleted // field with non-nil *FileMetadata. - AddedByFileNum map[base.FileNum]*FileMetadata + AddedTablesByFileNum map[base.FileNum]*FileMetadata // MarkedForCompactionCountDiff holds the aggregated count of files // marked for compaction added or removed. @@ -953,19 +953,19 @@ type BulkVersionEdit struct { // of the accumulation, because we need to decrease the refcount of the // deleted file in Apply. func (b *BulkVersionEdit) Accumulate(ve *VersionEdit) error { - for df, m := range ve.DeletedFiles { - dmap := b.Deleted[df.Level] + for df, m := range ve.DeletedTables { + dmap := b.DeletedTables[df.Level] if dmap == nil { dmap = make(map[base.FileNum]*FileMetadata) - b.Deleted[df.Level] = dmap + b.DeletedTables[df.Level] = dmap } if m == nil { // m is nil only when replaying a MANIFEST. - if b.AddedByFileNum == nil { + if b.AddedTablesByFileNum == nil { return errors.Errorf("deleted file L%d.%s's metadata is absent and bve.AddedByFileNum is nil", df.Level, df.FileNum) } - m = b.AddedByFileNum[df.FileNum] + m = b.AddedTablesByFileNum[df.FileNum] if m == nil { return base.CorruptionErrorf("pebble: file deleted L%d.%s before it was inserted", df.Level, df.FileNum) } @@ -973,11 +973,11 @@ func (b *BulkVersionEdit) Accumulate(ve *VersionEdit) error { if m.MarkedForCompaction { b.MarkedForCompactionCountDiff-- } - if _, ok := b.Added[df.Level][df.FileNum]; !ok { + if _, ok := b.AddedTables[df.Level][df.FileNum]; !ok { dmap[df.FileNum] = m } else { // Present in b.Added for the same level. - delete(b.Added[df.Level], df.FileNum) + delete(b.AddedTables[df.Level], df.FileNum) } } @@ -997,10 +997,10 @@ func (b *BulkVersionEdit) Accumulate(ve *VersionEdit) error { b.AddedFileBacking[fb.DiskFileNum] = fb } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { // A new file should not have been deleted in this or a preceding // VersionEdit at the same level (though files can move across levels). - if dmap := b.Deleted[nf.Level]; dmap != nil { + if dmap := b.DeletedTables[nf.Level]; dmap != nil { if _, ok := dmap[nf.Meta.FileNum]; ok { return base.CorruptionErrorf("pebble: file deleted L%d.%s before it was inserted", nf.Level, nf.Meta.FileNum) } @@ -1016,12 +1016,12 @@ func (b *BulkVersionEdit) Accumulate(ve *VersionEdit) error { return errors.Errorf("Added file L%d.%s's has no FileBacking", nf.Level, nf.Meta.FileNum) } - if b.Added[nf.Level] == nil { - b.Added[nf.Level] = make(map[base.FileNum]*FileMetadata) + if b.AddedTables[nf.Level] == nil { + b.AddedTables[nf.Level] = make(map[base.FileNum]*FileMetadata) } - b.Added[nf.Level][nf.Meta.FileNum] = nf.Meta - if b.AddedByFileNum != nil { - b.AddedByFileNum[nf.Meta.FileNum] = nf.Meta + b.AddedTables[nf.Level][nf.Meta.FileNum] = nf.Meta + if b.AddedTablesByFileNum != nil { + b.AddedTablesByFileNum[nf.Meta.FileNum] = nf.Meta } if nf.Meta.MarkedForCompaction { b.MarkedForCompactionCountDiff++ @@ -1076,7 +1076,7 @@ func (b *BulkVersionEdit) Apply( v.RangeKeyLevels[level] = curr.RangeKeyLevels[level].clone() } - if len(b.Added[level]) == 0 && len(b.Deleted[level]) == 0 { + if len(b.AddedTables[level]) == 0 && len(b.DeletedTables[level]) == 0 { // There are no edits on this level. if level == 0 { // Initialize L0Sublevels. @@ -1096,19 +1096,19 @@ func (b *BulkVersionEdit) Apply( lm := &v.Levels[level] lmRange := &v.RangeKeyLevels[level] - addedFilesMap := b.Added[level] - deletedFilesMap := b.Deleted[level] - if n := v.Levels[level].Len() + len(addedFilesMap); n == 0 { + addedTablesMap := b.AddedTables[level] + deletedTablesMap := b.DeletedTables[level] + if n := v.Levels[level].Len() + len(addedTablesMap); n == 0 { return nil, base.CorruptionErrorf( "pebble: internal error: No current or added files but have deleted files: %d", - errors.Safe(len(deletedFilesMap))) + errors.Safe(len(deletedTablesMap))) } // NB: addedFilesMap may be empty. If a file is present in addedFilesMap // for a level, it won't be present in deletedFilesMap for the same // level. - for _, f := range deletedFilesMap { + for _, f := range deletedTablesMap { if obsolete := v.Levels[level].remove(f); obsolete { // Deleting a file from the B-Tree may decrement its // reference count. However, because we cloned the @@ -1129,19 +1129,19 @@ func (b *BulkVersionEdit) Apply( } } - addedFiles := make([]*FileMetadata, 0, len(addedFilesMap)) - for _, f := range addedFilesMap { - addedFiles = append(addedFiles, f) + addedTables := make([]*FileMetadata, 0, len(addedTablesMap)) + for _, f := range addedTablesMap { + addedTables = append(addedTables, f) } // Sort addedFiles by file number. This isn't necessary, but tests which // replay invalid manifests check the error output, and the error output // depends on the order in which files are added to the btree. - slices.SortFunc(addedFiles, func(a, b *FileMetadata) int { + slices.SortFunc(addedTables, func(a, b *FileMetadata) int { return stdcmp.Compare(a.FileNum, b.FileNum) }) var sm, la *FileMetadata - for _, f := range addedFiles { + for _, f := range addedTables { // NB: allowedSeeks is used for read triggered compactions. It is set using // Options.Experimental.ReadCompactionRate which defaults to 32KB. var allowedSeeks int64 @@ -1175,14 +1175,14 @@ func (b *BulkVersionEdit) Apply( } if level == 0 { - if curr != nil && curr.L0Sublevels != nil && len(deletedFilesMap) == 0 { + if curr != nil && curr.L0Sublevels != nil && len(deletedTablesMap) == 0 { // Flushes and ingestions that do not delete any L0 files do not require // a regeneration of L0Sublevels from scratch. We can instead generate // it incrementally. var err error // AddL0Files requires addedFiles to be sorted in seqnum order. - SortBySeqNum(addedFiles) - v.L0Sublevels, err = curr.L0Sublevels.AddL0Files(addedFiles, flushSplitBytes, &v.Levels[0]) + SortBySeqNum(addedTables) + v.L0Sublevels, err = curr.L0Sublevels.AddL0Files(addedTables, flushSplitBytes, &v.Levels[0]) if errors.Is(err, errInvalidL0SublevelsOpt) { err = v.InitL0Sublevels(flushSplitBytes) } else if invariants.Enabled && err == nil { @@ -1215,8 +1215,8 @@ func (b *BulkVersionEdit) Apply( // Check consistency of the level in the vicinity of our edits. if sm != nil && la != nil { overlap := v.Levels[level].Slice().Overlaps(comparer.Compare, sm.UserKeyBounds()) - // overlap contains all of the added files. We want to ensure that - // the added files are consistent with neighboring existing files + // overlap contains all of the added tables. We want to ensure that + // the added tables are consistent with neighboring existing tables // too, so reslice the overlap to pull in a neighbor on each side. check := overlap.Reslice(func(start, end *LevelIterator) { if m := start.Prev(); m == nil { diff --git a/internal/manifest/version_edit_test.go b/internal/manifest/version_edit_test.go index d12071f59c..9d6d0b56e4 100644 --- a/internal/manifest/version_edit_test.go +++ b/internal/manifest/version_edit_test.go @@ -91,7 +91,7 @@ func TestVERoundTripAndAccumulate(t *testing.T) { NextFileNum: 44, LastSeqNum: 55, CreatedBackingTables: []*FileBacking{m1.FileBacking}, - NewFiles: []NewFileEntry{ + NewTables: []NewTableEntry{ { Level: 4, Meta: m2, @@ -224,7 +224,7 @@ func TestVersionEditRoundTrip(t *testing.T) { LastSeqNum: 55, RemovedBackingTables: []base.DiskFileNum{10, 11}, CreatedBackingTables: []*FileBacking{m5.FileBacking, m6.FileBacking}, - DeletedFiles: map[DeletedFileEntry]*FileMetadata{ + DeletedTables: map[DeletedTableEntry]*FileMetadata{ { Level: 3, FileNum: 703, @@ -234,7 +234,7 @@ func TestVersionEditRoundTrip(t *testing.T) { FileNum: 704, }: nil, }, - NewFiles: []NewFileEntry{ + NewTables: []NewTableEntry{ { Level: 4, Meta: m1, @@ -413,11 +413,11 @@ func TestVersionEditApply(t *testing.T) { } bve := BulkVersionEdit{} - bve.AddedByFileNum = make(map[base.FileNum]*FileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*FileMetadata) for _, l := range v.Levels { it := l.Iter() for f := it.First(); f != nil; f = it.Next() { - bve.AddedByFileNum[f.FileNum] = f + bve.AddedTablesByFileNum[f.FileNum] = f } } diff --git a/replay/replay.go b/replay/replay.go index e1f2b8bd4a..49604ed823 100644 --- a/replay/replay.go +++ b/replay/replay.go @@ -713,7 +713,7 @@ func (r *Runner) prepareWorkloadSteps(ctx context.Context) error { var v *manifest.Version var previousVersion *manifest.Version var bve manifest.BulkVersionEdit - bve.AddedByFileNum = make(map[base.FileNum]*manifest.FileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*manifest.FileMetadata) applyVE := func(ve *manifest.VersionEdit) error { return bve.Accumulate(ve) } @@ -723,7 +723,7 @@ func (r *Runner) prepareWorkloadSteps(ctx context.Context) error { r.Opts.Comparer, r.Opts.FlushSplitBytes, r.Opts.Experimental.ReadCompactionRate) - bve = manifest.BulkVersionEdit{AddedByFileNum: bve.AddedByFileNum} + bve = manifest.BulkVersionEdit{AddedTablesByFileNum: bve.AddedTablesByFileNum} return v, err } @@ -783,14 +783,14 @@ func (r *Runner) prepareWorkloadSteps(ctx context.Context) error { // r.workload.manifestOff, and we should skip it. continue } - if len(ve.NewFiles) == 0 && len(ve.DeletedFiles) == 0 { + if len(ve.NewTables) == 0 && len(ve.DeletedTables) == 0 { // Skip WAL rotations and other events that don't affect the // files of the LSM. continue } s := workloadStep{ve: ve} - if len(ve.DeletedFiles) > 0 { + if len(ve.DeletedTables) > 0 { // If a version edit deletes files, we assume it's a compaction. s.kind = compactionStepKind } else { @@ -800,7 +800,7 @@ func (r *Runner) prepareWorkloadSteps(ctx context.Context) error { s.kind = ingestStepKind } var newFiles []base.DiskFileNum - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { newFiles = append(newFiles, nf.Meta.FileBacking.DiskFileNum) if s.kind == ingestStepKind && (nf.Meta.SmallestSeqNum != nf.Meta.LargestSeqNum || nf.Level != 0) { s.kind = flushStepKind diff --git a/table_stats.go b/table_stats.go index 469d394a3e..4f4b63184f 100644 --- a/table_stats.go +++ b/table_stats.go @@ -55,9 +55,9 @@ func (d *DB) maybeCollectTableStatsLocked() { // updateTableStatsLocked is called when new files are introduced, after the // read state has been updated. It may trigger a new stat collection. // DB.mu must be locked when calling. -func (d *DB) updateTableStatsLocked(newFiles []manifest.NewFileEntry) { +func (d *DB) updateTableStatsLocked(newTables []manifest.NewTableEntry) { var needStats bool - for _, nf := range newFiles { + for _, nf := range newTables { if !nf.Meta.StatsValid() { needStats = true break @@ -67,7 +67,7 @@ func (d *DB) updateTableStatsLocked(newFiles []manifest.NewFileEntry) { return } - d.mu.tableStats.pending = append(d.mu.tableStats.pending, newFiles...) + d.mu.tableStats.pending = append(d.mu.tableStats.pending, newTables...) d.maybeCollectTableStatsLocked() } @@ -169,7 +169,7 @@ type collectedStats struct { } func (d *DB) loadNewFileStats( - rs *readState, pending []manifest.NewFileEntry, + rs *readState, pending []manifest.NewTableEntry, ) ([]collectedStats, []deleteCompactionHint) { var hints []deleteCompactionHint collected := make([]collectedStats, 0, len(pending)) diff --git a/tool/db.go b/tool/db.go index 76f8bf5358..4a20779e98 100644 --- a/tool/db.go +++ b/tool/db.go @@ -690,7 +690,7 @@ func (d *dbT) runProperties(cmd *cobra.Command, args []string) { cmp := base.DefaultComparer var bve manifest.BulkVersionEdit - bve.AddedByFileNum = make(map[base.FileNum]*manifest.FileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*manifest.FileMetadata) rr := record.NewReader(f, 0 /* logNum */) for { r, err := rr.Next() diff --git a/tool/find.go b/tool/find.go index 89cf0d86a7..ab9604bcad 100644 --- a/tool/find.go +++ b/tool/find.go @@ -260,11 +260,11 @@ func (f *findT) readManifests(stdout io.Writer) { if num := ve.MinUnflushedLogNum; num != 0 { f.editRefs[num] = append(f.editRefs[num], i) } - for df := range ve.DeletedFiles { + for df := range ve.DeletedTables { diskFileNum := base.PhysicalTableDiskFileNum(df.FileNum) f.editRefs[diskFileNum] = append(f.editRefs[diskFileNum], i) } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { // The same file can be deleted and added in a single version edit // which indicates a "move" compaction. Only add the edit to the list // once. @@ -575,14 +575,14 @@ func (f *findT) tableProvenance(fileNum base.FileNum) string { for len(editRefs) > 0 { ve := f.edits[editRefs[0]] editRefs = editRefs[1:] - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { if fileNum != nf.Meta.FileNum { continue } var buf bytes.Buffer switch { - case len(ve.DeletedFiles) > 0: + case len(ve.DeletedTables) > 0: // A version edit with deleted files is a compaction. The deleted // files are the inputs to the compaction. We're going to // reconstruct the input files and display those inputs that @@ -591,7 +591,7 @@ func (f *findT) tableProvenance(fileNum base.FileNum) string { // been elided. var sourceLevels []int levels := make(map[int][]base.FileNum) - for df := range ve.DeletedFiles { + for df := range ve.DeletedTables { files := levels[df.Level] if len(files) == 0 { sourceLevels = append(sourceLevels, df.Level) @@ -655,9 +655,9 @@ func (f *findT) tableProvenance(fileNum base.FileNum) string { for len(editRefs) > 0 { ve := f.edits[editRefs[0]] editRefs = editRefs[1:] - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { if fileNum == nf.Meta.FileNum { - for df := range ve.DeletedFiles { + for df := range ve.DeletedTables { if fileNum == df.FileNum { fmt.Fprintf(&buf, ", moved to L%d", nf.Level) break diff --git a/tool/lsm.go b/tool/lsm.go index a5dc528afc..3bce20ee46 100644 --- a/tool/lsm.go +++ b/tool/lsm.go @@ -243,8 +243,8 @@ func (l *lsmT) readManifest(path string) []*manifest.VersionEdit { func (l *lsmT) buildKeys(edits []*manifest.VersionEdit) { var keys []base.InternalKey for _, ve := range edits { - for i := range ve.NewFiles { - nf := &ve.NewFiles[i] + for i := range ve.NewTables { + nf := &ve.NewTables[i] keys = append(keys, nf.Meta.Smallest) keys = append(keys, nf.Meta.Largest) } @@ -283,7 +283,7 @@ func (l *lsmT) buildEdits(edits []*manifest.VersionEdit) error { for _, i := range ve.CreatedBackingTables { backings[i.DiskFileNum] = i } - if len(ve.DeletedFiles) == 0 && len(ve.NewFiles) == 0 { + if len(ve.DeletedTables) == 0 && len(ve.NewTables) == 0 { continue } @@ -293,8 +293,8 @@ func (l *lsmT) buildEdits(edits []*manifest.VersionEdit) error { Deleted: make(map[int][]base.FileNum), } - for j := range ve.NewFiles { - nf := &ve.NewFiles[j] + for j := range ve.NewTables { + nf := &ve.NewTables[j] if b, ok := backings[nf.BackingFileNum]; ok && nf.Meta.Virtual { nf.Meta.FileBacking = b } @@ -312,7 +312,7 @@ func (l *lsmT) buildEdits(edits []*manifest.VersionEdit) error { currentFiles[nf.Level] = append(currentFiles[nf.Level], nf.Meta) } - for df := range ve.DeletedFiles { + for df := range ve.DeletedTables { edit.Deleted[df.Level] = append(edit.Deleted[df.Level], df.FileNum) for j, f := range currentFiles[df.Level] { if f.FileNum == df.FileNum { @@ -351,7 +351,7 @@ func (l *lsmT) coalesceEdits(edits []*manifest.VersionEdit) ([]*manifest.Version } be := manifest.BulkVersionEdit{} - be.AddedByFileNum = make(map[base.FileNum]*manifest.FileMetadata) + be.AddedTablesByFileNum = make(map[base.FileNum]*manifest.FileMetadata) // Coalesce all edits from [0, l.startEdit) into a BulkVersionEdit. for _, ve := range edits[:l.startEdit] { @@ -362,12 +362,12 @@ func (l *lsmT) coalesceEdits(edits []*manifest.VersionEdit) ([]*manifest.Version } startingEdit := edits[l.startEdit] - var beNewFiles []manifest.NewFileEntry - beDeletedFiles := make(map[manifest.DeletedFileEntry]*manifest.FileMetadata) + var beNewFiles []manifest.NewTableEntry + beDeletedFiles := make(map[manifest.DeletedTableEntry]*manifest.FileMetadata) - for level, deletedFiles := range be.Deleted { + for level, deletedFiles := range be.DeletedTables { for _, file := range deletedFiles { - dfe := manifest.DeletedFileEntry{ + dfe := manifest.DeletedTableEntry{ Level: level, FileNum: file.FileNum, } @@ -376,22 +376,22 @@ func (l *lsmT) coalesceEdits(edits []*manifest.VersionEdit) ([]*manifest.Version } // Filter out added files that were also deleted in the BulkVersionEdit. - for level, newFiles := range be.Added { + for level, newFiles := range be.AddedTables { for _, file := range newFiles { - dfe := manifest.DeletedFileEntry{ + dfe := manifest.DeletedTableEntry{ Level: level, FileNum: file.FileNum, } if _, ok := beDeletedFiles[dfe]; !ok { - beNewFiles = append(beNewFiles, manifest.NewFileEntry{ + beNewFiles = append(beNewFiles, manifest.NewTableEntry{ Level: level, Meta: file, }) } } } - startingEdit.NewFiles = append(beNewFiles, startingEdit.NewFiles...) + startingEdit.NewTables = append(beNewFiles, startingEdit.NewTables...) edits = edits[l.startEdit:] return edits, nil @@ -402,14 +402,14 @@ func (l *lsmT) findKey(key base.InternalKey) int { } func (l *lsmT) reason(ve *manifest.VersionEdit) string { - if len(ve.DeletedFiles) > 0 { + if len(ve.DeletedTables) > 0 { return "compacted" } if ve.MinUnflushedLogNum != 0 { return "flushed" } - for i := range ve.NewFiles { - nf := &ve.NewFiles[i] + for i := range ve.NewTables { + nf := &ve.NewTables[i] if nf.Meta.SmallestSeqNum == nf.Meta.LargestSeqNum { return "ingested" } diff --git a/tool/manifest.go b/tool/manifest.go index c9ba098ec6..e0b50e941b 100644 --- a/tool/manifest.go +++ b/tool/manifest.go @@ -151,7 +151,7 @@ func (m *manifestT) runDump(cmd *cobra.Command, args []string) { fmt.Fprintf(stdout, "%s\n", arg) var bve manifest.BulkVersionEdit - bve.AddedByFileNum = make(map[base.FileNum]*manifest.FileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*manifest.FileMetadata) var comparer *base.Comparer var editIdx int rr := record.NewReader(f, 0 /* logNum */) @@ -206,12 +206,12 @@ func (m *manifestT) runDump(cmd *cobra.Command, args []string) { empty = false fmt.Fprintf(stdout, " last-seq-num: %d\n", ve.LastSeqNum) } - entries := make([]manifest.DeletedFileEntry, 0, len(ve.DeletedFiles)) - for df := range ve.DeletedFiles { + entries := make([]manifest.DeletedTableEntry, 0, len(ve.DeletedTables)) + for df := range ve.DeletedTables { empty = false entries = append(entries, df) } - slices.SortFunc(entries, func(a, b manifest.DeletedFileEntry) int { + slices.SortFunc(entries, func(a, b manifest.DeletedTableEntry) int { if v := cmp.Compare(a.Level, b.Level); v != 0 { return v } @@ -220,7 +220,7 @@ func (m *manifestT) runDump(cmd *cobra.Command, args []string) { for _, df := range entries { fmt.Fprintf(stdout, " deleted: L%d %s\n", df.Level, df.FileNum) } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { empty = false fmt.Fprintf(stdout, " added: L%d %s:%d", nf.Level, nf.Meta.FileNum, nf.Meta.Size) @@ -260,12 +260,12 @@ func anyOverlap(cmp base.Compare, ve *manifest.VersionEdit, start, end key) bool if start == nil && end == nil { return true } - for _, df := range ve.DeletedFiles { + for _, df := range ve.DeletedTables { if anyOverlapFile(cmp, df, start, end) { return true } } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { if anyOverlapFile(cmp, nf.Meta, start, end) { return true } @@ -323,7 +323,7 @@ func (m *manifestT) runSummarizeOne(stdout io.Writer, arg string) error { buckets = map[time.Time]*summaryBucket{} metadatas = map[base.FileNum]*manifest.FileMetadata{} ) - bve.AddedByFileNum = make(map[base.FileNum]*manifest.FileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*manifest.FileMetadata) rr := record.NewReader(f, 0 /* logNum */) numHistErrors := 0 for i := 0; ; i++ { @@ -354,10 +354,10 @@ func (m *manifestT) runSummarizeOne(stdout io.Writer, arg string) error { // // TODO(sumeer): this summarization needs a rewrite. We could do that // after adding an enum to the VersionEdit to aid the summarization. - isLikelyCompaction := len(ve.NewFiles) > 0 && len(ve.DeletedFiles) > 0 && len(ve.CreatedBackingTables) == 0 - isIntraL0Compaction := isLikelyCompaction && ve.NewFiles[0].Level == 0 + isLikelyCompaction := len(ve.NewTables) > 0 && len(ve.DeletedTables) > 0 && len(ve.CreatedBackingTables) == 0 + isIntraL0Compaction := isLikelyCompaction && ve.NewTables[0].Level == 0 veNewest := newestOverall - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { _, seen := metadatas[nf.Meta.FileNum] if seen && !isLikelyCompaction { // Output error and continue processing as usual. @@ -396,7 +396,7 @@ func (m *manifestT) runSummarizeOne(stdout io.Writer, arg string) error { buckets[bucketKey] = b } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { if !isLikelyCompaction { b.bytesAdded[nf.Level] += nf.Meta.Size } else if !isIntraL0Compaction { @@ -405,7 +405,7 @@ func (m *manifestT) runSummarizeOne(stdout io.Writer, arg string) error { } } - for dfe := range ve.DeletedFiles { + for dfe := range ve.DeletedTables { // Increase `bytesCompactOut` for the input level of any compactions // that remove bytes from a level (excluding intra-L0 compactions). if isLikelyCompaction && !isIntraL0Compaction && dfe.Level != manifest.NumLevels-1 { @@ -598,7 +598,7 @@ func (m *manifestT) runCheck(cmd *cobra.Command, args []string) { break } var bve manifest.BulkVersionEdit - bve.AddedByFileNum = addedByFileNum + bve.AddedTablesByFileNum = addedByFileNum if err := bve.Accumulate(&ve); err != nil { fmt.Fprintf(stderr, "%s\n", err) ok = false @@ -618,8 +618,8 @@ func (m *manifestT) runCheck(cmd *cobra.Command, args []string) { m.fmtKey.setForComparer(ve.ComparerName, m.comparers) } empty = empty && ve.MinUnflushedLogNum == 0 && ve.ObsoletePrevLogNum == 0 && - ve.LastSeqNum == 0 && len(ve.DeletedFiles) == 0 && - len(ve.NewFiles) == 0 + ve.LastSeqNum == 0 && len(ve.DeletedTables) == 0 && + len(ve.NewTables) == 0 if empty { continue } @@ -632,10 +632,10 @@ func (m *manifestT) runCheck(cmd *cobra.Command, args []string) { fmt.Fprintf(stdout, "Version state before failed Apply\n") m.printLevels(cmp.Compare, stdout, v) fmt.Fprintf(stdout, "Version edit that failed\n") - for df := range ve.DeletedFiles { + for df := range ve.DeletedTables { fmt.Fprintf(stdout, " deleted: L%d %s\n", df.Level, df.FileNum) } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { fmt.Fprintf(stdout, " added: L%d %s:%d", nf.Level, nf.Meta.FileNum, nf.Meta.Size) formatSeqNumRange(stdout, nf.Meta.SmallestSeqNum, nf.Meta.LargestSeqNum) diff --git a/version_set.go b/version_set.go index b8dc4f2a27..d2e7230fad 100644 --- a/version_set.go +++ b/version_set.go @@ -26,12 +26,12 @@ const manifestMarkerName = `manifest` // Provide type aliases for the various manifest structs. type bulkVersionEdit = manifest.BulkVersionEdit -type deletedFileEntry = manifest.DeletedFileEntry +type deletedFileEntry = manifest.DeletedTableEntry type fileMetadata = manifest.FileMetadata type physicalMeta = manifest.PhysicalFileMeta type virtualMeta = manifest.VirtualFileMeta type fileBacking = manifest.FileBacking -type newFileEntry = manifest.NewFileEntry +type newTableEntry = manifest.NewTableEntry type version = manifest.Version type versionEdit = manifest.VersionEdit type versionList = manifest.VersionList @@ -232,7 +232,7 @@ func (vs *versionSet) load( // Read the versionEdits in the manifest file. var bve bulkVersionEdit - bve.AddedByFileNum = make(map[base.FileNum]*fileMetadata) + bve.AddedTablesByFileNum = make(map[base.FileNum]*fileMetadata) manifest, err := vs.fs.Open(manifestPath) if err != nil { return errors.Wrapf(err, "pebble: could not open manifest file %q for DB %q", @@ -316,7 +316,7 @@ func (vs *versionSet) load( vs.virtualBackings.AddAndRef(b) } - for _, addedLevel := range bve.Added { + for _, addedLevel := range bve.AddedTables { for _, m := range addedLevel { if m.Virtual { vs.virtualBackings.AddTable(m) @@ -327,7 +327,7 @@ func (vs *versionSet) load( if invariants.Enabled { // There should be no deleted tables or backings, since we're starting from // an empty state. - for _, deletedLevel := range bve.Deleted { + for _, deletedLevel := range bve.DeletedTables { if len(deletedLevel) != 0 { panic("deleted files after manifest replay") } @@ -518,7 +518,7 @@ func (vs *versionSet) logAndApply( // // The logic below uses the min of the last snapshot file count and the file // count in the current version. - vs.rotationHelper.AddRecord(int64(len(ve.DeletedFiles) + len(ve.NewFiles))) + vs.rotationHelper.AddRecord(int64(len(ve.DeletedTables) + len(ve.NewTables))) sizeExceeded := vs.manifest.Size() >= vs.opts.MaxManifestFileSize requireRotation := forceRotation || vs.manifest == nil @@ -743,7 +743,7 @@ func getZombiesAndUpdateVirtualBackings( // Note that for the common case where there are very few elements, the map // will stay on the stack. stillUsed := make(map[base.DiskFileNum]struct{}) - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { if !nf.Meta.Virtual { stillUsed[nf.Meta.FileBacking.DiskFileNum] = struct{}{} _, localFileDelta := sizeIfLocal(nf.Meta.FileBacking, provider) @@ -753,7 +753,7 @@ func getZombiesAndUpdateVirtualBackings( for _, b := range ve.CreatedBackingTables { stillUsed[b.DiskFileNum] = struct{}{} } - for _, m := range ve.DeletedFiles { + for _, m := range ve.DeletedTables { if !m.Virtual { // NB: this deleted file may also be in NewFiles or // CreatedBackingTables, due to a file moving between levels, or @@ -780,12 +780,12 @@ func getZombiesAndUpdateVirtualBackings( _, localFileDelta := sizeIfLocal(b, provider) localLiveSizeDelta += localFileDelta } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { if nf.Meta.Virtual { virtualBackings.AddTable(nf.Meta) } } - for _, m := range ve.DeletedFiles { + for _, m := range ve.DeletedTables { if m.Virtual { virtualBackings.RemoveTable(m) } @@ -910,7 +910,7 @@ func (vs *versionSet) createManifest( for level, levelMetadata := range vs.currentVersion().Levels { iter := levelMetadata.Iter() for meta := iter.First(); meta != nil; meta = iter.Next() { - snapshot.NewFiles = append(snapshot.NewFiles, newFileEntry{ + snapshot.NewTables = append(snapshot.NewTables, newTableEntry{ Level: level, Meta: meta, }) @@ -1116,7 +1116,7 @@ func findCurrentManifest( return marker, manifestNum, true, nil } -func newFileMetrics(newFiles []manifest.NewFileEntry) map[int]*LevelMetrics { +func newFileMetrics(newFiles []manifest.NewTableEntry) map[int]*LevelMetrics { m := map[int]*LevelMetrics{} for _, nf := range newFiles { lm := m[nf.Level] diff --git a/version_set_test.go b/version_set_test.go index fb37bc21e5..577cf74f74 100644 --- a/version_set_test.go +++ b/version_set_test.go @@ -88,7 +88,7 @@ func TestVersionSet(t *testing.T) { if err != nil { td.Fatalf(t, "%v", err) } - for _, nf := range ve.NewFiles { + for _, nf := range ve.NewTables { // Set a size that depends on FileNum. nf.Meta.Size = uint64(nf.Meta.FileNum) * 100 nf.Meta.FileBacking = dedupBacking(nf.Meta.FileBacking) @@ -97,20 +97,20 @@ func TestVersionSet(t *testing.T) { createFile(nf.Meta.FileBacking.DiskFileNum) } } - for de := range ve.DeletedFiles { + for de := range ve.DeletedTables { m := metas[de.FileNum] if m == nil { td.Fatalf(t, "unknown FileNum %s", de.FileNum) } - ve.DeletedFiles[de] = m + ve.DeletedTables[de] = m } for i := range ve.CreatedBackingTables { ve.CreatedBackingTables[i] = dedupBacking(ve.CreatedBackingTables[i]) createFile(ve.CreatedBackingTables[i].DiskFileNum) } - fileMetrics := newFileMetrics(ve.NewFiles) - for de, f := range ve.DeletedFiles { + fileMetrics := newFileMetrics(ve.NewTables) + for de, f := range ve.DeletedTables { lm := fileMetrics[de.Level] if lm == nil { lm = &LevelMetrics{}