tmp

chunkenc/insdelta.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"math"
 
+	"gordenko.dev/dima/qb"
 	"gordenko.dev/dima/qb/conbuf"
 )
 
@@ -16,6 +17,7 @@ type ReverseInstantDeltaCompressor struct {
 	lastDelta     int64
 	lastDeltaSize int
 	h             byte
+	state         *InstantDeltaBound
 }
 
 func NewReverseInstantDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaCompressor {
@@ -147,30 +149,76 @@ type InstantDeltaBound struct {
 	Pos       int
 	H         byte
 	LastDelta int64
+	Chunks    [][]byte
 }
 
-func (s *ReverseInstantDeltaCompressor) GetState() InstantDeltaBound {
-	return InstantDeltaBound{
-		Pos:       s.pos - 1 - s.lastDeltaSize,
+// delta h
+func (s *ReverseInstantDeltaCompressor) Lock() {
+	if s.state != nil {
+		qb.Abort(qb.RepeatableLock, nil)
+	}
+	// позиція посувається вліво, отже може перескочити на попередній chunk
+	pos := s.pos - 1 - s.lastDeltaSize
+	chunksQty := pos / conbuf.ChunkSize
+	if (pos % conbuf.ChunkSize) > 0 {
+		chunksQty++
+	}
+	s.state = &InstantDeltaBound{
+		Pos:       pos,
 		H:         s.h,
 		LastDelta: s.lastDelta,
+		Chunks:    s.buf.Chunks()[:chunksQty],
 	}
 }
 
-func (s *ReverseInstantDeltaCompressor) Lock() {
-	// s.state = &CumulativeDeltaBound{
-	// 	Pos:       s.pos - 1 - s.lastDeltaSize,
-	// 	H:         s.h,
-	// 	LastDelta: s.lastDelta,
-	// 	Chunks:    s.buf.Chunks(),
-	// }
+// fix - повернути в Pool буфери
+func (s *ReverseInstantDeltaCompressor) Unlock() {
+	s.state = nil
 }
 
-func (s *ReverseInstantDeltaCompressor) Unlock() {
-	//s.state = nil
+func (s *ReverseInstantDeltaCompressor) Offset() int {
+	if s.state != nil {
+		return s.state.Pos
+	}
+	return 0
+}
+
+func (s *ReverseInstantDeltaCompressor) Snapshot() ([][]byte, int) {
+	if s.state == nil {
+		return s.buf.Chunks(), s.Size()
+	}
+	// ВАЖЛИВО!
+	// Треба відтворити стан останнього чанка
+	var (
+		pos          = s.state.Pos
+		chunk        = make([]byte, conbuf.ChunkSize)
+		lastChunkIdx = len(s.state.Chunks) - 1
+		qtyToCopy    = pos % conbuf.ChunkSize
+	)
+	copy(chunk, s.state.Chunks[lastChunkIdx][:qtyToCopy])
+	chunks := append(s.state.Chunks[:lastChunkIdx], chunk)
+
+	buf := conbuf.New(chunks)
+	pos += buf.ReversePutVarInt64(pos, s.state.LastDelta)
+	buf.SetByte(pos, s.state.H)
+	pos++
+	return chunks, pos
+}
+
+func (s *ReverseInstantDeltaCompressor) CreateDecompressor(fracDigits byte) qb.ValueDecompressor {
+	if s.state == nil {
+		d := NewReverseInstantDeltaDecompressor(s.buf, s.Size(), fracDigits)
+		d.RestoreFromEnd()
+		return d
+	}
+	d := NewReverseInstantDeltaDecompressor(s.buf, s.Size(), fracDigits)
+	d.RestoreFromBound(*s.state)
+	return d
 }
 
 func (s *ReverseInstantDeltaCompressor) Renew() {
+	// УВАГА!
+	// state не чіпаємо
 	s.buf = conbuf.New(nil)
 	s.pos = 0
 	//