dima/qb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wp

Browse Source
This commit is contained in:
Dima Gordenko
2026-06-14 07:57:01 +03:00
parent 685c48f94f
commit 181031a753
14 changed files with 626 additions and 591 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
storage/replay_metric.go
View File

@@ -2,101 +2,50 @@ package storage
import (
"fmt"
"io"
bin "gordenko.dev/dima/bin/little"
"gordenko.dev/dima/qb"
)
type ReplayMetric struct {
metricType qb.MetricType
fracDigits byte
lastPageNo uint32
buf []byte
databuf []byte // якщо розмір buf == DataPageSize, то databuf буде менше (мінус футер)
tSize int
vSize int
indexLevelTails []IndexLevelTail // root - last element
MetricType qb.MetricType
FracDigits byte
LastPageNo uint32
Buf []byte
TimestampsSize int
ValuesSize int
IndexLevelTails []IndexLevelTail // root - last element
}
func (s *ReplayMetric) ReadFrom(r io.Reader) (err error) {
metricType, err := bin.ReadByte(r)
if err != nil {
return
}
s.metricType = qb.MetricType(metricType)
s.fracDigits, err = bin.ReadByte(r)
if err != nil {
return
}
s.lastPageNo, err = bin.ReadUint32(r)
if err != nil {
return
}
s.tSize, err = bin.ReadUint16AsInt(r)
if err != nil {
return
}
s.vSize, err = bin.ReadUint16AsInt(r)
if err != nil {
return
}
err = bin.ReadNInto(r, s.databuf[len(s.databuf)-s.tSize:])
if err != nil {
return
}
err = bin.ReadNInto(r, s.databuf[:s.vSize])
if err != nil {
return
}
//
levelsCount, err := bin.ReadVarSize(r)
if err != nil {
return
}
for range levelsCount {
var (
buf = make([]byte, IndexPageSize)
count int
)
count, err = bin.ReadVarSize(r)
if err != nil {
return
}
err = bin.ReadNInto(r, buf[:count*IndexRecordSize])
if err != nil {
return
}
s.indexLevelTails = append(s.indexLevelTails, IndexLevelTail{
Buffer: buf,
RecordsCount: count,
})
}
return
// return occupied after write
func writeTimestampsWithRewind(buf []byte, occupied int, payload []byte, rewindOffset int) int {
// timestamps writes right-to-left
pos := DataPagePayloadSize - occupied
// timestamps rewind offset moves pos left-to-right
pos += rewindOffset
pos -= len(payload)
copy(buf[pos:], payload)
return DataPagePayloadSize - pos
}
// func appendNewRecordsToIndexTail(level IndexLevelTail, records []byte) {
// }
// func countReusedIndexPages(changedIndexLevels []ChangedIndexLevel) (count int) {
// return
// }
func writeValuesWithRewind(buf []byte, occupied int, payload []byte, rewindOffset int) int {
// values writes left-to-right
pos := occupied
// values rewind offset moves pos right-to-left
pos -= rewindOffset
copy(buf[pos:], payload)
return pos + len(payload)
}
func (s *ReplayMetric) MeasuresAppend(rec MeasuresAppendRecord) {
timestampsSize := rec.TimestampsRewindOffset - len(rec.Timestamps)
// копіюю нові дані із WAL з урахуванням offset-ів
copy(s.databuf[rec.ValuesRewindOffset:], rec.Values)
copy(s.databuf[len(s.databuf)-timestampsSize:], rec.Timestamps)
//
s.tSize = timestampsSize
s.vSize = rec.ValuesRewindOffset - len(rec.Values)
s.TimestampsSize = writeTimestampsWithRewind(s.Buf, s.TimestampsSize,
rec.Timestamps, rec.TimestampsRewindOffset)
s.ValuesSize = writeValuesWithRewind(s.Buf, s.ValuesSize,
rec.Values, rec.ValuesRewindOffset)
}
type AppendMeasuresResult struct {
IndexPages []PageToWrite
DataPages []PageToWrite
IndexPagesToRewrite []PageToWrite
DataPagesToRewrite []PageToWrite
ReusedIndexPagesCount int
ReusedDataPagesCount int
}
@@ -117,8 +66,7 @@ func (s *ReplayMetric) MeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
// 1. набиваю сторінки для перезапису в index файлі
if isLastPacket {
if head != nil {
indexPages = append(indexPages,
composeHeadIndexPage(levelIdx, s.indexLevelTails[levelIdx], head))
indexPages = append(indexPages, s.composeHeadIndexPage(levelIdx, head))
}
for _, x := range change.IndexPages {
indexPages = append(indexPages, PageToWrite{
@@ -129,8 +77,8 @@ func (s *ReplayMetric) MeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
}
// 2. Вношу зміни в поточні індексні хвости
if levelIdx < len(s.indexLevelTails) {
level := s.indexLevelTails[levelIdx]
if levelIdx < len(s.IndexLevelTails) {
level := s.IndexLevelTails[levelIdx]
if head != nil {
// попередній хвіст індексного рівня перетворився на head сторінку,
// отже TailRecords - це новий хвіст
@@ -142,13 +90,13 @@ func (s *ReplayMetric) MeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
copy(level.Buffer[pos:], change.TailRecords)
level.RecordsCount += newRecordsCount
}
s.indexLevelTails[levelIdx] = level
s.IndexLevelTails[levelIdx] = level
} else {
// додаю новий індексний рівень
buf := make([]byte, IndexPageSize)
copy(buf, change.TailRecords)
//
s.indexLevelTails = append(s.indexLevelTails, IndexLevelTail{
s.IndexLevelTails = append(s.IndexLevelTails, IndexLevelTail{
Buffer: buf,
RecordsCount: newRecordsCount,
})
@@ -169,7 +117,7 @@ func (s *ReplayMetric) MeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
// 4. набиваю сторінки для перезапису в data файлі
if isLastPacket {
dataPages = append(dataPages, composeHeadDataPage(s.databuf, rec.DataPageTail))
dataPages = append(dataPages, s.composeHeadDataPage(rec.DataPageTail))
for _, x := range rec.DataPages {
dataPages = append(dataPages, PageToWrite{
@@ -190,22 +138,22 @@ func (s *ReplayMetric) MeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
}
// HeadDataPage є полюбому, оскільки це транзакція із мінімум однією заповненою
// data сторінкою. Отже TailTimestamps і TailValues - це нові хвости data рівня.
copy(s.databuf, rec.TailValues)
pos := len(s.databuf) - len(rec.TailTimestamps)
copy(s.databuf[pos:], rec.TailTimestamps)
copy(s.Buf, rec.TailValues)
s.ValuesSize = len(rec.TailValues)
s.tSize = len(rec.TailTimestamps)
s.vSize = len(rec.TailValues)
pos := DataPagePayloadSize - len(rec.TailTimestamps)
copy(s.Buf[pos:], rec.TailTimestamps)
s.TimestampsSize = len(rec.TailTimestamps)
if len(rec.DataPages) == 0 {
s.lastPageNo = rec.DataPageTail.PageNo
s.LastPageNo = rec.DataPageTail.PageNo
} else {
s.lastPageNo = rec.DataPages[len(rec.DataPages)-1].PageNo
s.LastPageNo = rec.DataPages[len(rec.DataPages)-1].PageNo
}
return AppendMeasuresResult{
IndexPages: indexPages,
DataPages: dataPages,
IndexPagesToRewrite: indexPages,
DataPagesToRewrite: dataPages,
ReusedIndexPagesCount: reusedIndexPages,
ReusedDataPagesCount: reusedDataPages,
}
@@ -213,7 +161,8 @@ func (s *ReplayMetric) MeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
// HELPERS
func composeHeadIndexPage(levelIdx int, level IndexLevelTail, head *IndexPageTail) PageToWrite {
func (s *ReplayMetric) composeHeadIndexPage(levelIdx int, head *IndexPageTail) PageToWrite {
level := s.IndexLevelTails[levelIdx]
// розраховую pos, з якого буду дописувати хвіст
pos := level.RecordsCount * IndexRecordSize
// створюю копію сторінки
@@ -238,23 +187,21 @@ func composeHeadIndexPage(levelIdx int, level IndexLevelTail, head *IndexPageTai
}
}
func composeHeadDataPage(databuf []byte, head DataPageTail) PageToWrite {
// створюю копію сторінки
var (
page = make([]byte, DataPageSize)
timestampsSize = head.TimestampsRewindOffset - len(head.Timestamps)
)
// копіюю поточні дані
copy(page, databuf)
// копіюю нові дані із WAL з урахуванням offset-ів
copy(page[head.ValuesRewindOffset:], head.Values)
copy(page[len(page)-timestampsSize:], head.Timestamps)
func (s *ReplayMetric) composeHeadDataPage(head DataPageTail) PageToWrite {
// copy page
page := make([]byte, DataPageSize)
copy(page, s.Buf)
// append data
timestampsSize := writeTimestampsWithRewind(s.Buf, s.TimestampsSize,
head.Timestamps, head.TimestampsRewindOffset)
valuesSize := writeValuesWithRewind(s.Buf, s.ValuesSize,
head.Values, head.ValuesRewindOffset)
// запечатати сторінку
calculatedCRC := SealDataPage(SealDataPageIn{
Content: page,
PrevPageNo: head.PrevPageNo,
TimestampsSize: timestampsSize,
ValuesSize: head.ValuesRewindOffset + len(head.Values),
ValuesSize: valuesSize,
})
// перевірка CRC
if calculatedCRC != head.CRC32 {
@@ -267,19 +214,3 @@ func composeHeadDataPage(databuf []byte, head DataPageTail) PageToWrite {
Content: page,
}
}
// func (s *ReplayMetric) ToMetric() *worker.metric {
// databuf := s.buf[:storage.DataPagePayloadSize]
// values := enc.NewValueDeltaCompressor(s.metricType, s.fracDigits, databuf, s.vSize)
// return &_metric{
// metricType: s.metricType,
// fracDigits: s.fracDigits,
// lastPageNo: s.lastPageNo,
// lastValue: values.LastValue(),
// buffer: s.buf,
// timestamps: enc.NewTimeDeltaCompressor(databuf, s.tSize),
// values: values,
// indexLevelTails: s.indexLevelTails,
// }
// }

275
storage/snapshot.go
View File

@@ -1,275 +0,0 @@
package storage
import (
"bufio"
"fmt"
"io"
"os"
"path/filepath"
bin "gordenko.dev/dima/bin/little"
"gordenko.dev/dima/qb/util"
)
/*
Формат:
metricsQty - varsize
[metric]*
де metric - це:
index free list frozen pages - varsize
indexFreeList size - varsize
indexFreeList - Nb
data free list frozen pages - varsize
dataFreeList size - varsize
dataFreeList - Nb
CRC32 - 4b
*/
const ReadBufferSize = 8 * 1024 * 1024 // 8mb
type WritableMetric interface {
WriteTo(io.Writer) error
}
type WriteSnapshotIn struct {
SnapshotNumber int
Dir string
WriteBufferSize int
Metrics map[uint32]WritableMetric
FrozenIndexPagesCount int
IndexPageNumbers []uint32
FrozenDataPagesCount int
DataPageNumbers []uint32
}
func WriteSnapshot(in WriteSnapshotIn) (err error) {
var (
fileName = filepath.Join(in.Dir, fmt.Sprintf("%d.snapshot", in.SnapshotNumber))
hasher = util.NewHasher()
)
file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0666) //0770)
if err != nil {
return
}
dst := io.MultiWriter(bufio.NewWriterSize(file, in.WriteBufferSize), hasher)
_, err = bin.WriteVarSize(dst, len(in.Metrics))
if err != nil {
return
}
for metricID, metric := range in.Metrics {
err = bin.WriteUint32(dst, metricID)
if err != nil {
return
}
err = metric.WriteTo(dst)
if err != nil {
return
}
}
// free index pages
err = writeFreePages(dst, in.FrozenIndexPagesCount, in.IndexPageNumbers)
if err != nil {
return
}
// free data pages
err = writeFreePages(dst, in.FrozenDataPagesCount, in.DataPageNumbers)
if err != nil {
return
}
// CRC32
bin.WriteUint32(file, hasher.Sum32())
err = file.Close()
if err != nil {
return
}
// prevLogNumber := logNumber - 1
// prevChanges := filepath.Join(s.dir, fmt.Sprintf("%d.changes", prevLogNumber))
// prevSnapshot := filepath.Join(s.dir, fmt.Sprintf("%d.snapshot", prevLogNumber))
// isExist, err := isFileExist(prevChanges)
// if err != nil {
// return
// }
// if isExist {
// err = os.Remove(prevChanges)
// if err != nil {
// qb.Abort(qb.DeletePrevChangesFileFailed, err)
// }
// }
// isExist, err = isFileExist(prevSnapshot)
// if err != nil {
// return
// }
// if isExist {
// err = os.Remove(prevSnapshot)
// if err != nil {
// qb.Abort(qb.DeletePrevSnapshotFileFailed, err)
// }
// }
return
}
type ReadSnapshotOut struct {
Metrics map[uint32]*ReplayMetric
FrozenIndexPagesCount int
IndexPageNumbers []uint32
FrozenDataPagesCount int
DataPageNumbers []uint32
}
func ReadSnapshot(fileName string) (out ReadSnapshotOut, err error) {
var (
metrics = make(map[uint32]*ReplayMetric)
frozenIndexPagesCount int
indexPageNumbers []uint32
frozenDataPagesCount int
dataPageNumbers []uint32
hasher = util.NewHasher()
)
file, err := os.Open(fileName)
if err != nil {
return
}
defer file.Close()
stat, err := file.Stat()
if err != nil {
return
}
fileSize := stat.Size()
if fileSize == 0 {
return ReadSnapshotOut{
Metrics: metrics,
}, nil
}
if fileSize < 4 {
err = fmt.Errorf("%s is corrupted", fileName)
return
}
payloadSize := fileSize - 4
// 2. Створюємо великий буфер для NVMe (4 MB)
bufferedReader := bufio.NewReaderSize(file, readBufferSize)
// 3. Обмежуємо читання лише розміром Payload
limitReader := io.LimitReader(bufferedReader, payloadSize)
// 4. Створюємо хеш та обгортку TeeReader, яка рахує CRC32 на льоту
src := io.TeeReader(limitReader, hasher)
// читаю payload
metricsQty, err := bin.ReadVarSize(src)
if err != nil {
return
}
for range metricsQty {
var (
metricID uint32
buf = make([]byte, DataPageSize)
// для простоти створюю буфер максимального розміру
metric = &ReplayMetric{
buf: buf,
databuf: buf[:DataPagePayloadSize],
}
)
metricID, err = bin.ReadUint32(src)
if err != nil {
return
}
err = metric.ReadFrom(src)
if err != nil {
return
}
metrics[metricID] = metric
}
// index pages
frozenIndexPagesCount, indexPageNumbers, err = readFreePages(src)
if err != nil {
return
}
// data pages
frozenDataPagesCount, dataPageNumbers, err = readFreePages(src)
if err != nil {
return
}
// verify CRC32
expectedCRC, err := bin.ReadUint32(bufferedReader)
if err != nil {
return
}
calculatedCRC := hasher.Sum32()
if expectedCRC != calculatedCRC {
err = fmt.Errorf("%s is corrupted. Calculated CRC %d not equal expected CRC %d",
fileName, calculatedCRC, expectedCRC)
return
}
return ReadSnapshotOut{
Metrics: metrics,
FrozenIndexPagesCount: frozenIndexPagesCount,
IndexPageNumbers: indexPageNumbers,
FrozenDataPagesCount: frozenDataPagesCount,
DataPageNumbers: dataPageNumbers,
}, nil
}
// HELPERS
func writeFreePages(dst io.Writer, frozenPagesCount int, pageNumbers []uint32) (err error) {
_, err = bin.WriteVarSize(dst, frozenPagesCount)
if err != nil {
return
}
_, err = bin.WriteVarSize(dst, len(pageNumbers))
if err != nil {
return
}
for _, pageNo := range pageNumbers {
err = bin.WriteUint32(dst, pageNo)
if err != nil {
return
}
}
return
}
func readFreePages(src io.Reader) (_ int, _ []uint32, err error) {
var (
frozenPagesCount int
pageNumbers []uint32
)
frozenPagesCount, err = bin.ReadVarSize(src)
if err != nil {
return
}
pageNumbersCount, err := bin.ReadVarSize(src)
if err != nil {
return
}
for range pageNumbersCount {
var pageNo uint32
pageNo, err = bin.ReadUint32(src)
if err != nil {
return
}
pageNumbers = append(pageNumbers, pageNo)
}
return frozenPagesCount, pageNumbers, nil
}

8
storage/storage.go
View File

@@ -72,7 +72,7 @@ type MeasuresAppendWithGrow struct {
IndexLevelTails []IndexLevelTail
ResultCode byte
WrittenCount int
ResultCh chan struct{}
ResultCh chan AppendMeasuresResult
}
type MeasuresAppend struct {
@@ -83,7 +83,7 @@ type MeasuresAppend struct {
Values []byte
ResultCode byte
WrittenCount int
ResultCh chan struct{}
ResultCh chan AppendMeasuresResult
}
type MeasuresDelete struct {
@@ -100,7 +100,7 @@ type MeasuresAppendCommited struct {
MetricID uint32
ResultCode byte
WrittenCount int
ResultCh chan struct{}
ResultCh chan AppendMeasuresResult
}
type MeasuresAppendWithGrowCommited struct {
@@ -109,7 +109,7 @@ type MeasuresAppendWithGrowCommited struct {
Index []IndexLevelTail
ResultCode byte
WrittenCount int
ResultCh chan struct{}
ResultCh chan AppendMeasuresResult
}
type MeasuresDeleteCommited struct {

109
storage/storage_test.go
View File

@@ -868,82 +868,49 @@ func TestWritePreparer(t *testing.T) {
}
}
func TestWriteReadSnapshot(t *testing.T) {
metrics := make(map[uint32]*_metric)
metrics[1] = &_metric{
metricType: qb.Cumulative,
fracDigits: 3,
lastPageNo: 1000,
buffer: []byte{},
}
in := WriteSnapshotIn{
SnapshotNumber: 1,
Dir: ".",
WriteBufferSize: 8 * 1024 * 1024,
Metrics: metrics,
FrozenIndexPagesCount: 7,
IndexPageNumbers: []uint32{
1, 2, 3, 4, 5,
},
FrozenDataPagesCount: 8,
DataPageNumbers: []uint32{
6, 7, 8,
},
}
err := WriteSnapshot(in)
if err != nil {
t.Fatalf("writeSnapshot: %s", err)
}
out, err := ReadSnapshot("1.snapshot")
if err != nil {
return
}
if out.FrozenIndexPagesCount != in.FrozenIndexPagesCount {
t.Fatalf("FrozenIndexPagesCount: got %d are not equal expected %d",
out.FrozenIndexPagesCount, in.FrozenIndexPagesCount)
}
if out.FrozenDataPagesCount != in.FrozenDataPagesCount {
t.Fatalf("FrozenDataPagesCount: got %d are not equal expected %d",
out.FrozenDataPagesCount, in.FrozenDataPagesCount)
}
if !slices.Equal(out.IndexPageNumbers, in.IndexPageNumbers) {
t.Fatalf("IndexPageNumbers: got %v are not equal expected %v",
out.IndexPageNumbers, in.IndexPageNumbers)
}
if !slices.Equal(out.DataPageNumbers, in.DataPageNumbers) {
t.Fatalf("DataPageNumbers: got %v are not equal expected %v",
out.DataPageNumbers, in.DataPageNumbers)
}
for metricID, replay := range out.Metrics {
origin, ok := metrics[metricID]
if !ok {
t.Fatalf("decoded metricID %d not found in metrics", metricID)
func TestWriteTimestampsWithRewind(t *testing.T) {
DataPagePayloadSize = 8
var (
payload = []byte{
0xaa, 0xbb, 0xcc,
}
err = cmpMetric(replay, origin)
if err != nil {
t.Fatalf("metric %d: %s", metricID, err)
before = []byte{
0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x02, 0x01,
}
occupied = 4
after = []byte{
0x00, 0x00, 0x00, 0xaa, 0xbb, 0xcc, 0x02, 0x01,
}
occupiedAfter = 5
)
occupied = writeTimestampsWithRewind(before, occupied, payload, 2)
if occupied != occupiedAfter {
t.Fatalf("got occupied %d are not equal expected %d", occupied, occupiedAfter)
}
if !bytes.Equal(before, after) {
t.Fatalf("got buf % x are not equal expected % x", before, after)
}
}
func cmpMetric(replay *ReplayMetric, origin *_metric) error {
if replay.metricType != origin.metricType {
return fmt.Errorf("metricType: got %d are not equal expected %d",
replay.metricType, origin.metricType)
func TestWriteValuesWithRewind(t *testing.T) {
var (
payload = []byte{
0xaa, 0xbb, 0xcc,
}
before = []byte{
0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
}
occupied = 4
after = []byte{
0x01, 0x02, 0xaa, 0xbb, 0xcc, 0x00, 0x00, 0x00,
}
occupiedAfter = 5
)
occupied = writeValuesWithRewind(before, occupied, payload, 2)
if occupied != occupiedAfter {
t.Fatalf("got occupied %d are not equal expected %d", occupied, occupiedAfter)
}
if replay.fracDigits != origin.fracDigits {
return fmt.Errorf("fracDigits: got %d are not equal expected %d",
replay.fracDigits, origin.fracDigits)
if !bytes.Equal(before, after) {
t.Fatalf("got buf % x are not equal expected % x", before, after)
}
if replay.lastPageNo != origin.lastPageNo {
return fmt.Errorf("lastPageNo: got %d are not equal expected %d",
replay.lastPageNo, origin.lastPageNo)
}
// if !refect.DeepEq{
// return fmt.Errorf("lastPageNo: got %d are not equal expected %d",
// replay.lastPageNo, origin.lastPageNo)
// }
return nil
}

20
storage/wal_reader.go
View File

@@ -173,14 +173,14 @@ func (s *WALReader) parseRecords(body []byte) ([]any, error) {
// HELPERS
func (s *WALReader) Seek(offset int64) error {
ret, err := s.file.Seek(offset, 0)
if err != nil {
return err
}
// func (s *WALReader) Seek(offset int64) error {
// ret, err := s.file.Seek(offset, 0)
// if err != nil {
// return err
// }
if ret != offset {
return fmt.Errorf("ret %d != offset %d", ret, offset)
}
return nil
}
// if ret != offset {
// return fmt.Errorf("ret %d != offset %d", ret, offset)
// }
// return nil
// }

51
storage/wal_replayer.go
View File

@@ -36,14 +36,22 @@ func NewWALReplayer(opt WALReplayerOptions) (*WALReplayer, error) {
}, nil
}
func (s *WALReplayer) IndexPages() []PageToWrite {
func (s *WALReplayer) IndexPagesToRewrite() []PageToWrite {
return s.indexPages
}
func (s *WALReplayer) DataPages() []PageToWrite {
func (s *WALReplayer) DataPagesToRewrite() []PageToWrite {
return s.dataPages
}
func (s *WALReplayer) FreeIndexPages() []uint32 {
return s.freeIndexPages
}
func (s *WALReplayer) FreeDataPages() []uint32 {
return s.freeDataPages
}
func (s *WALReplayer) Replay() error {
for {
records, isLastPacket, err := s.walReader.NextPacket()
@@ -101,10 +109,9 @@ func (s *WALReplayer) onMetricAdd(rec MetricAddRecord) (err error) {
buf = make([]byte, DataPageSize)
)
s.metrics[rec.MetricID] = &ReplayMetric{
metricType: rec.MetricType,
fracDigits: byte(rec.FracDigits),
buf: buf,
databuf: buf[:DataPagePayloadSize],
MetricType: rec.MetricType,
FracDigits: rec.FracDigits,
Buf: buf,
}
return
}
@@ -137,39 +144,11 @@ func (s *WALReplayer) onMeasuresAppendWithGrow(rec MeasuresAppendWithGrowRecord,
result := metric.MeasuresAppendWithGrow(rec, isLastPacket)
//
if isLastPacket {
s.indexPages = append(s.indexPages, result.IndexPages...)
s.dataPages = append(s.dataPages, result.DataPages...)
s.indexPages = append(s.indexPages, result.IndexPagesToRewrite...)
s.dataPages = append(s.dataPages, result.DataPagesToRewrite...)
}
//
s.freeIndexPages = s.freeIndexPages[:len(s.freeIndexPages)-result.ReusedIndexPagesCount]
s.freeDataPages = s.freeDataPages[:len(s.freeDataPages)-result.ReusedDataPagesCount]
return
}
//func (s *WALReplayer) collectPagesToWrite(metric *ReplayMetric, rec WALRecordAppendMeasures) {
// metric.ApplyHeadDataPage(rec.CompletedDataPage)
// s.dataPages = append(s.dataPages, PageToWrite{
// PageNo: p.PageNo,
// Content: metric.buf,
// })
// for _, x := range rec.DataPages {
// s.dataPages = append(s.dataPages, PageToWrite{
// PageNo: x.PageNo,
// Content: x.Content,
// })
// }
//metric.ApplyHeadIndexPages(rec.ChangedIndexLevels)
//}
// func (s *WALReplayer) replayPacket(records []any, isLastPacket bool) {
// for _, untyped := range records {
// switch rec := untyped.(type) {
// case WALRecordAppendMeasures:
// s.onWALRecordAppendMeasures(rec, isLastPacket)
// }
// }
// return
// }