Add files using upload-large-folder tool

.gitattributes

@@ -3134,3 +3134,4 @@ platform/dbops/binaries/build/bin/m4 filter=lfs diff=lfs merge=lfs -text
 platform/dbops/binaries/build/bin/bison filter=lfs diff=lfs merge=lfs -text
 platform/dbops/binaries/build/bin/flex filter=lfs diff=lfs merge=lfs -text
 platform/dbops/binaries/build/bin/flex++ filter=lfs diff=lfs merge=lfs -text
+platform/dbops/binaries/weaviate-src/adapters/repos/db/vector/hnsw/compression_tests/fixtures/restart-from-zero-segments/1234567 filter=lfs diff=lfs merge=lfs -text

platform/dbops/binaries/weaviate-src/adapters/repos/db/inverted/stopwords/detector.go

@@ -0,0 +1,89 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package stopwords
+
+import (
+	"sync"
+
+	"github.com/weaviate/weaviate/entities/models"
+
+	"github.com/pkg/errors"
+)
+
+type StopwordDetector interface {
+	IsStopword(string) bool
+}
+
+type Detector struct {
+	sync.Mutex
+	stopwords map[string]struct{}
+}
+
+func NewDetectorFromConfig(config models.StopwordConfig) (*Detector, error) {
+	d, err := NewDetectorFromPreset(config.Preset)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create new detector from config")
+	}
+
+	d.SetAdditions(config.Additions)
+	d.SetRemovals(config.Removals)
+
+	return d, nil
+}
+
+func NewDetectorFromPreset(preset string) (*Detector, error) {
+	var list []string
+	var ok bool
+
+	if preset != "" {
+		list, ok = Presets[preset]
+		if !ok {
+			return nil, errors.Errorf("preset %q not known to stopword detector", preset)
+		}
+	}
+
+	d := &Detector{
+		stopwords: map[string]struct{}{},
+	}
+
+	for _, word := range list {
+		d.stopwords[word] = struct{}{}
+	}
+
+	return d, nil
+}
+
+func (d *Detector) SetAdditions(additions []string) {
+	d.Lock()
+	defer d.Unlock()
+
+	for _, add := range additions {
+		d.stopwords[add] = struct{}{}
+	}
+}
+
+func (d *Detector) SetRemovals(removals []string) {
+	d.Lock()
+	defer d.Unlock()
+
+	for _, rem := range removals {
+		delete(d.stopwords, rem)
+	}
+}
+
+func (d *Detector) IsStopword(word string) bool {
+	d.Lock()
+	defer d.Unlock()
+
+	_, ok := d.stopwords[word]
+	return ok
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/inverted/stopwords/detector_test.go

@@ -0,0 +1,159 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package stopwords
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+func TestStopwordDetector(t *testing.T) {
+	type testcase struct {
+		cfg               models.StopwordConfig
+		input             []string
+		expectedCountable int
+	}
+
+	runTest := func(t *testing.T, tests []testcase) {
+		for _, test := range tests {
+			sd, err := NewDetectorFromConfig(test.cfg)
+			require.Nil(t, err)
+
+			var result []string
+			for _, word := range test.input {
+				if !sd.IsStopword(word) {
+					result = append(result, word)
+				}
+			}
+			require.Equal(t, test.expectedCountable, len(result))
+		}
+	}
+
+	t.Run("with en preset, additions", func(t *testing.T) {
+		tests := []testcase{
+			{
+				cfg: models.StopwordConfig{
+					Preset:    "en",
+					Additions: []string{"dog"},
+				},
+				input:             []string{"dog", "dog", "dog", "dog"},
+				expectedCountable: 0,
+			},
+			{
+				cfg: models.StopwordConfig{
+					Preset:    "en",
+					Additions: []string{"dog"},
+				},
+				input:             []string{"dog", "dog", "dog", "cat"},
+				expectedCountable: 1,
+			},
+			{
+				cfg: models.StopwordConfig{
+					Preset:    "en",
+					Additions: []string{"dog"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 1,
+			},
+		}
+
+		runTest(t, tests)
+	})
+
+	t.Run("with no preset, additions", func(t *testing.T) {
+		tests := []testcase{
+			{
+				cfg: models.StopwordConfig{
+					Preset:    "none",
+					Additions: []string{"dog"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 4,
+			},
+		}
+
+		runTest(t, tests)
+	})
+
+	t.Run("with en preset, removals", func(t *testing.T) {
+		tests := []testcase{
+			{
+				cfg: models.StopwordConfig{
+					Preset:   "en",
+					Removals: []string{"a"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 3,
+			},
+			{
+				cfg: models.StopwordConfig{
+					Preset:   "en",
+					Removals: []string{"a", "is", "the"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 5,
+			},
+		}
+
+		runTest(t, tests)
+	})
+
+	t.Run("with en preset, removals", func(t *testing.T) {
+		tests := []testcase{
+			{
+				cfg: models.StopwordConfig{
+					Preset:   "en",
+					Removals: []string{"a"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 3,
+			},
+			{
+				cfg: models.StopwordConfig{
+					Preset:   "en",
+					Removals: []string{"a", "is", "the"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 5,
+			},
+		}
+
+		runTest(t, tests)
+	})
+
+	t.Run("with en preset, additions, removals", func(t *testing.T) {
+		tests := []testcase{
+			{
+				cfg: models.StopwordConfig{
+					Preset:    "en",
+					Additions: []string{"dog"},
+					Removals:  []string{"a"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 2,
+			},
+			{
+				cfg: models.StopwordConfig{
+					Preset:    "en",
+					Additions: []string{"dog", "best"},
+					Removals:  []string{"a", "the", "is"},
+				},
+				input:             []string{"a", "dog", "is", "the", "best"},
+				expectedCountable: 3,
+			},
+		}
+
+		runTest(t, tests)
+	})
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/inverted/stopwords/presets.go

@@ -0,0 +1,27 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package stopwords
+
+const (
+	EnglishPreset = "en"
+	NoPreset      = "none"
+)
+
+var Presets = map[string][]string{
+	EnglishPreset: {
+		"a", "an", "and", "are", "as", "at", "be", "but", "by", "for",
+		"if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that",
+		"the", "their", "then", "there", "these", "they", "this", "to", "was", "will",
+		"with",
+	},
+	NoPreset: {},
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/inverted/terms/terms.go

@@ -0,0 +1,500 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package terms
+
+import (
+	"context"
+	"encoding/binary"
+	"math"
+	"sort"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+type DocPointerWithScore struct {
+	Id uint64
+	// A Frequency of 0 indicates a tombstone
+	Frequency  float32
+	PropLength float32
+}
+
+func (d *DocPointerWithScore) FromBytes(in []byte, isTombstone bool, boost float32) error {
+	if len(in) < 12 {
+		return errors.Errorf("DocPointerWithScore: FromBytes: input too short, expected at least 12 bytes, got %d", len(in))
+	}
+	// This class is only to be used with a MapList that has fixed key and value lengths (8 and 8) for posting lists
+	// Thus, we can proceed with fixed offsets, and ignore reading the key and value lengths, at offset 0 and 10
+	// key will be at offset 2, value at offset 12
+	return d.FromKeyVal(in[2:10], in[12:], isTombstone, boost)
+}
+
+func (d *DocPointerWithScore) FromBytesInverted(in []byte, boost float32, propLen float32) error {
+	isTombstone := len(in) == 8
+	d.FromKeyVal(in[0:8], in[8:], isTombstone, boost)
+	d.PropLength = propLen
+	return nil
+}
+
+func (d *DocPointerWithScore) FromKeyVal(key []byte, value []byte, isTombstone bool, boost float32) error {
+	if len(key) != 8 {
+		return errors.Errorf("DocPointerWithScore: FromKeyVal: key length must be 8, got %d", len(key))
+	}
+
+	d.Id = binary.BigEndian.Uint64(key)
+	if isTombstone || len(value) < 8 { // tombstone, value length is also checked due to #4125
+		// Id and Freq are automatically set to 0
+		return nil
+	}
+	d.Frequency = math.Float32frombits(binary.LittleEndian.Uint32(value[:4])) * boost
+	d.PropLength = math.Float32frombits(binary.LittleEndian.Uint32(value[4:]))
+	return nil
+}
+
+type SortedDocPointerWithScoreMerger struct {
+	input   [][]DocPointerWithScore
+	output  []DocPointerWithScore
+	offsets []int
+}
+
+func NewSortedDocPointerWithScoreMerger() *SortedDocPointerWithScoreMerger {
+	return &SortedDocPointerWithScoreMerger{}
+}
+
+func (s *SortedDocPointerWithScoreMerger) init(segments [][]DocPointerWithScore) error {
+	s.input = segments
+
+	// all offset pointers initialized at 0 which is where we want to start
+	s.offsets = make([]int, len(segments))
+
+	// The maximum output is the sum of all the input segments if there are only
+	// unique keys and zero tombstones. If there are duplicate keys (i.e.
+	// updates) or tombstones, we will slice off some elements of the output
+	// later, but this way we can be sure each index will always be initialized
+	// correctly
+	maxOutput := 0
+	for _, seg := range segments {
+		maxOutput += len(seg)
+	}
+	s.output = make([]DocPointerWithScore, maxOutput)
+
+	return nil
+}
+
+func (s *SortedDocPointerWithScoreMerger) findSegmentWithLowestKey() (DocPointerWithScore, bool) {
+	bestSeg := -1
+	bestKey := uint64(0)
+
+	for segmentID := 0; segmentID < len(s.input); segmentID++ {
+		// check if a segment is already exhausted, then skip
+		if s.offsets[segmentID] >= len(s.input[segmentID]) {
+			continue
+		}
+
+		currKey := s.input[segmentID][s.offsets[segmentID]].Id
+		if bestSeg == -1 {
+			// first time we're running, no need to compare, just set to current
+			bestSeg = segmentID
+			bestKey = currKey
+			continue
+		}
+
+		if currKey > bestKey {
+			// the segment we are currently looking at has a higher key than our
+			// current best so we can completely ignore it
+			continue
+		}
+
+		if currKey < bestKey {
+			// the segment we are currently looking at is a better match than the
+			// previous, this means, we have found a new favorite, but the previous
+			// best will still be valid in a future round
+			bestSeg = segmentID
+			bestKey = currKey
+			continue
+		}
+
+		if currKey == bestKey {
+			// this the most interesting case: we are looking at a duplicate key. In
+			// this case the rightmost ("latest") segment takes precedence, however,
+			// we must make sure that the previous match gets discarded, otherwise we
+			// will find it again in the next round.
+			//
+			// We can simply increase the offset before updating the bestSeg pointer,
+			// which means we will never look at this element again
+			s.offsets[bestSeg]++
+
+			// now that the old element is discarded, we can update our pointers
+			bestSeg = segmentID
+			bestKey = currKey
+		}
+	}
+
+	if bestSeg == -1 {
+		// we didn't find anything, looks like we have exhausted all segments
+		return DocPointerWithScore{}, false
+	}
+
+	// we can now be sure that bestSeg,bestKey is the latest version of the
+	// lowest key, there is only one job left to do: increase the offset, so we
+	// never find this segment again
+	bestMatch := s.input[bestSeg][s.offsets[bestSeg]]
+	s.offsets[bestSeg]++
+
+	return bestMatch, true
+}
+
+func (s *SortedDocPointerWithScoreMerger) Do(ctx context.Context, segments [][]DocPointerWithScore) ([]DocPointerWithScore, error) {
+	if err := s.init(segments); err != nil {
+		return nil, errors.Wrap(err, "init sorted map decoder")
+	}
+
+	i := 0
+	for {
+		if i%100 == 0 && ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
+
+		match, ok := s.findSegmentWithLowestKey()
+		if !ok {
+			break
+		}
+
+		if match.Frequency == 0 { // tombstone
+			// the latest version of this key was a tombstone, so we can ignore it
+			continue
+		}
+
+		s.output[i] = match
+		i++
+	}
+
+	return s.output[:i], nil
+}
+
+type TermInterface interface {
+	// doubles as max impact (with tf=1, the max impact would be 1*Idf), if there
+	// is a boost for a queryTerm, simply apply it here once
+	Idf() float64
+	IdPointer() uint64
+	Exhausted() bool
+	Count() int
+	QueryTermIndex() int
+	AdvanceAtLeast(minID uint64)
+	AdvanceAtLeastShallow(minID uint64)
+	Advance()
+	Score(averagePropLength float64, additionalExplanations bool) (uint64, float64, *DocPointerWithScore)
+	CurrentBlockImpact() float32
+	CurrentBlockMaxId() uint64
+}
+
+type Term struct {
+	// doubles as max impact (with tf=1, the max impact would be 1*Idf), if there
+	// is a boost for a queryTerm, simply apply it here once
+	idf float64
+
+	idPointer      uint64
+	posPointer     uint64
+	Data           []DocPointerWithScore
+	exhausted      bool
+	queryTerm      string
+	queryTermIndex int
+	propertyBoost  float64
+	config         schema.BM25Config
+}
+
+func NewTerm(queryTerm string, queryTermIndex int, propertyBoost float32, config schema.BM25Config) *Term {
+	return &Term{
+		queryTerm:      queryTerm,
+		queryTermIndex: queryTermIndex,
+		propertyBoost:  float64(propertyBoost),
+		config:         config,
+	}
+}
+
+func (t *Term) Score(averagePropLength float64, additionalExplanations bool) (uint64, float64, *DocPointerWithScore) {
+	pair := t.Data[t.posPointer]
+	freq := float64(pair.Frequency)
+	tf := freq / (freq + t.config.K1*(1-t.config.B+t.config.B*float64(pair.PropLength)/averagePropLength))
+	if !additionalExplanations {
+		return t.idPointer, tf * t.idf * t.propertyBoost, nil
+	}
+	return t.idPointer, tf * t.idf * t.propertyBoost, &pair
+}
+
+func (t *Term) Advance() {
+	t.posPointer++
+	if t.posPointer >= uint64(len(t.Data)) {
+		t.exhausted = true
+		t.idPointer = math.MaxUint64 // force them to the end of the term list
+	} else {
+		t.idPointer = t.Data[t.posPointer].Id
+	}
+}
+
+func (t *Term) AdvanceAtLeast(minID uint64) {
+	for t.idPointer < minID {
+		t.posPointer++
+		if t.posPointer >= uint64(len(t.Data)) {
+			t.exhausted = true
+			t.idPointer = math.MaxUint64 // force them to the end of the term list
+			return
+		}
+		t.idPointer = t.Data[t.posPointer].Id
+	}
+}
+
+func (t *Term) AdvanceAtLeastShallow(minID uint64) {
+	t.AdvanceAtLeast(minID)
+	// go back one document, as the advance blockmax implementation relies on going to the document right before on a shallow advance,
+	// due to the way decoding works in the SegmentBlockMax implementation
+	t.posPointer--
+	t.exhausted = false
+	t.idPointer = t.Data[t.posPointer].Id
+}
+
+func (t *Term) Count() int {
+	return len(t.Data)
+}
+
+func (t *Term) Idf() float64 {
+	return t.idf
+}
+
+func (t *Term) IdPointer() uint64 {
+	return t.idPointer
+}
+
+func (t *Term) PosPointer() uint64 {
+	return t.posPointer
+}
+
+func (t *Term) Exhausted() bool {
+	return t.exhausted
+}
+
+func (t *Term) QueryTerm() string {
+	return t.queryTerm
+}
+
+func (t *Term) QueryTermIndex() int {
+	return t.queryTermIndex
+}
+
+func (t *Term) SetIdf(idf float64) {
+	t.idf = idf
+}
+
+func (t *Term) SetPosPointer(posPointer uint64) {
+	t.posPointer = posPointer
+}
+
+func (t *Term) SetIdPointer(idPointer uint64) {
+	t.idPointer = idPointer
+}
+
+func (t *Term) CurrentBlockImpact() float32 {
+	return float32(t.idf * t.propertyBoost)
+}
+
+func (t *Term) CurrentBlockMaxId() uint64 {
+	return t.idPointer
+}
+
+type Terms struct {
+	T     []TermInterface
+	Count int
+}
+
+func (t *Terms) CompletelyExhausted() bool {
+	for i := range t.T {
+		if !t.T[i].Exhausted() {
+			return false
+		}
+	}
+	return true
+}
+
+func (t *Terms) FindMinIDWand(minScore float64) (uint64, int, bool) {
+	cumScore := float64(0)
+
+	for i, term := range t.T {
+		if term.Exhausted() {
+			continue
+		}
+		cumScore += term.Idf()
+		if cumScore >= minScore {
+			return term.IdPointer(), i, false
+		}
+	}
+
+	return 0, 0, true
+}
+
+func (t *Terms) Pivot(minScore float64) bool {
+	minID, pivotPoint, abort := t.FindMinIDWand(minScore)
+	if abort {
+		return true
+	}
+	if pivotPoint == 0 {
+		return false
+	}
+
+	t.AdvanceAllAtLeast(minID, len(t.T)-1)
+
+	// we don't need to sort the entire list, just the first pivotPoint elements
+	t.SortFirst()
+
+	return false
+}
+
+func (t *Terms) AdvanceAllAtLeast(minID uint64, pivot int) {
+	for i := range t.T[:pivot] {
+		t.T[i].AdvanceAtLeast(minID)
+	}
+}
+
+func (t *Terms) FindMinID(minScore float64) (uint64, int, bool) {
+	cumScore := float64(0)
+	for i, term := range t.T {
+		if term.Exhausted() {
+			continue
+		}
+		cumScore += float64(term.CurrentBlockImpact())
+		if cumScore >= minScore {
+			// find if there is another term with the same id
+			for j := i + 1; j < len(t.T); j++ {
+				if t.T[j].IdPointer() != term.IdPointer() {
+					return t.T[j-1].IdPointer(), j - 1, false
+				}
+			}
+			return t.T[len(t.T)-1].IdPointer(), len(t.T) - 1, false
+		}
+	}
+
+	return 0, 0, true
+}
+
+func (t *Terms) FindFirstNonExhausted() (int, bool) {
+	for i := range t.T {
+		if !t.T[i].Exhausted() {
+			return i, true
+		}
+	}
+
+	return -1, false
+}
+
+func (t *Terms) ScoreNext(averagePropLength float64, additionalExplanations bool, minimumOrTokensMatch int) (uint64, float64, []*DocPointerWithScore, bool) {
+	var docInfos []*DocPointerWithScore
+
+	pos, ok := t.FindFirstNonExhausted()
+	if !ok {
+		// done, nothing left to score
+		return 0, 0, docInfos, false
+	}
+
+	if len(t.T) == 0 {
+		return 0, 0, docInfos, false
+	}
+
+	if additionalExplanations {
+		docInfos = make([]*DocPointerWithScore, t.Count)
+	}
+
+	id := t.T[pos].IdPointer()
+	var cumScore float64
+
+	matchedTerms := 0
+
+	if len(t.T)-pos < minimumOrTokensMatch {
+		return 0, 0, docInfos, false
+	}
+
+	for i := pos; i < len(t.T); i++ {
+		if t.T[i].IdPointer() != id || t.T[i].Exhausted() {
+			continue
+		}
+		matchedTerms++
+		term := t.T[i]
+		_, score, docInfo := term.Score(averagePropLength, additionalExplanations)
+		term.Advance()
+		if additionalExplanations {
+			docInfos[term.QueryTermIndex()] = docInfo
+		}
+		cumScore += score
+	}
+
+	if matchedTerms < minimumOrTokensMatch {
+		// not enough terms matched, return 0
+		return 0, 0, docInfos, false
+	}
+
+	// t.FullSort()
+	return id, cumScore, docInfos, true
+}
+
+// provide sort interface
+func (t *Terms) Len() int {
+	return len(t.T)
+}
+
+func (t *Terms) Less(i, j int) bool {
+	return t.T[i].IdPointer() < t.T[j].IdPointer()
+}
+
+func (t *Terms) Swap(i, j int) {
+	t.T[i], t.T[j] = t.T[j], t.T[i]
+}
+
+func (t *Terms) SortFull() {
+	sort.Sort(t)
+}
+
+func (t *Terms) SortFirst() {
+	min := uint64(0)
+	minIndex := -1
+	for i := 0; i < len(t.T); i++ {
+		if minIndex == -1 || (t.T[i].IdPointer() < min && !t.T[i].Exhausted()) {
+			min = t.T[i].IdPointer()
+			minIndex = i
+		}
+	}
+	if minIndex > 0 {
+		t.T[0], t.T[minIndex] = t.T[minIndex], t.T[0]
+	}
+}
+
+func (t *Terms) SortPartial(nextList int) {
+	for i := nextList + 1; i < len(t.T); i++ {
+		if t.T[i].IdPointer() <= t.T[i-1].IdPointer() {
+			// swap
+			t.T[i], t.T[i-1] = t.T[i-1], t.T[i]
+		} else {
+			break
+		}
+	}
+}
+
+func (t *Terms) GetBlockUpperBound(pivot int, pivotId uint64) float32 {
+	blockMaxScore := float32(0)
+	for i := 0; i < pivot+1; i++ {
+		if t.T[i].Exhausted() {
+			continue
+		}
+		if t.T[i].CurrentBlockMaxId() < pivotId {
+			t.T[i].AdvanceAtLeastShallow(pivotId)
+		}
+		blockMaxScore += t.T[i].CurrentBlockImpact()
+	}
+	return blockMaxScore
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/inverted/terms/terms_block.go

@@ -0,0 +1,96 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package terms
+
+import (
+	"encoding/binary"
+)
+
+var (
+	BLOCK_SIZE = 128
+	// if we are only encoding few documents, we can encode the doc ids and tfs as full bytes.
+	// Limit for this is currently set to 1
+	ENCODE_AS_FULL_BYTES = 1
+)
+
+type BlockEntry struct {
+	MaxId               uint64
+	Offset              uint32
+	MaxImpactTf         uint32
+	MaxImpactPropLength uint32
+}
+
+func (b BlockEntry) Size() int {
+	return 20
+}
+
+func (b *BlockEntry) Encode() []byte {
+	out := make([]byte, 20)
+	binary.LittleEndian.PutUint64(out, b.MaxId)
+	binary.LittleEndian.PutUint32(out[8:], b.Offset)
+	binary.LittleEndian.PutUint32(out[12:], b.MaxImpactTf)
+	binary.LittleEndian.PutUint32(out[16:], b.MaxImpactPropLength)
+	return out
+}
+
+func DecodeBlockEntry(data []byte) *BlockEntry {
+	return &BlockEntry{
+		MaxId:               binary.LittleEndian.Uint64(data),
+		Offset:              binary.LittleEndian.Uint32(data[8:]),
+		MaxImpactTf:         binary.LittleEndian.Uint32(data[12:]),
+		MaxImpactPropLength: binary.LittleEndian.Uint32(data[16:]),
+	}
+}
+
+type BlockDataDecoded struct {
+	DocIds []uint64
+	Tfs    []uint64
+}
+
+type BlockData struct {
+	DocIds []byte
+	Tfs    []byte
+}
+
+func (b *BlockData) Size() int {
+	return 2*2 + len(b.DocIds) + len(b.Tfs)
+}
+
+func (b *BlockData) Encode() []byte {
+	out := make([]byte, len(b.DocIds)+len(b.Tfs)+4)
+	offset := 0
+	// write the lengths of the slices
+	binary.LittleEndian.PutUint16(out[offset:], uint16(len(b.DocIds)))
+	offset += 2
+	binary.LittleEndian.PutUint16(out[offset:], uint16(len(b.Tfs)))
+	offset += 2
+
+	offset += copy(out[offset:], b.DocIds)
+	copy(out[offset:], b.Tfs)
+	return out
+}
+
+func DecodeBlockData(data []byte) *BlockData {
+	docIdsLen := binary.LittleEndian.Uint16(data)
+	termFreqsLen := binary.LittleEndian.Uint16(data[2:])
+	return &BlockData{
+		DocIds: data[4 : 4+docIdsLen],
+		Tfs:    data[4+docIdsLen : 4+docIdsLen+termFreqsLen],
+	}
+}
+
+func DecodeBlockDataReusable(data []byte, out *BlockData) {
+	docIdsLen := binary.LittleEndian.Uint16(data)
+	termFreqsLen := binary.LittleEndian.Uint16(data[2:])
+	out.DocIds = data[4 : 4+docIdsLen]
+	out.Tfs = data[4+docIdsLen : 4+docIdsLen+termFreqsLen]
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/cursor_segment_collection_reusable.go

@@ -0,0 +1,132 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"errors"
+	"io"
+
+	"github.com/weaviate/weaviate/entities/lsmkv"
+)
+
+type segmentCursorCollectionReusable struct {
+	cache   *cacheReader
+	nodeBuf segmentCollectionNode
+}
+
+func (s *segment) newCollectionCursorReusable() *segmentCursorCollectionReusable {
+	return &segmentCursorCollectionReusable{
+		cache: newCacheReader(s),
+	}
+}
+
+func (s *segmentCursorCollectionReusable) next() ([]byte, []value, error) {
+	if err := s.cache.CheckPosition(); err != nil {
+		return nil, nil, err
+	}
+	return s.parseCollectionNodeInto()
+}
+
+func (s *segmentCursorCollectionReusable) first() ([]byte, []value, error) {
+	s.cache.Reset()
+	if err := s.cache.CheckPosition(); err != nil {
+		return nil, nil, err
+	}
+	return s.parseCollectionNodeInto()
+}
+
+func (s *segmentCursorCollectionReusable) parseCollectionNodeInto() ([]byte, []value, error) {
+	err := ParseCollectionNodeInto(s.cache, &s.nodeBuf)
+	if err != nil {
+		return s.nodeBuf.primaryKey, nil, err
+	}
+
+	return s.nodeBuf.primaryKey, s.nodeBuf.values, nil
+}
+
+type cacheReader struct {
+	readCache         []byte
+	positionInCache   uint64
+	segment           *segment
+	positionInSegment uint64
+}
+
+func newCacheReader(s *segment) *cacheReader {
+	cacheSize := uint64(4096)
+	if s.dataEndPos-s.dataStartPos < cacheSize {
+		cacheSize = s.dataEndPos - s.dataStartPos
+	}
+
+	return &cacheReader{
+		readCache:         make([]byte, 0, cacheSize),
+		segment:           s,
+		positionInSegment: s.dataStartPos,
+	}
+}
+
+func (c *cacheReader) CheckPosition() error {
+	if c.positionInSegment >= c.segment.dataEndPos {
+		return lsmkv.NotFound
+	}
+	return nil
+}
+
+func (c *cacheReader) Reset() {
+	c.positionInCache = 0
+	c.positionInSegment = c.segment.dataStartPos
+	c.readCache = c.readCache[:0] // forces a new read
+}
+
+func (c *cacheReader) Read(p []byte) (n int, err error) {
+	length := uint64(len(p))
+	if c.positionInSegment+length > c.segment.dataEndPos {
+		return 0, lsmkv.NotFound
+	}
+	if c.positionInCache+length > uint64(len(c.readCache)) {
+		if err := c.loadDataIntoCache(len(p)); err != nil {
+			return 0, err
+		}
+	}
+	copy(p, c.readCache[c.positionInCache:c.positionInCache+length])
+
+	c.positionInSegment += length
+	c.positionInCache += length
+
+	return len(p), nil
+}
+
+func (c *cacheReader) loadDataIntoCache(readLength int) error {
+	at, err := c.segment.newNodeReader(nodeOffset{start: c.positionInSegment}, "CursorCollectionReusable")
+	if err != nil {
+		return err
+	}
+	defer at.Release()
+
+	// Restore the original buffer capacity before reading
+	c.readCache = c.readCache[:cap(c.readCache)]
+
+	if readLength > len(c.readCache) {
+		c.readCache = make([]byte, readLength)
+	}
+
+	read, err := at.Read(c.readCache)
+	if err != nil && (!errors.Is(err, io.EOF) || read == 0) {
+		return err
+	}
+	if read < readLength {
+		return lsmkv.NotFound
+	}
+
+	c.readCache = c.readCache[:read]
+	c.positionInCache = 0
+	return nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/cursor_segment_inverted_reusable.go

@@ -0,0 +1,140 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"encoding/binary"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/inverted/terms"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+)
+
+type segmentCursorInvertedReusable struct {
+	segment     *segment
+	nextOffset  uint64
+	nodeBuf     binarySearchNodeMap
+	propLengths map[uint64]uint32
+}
+
+func (s *segment) newInvertedCursorReusable() *segmentCursorInvertedReusable {
+	propLengths, err := s.GetPropertyLengths()
+	if err != nil {
+		return nil
+	}
+	return &segmentCursorInvertedReusable{
+		segment:     s,
+		propLengths: propLengths,
+	}
+}
+
+func (s *segmentCursorInvertedReusable) seek(key []byte) ([]byte, []MapPair, error) {
+	node, err := s.segment.index.Seek(key)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	err = s.parseInvertedNodeInto(nodeOffset{node.Start, node.End})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	s.nextOffset = node.End
+
+	return s.nodeBuf.key, s.nodeBuf.values, nil
+}
+
+func (s *segmentCursorInvertedReusable) next() ([]byte, []MapPair, error) {
+	if s.nextOffset >= s.segment.dataEndPos {
+		return nil, nil, lsmkv.NotFound
+	}
+
+	err := s.parseInvertedNodeInto(nodeOffset{start: s.nextOffset})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return s.nodeBuf.key, s.nodeBuf.values, nil
+}
+
+func (s *segmentCursorInvertedReusable) first() ([]byte, []MapPair, error) {
+	s.nextOffset = s.segment.dataStartPos
+
+	if s.nextOffset >= s.segment.dataEndPos {
+		return nil, nil, lsmkv.NotFound
+	}
+
+	err := s.parseInvertedNodeInto(nodeOffset{start: s.nextOffset})
+	if err != nil {
+		return nil, nil, err
+	}
+	return s.nodeBuf.key, s.nodeBuf.values, nil
+}
+
+func (s *segmentCursorInvertedReusable) parseInvertedNodeInto(offset nodeOffset) error {
+	buffer := make([]byte, 16)
+	r, err := s.segment.newNodeReader(offset, "segmentCursorInvertedReusable")
+	if err != nil {
+		return err
+	}
+	defer r.Release()
+
+	_, err = r.Read(buffer)
+	if err != nil {
+		return err
+	}
+	docCount := binary.LittleEndian.Uint64(buffer[:8])
+	end := uint64(20)
+	if docCount > uint64(terms.ENCODE_AS_FULL_BYTES) {
+		end = binary.LittleEndian.Uint64(buffer[8:16]) + 16
+	}
+	offset.end = offset.start + end + 4
+
+	r, err = s.segment.newNodeReader(offset, "segmentCursorInvertedReusable")
+	if err != nil {
+		return err
+	}
+	defer r.Release()
+
+	allBytes := make([]byte, offset.end-offset.start)
+
+	_, err = r.Read(allBytes)
+	if err != nil {
+		return err
+	}
+
+	nodes, _ := decodeAndConvertFromBlocks(allBytes)
+
+	keyLen := binary.LittleEndian.Uint32(allBytes[len(allBytes)-4:])
+
+	offset.start = offset.end
+	offset.end += uint64(keyLen)
+	key := make([]byte, keyLen)
+
+	// empty keys are possible if using non-word tokenizers, so let's handle them
+	if keyLen > 0 {
+		r, err = s.segment.newNodeReader(offset, "segmentCursorInvertedReusable")
+		if err != nil {
+			return err
+		}
+		defer r.Release()
+		_, err = r.Read(key)
+		if err != nil {
+			return err
+		}
+	}
+	s.nodeBuf.key = key
+	s.nodeBuf.values = nodes
+
+	s.nextOffset = offset.end
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/cursor_segment_map.go

@@ -0,0 +1,167 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"io"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+)
+
+type segmentCursorMap struct {
+	segment    *segment
+	nextOffset uint64
+}
+
+func (s *segment) newMapCursor() *segmentCursorMap {
+	return &segmentCursorMap{
+		segment: s,
+	}
+}
+
+func (sg *SegmentGroup) newMapCursors() ([]innerCursorMap, func()) {
+	segments, release := sg.getAndLockSegments()
+
+	out := make([]innerCursorMap, len(segments))
+
+	for i, segment := range segments {
+		sgm := segment.getSegment()
+		if sgm.getStrategy() == segmentindex.StrategyInverted {
+			out[i] = sgm.newInvertedCursorReusable()
+		} else {
+			out[i] = sgm.newMapCursor()
+		}
+	}
+
+	return out, release
+}
+
+func (s *segmentCursorMap) decode(parsed segmentCollectionNode) ([]MapPair, error) {
+	pairs := make([]MapPair, len(parsed.values))
+	for i := range pairs {
+		if s.segment.strategy == segmentindex.StrategyInverted {
+			if err := pairs[i].FromBytesInverted(parsed.values[i].value, false); err != nil {
+				return nil, err
+			}
+		} else {
+			if err := pairs[i].FromBytes(parsed.values[i].value, false); err != nil {
+				return nil, err
+			}
+		}
+		pairs[i].Tombstone = parsed.values[i].tombstone
+	}
+	return pairs, nil
+}
+
+func (s *segmentCursorMap) seek(key []byte) ([]byte, []MapPair, error) {
+	node, err := s.segment.index.Seek(key)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var parsed segmentCollectionNode
+
+	if s.segment.strategy == segmentindex.StrategyInverted {
+		parsed, err = s.parseInvertedNode(nodeOffset{node.Start, node.End})
+	} else {
+		parsed, err = s.parseCollectionNode(nodeOffset{node.Start, node.End})
+	}
+	// make sure to set the next offset before checking the error. The error
+	// could be 'Deleted' which would require that the offset is still advanced
+	// for the next cycle
+	s.nextOffset = node.End
+	if err != nil {
+		return parsed.primaryKey, nil, err
+	}
+
+	pairs, err := s.decode(parsed)
+	return parsed.primaryKey, pairs, err
+}
+
+func (s *segmentCursorMap) next() ([]byte, []MapPair, error) {
+	if s.nextOffset >= s.segment.dataEndPos {
+		return nil, nil, lsmkv.NotFound
+	}
+
+	var parsed segmentCollectionNode
+	var err error
+
+	if s.segment.strategy == segmentindex.StrategyInverted {
+		parsed, err = s.parseInvertedNode(nodeOffset{start: s.nextOffset})
+	} else {
+		parsed, err = s.parseCollectionNode(nodeOffset{start: s.nextOffset})
+	}
+	// make sure to set the next offset before checking the error. The error
+	// could be 'Deleted' which would require that the offset is still advanced
+	// for the next cycle
+	s.nextOffset = s.nextOffset + uint64(parsed.offset)
+	if err != nil {
+		return parsed.primaryKey, nil, err
+	}
+
+	pairs, err := s.decode(parsed)
+	return parsed.primaryKey, pairs, err
+}
+
+func (s *segmentCursorMap) first() ([]byte, []MapPair, error) {
+	if s.segment.dataStartPos == s.segment.dataEndPos {
+		return nil, nil, lsmkv.NotFound
+	}
+
+	s.nextOffset = s.segment.dataStartPos
+
+	var parsed segmentCollectionNode
+	var err error
+
+	if s.segment.strategy == segmentindex.StrategyInverted {
+		parsed, err = s.parseInvertedNode(nodeOffset{start: s.nextOffset})
+	} else {
+		parsed, err = s.parseCollectionNode(nodeOffset{start: s.nextOffset})
+	}
+	// make sure to set the next offset before checking the error. The error
+	// could be 'Deleted' which would require that the offset is still advanced
+	// for the next cycle
+	s.nextOffset = s.nextOffset + uint64(parsed.offset)
+	if err != nil {
+		if errors.Is(err, io.EOF) {
+			// an empty map could have been generated due to an issue in compaction
+			return nil, nil, lsmkv.NotFound
+		}
+
+		return parsed.primaryKey, nil, err
+	}
+
+	pairs, err := s.decode(parsed)
+	return parsed.primaryKey, pairs, err
+}
+
+func (s *segmentCursorMap) parseCollectionNode(offset nodeOffset) (segmentCollectionNode, error) {
+	r, err := s.segment.newNodeReader(offset, "segmentCursorMap")
+	if err != nil {
+		return segmentCollectionNode{}, err
+	}
+	defer r.Release()
+
+	return ParseCollectionNode(r)
+}
+
+func (s *segmentCursorMap) parseInvertedNode(offset nodeOffset) (segmentCollectionNode, error) {
+	r, err := s.segment.newNodeReader(offset, "segmentCursorMap")
+	if err != nil {
+		return segmentCollectionNode{}, err
+	}
+	defer r.Release()
+
+	return ParseInvertedNode(r)
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/cursor_segment_replace.go

@@ -0,0 +1,303 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"github.com/weaviate/weaviate/entities/lsmkv"
+	"github.com/weaviate/weaviate/usecases/byteops"
+)
+
+type segmentCursorReplace struct {
+	segment       *segment
+	index         diskIndex
+	keyFn         func(n *segmentReplaceNode) []byte
+	firstOffsetFn func() (uint64, error)
+	nextOffsetFn  func(n *segmentReplaceNode) (uint64, error)
+	currOffset    uint64
+	reusableNode  *segmentReplaceNode
+	reusableBORW  byteops.ReadWriter
+}
+
+func (s *segment) newCursor() *segmentCursorReplace {
+	cursor := &segmentCursorReplace{
+		segment: s,
+		index:   s.index,
+		firstOffsetFn: func() (uint64, error) {
+			if s.dataStartPos == s.dataEndPos {
+				return 0, lsmkv.NotFound
+			}
+			return s.dataStartPos, nil
+		},
+		currOffset: s.dataStartPos,
+		keyFn: func(n *segmentReplaceNode) []byte {
+			return n.primaryKey
+		},
+		reusableNode: &segmentReplaceNode{},
+		reusableBORW: byteops.NewReadWriter(nil),
+	}
+
+	cursor.nextOffsetFn = func(n *segmentReplaceNode) (uint64, error) {
+		return cursor.currOffset + uint64(n.offset), nil
+	}
+
+	return cursor
+}
+
+// Note: scanning over secondary keys is sub-optimal
+// i.e. no sequential scan is possible as when scanning over the primary key
+
+func (s *segment) newCursorWithSecondaryIndex(pos int) *segmentCursorReplace {
+	return &segmentCursorReplace{
+		segment: s,
+		index:   s.secondaryIndices[pos],
+		keyFn: func(n *segmentReplaceNode) []byte {
+			return n.secondaryKeys[pos]
+		},
+		firstOffsetFn: func() (uint64, error) {
+			index := s.secondaryIndices[pos]
+			n, err := index.Seek(nil)
+			if err != nil {
+				return 0, err
+			}
+			return n.Start, nil
+		},
+		nextOffsetFn: func(n *segmentReplaceNode) (uint64, error) {
+			index := s.secondaryIndices[pos]
+			next, err := index.Next(n.secondaryKeys[pos])
+			if err != nil {
+				return 0, err
+			}
+			return next.Start, nil
+		},
+		reusableNode: &segmentReplaceNode{
+			secondaryIndexCount: s.secondaryIndexCount,
+			secondaryKeys:       make([][]byte, s.secondaryIndexCount),
+		},
+		reusableBORW: byteops.NewReadWriter(nil),
+	}
+}
+
+func (sg *SegmentGroup) newCursors() ([]innerCursorReplace, func()) {
+	segments, release := sg.getAndLockSegments()
+
+	out := make([]innerCursorReplace, len(segments))
+
+	for i, segment := range segments {
+		out[i] = segment.newCursor()
+	}
+
+	return out, release
+}
+
+func (sg *SegmentGroup) newCursorsWithFlushingSupport() ([]innerCursorReplace, func()) {
+	sg.cursorsLock.Lock()
+	defer sg.cursorsLock.Unlock()
+
+	sg.activeCursors++
+
+	sg.maintenanceLock.RLock()
+
+	var segments []Segment
+
+	if len(sg.enqueuedSegments) == 0 {
+		segments = sg.segments
+	} else {
+		segments = make([]Segment, 0, len(sg.segments)+len(sg.enqueuedSegments))
+		segments = append(segments, sg.segments...)
+		segments = append(segments, sg.enqueuedSegments...)
+	}
+
+	out := make([]innerCursorReplace, 0, len(segments))
+
+	for _, segment := range segments {
+		out = append(out, segment.newCursor())
+	}
+
+	release := func() {
+		sg.maintenanceLock.RUnlock()
+
+		sg.cursorsLock.Lock()
+		defer sg.cursorsLock.Unlock()
+
+		sg.activeCursors--
+
+		if sg.activeCursors == 0 && len(sg.enqueuedSegments) > 0 {
+			sg.maintenanceLock.Lock()
+			defer sg.maintenanceLock.Unlock()
+
+			sg.segments = append(sg.segments, sg.enqueuedSegments...)
+			sg.enqueuedSegments = nil
+		}
+	}
+
+	return out, release
+}
+
+func (sg *SegmentGroup) newCursorsWithSecondaryIndex(pos int) ([]innerCursorReplace, func()) {
+	segments, release := sg.getAndLockSegments()
+	out := make([]innerCursorReplace, 0, len(segments))
+
+	for _, segment := range segments {
+		if int(segment.getSecondaryIndexCount()) <= pos {
+			continue
+		}
+		out = append(out, segment.newCursorWithSecondaryIndex(pos))
+	}
+
+	return out, release
+}
+
+func (s *segmentCursorReplace) seek(key []byte) ([]byte, []byte, error) {
+	node, err := s.index.Seek(key)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	s.currOffset = node.Start
+
+	err = s.parseReplaceNodeInto(nodeOffset{start: node.Start, end: node.End},
+		s.segment.contents[node.Start:node.End])
+	if err != nil {
+		return s.keyFn(s.reusableNode), nil, err
+	}
+
+	return s.keyFn(s.reusableNode), s.reusableNode.value, nil
+}
+
+func (s *segmentCursorReplace) next() ([]byte, []byte, error) {
+	nextOffset, err := s.nextOffsetFn(s.reusableNode)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if nextOffset >= s.segment.dataEndPos {
+		return nil, nil, lsmkv.NotFound
+	}
+
+	s.currOffset = nextOffset
+
+	err = s.parseReplaceNodeInto(nodeOffset{start: s.currOffset},
+		s.segment.contents[s.currOffset:])
+	if err != nil {
+		return s.keyFn(s.reusableNode), nil, err
+	}
+
+	return s.keyFn(s.reusableNode), s.reusableNode.value, nil
+}
+
+func (s *segmentCursorReplace) first() ([]byte, []byte, error) {
+	firstOffset, err := s.firstOffsetFn()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	s.currOffset = firstOffset
+
+	err = s.parseReplaceNodeInto(nodeOffset{start: s.currOffset},
+		s.segment.contents[s.currOffset:])
+	if err != nil {
+		return s.keyFn(s.reusableNode), nil, err
+	}
+
+	return s.keyFn(s.reusableNode), s.reusableNode.value, nil
+}
+
+func (s *segmentCursorReplace) nextWithAllKeys() (n segmentReplaceNode, err error) {
+	nextOffset, err := s.nextOffsetFn(s.reusableNode)
+	if err != nil {
+		return n, err
+	}
+
+	if nextOffset >= s.segment.dataEndPos {
+		return n, lsmkv.NotFound
+	}
+
+	s.currOffset = nextOffset
+
+	n, err = s.parseReplaceNode(nodeOffset{start: s.currOffset})
+
+	s.reusableNode = &n
+
+	return n, err
+}
+
+func (s *segmentCursorReplace) firstWithAllKeys() (n segmentReplaceNode, err error) {
+	firstOffset, err := s.firstOffsetFn()
+	if err != nil {
+		return n, err
+	}
+
+	s.currOffset = firstOffset
+
+	n, err = s.parseReplaceNode(nodeOffset{start: s.currOffset})
+
+	s.reusableNode = &n
+
+	return n, err
+}
+
+func (s *segmentCursorReplace) parseReplaceNode(offset nodeOffset) (segmentReplaceNode, error) {
+	r, err := s.segment.newNodeReader(offset, "segmentCursorReplace")
+	if err != nil {
+		return segmentReplaceNode{}, err
+	}
+	defer r.Release()
+
+	out, err := ParseReplaceNode(r, s.segment.secondaryIndexCount)
+	if out.tombstone {
+		return out, lsmkv.Deleted
+	}
+	return out, err
+}
+
+func (s *segmentCursorReplace) parseReplaceNodeInto(offset nodeOffset, buf []byte) error {
+	if s.segment.readFromMemory {
+		return s.parse(buf)
+	}
+
+	r, err := s.segment.newNodeReader(offset, "segmentCursorReplace")
+	if err != nil {
+		return err
+	}
+	defer r.Release()
+
+	err = ParseReplaceNodeIntoPread(r, s.segment.secondaryIndexCount, s.reusableNode)
+	if err != nil {
+		return err
+	}
+
+	if s.reusableNode.tombstone {
+		return lsmkv.Deleted
+	}
+
+	return nil
+}
+
+func (s *segmentCursorReplace) parse(in []byte) error {
+	if len(in) == 0 {
+		return lsmkv.NotFound
+	}
+
+	s.reusableBORW.ResetBuffer(in)
+
+	err := ParseReplaceNodeIntoMMAP(&s.reusableBORW, s.segment.secondaryIndexCount,
+		s.reusableNode)
+	if err != nil {
+		return err
+	}
+
+	if s.reusableNode.tombstone {
+		return lsmkv.Deleted
+	}
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/cursor_segment_roaring_set.go

@@ -0,0 +1,54 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+)
+
+func (s *segment) newRoaringSetCursor() *roaringset.SegmentCursor {
+	return roaringset.NewSegmentCursor(s.contents[s.dataStartPos:s.dataEndPos],
+		&roaringSetSeeker{s.index})
+}
+
+func (sg *SegmentGroup) newRoaringSetCursors() ([]roaringset.InnerCursor, func()) {
+	segments, release := sg.getAndLockSegments()
+
+	out := make([]roaringset.InnerCursor, len(segments))
+
+	for i, segment := range segments {
+		out[i] = segment.newRoaringSetCursor()
+	}
+
+	return out, release
+}
+
+// diskIndex returns node's Start and End offsets
+// taking into account HeaderSize. SegmentCursor of RoaringSet
+// accepts only payload part of underlying segment content, therefore
+// offsets should be adjusted and reduced by HeaderSize
+type roaringSetSeeker struct {
+	diskIndex diskIndex
+}
+
+func (s *roaringSetSeeker) Seek(key []byte) (segmentindex.Node, error) {
+	node, err := s.diskIndex.Seek(key)
+	if err != nil {
+		return segmentindex.Node{}, err
+	}
+	return segmentindex.Node{
+		Key:   node.Key,
+		Start: node.Start - segmentindex.HeaderSize,
+		End:   node.End - segmentindex.HeaderSize,
+	}, nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/cursor_segment_roaring_set_range.go

@@ -0,0 +1,57 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"io"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+	"github.com/weaviate/weaviate/entities/concurrency"
+)
+
+func (sg *SegmentGroup) newRoaringSetRangeReaders() ([]roaringsetrange.InnerReader, func()) {
+	segments, release := sg.getAndLockSegments()
+
+	readers := make([]roaringsetrange.InnerReader, len(segments))
+	for i, segment := range segments {
+		readers[i] = segment.newRoaringSetRangeReader()
+	}
+
+	return readers, release
+}
+
+func (s *segment) newRoaringSetRangeReader() *roaringsetrange.SegmentReader {
+	var segmentCursor roaringsetrange.SegmentCursor
+	if s.readFromMemory {
+		segmentCursor = roaringsetrange.NewSegmentCursorMmap(s.contents[s.dataStartPos:s.dataEndPos])
+	} else {
+		sectionReader := io.NewSectionReader(s.contentFile, int64(s.dataStartPos), int64(s.dataEndPos))
+		// since segment reader concurrenlty fetches next segment and merges bitmaps of previous segments
+		// at least 2 buffers needs to be used by cursor not to overwrite data before they are consumed.
+		segmentCursor = roaringsetrange.NewSegmentCursorPread(sectionReader, 2)
+	}
+
+	return roaringsetrange.NewSegmentReaderConcurrent(
+		roaringsetrange.NewGaplessSegmentCursor(segmentCursor),
+		concurrency.SROAR_MERGE)
+}
+
+func (s *segment) newRoaringSetRangeCursor() roaringsetrange.SegmentCursor {
+	if s.readFromMemory {
+		return roaringsetrange.NewSegmentCursorMmap(s.contents[s.dataStartPos:s.dataEndPos])
+	}
+
+	sectionReader := io.NewSectionReader(s.contentFile, int64(s.dataStartPos), int64(s.dataEndPos))
+	// compactor does not work concurrently, next segment is fetched after previous one gets consumed,
+	// therefore just one buffer is sufficient.
+	return roaringsetrange.NewSegmentCursorPread(sectionReader, 1)
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/doc.go

@@ -0,0 +1,75 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+/*
+# LSMKV (= Log-structured Merge-Tree Key-Value Store)
+
+This package contains Weaviate's custom LSM store. While modeled after the
+usecases that are required for Weaviate to be fast, reliable, and scalable, it
+is technically completely independent. You could build your own database on top
+of this key-value store.
+
+Covering the architecture of [LSM Stores] in general goes beyond the scope of
+this documentation. Therefore things that are specific to this implementation
+are highlighted.
+
+# Strategies
+
+To understand the different type of buckets in this store, you need to
+familiarize yourself with the following strategies. A strategy defines a
+different usecase for a [Bucket].
+
+  - "Replace"
+
+    Replace resembles the classical key-value store. Each key has exactly one
+    value. A subsequent PUT on an an existing key, replaces the value (hence
+    the name "replace"). Once replaced a former value can no longer be
+    retrieved, and will eventually be removed in compactions.
+
+  - "Set" (aka "SetCollection")
+
+    A set behaves like an unordered collection of independent values. In other
+    words a single key has multiple values. For example, for key "foo", you
+    could have values "bar1", "bar2", "bazzinga". A bucket of this type is
+    optimized for cheap writes to add new set additions. For example adding
+    another set element has a fixed cost independent of the number of the
+    existing set length. This makes it very well suited for building an
+    inverted index.
+
+    Retrieving a Set has a slight cost to it if a set is spread across multiple
+    segments. This cost will eventually reduce as more and more compactions
+    happen. In the ideal case (fully compacted DB), retrieving a Set requires
+    just a single disk read.
+
+  - "Map" (aka "MapCollection")
+
+    Maps are similar to Sets in the sense that for a single key there are
+    multiple values. However, each value is in itself a key-value pair. This
+    makes this type very similar to a dict or hashmap type. For example for
+    key "foo", you could have value pairs: "bar":17, "baz":19.
+
+    This makes a map a great use case for an inverted index that needs to store
+    additional info beyond just the docid-pointer, such as in the case of a
+    BM25 index where the term frequency needs to be stored.
+
+    The same performance-considerations as for sets apply.
+
+# Navigate around these docs
+
+Good entrypoints to learn more about how this package works include [Store]
+with [New] and [Store.CreateOrLoadBucket], as well as [Bucket] with
+[Bucket.Get], [Bucket.GetBySecondary], [Bucket.Put], etc.
+
+Each strategy also supports cursor types: [CursorReplace] can be created using [Bucket.Cursor], [CursorSet] can be created with [Bucket.SetCursor] , and [CursorMap] can be created with [Bucket.MapCursor].
+
+[LSM Stores]: https://en.wikipedia.org/wiki/Log-structured_merge-tree
+*/
+package lsmkv

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/entities/doc.go

@@ -0,0 +1,13 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// ent contains common types used throughout various lsmkv (sub-)packages
+package entities

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/entities/strategies.go

@@ -0,0 +1,48 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package entities
+
+const (
+	// StrategyReplace allows for idem-potent PUT where the latest takes presence
+	StrategyReplace       = "replace"
+	StrategySetCollection = "setcollection"
+	StrategyMapCollection = "mapcollection"
+	StrategyRoaringSet    = "roaringset"
+	StrategyInverted      = "inverted"
+)
+
+type SegmentStrategy uint16
+
+const (
+	SegmentStrategyReplace SegmentStrategy = iota
+	SegmentStrategySetCollection
+	SegmentStrategyMapCollection
+	SegmentStrategyRoaringSet
+	SegmentStrategyInverted
+)
+
+func SegmentStrategyFromString(in string) SegmentStrategy {
+	switch in {
+	case StrategyReplace:
+		return SegmentStrategyReplace
+	case StrategySetCollection:
+		return SegmentStrategySetCollection
+	case StrategyMapCollection:
+		return SegmentStrategyMapCollection
+	case StrategyRoaringSet:
+		return SegmentStrategyRoaringSet
+	case StrategyInverted:
+		return SegmentStrategyInverted
+	default:
+		panic("unsupported strategy")
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/global_bucket_registry.go

@@ -0,0 +1,56 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+)
+
+type globalBucketRegistry struct {
+	buckets map[string]struct{}
+	mu      sync.Mutex
+}
+
+func newGlobalBucketRegistry() *globalBucketRegistry {
+	return &globalBucketRegistry{
+		buckets: make(map[string]struct{}),
+	}
+}
+
+var GlobalBucketRegistry *globalBucketRegistry
+
+func init() {
+	GlobalBucketRegistry = newGlobalBucketRegistry()
+}
+
+var ErrBucketAlreadyRegistered = errors.New("bucket already registered")
+
+func (r *globalBucketRegistry) TryAdd(absoluteBucketPath string) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if _, ok := r.buckets[absoluteBucketPath]; ok {
+		return fmt.Errorf("bucket %q: %w", absoluteBucketPath, ErrBucketAlreadyRegistered)
+	}
+
+	r.buckets[absoluteBucketPath] = struct{}{}
+	return nil
+}
+
+func (r *globalBucketRegistry) Remove(absoluteBucketPath string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	delete(r.buckets, absoluteBucketPath)
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/helper_for_test.go

@@ -0,0 +1,24 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+//go:build integrationTest
+// +build integrationTest
+
+package lsmkv
+
+import (
+	"math/rand"
+	"time"
+)
+
+func getRandomSeed() *rand.Rand {
+	return rand.New(rand.NewSource(time.Now().UnixNano()))
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/lazy_segment.go

@@ -0,0 +1,274 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"sync"
+
+	"github.com/weaviate/sroar"
+
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+)
+
+type lazySegment struct {
+	path        string
+	logger      logrus.FieldLogger
+	metrics     *Metrics
+	existsLower existsOnLowerSegmentsFn
+	cfg         segmentConfig
+
+	segment *segment
+	mux     sync.Mutex
+}
+
+func newLazySegment(path string, logger logrus.FieldLogger, metrics *Metrics,
+	existsLower existsOnLowerSegmentsFn, cfg segmentConfig,
+) (*lazySegment, error) {
+	if metrics != nil && metrics.LazySegmentInit != nil {
+		metrics.LazySegmentInit.Inc()
+	}
+
+	return &lazySegment{
+		path:        path,
+		logger:      logger,
+		metrics:     metrics,
+		existsLower: existsLower,
+		cfg:         cfg,
+	}, nil
+}
+
+func (s *lazySegment) load() error {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	if s.segment == nil {
+		segment, err := newSegment(s.path, s.logger, s.metrics, s.existsLower, s.cfg)
+		if err != nil {
+			return err
+		}
+		s.segment = segment
+		if s.metrics != nil && s.metrics.LazySegmentLoad != nil {
+			s.metrics.LazySegmentLoad.Inc()
+		}
+	}
+
+	return nil
+}
+
+func (s *lazySegment) mustLoad() {
+	err := s.load()
+	if err != nil {
+		panic(fmt.Errorf("error loading segment %q: %w", s.path, err))
+	}
+}
+
+func (s *lazySegment) getPath() string {
+	return s.path
+}
+
+func (s *lazySegment) setPath(path string) {
+	s.mustLoad()
+	s.segment.setPath(path)
+}
+
+func (s *lazySegment) getStrategy() segmentindex.Strategy {
+	strategy, found := s.numberFromPath("s")
+	if found {
+		return segmentindex.Strategy(strategy)
+	}
+	s.mustLoad()
+	return s.segment.getStrategy()
+}
+
+func (s *lazySegment) getSecondaryIndexCount() uint16 {
+	s.mustLoad()
+	return s.segment.getSecondaryIndexCount()
+}
+
+func (s *lazySegment) getLevel() uint16 {
+	level, found := s.numberFromPath("l")
+	if found {
+		return uint16(level)
+	}
+
+	s.mustLoad()
+	return s.segment.getLevel()
+}
+
+func (s *lazySegment) getSize() int64 {
+	s.mustLoad()
+	return s.segment.getSize()
+}
+
+func (s *lazySegment) setSize(size int64) {
+	s.mustLoad()
+	s.segment.setSize(size)
+}
+
+func (s *lazySegment) PayloadSize() int {
+	s.mustLoad()
+	return s.segment.PayloadSize()
+}
+
+func (s *lazySegment) Size() int {
+	s.mustLoad()
+	return s.segment.Size()
+}
+
+func (s *lazySegment) close() error {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	if s.metrics != nil && s.metrics.LazySegmentClose != nil {
+		s.metrics.LazySegmentClose.Inc()
+	}
+	if s.segment == nil {
+		return nil
+	}
+	if s.metrics != nil && s.metrics.LazySegmentUnLoad != nil {
+		s.metrics.LazySegmentUnLoad.Inc()
+	}
+	return s.segment.close()
+}
+
+func (s *lazySegment) get(key []byte) ([]byte, error) {
+	s.mustLoad()
+	return s.segment.get(key)
+}
+
+func (s *lazySegment) getBySecondaryIntoMemory(pos int, key []byte, buffer []byte) ([]byte, []byte, []byte, error) {
+	s.mustLoad()
+	return s.segment.getBySecondaryIntoMemory(pos, key, buffer)
+}
+
+func (s *lazySegment) getCollection(key []byte) ([]value, error) {
+	s.mustLoad()
+	return s.segment.getCollection(key)
+}
+
+func (s *lazySegment) getInvertedData() *segmentInvertedData {
+	s.mustLoad()
+	return s.segment.getInvertedData()
+}
+
+func (s *lazySegment) getSegment() *segment {
+	s.mustLoad()
+	return s.segment
+}
+
+func (s *lazySegment) isLoaded() bool {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	return s.segment != nil
+}
+
+func (s *lazySegment) markForDeletion() error {
+	s.mustLoad()
+	return s.segment.markForDeletion()
+}
+
+func (s *lazySegment) MergeTombstones(other *sroar.Bitmap) (*sroar.Bitmap, error) {
+	s.mustLoad()
+	return s.segment.MergeTombstones(other)
+}
+
+func (s *lazySegment) newCollectionCursor() *segmentCursorCollection {
+	s.mustLoad()
+	return s.segment.newCollectionCursor()
+}
+
+func (s *lazySegment) newCollectionCursorReusable() *segmentCursorCollectionReusable {
+	s.mustLoad()
+	return s.segment.newCollectionCursorReusable()
+}
+
+func (s *lazySegment) newCursor() *segmentCursorReplace {
+	s.mustLoad()
+	return s.segment.newCursor()
+}
+
+func (s *lazySegment) newCursorWithSecondaryIndex(pos int) *segmentCursorReplace {
+	s.mustLoad()
+	return s.segment.newCursorWithSecondaryIndex(pos)
+}
+
+func (s *lazySegment) newMapCursor() *segmentCursorMap {
+	s.mustLoad()
+	return s.segment.newMapCursor()
+}
+
+func (s *lazySegment) newNodeReader(offset nodeOffset, operation string) (*nodeReader, error) {
+	s.mustLoad()
+	return s.segment.newNodeReader(offset, operation)
+}
+
+func (s *lazySegment) newRoaringSetCursor() *roaringset.SegmentCursor {
+	s.mustLoad()
+	return s.segment.newRoaringSetCursor()
+}
+
+func (s *lazySegment) newRoaringSetRangeCursor() roaringsetrange.SegmentCursor {
+	s.mustLoad()
+	return s.segment.newRoaringSetRangeCursor()
+}
+
+func (s *lazySegment) newRoaringSetRangeReader() *roaringsetrange.SegmentReader {
+	s.mustLoad()
+	return s.segment.newRoaringSetRangeReader()
+}
+
+func (s *lazySegment) quantileKeys(q int) [][]byte {
+	s.mustLoad()
+	return s.segment.quantileKeys(q)
+}
+
+func (s *lazySegment) ReadOnlyTombstones() (*sroar.Bitmap, error) {
+	s.mustLoad()
+	return s.segment.ReadOnlyTombstones()
+}
+
+func (s *lazySegment) replaceStratParseData(in []byte) ([]byte, []byte, error) {
+	s.mustLoad()
+	return s.segment.replaceStratParseData(in)
+}
+
+func (s *lazySegment) roaringSetGet(key []byte, bitmapBufPool roaringset.BitmapBufPool,
+) (roaringset.BitmapLayer, func(), error) {
+	s.mustLoad()
+	return s.segment.roaringSetGet(key, bitmapBufPool)
+}
+
+func (s *lazySegment) roaringSetMergeWith(key []byte, input roaringset.BitmapLayer, bitmapBufPool roaringset.BitmapBufPool,
+) error {
+	s.mustLoad()
+	return s.segment.roaringSetMergeWith(key, input, bitmapBufPool)
+}
+
+func (s *lazySegment) numberFromPath(str string) (int, bool) {
+	template := fmt.Sprintf(`\.%s(\d+)\.`, str)
+	re := regexp.MustCompile(template)
+	match := re.FindStringSubmatch(s.path)
+	if len(match) > 1 {
+		num, err := strconv.Atoi(match[1])
+		if err == nil {
+			return num, true
+		}
+	}
+	return 0, false
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable.go

@@ -0,0 +1,507 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/weaviate/weaviate/usecases/memwatch"
+
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/sroar"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+	"github.com/weaviate/weaviate/entities/models"
+)
+
+type Memtable struct {
+	sync.RWMutex
+	key                *binarySearchTree
+	keyMulti           *binarySearchTreeMulti
+	keyMap             *binarySearchTreeMap
+	primaryIndex       *binarySearchTree
+	roaringSet         *roaringset.BinarySearchTree
+	roaringSetRange    *roaringsetrange.Memtable
+	commitlog          memtableCommitLogger
+	allocChecker       memwatch.AllocChecker
+	size               uint64
+	path               string
+	strategy           string
+	secondaryIndices   uint16
+	secondaryToPrimary []map[string][]byte
+	// stores time memtable got dirty to determine when flush is needed
+	dirtyAt             time.Time
+	createdAt           time.Time
+	metrics             *memtableMetrics
+	writesSinceLastSync bool
+
+	tombstones *sroar.Bitmap
+
+	enableChecksumValidation bool
+
+	bm25config                   *models.BM25Config
+	averagePropLength            float64
+	propLengthCount              uint64
+	writeSegmentInfoIntoFileName bool
+}
+
+func newMemtable(path string, strategy string, secondaryIndices uint16,
+	cl memtableCommitLogger, metrics *Metrics, logger logrus.FieldLogger,
+	enableChecksumValidation bool, bm25config *models.BM25Config, writeSegmentInfoIntoFileName bool, allocChecker memwatch.AllocChecker,
+) (*Memtable, error) {
+	m := &Memtable{
+		key:                          &binarySearchTree{},
+		keyMulti:                     &binarySearchTreeMulti{},
+		keyMap:                       &binarySearchTreeMap{},
+		primaryIndex:                 &binarySearchTree{}, // todo, sort upfront
+		roaringSet:                   &roaringset.BinarySearchTree{},
+		roaringSetRange:              roaringsetrange.NewMemtable(logger),
+		commitlog:                    cl,
+		path:                         path,
+		strategy:                     strategy,
+		secondaryIndices:             secondaryIndices,
+		dirtyAt:                      time.Time{},
+		createdAt:                    time.Now(),
+		metrics:                      newMemtableMetrics(metrics, filepath.Dir(path), strategy),
+		enableChecksumValidation:     enableChecksumValidation,
+		bm25config:                   bm25config,
+		writeSegmentInfoIntoFileName: writeSegmentInfoIntoFileName,
+	}
+
+	if m.secondaryIndices > 0 {
+		m.secondaryToPrimary = make([]map[string][]byte, m.secondaryIndices)
+		for i := range m.secondaryToPrimary {
+			m.secondaryToPrimary[i] = map[string][]byte{}
+		}
+	}
+
+	m.metrics.size(m.size)
+
+	if m.strategy == StrategyInverted {
+		m.tombstones = sroar.NewBitmap()
+	}
+
+	return m, nil
+}
+
+func (m *Memtable) get(key []byte) ([]byte, error) {
+	start := time.Now()
+	defer m.metrics.get(start.UnixNano())
+
+	if m.strategy != StrategyReplace {
+		return nil, errors.Errorf("get only possible with strategy 'replace'")
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	return m.key.get(key)
+}
+
+func (m *Memtable) getBySecondary(pos int, key []byte) ([]byte, error) {
+	start := time.Now()
+	defer m.metrics.getBySecondary(start.UnixNano())
+
+	if m.strategy != StrategyReplace {
+		return nil, errors.Errorf("get only possible with strategy 'replace'")
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	primary := m.secondaryToPrimary[pos][string(key)]
+	if primary == nil {
+		return nil, lsmkv.NotFound
+	}
+
+	return m.key.get(primary)
+}
+
+func (m *Memtable) put(key, value []byte, opts ...SecondaryKeyOption) error {
+	start := time.Now()
+	defer m.metrics.put(start.UnixNano())
+
+	if m.strategy != StrategyReplace {
+		return errors.Errorf("put only possible with strategy 'replace'")
+	}
+
+	m.Lock()
+	defer m.Unlock()
+	m.writesSinceLastSync = true
+
+	var secondaryKeys [][]byte
+	if m.secondaryIndices > 0 {
+		secondaryKeys = make([][]byte, m.secondaryIndices)
+		for _, opt := range opts {
+			if err := opt(secondaryKeys); err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := m.commitlog.put(segmentReplaceNode{
+		primaryKey:          key,
+		value:               value,
+		secondaryIndexCount: m.secondaryIndices,
+		secondaryKeys:       secondaryKeys,
+		tombstone:           false,
+	}); err != nil {
+		return errors.Wrap(err, "write into commit log")
+	}
+
+	netAdditions, previousKeys := m.key.insert(key, value, secondaryKeys)
+
+	for i, sec := range previousKeys {
+		m.secondaryToPrimary[i][string(sec)] = nil
+	}
+
+	for i, sec := range secondaryKeys {
+		m.secondaryToPrimary[i][string(sec)] = key
+	}
+
+	m.size += uint64(netAdditions)
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+
+	return nil
+}
+
+func (m *Memtable) setTombstone(key []byte, opts ...SecondaryKeyOption) error {
+	start := time.Now()
+	defer m.metrics.setTombstone(start.UnixNano())
+
+	if m.strategy != "replace" {
+		return errors.Errorf("setTombstone only possible with strategy 'replace'")
+	}
+
+	m.Lock()
+	defer m.Unlock()
+	m.writesSinceLastSync = true
+
+	var secondaryKeys [][]byte
+	if m.secondaryIndices > 0 {
+		secondaryKeys = make([][]byte, m.secondaryIndices)
+		for _, opt := range opts {
+			if err := opt(secondaryKeys); err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := m.commitlog.put(segmentReplaceNode{
+		primaryKey:          key,
+		value:               nil,
+		secondaryIndexCount: m.secondaryIndices,
+		secondaryKeys:       secondaryKeys,
+		tombstone:           true,
+	}); err != nil {
+		return errors.Wrap(err, "write into commit log")
+	}
+
+	m.key.setTombstone(key, nil, secondaryKeys)
+	m.size += uint64(len(key)) + 1 // 1 byte for tombstone
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+
+	return nil
+}
+
+func (m *Memtable) setTombstoneWith(key []byte, deletionTime time.Time, opts ...SecondaryKeyOption) error {
+	start := time.Now()
+	defer m.metrics.setTombstone(start.UnixNano())
+
+	if m.strategy != "replace" {
+		return errors.Errorf("setTombstone only possible with strategy 'replace'")
+	}
+
+	m.Lock()
+	defer m.Unlock()
+	m.writesSinceLastSync = true
+
+	var secondaryKeys [][]byte
+	if m.secondaryIndices > 0 {
+		secondaryKeys = make([][]byte, m.secondaryIndices)
+		for _, opt := range opts {
+			if err := opt(secondaryKeys); err != nil {
+				return err
+			}
+		}
+	}
+
+	tombstonedVal := tombstonedValue(deletionTime)
+
+	if err := m.commitlog.put(segmentReplaceNode{
+		primaryKey:          key,
+		value:               tombstonedVal[:],
+		secondaryIndexCount: m.secondaryIndices,
+		secondaryKeys:       secondaryKeys,
+		tombstone:           true,
+	}); err != nil {
+		return errors.Wrap(err, "write into commit log")
+	}
+
+	m.key.setTombstone(key, tombstonedVal[:], secondaryKeys)
+	m.size += uint64(len(key)) + 1 // 1 byte for tombstone
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+
+	return nil
+}
+
+func tombstonedValue(deletionTime time.Time) []byte {
+	var tombstonedVal [1 + 8]byte // version=1 deletionTime
+	tombstonedVal[0] = 1
+	binary.LittleEndian.PutUint64(tombstonedVal[1:], uint64(deletionTime.UnixMilli()))
+	return tombstonedVal[:]
+}
+
+func errorFromTombstonedValue(tombstonedVal []byte) error {
+	if len(tombstonedVal) == 0 {
+		return lsmkv.Deleted
+	}
+
+	if tombstonedVal[0] != 1 {
+		return fmt.Errorf("unexpected tomstoned value, unsupported version %d", tombstonedVal[0])
+	}
+
+	if len(tombstonedVal) != 9 {
+		return fmt.Errorf("unexpected tomstoned value, invalid length")
+	}
+
+	deletionTimeUnixMilli := int64(binary.LittleEndian.Uint64(tombstonedVal[1:]))
+
+	return lsmkv.NewErrDeleted(time.UnixMilli(deletionTimeUnixMilli))
+}
+
+func (m *Memtable) getCollection(key []byte) ([]value, error) {
+	start := time.Now()
+	defer m.metrics.getCollection(start.UnixNano())
+
+	// TODO amourao: check if this is needed for StrategyInverted
+	if m.strategy != StrategySetCollection && m.strategy != StrategyMapCollection && m.strategy != StrategyInverted {
+		return nil, errors.Errorf("getCollection only possible with strategies %q, %q, %q",
+			StrategySetCollection, StrategyMapCollection, StrategyInverted)
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	v, err := m.keyMulti.get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	return v, nil
+}
+
+func (m *Memtable) getMap(key []byte) ([]MapPair, error) {
+	start := time.Now()
+	defer m.metrics.getMap(start.UnixNano())
+
+	if m.strategy != StrategyMapCollection && m.strategy != StrategyInverted {
+		return nil, errors.Errorf("getMap only possible with strategies %q, %q",
+			StrategyMapCollection, StrategyInverted)
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	v, err := m.keyMap.get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	return v, nil
+}
+
+func (m *Memtable) append(key []byte, values []value) error {
+	start := time.Now()
+	defer m.metrics.append(start.UnixNano())
+
+	if m.strategy != StrategySetCollection && m.strategy != StrategyMapCollection {
+		return errors.Errorf("append only possible with strategies %q, %q",
+			StrategySetCollection, StrategyMapCollection)
+	}
+
+	m.Lock()
+	defer m.Unlock()
+	m.writesSinceLastSync = true
+
+	if err := m.commitlog.append(segmentCollectionNode{
+		primaryKey: key,
+		values:     values,
+	}); err != nil {
+		return errors.Wrap(err, "write into commit log")
+	}
+
+	m.keyMulti.insert(key, values)
+	m.size += uint64(len(key))
+	for _, value := range values {
+		m.size += uint64(len(value.value))
+	}
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+
+	return nil
+}
+
+func (m *Memtable) appendMapSorted(key []byte, pair MapPair) error {
+	start := time.Now()
+	defer m.metrics.appendMapSorted(start.UnixNano())
+
+	if m.strategy != StrategyMapCollection && m.strategy != StrategyInverted {
+		return errors.Errorf("append only possible with strategy %q, %q",
+			StrategyMapCollection, StrategyInverted)
+	}
+
+	valuesForCommitLog, err := pair.Bytes()
+	if err != nil {
+		return err
+	}
+
+	newNode := segmentCollectionNode{
+		primaryKey: key,
+		values: []value{
+			{
+				value:     valuesForCommitLog,
+				tombstone: pair.Tombstone,
+			},
+		},
+	}
+
+	m.Lock()
+	defer m.Unlock()
+	m.writesSinceLastSync = true
+
+	if err := m.commitlog.append(newNode); err != nil {
+		return errors.Wrap(err, "write into commit log")
+	}
+
+	m.keyMap.insert(key, pair)
+	m.size += uint64(len(key) + len(valuesForCommitLog))
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+
+	return nil
+}
+
+func (m *Memtable) Size() uint64 {
+	m.RLock()
+	defer m.RUnlock()
+
+	return m.size
+}
+
+func (m *Memtable) ActiveDuration() time.Duration {
+	m.RLock()
+	defer m.RUnlock()
+
+	return time.Since(m.createdAt)
+}
+
+func (m *Memtable) updateDirtyAt() {
+	if m.dirtyAt.IsZero() {
+		m.dirtyAt = time.Now()
+	}
+}
+
+// returns time memtable got dirty (1st write occurred)
+// (0 if clean)
+func (m *Memtable) DirtyDuration() time.Duration {
+	m.RLock()
+	defer m.RUnlock()
+
+	if m.dirtyAt.IsZero() {
+		return 0
+	}
+	return time.Since(m.dirtyAt)
+}
+
+func (m *Memtable) countStats() *countStats {
+	m.RLock()
+	defer m.RUnlock()
+	return m.key.countStats()
+}
+
+// the WAL uses a buffer and isn't written until the buffer size is crossed or
+// this function explicitly called. This allows to safge unnecessary disk
+// writes in larger operations, such as batches. It is sufficient to call write
+// on the WAL just once. This does not make a batch atomic, but it guarantees
+// that the WAL is written before a successful response is returned to the
+// user.
+func (m *Memtable) writeWAL() error {
+	m.Lock()
+	defer m.Unlock()
+
+	return m.commitlog.flushBuffers()
+}
+
+func (m *Memtable) ReadOnlyTombstones() (*sroar.Bitmap, error) {
+	if m.strategy != StrategyInverted {
+		return nil, errors.Errorf("tombstones only supported for strategy %q", StrategyInverted)
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	if m.tombstones != nil {
+		return m.tombstones.Clone(), nil
+	}
+
+	return nil, lsmkv.NotFound
+}
+
+func (m *Memtable) SetTombstone(docId uint64) error {
+	if m.strategy != StrategyInverted {
+		return errors.Errorf("tombstones only supported for strategy %q", StrategyInverted)
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	m.tombstones.Set(docId)
+
+	return nil
+}
+
+func (m *Memtable) GetPropLengths() (uint64, uint64, error) {
+	m.RLock()
+	flatA := m.keyMap.flattenInOrder()
+	m.RUnlock()
+
+	docIdsLengths := make(map[uint64]uint32)
+	propLengthSum := uint64(0)
+	propLengthCount := uint64(0)
+
+	for _, mapNode := range flatA {
+		for j := range mapNode.values {
+			docId := binary.BigEndian.Uint64(mapNode.values[j].Key)
+			if !mapNode.values[j].Tombstone {
+				fieldLength := math.Float32frombits(binary.LittleEndian.Uint32(mapNode.values[j].Value[4:]))
+				if _, ok := docIdsLengths[docId]; !ok {
+					propLengthSum += uint64(fieldLength)
+					propLengthCount++
+				}
+				docIdsLengths[docId] = uint32(fieldLength)
+			}
+		}
+	}
+
+	return propLengthSum, propLengthCount, nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_flush.go

@@ -0,0 +1,333 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/entities/diskio"
+)
+
+func (m *Memtable) flushWAL() error {
+	if err := m.commitlog.close(); err != nil {
+		return err
+	}
+
+	if m.Size() == 0 {
+		// this is an empty memtable, nothing to do
+		// however, we still have to cleanup the commit log, otherwise we will
+		// attempt to recover from it on the next cycle
+		if err := m.commitlog.delete(); err != nil {
+			return errors.Wrap(err, "delete commit log file")
+		}
+		return nil
+	}
+
+	// fsync parent directory
+	err := diskio.Fsync(filepath.Dir(m.path))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *Memtable) flush() (segmentPath string, rerr error) {
+	// close the commit log first, this also forces it to be fsynced. If
+	// something fails there, don't proceed with flushing. The commit log will
+	// only be deleted at the very end, if the flush was successful
+	// (indicated by a successful close of the flush file - which indicates a
+	// successful fsync)
+
+	if err := m.commitlog.close(); err != nil {
+		return "", errors.Wrap(err, "close commit log file")
+	}
+
+	if m.Size() == 0 {
+		// this is an empty memtable, nothing to do
+		// however, we still have to cleanup the commit log, otherwise we will
+		// attempt to recover from it on the next cycle
+		if err := m.commitlog.delete(); err != nil {
+			return "", errors.Wrap(err, "delete commit log file")
+		}
+		return "", nil
+	}
+	var tmpSegmentPath string
+	if m.writeSegmentInfoIntoFileName {
+		// new segments are always level 0
+		tmpSegmentPath = m.path + segmentExtraInfo(0, SegmentStrategyFromString(m.strategy)) + ".db.tmp"
+	} else {
+		tmpSegmentPath = m.path + ".db.tmp"
+	}
+
+	f, err := os.OpenFile(tmpSegmentPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o666)
+	if err != nil {
+		return "", err
+	}
+	defer func() {
+		if rerr != nil {
+			f.Close()
+			os.Remove(tmpSegmentPath)
+		}
+	}()
+
+	observeWrite := m.metrics.writeMemtable
+	cb := func(written int64) {
+		observeWrite(written)
+	}
+	meteredF := diskio.NewMeteredWriter(f, cb)
+
+	bufw := bufio.NewWriter(meteredF)
+	segmentFile := segmentindex.NewSegmentFile(
+		segmentindex.WithBufferedWriter(bufw),
+		segmentindex.WithChecksumsDisabled(!m.enableChecksumValidation),
+	)
+
+	var keys []segmentindex.Key
+	skipIndices := false
+
+	switch m.strategy {
+	case StrategyReplace:
+		if keys, err = m.flushDataReplace(segmentFile); err != nil {
+			return "", err
+		}
+
+	case StrategySetCollection:
+		if keys, err = m.flushDataSet(segmentFile); err != nil {
+			return "", err
+		}
+
+	case StrategyRoaringSet:
+		if keys, err = m.flushDataRoaringSet(segmentFile); err != nil {
+			return "", err
+		}
+
+	case StrategyRoaringSetRange:
+		if keys, err = m.flushDataRoaringSetRange(segmentFile); err != nil {
+			return "", err
+		}
+		skipIndices = true
+
+	case StrategyMapCollection:
+		if keys, err = m.flushDataMap(segmentFile); err != nil {
+			return "", err
+		}
+	case StrategyInverted:
+		if keys, _, err = m.flushDataInverted(segmentFile, meteredF, bufw); err != nil {
+			return "", err
+		}
+		skipIndices = true
+	default:
+		return "", fmt.Errorf("cannot flush strategy %s", m.strategy)
+	}
+
+	if !skipIndices {
+		indexes := &segmentindex.Indexes{
+			Keys:                keys,
+			SecondaryIndexCount: m.secondaryIndices,
+			ScratchSpacePath:    m.path + ".scratch.d",
+			ObserveWrite: monitoring.GetMetrics().FileIOWrites.With(prometheus.Labels{
+				"strategy":  m.strategy,
+				"operation": "writeIndices",
+			}),
+			AllocChecker: m.allocChecker,
+		}
+
+		if _, err := segmentFile.WriteIndexes(indexes, int64(m.size)); err != nil {
+			return "", err
+		}
+	}
+
+	if _, err := segmentFile.WriteChecksum(); err != nil {
+		return "", err
+	}
+
+	if err := f.Sync(); err != nil {
+		return "", err
+	}
+
+	if err := f.Close(); err != nil {
+		return "", err
+	}
+
+	segmentPath = strings.TrimSuffix(tmpSegmentPath, ".tmp")
+	err = os.Rename(tmpSegmentPath, segmentPath)
+	if err != nil {
+		return "", err
+	}
+
+	// fsync parent directory
+	err = diskio.Fsync(filepath.Dir(m.path))
+	if err != nil {
+		return "", err
+	}
+
+	// only now that the file has been flushed is it safe to delete the commit log
+	// TODO: there might be an interest in keeping the commit logs around for
+	// longer as they might come in handy for replication
+	return segmentPath, m.commitlog.delete()
+}
+
+func (m *Memtable) flushDataReplace(f *segmentindex.SegmentFile) ([]segmentindex.Key, error) {
+	flat := m.key.flattenInOrder()
+
+	totalDataLength := totalKeyAndValueSize(flat)
+	perObjectAdditions := len(flat) * (1 + 8 + 4 + int(m.secondaryIndices)*4) // 1 byte for the tombstone, 8 bytes value length encoding, 4 bytes key length encoding, + 4 bytes key encoding for every secondary index
+	headerSize := segmentindex.HeaderSize
+	header := &segmentindex.Header{
+		IndexStart:       uint64(totalDataLength + perObjectAdditions + headerSize),
+		Level:            0, // always level zero on a new one
+		Version:          segmentindex.ChooseHeaderVersion(m.enableChecksumValidation),
+		SecondaryIndices: m.secondaryIndices,
+		Strategy:         SegmentStrategyFromString(m.strategy),
+	}
+
+	n, err := f.WriteHeader(header)
+	if err != nil {
+		return nil, err
+	}
+	headerSize = int(n)
+	keys := make([]segmentindex.Key, len(flat))
+
+	totalWritten := headerSize
+	for i, node := range flat {
+		segNode := &segmentReplaceNode{
+			offset:              totalWritten,
+			tombstone:           node.tombstone,
+			value:               node.value,
+			primaryKey:          node.key,
+			secondaryKeys:       node.secondaryKeys,
+			secondaryIndexCount: m.secondaryIndices,
+		}
+
+		ki, err := segNode.KeyIndexAndWriteTo(f.BodyWriter())
+		if err != nil {
+			return nil, errors.Wrapf(err, "write node %d", i)
+		}
+
+		keys[i] = ki
+		totalWritten = ki.ValueEnd
+	}
+
+	return keys, nil
+}
+
+func (m *Memtable) flushDataSet(f *segmentindex.SegmentFile) ([]segmentindex.Key, error) {
+	flat := m.keyMulti.flattenInOrder()
+	return m.flushDataCollection(f, flat)
+}
+
+func (m *Memtable) flushDataMap(f *segmentindex.SegmentFile) ([]segmentindex.Key, error) {
+	m.RLock()
+	flat := m.keyMap.flattenInOrder()
+	m.RUnlock()
+
+	// by encoding each map pair we can force the same structure as for a
+	// collection, which means we can reuse the same flushing logic
+	asMulti := make([]*binarySearchNodeMulti, len(flat))
+	for i, mapNode := range flat {
+		asMulti[i] = &binarySearchNodeMulti{
+			key:    mapNode.key,
+			values: make([]value, len(mapNode.values)),
+		}
+
+		for j := range asMulti[i].values {
+			enc, err := mapNode.values[j].Bytes()
+			if err != nil {
+				return nil, err
+			}
+
+			asMulti[i].values[j] = value{
+				value:     enc,
+				tombstone: mapNode.values[j].Tombstone,
+			}
+		}
+
+	}
+	return m.flushDataCollection(f, asMulti)
+}
+
+func (m *Memtable) flushDataCollection(f *segmentindex.SegmentFile,
+	flat []*binarySearchNodeMulti,
+) ([]segmentindex.Key, error) {
+	totalDataLength := totalValueSizeCollection(flat)
+	header := &segmentindex.Header{
+		IndexStart:       uint64(totalDataLength + segmentindex.HeaderSize),
+		Level:            0, // always level zero on a new one
+		Version:          segmentindex.ChooseHeaderVersion(m.enableChecksumValidation),
+		SecondaryIndices: m.secondaryIndices,
+		Strategy:         SegmentStrategyFromString(m.strategy),
+	}
+
+	n, err := f.WriteHeader(header)
+	if err != nil {
+		return nil, err
+	}
+	headerSize := int(n)
+	keys := make([]segmentindex.Key, len(flat))
+
+	totalWritten := headerSize
+	for i, node := range flat {
+		ki, err := (&segmentCollectionNode{
+			values:     node.values,
+			primaryKey: node.key,
+			offset:     totalWritten,
+		}).KeyIndexAndWriteTo(f.BodyWriter())
+		if err != nil {
+			return nil, errors.Wrapf(err, "write node %d", i)
+		}
+
+		keys[i] = ki
+		totalWritten = ki.ValueEnd
+	}
+
+	return keys, nil
+}
+
+func totalKeyAndValueSize(in []*binarySearchNode) int {
+	var sum int
+	for _, n := range in {
+		sum += len(n.value)
+		sum += len(n.key)
+		for _, sec := range n.secondaryKeys {
+			sum += len(sec)
+		}
+	}
+
+	return sum
+}
+
+func totalValueSizeCollection(in []*binarySearchNodeMulti) int {
+	var sum int
+	for _, n := range in {
+		sum += 8 // uint64 to indicate array length
+		for _, v := range n.values {
+			sum += 1 // bool to indicate value tombstone
+			sum += 8 // uint64 to indicate value length
+			sum += len(v.value)
+		}
+
+		sum += 4 // uint32 to indicate key size
+		sum += len(n.key)
+	}
+
+	return sum
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_flush_inverted.go

@@ -0,0 +1,261 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"encoding/gob"
+	"fmt"
+	"math"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/weaviate/sroar"
+	"github.com/weaviate/weaviate/adapters/repos/db/compactor"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/varenc"
+	"github.com/weaviate/weaviate/entities/diskio"
+	"github.com/weaviate/weaviate/usecases/config"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+)
+
+func (m *Memtable) flushDataInverted(f *segmentindex.SegmentFile, ogF *diskio.MeteredWriter, bufw *bufio.Writer) ([]segmentindex.Key, *sroar.Bitmap, error) {
+	m.RLock()
+	flatA := m.keyMap.flattenInOrder()
+	m.RUnlock()
+
+	// by encoding each map pair we can force the same structure as for a
+	// collection, which means we can reuse the same flushing logic
+	flat := make([]*binarySearchNodeMap, len(flatA))
+
+	actuallyWritten := 0
+	actuallyWrittenKeys := make(map[string]struct{})
+	tombstones := m.tombstones
+
+	docIdsLengths := make(map[uint64]uint32)
+	propLengthSum := uint64(0)
+	propLengthCount := uint64(0)
+
+	for i, mapNode := range flatA {
+		flat[i] = &binarySearchNodeMap{
+			key:    mapNode.key,
+			values: make([]MapPair, 0, len(mapNode.values)),
+		}
+
+		for j := range mapNode.values {
+			docId := binary.BigEndian.Uint64(mapNode.values[j].Key)
+			if !mapNode.values[j].Tombstone {
+				fieldLength := math.Float32frombits(binary.LittleEndian.Uint32(mapNode.values[j].Value[4:]))
+				flat[i].values = append(flat[i].values, mapNode.values[j])
+				actuallyWritten++
+				actuallyWrittenKeys[string(mapNode.key)] = struct{}{}
+				if _, ok := docIdsLengths[docId]; !ok {
+					propLengthSum += uint64(fieldLength)
+					propLengthCount++
+				}
+				docIdsLengths[docId] = uint32(fieldLength)
+			} else {
+				tombstones.Set(docId)
+			}
+		}
+
+	}
+
+	// weighted average of m.averagePropLength and the average of the current flush
+	// averaged by propLengthCount and m.propLengthCount
+	if m.averagePropLength == 0 {
+		m.averagePropLength = float64(propLengthSum) / float64(propLengthCount)
+		m.propLengthCount = propLengthCount
+	} else {
+		m.averagePropLength = (m.averagePropLength*float64(m.propLengthCount) + float64(propLengthSum)) / float64(m.propLengthCount+propLengthCount)
+		m.propLengthCount += propLengthCount
+	}
+
+	tombstoneBuffer := make([]byte, 0)
+	if !tombstones.IsEmpty() {
+		tombstoneBuffer = tombstones.ToBuffer()
+	}
+
+	header := segmentindex.Header{
+		Version:          segmentindex.ChooseHeaderVersion(m.enableChecksumValidation),
+		IndexStart:       0, // will be updated later
+		Level:            0, // always level zero on a new one
+		SecondaryIndices: m.secondaryIndices,
+		Strategy:         SegmentStrategyFromString(StrategyInverted),
+	}
+
+	headerInverted := segmentindex.HeaderInverted{
+		KeysOffset:            uint64(segmentindex.HeaderSize + segmentindex.SegmentInvertedDefaultHeaderSize + segmentindex.SegmentInvertedDefaultFieldCount),
+		TombstoneOffset:       0,
+		PropertyLengthsOffset: 0,
+		Version:               0,
+		BlockSize:             uint8(segmentindex.SegmentInvertedDefaultBlockSize),
+		DataFieldCount:        uint8(segmentindex.SegmentInvertedDefaultFieldCount),
+		DataFields:            []varenc.VarEncDataType{varenc.DeltaVarIntUint64, varenc.VarIntUint64},
+	}
+
+	docIdEncoder := varenc.GetVarEncEncoder64(headerInverted.DataFields[0])
+	tfEncoder := varenc.GetVarEncEncoder64(headerInverted.DataFields[1])
+	docIdEncoder.Init(segmentindex.SegmentInvertedDefaultBlockSize)
+	tfEncoder.Init(segmentindex.SegmentInvertedDefaultBlockSize)
+
+	headerEmpty := make([]byte, headerInverted.KeysOffset)
+	if _, err := bufw.Write(headerEmpty); err != nil {
+		return nil, nil, err
+	}
+
+	totalWritten := len(headerEmpty)
+	keysStartOffset := totalWritten
+
+	buf := make([]byte, 8)
+
+	keys := make([]segmentindex.Key, len(flat))
+	actuallyWritten = 0
+
+	bw := f.BodyWriter()
+	if bw == nil {
+		return nil, nil, fmt.Errorf("segment file body writer is nil, cannot write inverted index")
+	}
+
+	for _, mapNode := range flat {
+		if len(mapNode.values) > 0 {
+
+			ki := segmentindex.Key{
+				Key:        mapNode.key,
+				ValueStart: totalWritten,
+			}
+
+			b := config.DefaultBM25b
+			k1 := config.DefaultBM25k1
+			if m.bm25config != nil {
+				b = m.bm25config.B
+				k1 = m.bm25config.K1
+			}
+
+			blocksEncoded, _ := createAndEncodeBlocksWithLengths(mapNode.values, docIdEncoder, tfEncoder, float64(b), float64(k1), m.averagePropLength)
+
+			if _, err := bw.Write(blocksEncoded); err != nil {
+				return nil, nil, err
+			}
+			totalWritten += len(blocksEncoded)
+
+			// write key length
+			binary.LittleEndian.PutUint32(buf, uint32(len(mapNode.key)))
+			if _, err := bw.Write(buf[:4]); err != nil {
+				return nil, nil, err
+			}
+
+			totalWritten += 4
+
+			// write key
+			if _, err := bw.Write(mapNode.key); err != nil {
+				return nil, nil, err
+			}
+			totalWritten += len(mapNode.key)
+
+			ki.ValueEnd = totalWritten
+
+			keys[actuallyWritten] = ki
+			actuallyWritten++
+		}
+	}
+
+	tombstoneOffset := totalWritten
+
+	binary.LittleEndian.PutUint64(buf, uint64(len(tombstoneBuffer)))
+	if _, err := bw.Write(buf); err != nil {
+		return nil, nil, err
+	}
+	totalWritten += 8
+
+	if _, err := bw.Write(tombstoneBuffer); err != nil {
+		return nil, nil, err
+	}
+	totalWritten += len(tombstoneBuffer)
+	propLengthsOffset := totalWritten
+
+	b := new(bytes.Buffer)
+
+	propLengthAvg := float64(propLengthSum) / float64(propLengthCount)
+
+	binary.LittleEndian.PutUint64(buf, math.Float64bits(propLengthAvg))
+	if _, err := bw.Write(buf); err != nil {
+		return nil, nil, err
+	}
+	totalWritten += 8
+
+	binary.LittleEndian.PutUint64(buf, propLengthCount)
+	if _, err := bw.Write(buf); err != nil {
+		return nil, nil, err
+	}
+	totalWritten += 8
+
+	e := gob.NewEncoder(b)
+
+	// Encoding the map
+	err := e.Encode(docIdsLengths)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	binary.LittleEndian.PutUint64(buf, uint64(b.Len()))
+	if _, err := bw.Write(buf); err != nil {
+		return nil, nil, err
+	}
+	totalWritten += 8
+
+	if _, err := bw.Write(b.Bytes()); err != nil {
+		return nil, nil, err
+	}
+
+	totalWritten += b.Len()
+
+	treeOffset := totalWritten
+
+	header.IndexStart = uint64(treeOffset)
+
+	headerInverted.KeysOffset = uint64(keysStartOffset)
+	headerInverted.TombstoneOffset = uint64(tombstoneOffset)
+	headerInverted.PropertyLengthsOffset = uint64(propLengthsOffset)
+
+	f.SetHeader(&header)
+	f.SetHeaderInverted(&headerInverted)
+
+	indexes := &segmentindex.Indexes{
+		Keys:                keys,
+		SecondaryIndexCount: m.secondaryIndices,
+		ScratchSpacePath:    m.path + ".scratch.d",
+		ObserveWrite: monitoring.GetMetrics().FileIOWrites.With(prometheus.Labels{
+			"strategy":  m.strategy,
+			"operation": "writeIndices",
+		}),
+	}
+
+	if _, err := f.WriteIndexes(indexes, int64(m.size)); err != nil {
+		return nil, nil, err
+	}
+
+	// flush buffered, so we can safely seek on underlying writer
+
+	if err := bufw.Flush(); err != nil {
+		return nil, nil, fmt.Errorf("flush buffered: %w", err)
+	}
+
+	version := segmentindex.ChooseHeaderVersion(m.enableChecksumValidation)
+	if err := compactor.WriteHeaders(nil, ogF, bufw, f, 0, version,
+		header.SecondaryIndices, header.IndexStart, segmentindex.StrategyInverted, &headerInverted); err != nil {
+		return nil, nil, fmt.Errorf("write headers: %w", err)
+	}
+
+	return keys[:actuallyWritten], tombstones, nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_flush_roaring_set.go

@@ -0,0 +1,73 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"fmt"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+)
+
+func (m *Memtable) flushDataRoaringSet(f *segmentindex.SegmentFile) ([]segmentindex.Key, error) {
+	flat := m.roaringSet.FlattenInOrder()
+
+	totalDataLength := totalPayloadSizeRoaringSet(flat)
+	header := &segmentindex.Header{
+		IndexStart:       uint64(totalDataLength + segmentindex.HeaderSize),
+		Level:            0, // always level zero on a new one
+		Version:          segmentindex.ChooseHeaderVersion(m.enableChecksumValidation),
+		SecondaryIndices: 0,
+		Strategy:         segmentindex.StrategyRoaringSet,
+	}
+
+	n, err := f.WriteHeader(header)
+	if err != nil {
+		return nil, err
+	}
+	headerSize := int(n)
+	keys := make([]segmentindex.Key, len(flat))
+
+	totalWritten := headerSize
+	for i, node := range flat {
+		sn, err := roaringset.NewSegmentNode(node.Key, node.Value.Additions,
+			node.Value.Deletions)
+		if err != nil {
+			return nil, fmt.Errorf("create segment node: %w", err)
+		}
+
+		ki, err := sn.KeyIndexAndWriteTo(f.BodyWriter(), totalWritten)
+		if err != nil {
+			return nil, fmt.Errorf("write node %d: %w", i, err)
+		}
+
+		keys[i] = ki
+		totalWritten = ki.ValueEnd
+	}
+
+	return keys, nil
+}
+
+func totalPayloadSizeRoaringSet(in []*roaringset.BinarySearchNode) int {
+	var sum int
+	for _, n := range in {
+		sum += 8 // uint64 to segment length
+		sum += 8 // uint64 to indicate length of additions bitmap
+		sum += len(n.Value.Additions.ToBuffer())
+		sum += 8 // uint64 to indicate length of deletions bitmap
+		sum += len(n.Value.Deletions.ToBuffer())
+		sum += 4 // uint32 to indicate key size
+		sum += len(n.Key)
+	}
+
+	return sum
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_flush_roaring_set_range.go

@@ -0,0 +1,68 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"fmt"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+)
+
+func (m *Memtable) flushDataRoaringSetRange(f *segmentindex.SegmentFile) ([]segmentindex.Key, error) {
+	nodes := m.roaringSetRange.Nodes()
+
+	totalDataLength := totalPayloadSizeRoaringSetRange(nodes)
+	header := &segmentindex.Header{
+		IndexStart:       uint64(totalDataLength + segmentindex.HeaderSize),
+		Level:            0, // always level zero on a new one
+		Version:          segmentindex.ChooseHeaderVersion(m.enableChecksumValidation),
+		SecondaryIndices: 0,
+		Strategy:         segmentindex.StrategyRoaringSetRange,
+	}
+
+	_, err := f.WriteHeader(header)
+	if err != nil {
+		return nil, err
+	}
+
+	for i, node := range nodes {
+		sn, err := roaringsetrange.NewSegmentNode(node.Key, node.Additions, node.Deletions)
+		if err != nil {
+			return nil, fmt.Errorf("create segment node: %w", err)
+		}
+
+		_, err = f.BodyWriter().Write(sn.ToBuffer())
+		if err != nil {
+			return nil, fmt.Errorf("write segment node %d: %w", i, err)
+		}
+	}
+
+	return make([]segmentindex.Key, 0), nil
+}
+
+func totalPayloadSizeRoaringSetRange(nodes []*roaringsetrange.MemtableNode) int {
+	var sum int
+	for _, node := range nodes {
+		sum += 8 // uint64 to segment length
+		sum += 1 // key (fixed size)
+		sum += 8 // uint64 to indicate length of additions bitmap
+		sum += len(node.Additions.ToBuffer())
+
+		if node.Key == 0 {
+			sum += 8 // uint64 to indicate length of deletions bitmap
+			sum += len(node.Deletions.ToBuffer())
+		}
+	}
+
+	return sum
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_metrics.go

@@ -0,0 +1,43 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+type memtableMetrics struct {
+	put             NsObserver
+	setTombstone    NsObserver
+	append          NsObserver
+	appendMapSorted NsObserver
+	get             NsObserver
+	getBySecondary  NsObserver
+	getMap          NsObserver
+	getCollection   NsObserver
+	size            Setter
+	writeMemtable   BytesWriteObserver
+}
+
+// newMemtableMetrics curries the prometheus-functions just once to make sure
+// they don't have to be curried on the hotpath where we this would lead to a
+// lot of allocations.
+func newMemtableMetrics(metrics *Metrics, path, strategy string) *memtableMetrics {
+	return &memtableMetrics{
+		put:             metrics.MemtableOpObserver(path, strategy, "put"),
+		setTombstone:    metrics.MemtableOpObserver(path, strategy, "setTombstone"),
+		append:          metrics.MemtableOpObserver(path, strategy, "append"),
+		appendMapSorted: metrics.MemtableOpObserver(path, strategy, "appendMapSorted"),
+		get:             metrics.MemtableOpObserver(path, strategy, "get"),
+		getBySecondary:  metrics.MemtableOpObserver(path, strategy, "getBySecondary"),
+		getMap:          metrics.MemtableOpObserver(path, strategy, "getMap"),
+		getCollection:   metrics.MemtableOpObserver(path, strategy, "getCollection"),
+		size:            metrics.MemtableSizeSetter(path, strategy),
+		writeMemtable:   metrics.MemtableWriteObserver(strategy, "flushMemtable"),
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_roaring_set.go

@@ -0,0 +1,149 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"github.com/pkg/errors"
+	"github.com/weaviate/sroar"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+)
+
+func (m *Memtable) roaringSetAddOne(key []byte, value uint64) error {
+	return m.roaringSetAddList(key, []uint64{value})
+}
+
+func (m *Memtable) roaringSetAddList(key []byte, values []uint64) error {
+	if err := CheckStrategyRoaringSet(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetAddCommitLog(key, values, []uint64{}); err != nil {
+		return err
+	}
+
+	m.roaringSet.Insert(key, roaringset.Insert{Additions: values})
+
+	m.roaringSetAdjustMeta(len(values))
+	return nil
+}
+
+func (m *Memtable) roaringSetAddBitmap(key []byte, bm *sroar.Bitmap) error {
+	if err := CheckStrategyRoaringSet(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetAddCommitLog(key, bm.ToArray(), []uint64{}); err != nil {
+		return err
+	}
+
+	m.roaringSet.Insert(key, roaringset.Insert{Additions: bm.ToArray()})
+
+	m.roaringSetAdjustMeta(bm.GetCardinality())
+	return nil
+}
+
+func (m *Memtable) roaringSetRemoveOne(key []byte, value uint64) error {
+	return m.roaringSetRemoveList(key, []uint64{value})
+}
+
+func (m *Memtable) roaringSetRemoveList(key []byte, values []uint64) error {
+	if err := CheckStrategyRoaringSet(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetAddCommitLog(key, []uint64{}, values); err != nil {
+		return err
+	}
+
+	m.roaringSet.Insert(key, roaringset.Insert{Deletions: values})
+
+	m.roaringSetAdjustMeta(len(values))
+	return nil
+}
+
+func (m *Memtable) roaringSetRemoveBitmap(key []byte, bm *sroar.Bitmap) error {
+	if err := CheckStrategyRoaringSet(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetAddCommitLog(key, []uint64{}, bm.ToArray()); err != nil {
+		return err
+	}
+
+	m.roaringSet.Insert(key, roaringset.Insert{Deletions: bm.ToArray()})
+
+	m.roaringSetAdjustMeta(bm.GetCardinality())
+	return nil
+}
+
+func (m *Memtable) roaringSetAddRemoveSlices(key []byte, additions []uint64, deletions []uint64) error {
+	if err := CheckStrategyRoaringSet(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetAddCommitLog(key, additions, deletions); err != nil {
+		return err
+	}
+
+	m.roaringSet.Insert(key, roaringset.Insert{
+		Additions: additions,
+		Deletions: deletions,
+	})
+
+	m.roaringSetAdjustMeta(len(additions) + len(deletions))
+	return nil
+}
+
+// returned bitmaps are cloned and safe to mutate
+func (m *Memtable) roaringSetGet(key []byte) (roaringset.BitmapLayer, error) {
+	if err := CheckStrategyRoaringSet(m.strategy); err != nil {
+		return roaringset.BitmapLayer{}, err
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	return m.roaringSet.Get(key)
+}
+
+func (m *Memtable) roaringSetAdjustMeta(entriesChanged int) {
+	// in the worst case roaring bitmaps take 2 bytes per entry. A reasonable
+	// estimation is therefore to take the changed entries and multiply them by
+	// 2.
+	m.size += uint64(entriesChanged * 2)
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+}
+
+func (m *Memtable) roaringSetAddCommitLog(key []byte, additions []uint64, deletions []uint64) error {
+	if node, err := roaringset.NewSegmentNodeList(key, additions, deletions); err != nil {
+		return errors.Wrap(err, "create node for commit log")
+	} else if err := m.commitlog.add(node); err != nil {
+		return errors.Wrap(err, "add node to commit log")
+	}
+	return nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_roaring_set_range.go

@@ -0,0 +1,98 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"encoding/binary"
+
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+)
+
+func (m *Memtable) roaringSetRangeAdd(key uint64, values ...uint64) error {
+	if err := CheckStrategyRoaringSetRange(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetRangeAddCommitLog(key, values, nil); err != nil {
+		return err
+	}
+
+	m.roaringSetRange.Insert(key, values)
+
+	m.roaringSetRangeAdjustMeta(len(values))
+	return nil
+}
+
+func (m *Memtable) roaringSetRangeRemove(key uint64, values ...uint64) error {
+	if err := CheckStrategyRoaringSetRange(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetRangeAddCommitLog(key, nil, values); err != nil {
+		return err
+	}
+
+	m.roaringSetRange.Delete(key, values)
+
+	m.roaringSetRangeAdjustMeta(len(values))
+	return nil
+}
+
+func (m *Memtable) roaringSetRangeAddRemove(key uint64, additions []uint64, deletions []uint64) error {
+	if err := CheckStrategyRoaringSetRange(m.strategy); err != nil {
+		return err
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	if err := m.roaringSetRangeAddCommitLog(key, additions, deletions); err != nil {
+		return err
+	}
+
+	m.roaringSetRange.Delete(key, deletions)
+	m.roaringSetRange.Insert(key, additions)
+
+	m.roaringSetRangeAdjustMeta(len(additions) + len(deletions))
+	return nil
+}
+
+func (m *Memtable) roaringSetRangeAdjustMeta(entriesChanged int) {
+	// TODO roaring-set-range new estimations
+
+	// in the worst case roaring bitmaps take 2 bytes per entry. A reasonable
+	// estimation is therefore to take the changed entries and multiply them by
+	// 2.
+	m.size += uint64(entriesChanged * 2)
+	m.metrics.size(m.size)
+	m.updateDirtyAt()
+}
+
+func (m *Memtable) roaringSetRangeAddCommitLog(key uint64, additions []uint64, deletions []uint64) error {
+	// TODO roaring-set-range improved commit log
+
+	keyBuf := make([]byte, 8)
+	binary.BigEndian.PutUint64(keyBuf, key)
+	if node, err := roaringset.NewSegmentNodeList(keyBuf, additions, deletions); err != nil {
+		return errors.Wrap(err, "create node for commit log")
+	} else if err := m.commitlog.add(node); err != nil {
+		return errors.Wrap(err, "add node to commit log")
+	}
+	return nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_roaring_set_range_test.go

@@ -0,0 +1,120 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"context"
+	"math/rand"
+	"path"
+	"testing"
+	"time"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+	"github.com/weaviate/weaviate/entities/filters"
+)
+
+func TestMemtableRoaringSetRange(t *testing.T) {
+	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))
+	logger, _ := test.NewNullLogger()
+	memPath := func() string {
+		return path.Join(t.TempDir(), "memtable")
+	}
+
+	t.Run("concurrent writes and search", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSetRange, 0)
+		require.NoError(t, err)
+		m, err := newMemtable(memPath(), StrategyRoaringSetRange, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		addKeyVals := func(k uint64) error {
+			return m.roaringSetRangeAdd(k, k+1000, k+2000, k+3000)
+		}
+		removeKeyVals := func(k uint64) error {
+			return m.roaringSetRangeRemove(k, k+1000, k+2000, k+3000)
+		}
+		assertRead_LTE4_GT7 := func(t *testing.T, reader roaringsetrange.InnerReader) {
+			expAddLTE4 := []uint64{
+				1000, 2000, 3000,
+				1002, 2002, 3002,
+				1004, 2004, 3004,
+			}
+			expAddGT7 := []uint64{
+				1008, 2008, 3008,
+			}
+			expDel := []uint64{
+				1000, 2000, 3000,
+				1001, 2001, 3001,
+				1002, 2002, 3002,
+				1003, 2003, 3003,
+				1004, 2004, 3004,
+				1005, 2005, 3005,
+				1006, 2006, 3006,
+				1007, 2007, 3007,
+				1008, 2008, 3008,
+				1009, 2009, 3009,
+			}
+
+			layerLTE4, release, err := reader.Read(context.Background(), 4, filters.OperatorLessThanEqual)
+			require.NoError(t, err)
+			defer release()
+
+			layerGT7, release, err := reader.Read(context.Background(), 7, filters.OperatorGreaterThan)
+			require.NoError(t, err)
+			defer release()
+
+			assert.ElementsMatch(t, expAddLTE4, layerLTE4.Additions.ToArray())
+			assert.ElementsMatch(t, expDel, layerLTE4.Deletions.ToArray())
+			assert.ElementsMatch(t, expAddGT7, layerGT7.Additions.ToArray())
+			assert.ElementsMatch(t, expDel, layerGT7.Deletions.ToArray())
+		}
+
+		// populate with initial data
+		for i := uint64(0); i < 10; i = i + 2 {
+			assert.NoError(t, addKeyVals(i))
+		}
+		for i := uint64(1); i < 10; i = i + 2 {
+			assert.NoError(t, removeKeyVals(i))
+		}
+
+		// create reader
+		reader := m.newRoaringSetRangeReader()
+
+		// assert data
+		assertRead_LTE4_GT7(t, reader)
+
+		// concurrently mutate memtable
+		chStart := make(chan struct{})
+		chFinish := make(chan struct{})
+		go func() {
+			chStart <- struct{}{}
+			for {
+				select {
+				case <-chFinish:
+					return
+				default:
+					addKeyVals(uint64(rnd.Int31n(1000)))
+					removeKeyVals(uint64(rnd.Int31n(1000)))
+				}
+			}
+		}()
+
+		// assert search results do not contain muted data
+		<-chStart
+		for i := 0; i < 256; i++ {
+			assertRead_LTE4_GT7(t, reader)
+		}
+		chFinish <- struct{}{}
+	})
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_roaring_set_test.go

@@ -0,0 +1,245 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"path"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+)
+
+func TestMemtableRoaringSet(t *testing.T) {
+	logger, _ := test.NewNullLogger()
+	memPath := func() string {
+		return path.Join(t.TempDir(), "fake")
+	}
+
+	t.Run("inserting individual entries", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		assert.Nil(t, m.roaringSetAddOne(key1, 1))
+		assert.Nil(t, m.roaringSetAddOne(key1, 2))
+		assert.Nil(t, m.roaringSetAddOne(key2, 3))
+		assert.Nil(t, m.roaringSetAddOne(key2, 4))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.True(t, setKey1.Additions.Contains(1))
+		assert.True(t, setKey1.Additions.Contains(2))
+		assert.False(t, setKey1.Additions.Contains(3))
+		assert.False(t, setKey1.Additions.Contains(4))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.False(t, setKey2.Additions.Contains(1))
+		assert.False(t, setKey2.Additions.Contains(2))
+		assert.True(t, setKey2.Additions.Contains(3))
+		assert.True(t, setKey2.Additions.Contains(4))
+
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("inserting lists", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		assert.Nil(t, m.roaringSetAddList(key1, []uint64{1, 2}))
+		assert.Nil(t, m.roaringSetAddList(key2, []uint64{3, 4}))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.True(t, setKey1.Additions.Contains(1))
+		assert.True(t, setKey1.Additions.Contains(2))
+		assert.False(t, setKey1.Additions.Contains(3))
+		assert.False(t, setKey1.Additions.Contains(4))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.False(t, setKey2.Additions.Contains(1))
+		assert.False(t, setKey2.Additions.Contains(2))
+		assert.True(t, setKey2.Additions.Contains(3))
+		assert.True(t, setKey2.Additions.Contains(4))
+
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("inserting bitmaps", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		bm1 := roaringset.NewBitmap(1, 2)
+		assert.Nil(t, m.roaringSetAddBitmap(key1, bm1))
+		bm2 := roaringset.NewBitmap(3, 4)
+		assert.Nil(t, m.roaringSetAddBitmap(key2, bm2))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.True(t, setKey1.Additions.Contains(1))
+		assert.True(t, setKey1.Additions.Contains(2))
+		assert.False(t, setKey1.Additions.Contains(3))
+		assert.False(t, setKey1.Additions.Contains(4))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.False(t, setKey2.Additions.Contains(1))
+		assert.False(t, setKey2.Additions.Contains(2))
+		assert.True(t, setKey2.Additions.Contains(3))
+		assert.True(t, setKey2.Additions.Contains(4))
+
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("removing individual entries", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		assert.Nil(t, m.roaringSetRemoveOne(key1, 7))
+		assert.Nil(t, m.roaringSetRemoveOne(key2, 8))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.False(t, setKey1.Additions.Contains(7))
+		assert.True(t, setKey1.Deletions.Contains(7))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.False(t, setKey2.Additions.Contains(8))
+		assert.True(t, setKey2.Deletions.Contains(8))
+
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("removing lists", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		assert.Nil(t, m.roaringSetRemoveList(key1, []uint64{7, 8}))
+		assert.Nil(t, m.roaringSetRemoveList(key2, []uint64{9, 10}))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.Equal(t, 0, setKey1.Additions.GetCardinality())
+		assert.Equal(t, 2, setKey1.Deletions.GetCardinality())
+		assert.True(t, setKey1.Deletions.Contains(7))
+		assert.True(t, setKey1.Deletions.Contains(8))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.Equal(t, 0, setKey2.Additions.GetCardinality())
+		assert.Equal(t, 2, setKey2.Deletions.GetCardinality())
+		assert.True(t, setKey2.Deletions.Contains(9))
+		assert.True(t, setKey2.Deletions.Contains(10))
+
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("removing bitmaps", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		assert.Nil(t, m.roaringSetRemoveBitmap(key1, roaringset.NewBitmap(7, 8)))
+		assert.Nil(t, m.roaringSetRemoveBitmap(key2, roaringset.NewBitmap(9, 10)))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.Equal(t, 0, setKey1.Additions.GetCardinality())
+		assert.Equal(t, 2, setKey1.Deletions.GetCardinality())
+		assert.True(t, setKey1.Deletions.Contains(7))
+		assert.True(t, setKey1.Deletions.Contains(8))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.Equal(t, 0, setKey2.Additions.GetCardinality())
+		assert.Equal(t, 2, setKey2.Deletions.GetCardinality())
+		assert.True(t, setKey2.Deletions.Contains(9))
+		assert.True(t, setKey2.Deletions.Contains(10))
+
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("adding/removing slices", func(t *testing.T) {
+		cl, err := newCommitLogger(memPath(), StrategyRoaringSet, 0)
+		require.NoError(t, err)
+
+		m, err := newMemtable(memPath(), StrategyRoaringSet, 0, cl, nil, logger, false, nil, false, nil)
+		require.Nil(t, err)
+
+		key1, key2 := []byte("key1"), []byte("key2")
+
+		assert.Nil(t, m.roaringSetAddRemoveSlices(key1,
+			[]uint64{1, 2}, []uint64{7, 8}))
+		assert.Nil(t, m.roaringSetAddRemoveSlices(key2,
+			[]uint64{3, 4}, []uint64{9, 10}))
+		assert.Greater(t, m.Size(), uint64(0))
+
+		setKey1, err := m.roaringSetGet(key1)
+		require.Nil(t, err)
+		assert.Equal(t, 2, setKey1.Additions.GetCardinality())
+		assert.True(t, setKey1.Additions.Contains(1))
+		assert.True(t, setKey1.Additions.Contains(2))
+		assert.Equal(t, 2, setKey1.Deletions.GetCardinality())
+		assert.True(t, setKey1.Deletions.Contains(7))
+		assert.True(t, setKey1.Deletions.Contains(8))
+
+		setKey2, err := m.roaringSetGet(key2)
+		require.Nil(t, err)
+		assert.Equal(t, 2, setKey2.Additions.GetCardinality())
+		assert.True(t, setKey2.Additions.Contains(3))
+		assert.True(t, setKey2.Additions.Contains(4))
+		assert.Equal(t, 2, setKey2.Deletions.GetCardinality())
+		assert.True(t, setKey2.Deletions.Contains(9))
+		assert.True(t, setKey2.Deletions.Contains(10))
+
+		require.Nil(t, m.commitlog.close())
+	})
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_size_advisor.go

@@ -0,0 +1,87 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import "time"
+
+// if not enough config is provided we can fall back to this reasonable default
+// value
+const reasonableMemtableDefault = 10 * 1024 * 1024
+
+type memtableSizeAdvisorCfg struct {
+	initial     int
+	stepSize    int
+	maxSize     int
+	minDuration time.Duration
+	maxDuration time.Duration
+}
+
+type memtableSizeAdvisor struct {
+	cfg    memtableSizeAdvisorCfg
+	active bool
+}
+
+func newMemtableSizeAdvisor(cfg memtableSizeAdvisorCfg) *memtableSizeAdvisor {
+	a := &memtableSizeAdvisor{
+		cfg: cfg,
+	}
+
+	// only activate if initial size, step size, max size, and max duration are
+	// given
+	if a.cfg.maxSize > 0 && a.cfg.initial > 0 && a.cfg.stepSize > 0 && a.cfg.maxDuration > 0 {
+		a.active = true
+	}
+
+	return a
+}
+
+func (m memtableSizeAdvisor) Initial() int {
+	if m.active {
+		return m.cfg.initial
+	} else {
+		return reasonableMemtableDefault
+	}
+}
+
+func (m memtableSizeAdvisor) NextTarget(previousTarget int,
+	timeSinceFlush time.Duration,
+) (int, bool) {
+	if !m.active {
+		return reasonableMemtableDefault, false
+	}
+
+	if timeSinceFlush < m.cfg.minDuration {
+		next := min(previousTarget+m.cfg.stepSize, m.cfg.maxSize)
+		return next, next != previousTarget
+	}
+	if timeSinceFlush > m.cfg.maxDuration {
+		next := max(previousTarget-m.cfg.stepSize, m.cfg.initial)
+		return next, next != previousTarget
+	}
+	return previousTarget, false
+}
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+
+	return b
+}
+
+func max(a, b int) int {
+	if a >= b {
+		return a
+	}
+
+	return b
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_size_advisor_test.go

@@ -0,0 +1,119 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const Megabyte = 1024 * 1024
+
+func TestMemtableSizeAdvisor_Initial(t *testing.T) {
+	a := newMemtableSizeAdvisor(memtableSizeAdvisorCfg{
+		initial: 10 * Megabyte,
+	})
+
+	assert.Equal(t, 10485760, a.Initial())
+}
+
+func TestMemtableSizeAdvisor_NextTarget(t *testing.T) {
+	a := newMemtableSizeAdvisor(memtableSizeAdvisorCfg{
+		initial:     10 * Megabyte,
+		minDuration: 10 * time.Second,
+		maxDuration: 30 * time.Second,
+		stepSize:    10 * Megabyte,
+		maxSize:     100 * Megabyte,
+	})
+
+	type test struct {
+		name            string
+		current         int
+		lastCycle       time.Duration
+		expectedChanged bool
+		expectedTarget  int
+	}
+
+	tests := []test{
+		{
+			name:            "completely within range",
+			current:         10 * Megabyte,
+			lastCycle:       17 * time.Second,
+			expectedChanged: false,
+			expectedTarget:  10 * Megabyte,
+		},
+		{
+			name:            "cycle too short",
+			current:         10 * Megabyte,
+			lastCycle:       7 * time.Second,
+			expectedChanged: true,
+			expectedTarget:  20 * Megabyte,
+		},
+		{
+			name:            "cycle too long",
+			current:         100 * Megabyte,
+			lastCycle:       47 * time.Second,
+			expectedChanged: true,
+			expectedTarget:  90 * Megabyte,
+		},
+		{
+			name:            "cycle too short, but approaching limit",
+			current:         95 * Megabyte,
+			lastCycle:       7 * time.Second,
+			expectedChanged: true,
+			expectedTarget:  100 * Megabyte, // not 105 (!)
+		},
+		{
+			name:            "cycle too short, but already at limit",
+			current:         100 * Megabyte,
+			lastCycle:       7 * time.Second,
+			expectedChanged: false,
+			expectedTarget:  100 * Megabyte,
+		},
+		{
+			name:            "cycle too long, but barely above initial size",
+			current:         12 * Megabyte,
+			lastCycle:       47 * time.Second,
+			expectedChanged: true,
+			expectedTarget:  10 * Megabyte, // not 2 (1)
+		},
+		{
+			name:            "cycle too long, but already at initial size",
+			current:         10 * Megabyte,
+			lastCycle:       47 * time.Second,
+			expectedChanged: false,
+			expectedTarget:  10 * Megabyte,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			newTarget, changed := a.NextTarget(test.current, test.lastCycle)
+			assert.Equal(t, test.expectedTarget, newTarget, "expect new target")
+			assert.Equal(t, test.expectedChanged, changed, "expect changed")
+		})
+	}
+
+	target, changed := a.NextTarget(10*1024*1024, 17*time.Second)
+	assert.False(t, changed)
+	assert.Equal(t, 10*1024*1024, target)
+}
+
+func TestMemtableSizeAdvisor_MissingConfig(t *testing.T) {
+	// even with an all-default value config the advisor should still return
+	// reasonable results, for example many integration tests might not provide a
+	// reasonable config to the advisor
+	a := newMemtableSizeAdvisor(memtableSizeAdvisorCfg{})
+	assert.Equal(t, 10485760, a.Initial())
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/memtable_test.go

@@ -0,0 +1,80 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"path"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+)
+
+// This test prevents a regression on
+// https://www.youtube.com/watch?v=OS8taasZl8k
+func Test_MemtableSecondaryKeyBug(t *testing.T) {
+	dir := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+	cl, err := newCommitLogger(dir, StrategyReplace, 0)
+	require.NoError(t, err)
+
+	m, err := newMemtable(path.Join(dir, "will-never-flush"), StrategyReplace, 1, cl, nil, logger, false, nil, false, nil)
+	require.Nil(t, err)
+	t.Cleanup(func() {
+		require.Nil(t, m.commitlog.close())
+	})
+
+	t.Run("add initial value", func(t *testing.T) {
+		err = m.put([]byte("my-key"), []byte("my-value"),
+			WithSecondaryKey(0, []byte("secondary-key-initial")))
+		require.Nil(t, err)
+	})
+
+	t.Run("retrieve by primary", func(t *testing.T) {
+		val, err := m.get([]byte("my-key"))
+		require.Nil(t, err)
+		assert.Equal(t, []byte("my-value"), val)
+	})
+
+	t.Run("retrieve by initial secondary", func(t *testing.T) {
+		val, err := m.getBySecondary(0, []byte("secondary-key-initial"))
+		require.Nil(t, err)
+		assert.Equal(t, []byte("my-value"), val)
+	})
+
+	t.Run("update value with different secondary key", func(t *testing.T) {
+		err = m.put([]byte("my-key"), []byte("my-value-updated"),
+			WithSecondaryKey(0, []byte("different-secondary-key")))
+		require.Nil(t, err)
+	})
+
+	t.Run("retrieve by primary again", func(t *testing.T) {
+		val, err := m.get([]byte("my-key"))
+		require.Nil(t, err)
+		assert.Equal(t, []byte("my-value-updated"), val)
+	})
+
+	t.Run("retrieve by updated secondary", func(t *testing.T) {
+		val, err := m.getBySecondary(0, []byte("different-secondary-key"))
+		require.Nil(t, err)
+		assert.Equal(t, []byte("my-value-updated"), val)
+	})
+
+	t.Run("retrieve by initial secondary - should not find anything", func(t *testing.T) {
+		val, err := m.getBySecondary(0, []byte("secondary-key-initial"))
+		assert.Equal(t, lsmkv.NotFound, err)
+		assert.Nil(t, val)
+	})
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/metrics.go

@@ -0,0 +1,328 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+)
+
+type (
+	NsObserver         func(ns int64)
+	BytesWriteObserver func(bytes int64)
+	BytesReadObserver  func(bytes int64, nanoseconds int64)
+	Setter             func(val uint64)
+	TimeObserver       func(start time.Time)
+)
+
+type Metrics struct {
+	CompactionReplace            *prometheus.GaugeVec
+	CompactionSet                *prometheus.GaugeVec
+	CompactionMap                *prometheus.GaugeVec
+	CompactionRoaringSet         *prometheus.GaugeVec
+	CompactionRoaringSetRange    *prometheus.GaugeVec
+	ActiveSegments               *prometheus.GaugeVec
+	ObjectsBucketSegments        *prometheus.GaugeVec
+	CompressedVecsBucketSegments *prometheus.GaugeVec
+	bloomFilters                 prometheus.ObserverVec
+	SegmentObjects               *prometheus.GaugeVec
+	SegmentSize                  *prometheus.GaugeVec
+	SegmentCount                 *prometheus.GaugeVec
+	SegmentUnloaded              *prometheus.GaugeVec
+	startupDurations             prometheus.ObserverVec
+	startupDiskIO                prometheus.ObserverVec
+	objectCount                  prometheus.Gauge
+	memtableDurations            prometheus.ObserverVec
+	memtableSize                 *prometheus.GaugeVec
+	DimensionSum                 *prometheus.GaugeVec
+	IOWrite                      *prometheus.SummaryVec
+	IORead                       *prometheus.SummaryVec
+	LazySegmentUnLoad            prometheus.Gauge
+	LazySegmentLoad              prometheus.Gauge
+	LazySegmentClose             prometheus.Gauge
+	LazySegmentInit              prometheus.Gauge
+
+	groupClasses        bool
+	criticalBucketsOnly bool
+}
+
+func NewMetrics(promMetrics *monitoring.PrometheusMetrics, className,
+	shardName string,
+) *Metrics {
+	if promMetrics.Group {
+		className = "n/a"
+		shardName = "n/a"
+	}
+
+	replace := promMetrics.AsyncOperations.MustCurryWith(prometheus.Labels{
+		"operation":  "compact_lsm_segments_stratreplace",
+		"class_name": className,
+		"shard_name": shardName,
+	})
+
+	set := promMetrics.AsyncOperations.MustCurryWith(prometheus.Labels{
+		"operation":  "compact_lsm_segments_stratset",
+		"class_name": className,
+		"shard_name": shardName,
+	})
+
+	roaringSet := promMetrics.AsyncOperations.MustCurryWith(prometheus.Labels{
+		"operation":  "compact_lsm_segments_stratroaringset",
+		"class_name": className,
+		"shard_name": shardName,
+	})
+
+	roaringSetRange := promMetrics.AsyncOperations.MustCurryWith(prometheus.Labels{
+		"operation":  "compact_lsm_segments_stratroaringsetrange",
+		"class_name": className,
+		"shard_name": shardName,
+	})
+
+	stratMap := promMetrics.AsyncOperations.MustCurryWith(prometheus.Labels{
+		"operation":  "compact_lsm_segments_stratmap",
+		"class_name": className,
+		"shard_name": shardName,
+	})
+
+	lazySegmentInit := monitoring.GetMetrics().AsyncOperations.With(prometheus.Labels{
+		"operation":  "lazySegmentInit",
+		"class_name": className,
+		"shard_name": shardName,
+		"path":       "n/a",
+	})
+
+	lazySegmentLoad := monitoring.GetMetrics().AsyncOperations.With(prometheus.Labels{
+		"operation":  "lazySegmentLoad",
+		"class_name": className,
+		"shard_name": shardName,
+		"path":       "n/a",
+	})
+
+	lazySegmentClose := monitoring.GetMetrics().AsyncOperations.With(prometheus.Labels{
+		"operation":  "lazySegmentClose",
+		"class_name": className,
+		"shard_name": shardName,
+		"path":       "n/a",
+	})
+	lazySegmentUnload := monitoring.GetMetrics().AsyncOperations.With(prometheus.Labels{
+		"operation":  "lazySegmentUnLoad",
+		"class_name": className,
+		"shard_name": shardName,
+		"path":       "n/a",
+	})
+
+	return &Metrics{
+		groupClasses:              promMetrics.Group,
+		criticalBucketsOnly:       promMetrics.LSMCriticalBucketsOnly,
+		CompactionReplace:         replace,
+		CompactionSet:             set,
+		CompactionMap:             stratMap,
+		CompactionRoaringSet:      roaringSet,
+		CompactionRoaringSetRange: roaringSetRange,
+		ActiveSegments: promMetrics.LSMSegmentCount.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		ObjectsBucketSegments: promMetrics.LSMObjectsBucketSegmentCount.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		CompressedVecsBucketSegments: promMetrics.LSMCompressedVecsBucketSegmentCount.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		bloomFilters: promMetrics.LSMBloomFilters.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		SegmentObjects: promMetrics.LSMSegmentObjects.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		SegmentSize: promMetrics.LSMSegmentSize.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		SegmentCount: promMetrics.LSMSegmentCountByLevel.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		SegmentUnloaded: promMetrics.LSMSegmentUnloaded.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		startupDiskIO: promMetrics.StartupDiskIO.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		startupDurations: promMetrics.StartupDurations.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		objectCount: promMetrics.ObjectCount.With(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		memtableDurations: promMetrics.LSMMemtableDurations.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		memtableSize: promMetrics.LSMMemtableSize.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		DimensionSum: promMetrics.VectorDimensionsSum.MustCurryWith(prometheus.Labels{
+			"class_name": className,
+			"shard_name": shardName,
+		}),
+		IOWrite:           promMetrics.FileIOWrites,
+		IORead:            promMetrics.FileIOReads,
+		LazySegmentLoad:   lazySegmentLoad,
+		LazySegmentClose:  lazySegmentClose,
+		LazySegmentInit:   lazySegmentInit,
+		LazySegmentUnLoad: lazySegmentUnload,
+	}
+}
+
+func noOpTimeObserver(start time.Time) {
+	// do nothing
+}
+
+func noOpNsObserver(startNs int64) {
+	// do nothing
+}
+
+func noOpNsReadObserver(startNs int64, time int64) {
+	// do nothing
+}
+
+func noOpSetter(val uint64) {
+	// do nothing
+}
+
+func (m *Metrics) MemtableOpObserver(path, strategy, op string) NsObserver {
+	if m == nil {
+		return noOpNsObserver
+	}
+
+	if m.groupClasses {
+		path = "n/a"
+	}
+
+	curried := m.memtableDurations.With(prometheus.Labels{
+		"operation": op,
+		"path":      path,
+		"strategy":  strategy,
+	})
+
+	return func(startNs int64) {
+		took := float64(time.Now().UnixNano()-startNs) / float64(time.Millisecond)
+		curried.Observe(took)
+	}
+}
+
+func (m *Metrics) MemtableWriteObserver(strategy, op string) BytesWriteObserver {
+	if m == nil {
+		return noOpNsObserver
+	}
+
+	curried := m.IOWrite.With(prometheus.Labels{
+		"operation": op,
+		"strategy":  strategy,
+	})
+
+	return func(bytes int64) {
+		curried.Observe(float64(bytes))
+	}
+}
+
+func (m *Metrics) ReadObserver(op string) BytesReadObserver {
+	if m == nil {
+		return noOpNsReadObserver
+	}
+
+	curried := m.IORead.With(prometheus.Labels{
+		"operation": op,
+	})
+
+	return func(n int64, nanoseconds int64) { curried.Observe(float64(n)) }
+}
+
+func (m *Metrics) MemtableSizeSetter(path, strategy string) Setter {
+	if m == nil || m.groupClasses {
+		// this metric would set absolute values, that's not possible in
+		// grouped mode, each call would essentially overwrite the last
+		return noOpSetter
+	}
+
+	curried := m.memtableSize.With(prometheus.Labels{
+		"path":     path,
+		"strategy": strategy,
+	})
+
+	return func(size uint64) {
+		curried.Set(float64(size))
+	}
+}
+
+func (m *Metrics) BloomFilterObserver(strategy, operation string) TimeObserver {
+	if m == nil {
+		return noOpTimeObserver
+	}
+
+	curried := m.bloomFilters.With(prometheus.Labels{
+		"strategy":  strategy,
+		"operation": operation,
+	})
+
+	return func(before time.Time) {
+		curried.Observe(float64(time.Since(before)) / float64(time.Millisecond))
+	}
+}
+
+func (m *Metrics) TrackStartupReadWALDiskIO(read int64, nanoseconds int64) {
+	if m == nil {
+		return
+	}
+
+	seconds := float64(nanoseconds) / float64(time.Second)
+	throughput := float64(read) / float64(seconds)
+	m.startupDiskIO.With(prometheus.Labels{"operation": "lsm_recover_wal"}).Observe(throughput)
+}
+
+func (m *Metrics) TrackStartupBucket(start time.Time) {
+	if m == nil {
+		return
+	}
+
+	took := float64(time.Since(start)) / float64(time.Millisecond)
+	m.startupDurations.With(prometheus.Labels{"operation": "lsm_startup_bucket"}).Observe(took)
+}
+
+func (m *Metrics) TrackStartupBucketRecovery(start time.Time) {
+	if m == nil {
+		return
+	}
+
+	took := float64(time.Since(start)) / float64(time.Millisecond)
+	m.startupDurations.With(prometheus.Labels{"operation": "lsm_startup_bucket_recovery"}).Observe(took)
+}
+
+func (m *Metrics) ObjectCount(count int) {
+	if m == nil {
+		return
+	}
+
+	m.objectCount.Set(float64(count))
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/mmap_vs_read_test.go

@@ -0,0 +1,99 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"crypto/rand"
+	"io"
+	"os"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/usecases/mmap"
+)
+
+func BenchmarkMMap(b *testing.B) {
+	tests := []struct {
+		size int
+	}{
+		{size: 100},
+		{size: 1000},
+		{size: 10000},
+		{size: 100000},
+	}
+
+	dir := b.TempDir()
+	f, err := os.Create(dir + "/test.tmp")
+	require.NoError(b, err)
+
+	bytes := make([]byte, 100000)
+	read, err := rand.Read(bytes)
+	require.NoError(b, err)
+	require.Equal(b, read, len(bytes))
+
+	written, err := f.Write(bytes)
+	require.NoError(b, err)
+	require.Equal(b, written, len(bytes))
+
+	b.ResetTimer()
+
+	for _, test := range tests {
+		sum := 0
+		for i := range bytes[:test.size] {
+			sum += int(bytes[i])
+		}
+
+		b.Run(strconv.Itoa(test.size)+"mmap", func(b *testing.B) {
+			b.ReportAllocs()
+
+			for i := 0; i < b.N; i++ {
+				// not needed here, but we need to do it to have the same overhead in both tests
+				_, err := f.Seek(0, io.SeekStart)
+				require.NoError(b, err)
+
+				contents, err := mmap.MapRegion(f, int(test.size), mmap.RDONLY, 0, 0)
+				require.NoError(b, err)
+
+				innerSum := 0
+				for j := range contents {
+					innerSum += int(contents[j])
+				}
+				require.Equal(b, sum, innerSum)
+				require.NoError(b, contents.Unmap())
+			}
+		})
+
+		b.Run(strconv.Itoa(test.size)+"full read", func(b *testing.B) {
+			b.ReportAllocs()
+
+			for i := 0; i < b.N; i++ {
+				_, err := f.Seek(0, io.SeekStart)
+				require.NoError(b, err)
+
+				data := make([]byte, test.size)
+				n, err := f.Read(data)
+				if err != nil {
+					return
+				}
+				require.NoError(b, err)
+				require.Equal(b, n, test.size)
+
+				innerSum := 0
+				for j := range data {
+					innerSum += int(data[j])
+				}
+				require.Equal(b, sum, innerSum)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/mock_bucket_creator.go

@@ -0,0 +1,129 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+// Code generated by mockery v2.53.2. DO NOT EDIT.
+
+package lsmkv
+
+import (
+	context "context"
+
+	logrus "github.com/sirupsen/logrus"
+	cyclemanager "github.com/weaviate/weaviate/entities/cyclemanager"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockBucketCreator is an autogenerated mock type for the BucketCreator type
+type MockBucketCreator struct {
+	mock.Mock
+}
+
+type MockBucketCreator_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockBucketCreator) EXPECT() *MockBucketCreator_Expecter {
+	return &MockBucketCreator_Expecter{mock: &_m.Mock}
+}
+
+// NewBucket provides a mock function with given fields: ctx, dir, rootDir, logger, metrics, compactionCallbacks, flushCallbacks, opts
+func (_m *MockBucketCreator) NewBucket(ctx context.Context, dir string, rootDir string, logger logrus.FieldLogger, metrics *Metrics, compactionCallbacks cyclemanager.CycleCallbackGroup, flushCallbacks cyclemanager.CycleCallbackGroup, opts ...BucketOption) (*Bucket, error) {
+	_va := make([]interface{}, len(opts))
+	for _i := range opts {
+		_va[_i] = opts[_i]
+	}
+	var _ca []interface{}
+	_ca = append(_ca, ctx, dir, rootDir, logger, metrics, compactionCallbacks, flushCallbacks)
+	_ca = append(_ca, _va...)
+	ret := _m.Called(_ca...)
+
+	if len(ret) == 0 {
+		panic("no return value specified for NewBucket")
+	}
+
+	var r0 *Bucket
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, logrus.FieldLogger, *Metrics, cyclemanager.CycleCallbackGroup, cyclemanager.CycleCallbackGroup, ...BucketOption) (*Bucket, error)); ok {
+		return rf(ctx, dir, rootDir, logger, metrics, compactionCallbacks, flushCallbacks, opts...)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, string, string, logrus.FieldLogger, *Metrics, cyclemanager.CycleCallbackGroup, cyclemanager.CycleCallbackGroup, ...BucketOption) *Bucket); ok {
+		r0 = rf(ctx, dir, rootDir, logger, metrics, compactionCallbacks, flushCallbacks, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*Bucket)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, string, string, logrus.FieldLogger, *Metrics, cyclemanager.CycleCallbackGroup, cyclemanager.CycleCallbackGroup, ...BucketOption) error); ok {
+		r1 = rf(ctx, dir, rootDir, logger, metrics, compactionCallbacks, flushCallbacks, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockBucketCreator_NewBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBucket'
+type MockBucketCreator_NewBucket_Call struct {
+	*mock.Call
+}
+
+// NewBucket is a helper method to define mock.On call
+//   - ctx context.Context
+//   - dir string
+//   - rootDir string
+//   - logger logrus.FieldLogger
+//   - metrics *Metrics
+//   - compactionCallbacks cyclemanager.CycleCallbackGroup
+//   - flushCallbacks cyclemanager.CycleCallbackGroup
+//   - opts ...BucketOption
+func (_e *MockBucketCreator_Expecter) NewBucket(ctx interface{}, dir interface{}, rootDir interface{}, logger interface{}, metrics interface{}, compactionCallbacks interface{}, flushCallbacks interface{}, opts ...interface{}) *MockBucketCreator_NewBucket_Call {
+	return &MockBucketCreator_NewBucket_Call{Call: _e.mock.On("NewBucket",
+		append([]interface{}{ctx, dir, rootDir, logger, metrics, compactionCallbacks, flushCallbacks}, opts...)...)}
+}
+
+func (_c *MockBucketCreator_NewBucket_Call) Run(run func(ctx context.Context, dir string, rootDir string, logger logrus.FieldLogger, metrics *Metrics, compactionCallbacks cyclemanager.CycleCallbackGroup, flushCallbacks cyclemanager.CycleCallbackGroup, opts ...BucketOption)) *MockBucketCreator_NewBucket_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		variadicArgs := make([]BucketOption, len(args)-7)
+		for i, a := range args[7:] {
+			if a != nil {
+				variadicArgs[i] = a.(BucketOption)
+			}
+		}
+		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(logrus.FieldLogger), args[4].(*Metrics), args[5].(cyclemanager.CycleCallbackGroup), args[6].(cyclemanager.CycleCallbackGroup), variadicArgs...)
+	})
+	return _c
+}
+
+func (_c *MockBucketCreator_NewBucket_Call) Return(_a0 *Bucket, _a1 error) *MockBucketCreator_NewBucket_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *MockBucketCreator_NewBucket_Call) RunAndReturn(run func(context.Context, string, string, logrus.FieldLogger, *Metrics, cyclemanager.CycleCallbackGroup, cyclemanager.CycleCallbackGroup, ...BucketOption) (*Bucket, error)) *MockBucketCreator_NewBucket_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockBucketCreator creates a new instance of MockBucketCreator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockBucketCreator(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockBucketCreator {
+	mock := &MockBucketCreator{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/quantile_keys.go

@@ -0,0 +1,127 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"bytes"
+	"math"
+	"sort"
+)
+
+// QuantileKeys returns an approximation of the keys that make up the specified
+// quantiles. This can be used to start parallel cursors at fairly evenly
+// distributed positions in the segment.
+//
+// To understand the approximation, checkout
+// [lsmkv.segmentindex.DiskTree.QuantileKeys] that runs on each segment.
+//
+// Some things to keep in mind:
+//
+//  1. It may return fewer keys than requested (including 0) if the segment
+//     contains fewer entries
+//  2. It may return keys that do not exist, for example because they are
+//     tombstoned. This is acceptable, as a key does not have to exist to be used
+//     as part of .Seek() in a cursor.
+//  3. It will never return duplicates, to make sure all parallel cursors
+//     return unique values.
+func (b *Bucket) QuantileKeys(q int) [][]byte {
+	if q <= 0 {
+		return nil
+	}
+
+	b.flushLock.RLock()
+	defer b.flushLock.RUnlock()
+
+	keys := b.disk.quantileKeys(q)
+	return keys
+}
+
+func (sg *SegmentGroup) quantileKeys(q int) [][]byte {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	var keys [][]byte
+
+	if len(segments) == 0 {
+		return keys
+	}
+
+	for _, s := range segments {
+		keys = append(keys, s.quantileKeys(q)...)
+	}
+
+	// re-sort keys
+	sort.Slice(keys, func(i, j int) bool {
+		return bytes.Compare(keys[i], keys[j]) < 0
+	})
+
+	// There could be duplicates if a key was modified in multiple segments, we
+	// need to remove them. Since the list is sorted at this, this is fairly easy
+	// to do:
+	uniqueKeys := make([][]byte, 0, len(keys))
+	for i := range keys {
+		if i == 0 || !bytes.Equal(keys[i], keys[i-1]) {
+			uniqueKeys = append(uniqueKeys, keys[i])
+		}
+	}
+
+	return pickEvenlyDistributedKeys(uniqueKeys, q)
+}
+
+func (s *segment) quantileKeys(q int) [][]byte {
+	return s.index.QuantileKeys(q)
+}
+
+// pickEvenlyDistributedKeys picks q keys from the input keys, trying to keep
+// the distribution as even as possible. The input keys are assumed to be
+// sorted. It never returns duplicates, see the unit test proving this.
+//
+// Important to keep in mind is that our input values do not contain the first
+// and last elements, but rather the first quantile points.
+// This is because they were obtained using
+// [lsmkv.segmentindex.DiskTree.QuantileKeys] which traverses the binary tree
+// to a certain depth. The first element in the list is the element you get
+// from continuously following the left child until you hit the maximum
+// traversal depth. Respectively, the last element is the element you get from
+// continuously following the right child until you hit the maximum traversal
+// depth.
+// This means that when a cursor uses those keys, it will need to add two
+// special cases:
+//
+//  1. It needs to start with the actual first element and read to the first
+//     checkpoint
+//  2. When reaching the last checkpoint, it needs to keep reading
+//     until the cursor no longer returns elements.
+//
+// As a result our goal here is to keep the gaps as even as possible. For
+// example, assume the keys ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
+// and we want to pick 3 keys. We would return ["C", "F", "I"], thus keeping
+// the spacing fairly even.
+func pickEvenlyDistributedKeys(uniqueKeys [][]byte, q int) [][]byte {
+	if q >= len(uniqueKeys) {
+		// impossible to pick, simply return the input
+		return uniqueKeys
+	}
+
+	// we now have the guarantee that q > len(uniqueKeys), which means it is
+	// possible to pick q keys without overlap while keeping the distribution as
+	// even as possible
+	finalKeys := make([][]byte, q)
+	stepSize := float64(len(uniqueKeys)) / float64(q)
+	for i := range finalKeys {
+		pos := int(math.Round(float64(i)*stepSize + 0.5*stepSize))
+
+		finalKeys[i] = uniqueKeys[pos]
+	}
+
+	return finalKeys
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/quantile_keys_test.go

@@ -0,0 +1,174 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/cyclemanager"
+)
+
+func TestQuantileKeysSingleSegment(t *testing.T) {
+	dir := t.TempDir()
+	ctx := context.Background()
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(
+		ctx, dir, "", logger, nil, cyclemanager.NewCallbackGroupNoop(),
+		cyclemanager.NewCallbackGroupNoop())
+	require.Nil(t, err)
+
+	importConsecutiveKeys(t, b, 0, 1000)
+
+	// all cyclemmanagers are noops, so we need to explicitly flush if we want a
+	// segment to be built
+	require.Nil(t, b.FlushAndSwitch())
+
+	quantiles := b.QuantileKeys(10)
+
+	asNumbers := make([]uint64, len(quantiles))
+	for i, q := range quantiles {
+		asNumbers[i] = binary.BigEndian.Uint64(q)
+	}
+
+	// validate there are no duplicates, and each key is strictly greater than
+	// the last
+	for i, n := range asNumbers {
+		if i == 0 {
+			continue
+		}
+
+		prev := asNumbers[i-1]
+		assert.Greater(t, n, prev)
+	}
+
+	// assert on distribution
+	idealStepSize := float64(1000) / float64(len(asNumbers)+1)
+	for i, n := range asNumbers {
+		actualStepSize := float64(n) / float64(i+1)
+		assert.InEpsilon(t, idealStepSize, actualStepSize, 0.1)
+	}
+}
+
+func TestQuantileKeysMultipleSegmentsUniqueEntries(t *testing.T) {
+	dir := t.TempDir()
+	ctx := context.Background()
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(
+		ctx, dir, "", logger, nil, cyclemanager.NewCallbackGroupNoop(),
+		cyclemanager.NewCallbackGroupNoop())
+	require.Nil(t, err)
+
+	importConsecutiveKeys(t, b, 0, 1000)
+
+	// all cyclemmanagers are noops, so we need to explicitly flush if we want a
+	// segment to be built
+	require.Nil(t, b.FlushAndSwitch())
+
+	importConsecutiveKeys(t, b, 1000, 2000)
+
+	// all cyclemmanagers are noops, so we need to explicitly flush if we want a
+	// segment to be built
+	require.Nil(t, b.FlushAndSwitch())
+
+	quantiles := b.QuantileKeys(10)
+
+	asNumbers := make([]uint64, len(quantiles))
+	for i, q := range quantiles {
+		asNumbers[i] = binary.BigEndian.Uint64(q)
+	}
+
+	// validate there are no duplicates, and each key is strictly greater than
+	// the last
+	for i, n := range asNumbers {
+		if i == 0 {
+			continue
+		}
+
+		prev := asNumbers[i-1]
+		assert.Greater(t, n, prev)
+	}
+}
+
+func importConsecutiveKeys(t *testing.T, b *Bucket, start, end uint64) {
+	for i := start; i < end; i++ {
+		key := make([]byte, 8)
+		binary.BigEndian.PutUint64(key, i)
+		err := b.Put(key, key)
+		require.Nil(t, err)
+	}
+}
+
+func TestKeyDistributionExample(t *testing.T) {
+	inputKeyStrings := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J"}
+	inputKeys := make([][]byte, len(inputKeyStrings))
+	for i, s := range inputKeyStrings {
+		inputKeys[i] = []byte(s)
+	}
+	q := 3
+
+	picked := pickEvenlyDistributedKeys(inputKeys, q)
+	expectKeyStrings := []string{"C", "F", "I"}
+	expectKeys := make([][]byte, len(expectKeyStrings))
+	for i, s := range expectKeyStrings {
+		expectKeys[i] = []byte(s)
+	}
+
+	assert.Equal(t, expectKeys, picked)
+}
+
+func TestPickEvenlyDistributedKeys(t *testing.T) {
+	for input := 0; input < 100; input++ {
+		for q := 1; q < 100; q++ {
+			t.Run(fmt.Sprintf("input=%d, q=%d", input, q), func(t *testing.T) {
+				keys := make([][]byte, input)
+				for i := 0; i < input; i++ {
+					key := make([]byte, 8)
+					binary.BigEndian.PutUint64(key, uint64(i))
+					keys[i] = key
+				}
+
+				picked := pickEvenlyDistributedKeys(keys, q)
+
+				// make sure there are never more results than q
+				require.LessOrEqual(t, len(picked), q)
+
+				// make sure that we get q results if there are at least q keys
+				if input >= q {
+					require.Equal(t, q, len(picked))
+				} else {
+					// if there are fewer keys than q, we should get all of them
+					require.Equal(t, input, len(picked))
+				}
+
+				// make sure there are no duplicates
+				for i, key := range picked {
+					if i == 0 {
+						continue
+					}
+
+					prev := binary.BigEndian.Uint64(picked[i-1])
+					curr := binary.BigEndian.Uint64(key)
+
+					require.Greater(t, curr, prev, "found duplicate picks")
+				}
+			})
+		}
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/rbtree/rbtree.go

@@ -0,0 +1,176 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package rbtree
+
+type Node interface {
+	Parent() Node
+	SetParent(Node)
+	Left() Node
+	SetLeft(Node)
+	Right() Node
+	SetRight(Node)
+	IsRed() bool
+	SetRed(bool)
+	IsNil() bool
+}
+
+// This function rebalances and recolours trees to be valid RB trees. It needs to be called after each node that
+// was added to the tree.
+//
+// Deletions are currently not supported as this is done through the tombstone flag and from the POV of the RB-tree
+// tombstone-nodes are just normal nodes that get rebalanced the normal way.
+//
+// Throughout this file the following relationships between nodes are used:
+// GP = grandparent, P = parent, U = uncle, S = sibling, N = node that was just added
+//
+//	   GP
+//	 /   \
+//	U     P
+//	     / \
+//	    S   N
+func Rebalance(node Node) Node {
+	for {
+		parent := node.Parent()
+
+		// if parent is black or the current node is the root node (== parent is nil) there is nothing to do
+		if !parent.IsRed() {
+			return nil
+		}
+
+		grandparent := node.Parent().Parent()
+		var uncle Node
+		if parent == grandparent.Right() {
+			uncle = grandparent.Left()
+		} else {
+			uncle = grandparent.Right()
+		}
+
+		if uncle.IsRed() {
+			// if uncle is red, recoloring the tree up to the grandparent results in a valid RBtree.
+			// The color of the grandfather changes to red, so there might be more fixes needed. Therefore
+			// go up the tree and repeat.
+			recolourNodes(parent, grandparent, uncle)
+			node = grandparent
+		} else {
+			// if uncle is black, there are four possible cases:
+			//   parent is the right child grandparent:
+			//    1) node is right child of parent => left rotate around GP
+			//    2) node is left child of parent => right rotate around parent results in case 1
+			//   For cases 3 and 4 just replace left and right in the two cases above
+			//
+			// In all of these cases the grandfather stays black and there is no need for further fixes up the tree
+			var newRoot Node
+			if parent == grandparent.Right() {
+				if node == parent.Left() {
+					rightRotate(parent)
+					// node and parent switch places in the tree, update parent to recolour the current node
+					parent = node
+				}
+				newRoot = leftRotate(grandparent)
+			} else { // parent == grandparent.left
+				if node == parent.Right() {
+					leftRotate(parent)
+					parent = node
+				}
+				newRoot = rightRotate(grandparent)
+			}
+			recolourNodes(grandparent, parent)
+			return newRoot
+		}
+	}
+}
+
+func recolourNodes(nodes ...Node) {
+	for _, n := range nodes {
+		if !n.IsNil() {
+			if n.IsRed() {
+				n.SetRed(false)
+			} else {
+				n.SetRed(true)
+			}
+		}
+	}
+}
+
+// Rotate the tree left around the given node.
+//
+// After this rotation, the former right child (FC) will be the new parent and the former parent (FP) will
+// be the left node of the new parent. The left child of the former child is transferred to the former parent.
+//
+//	    FP                                FC
+//	 /      \         left rotate        /  \
+//	FP_R     FC          =>            FP   FC_R
+//	        / \                       / \
+//	     FC_L   FC_R               FP_R  FC_L
+//
+// In case FP was the root of the tree, FC will be the new root of the tree.
+func leftRotate(rotationNode Node) Node {
+	formerChild := rotationNode.Right()
+	rootRotate := rotationNode.Parent().IsNil()
+
+	// former child node becomes new parent unless the rotation is around the root node
+	if rootRotate {
+		formerChild.SetParent(nil)
+	} else {
+		if rotationNode.Parent().Left() == rotationNode {
+			rotationNode.Parent().SetLeft(formerChild)
+		} else {
+			rotationNode.Parent().SetRight(formerChild)
+		}
+		formerChild.SetParent(rotationNode.Parent())
+	}
+
+	rotationNode.SetParent(formerChild)
+
+	// Switch left child from former_child to rotation node
+	rotationNode.SetRight(formerChild.Left())
+	if formerChild.Left() != nil {
+		formerChild.Left().SetParent(rotationNode)
+	}
+	formerChild.SetLeft(rotationNode)
+
+	if rootRotate {
+		return formerChild
+	} else {
+		return nil
+	}
+}
+
+// Same as leftRotate, just switch left and right everywhere
+func rightRotate(rotationNode Node) Node {
+	formerChild := rotationNode.Left()
+	rootRotate := rotationNode.Parent().IsNil()
+
+	if rootRotate {
+		formerChild.SetParent(nil)
+	} else {
+		if rotationNode.Parent().Left() == rotationNode {
+			rotationNode.Parent().SetLeft(formerChild)
+		} else {
+			rotationNode.Parent().SetRight(formerChild)
+		}
+		formerChild.SetParent(rotationNode.Parent())
+	}
+	rotationNode.SetParent(formerChild)
+
+	rotationNode.SetLeft(formerChild.Right())
+	if formerChild.Right() != nil {
+		formerChild.Right().SetParent(rotationNode)
+	}
+	formerChild.SetRight(rotationNode)
+
+	if rootRotate {
+		return formerChild
+	} else {
+		return nil
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/recover_from_wal_integration_test.go

@@ -0,0 +1,973 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+//go:build integrationTest
+// +build integrationTest
+
+package lsmkv
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+	"github.com/weaviate/weaviate/entities/cyclemanager"
+	"github.com/weaviate/weaviate/entities/filters"
+)
+
+func TestReplaceStrategy_RecoverFromWAL(t *testing.T) {
+	dirNameOriginal := t.TempDir()
+	dirNameRecovered := t.TempDir()
+
+	t.Run("with some previous state", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			WithStrategy(StrategyReplace), WithMinWalThreshold(0))
+		require.Nil(t, err)
+
+		// so big it effectively never triggers as part of this test
+		b.SetMemtableThreshold(1e9)
+
+		t.Run("set one key that will be flushed orderly", func(t *testing.T) {
+			// the motivation behind flushing this initial segment is to check that
+			// deletion as part of the recovery also works correctly. If we would
+			// just delete something that was created as part of the same memtable,
+			// the tests would still pass, even with removing the logic that recovers
+			// tombstones.
+			//
+			// To make sure they fail in this case, this prior state was introduced.
+			// An entry with key "key-2" is introduced in a previous segment, so if
+			// the deletion fails as part of the recovery this key would still be
+			// present later on. With the deletion working correctly it will be gone.
+			//
+			// You can test this by commenting the "p.memtable.setTombstone()" line
+			// in p.doReplace(). This will fail the tests suite, but prior to this
+			// addition it would have passed.
+			key2 := []byte("key-2")
+			orig2 := []byte("delete me later - you should never find me again")
+
+			err = b.Put(key2, orig2)
+			require.Nil(t, err)
+		})
+
+		t.Run("shutdown (orderly) bucket to create first segment", func(t *testing.T) {
+			b.Shutdown(context.Background())
+
+			// then recreate bucket
+			var err error
+			b, err = NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyReplace), WithMinWalThreshold(0))
+			require.Nil(t, err)
+		})
+
+		t.Run("set original values", func(t *testing.T) {
+			key1 := []byte("key-1")
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			orig1 := []byte("original value for key1")
+			orig2 := []byte("original value for key2")
+			orig3 := []byte("original value for key3")
+
+			err = b.Put(key1, orig1)
+			require.Nil(t, err)
+			err = b.Put(key2, orig2)
+			require.Nil(t, err)
+			err = b.Put(key3, orig3)
+			require.Nil(t, err)
+		})
+
+		t.Run("delete one, update one", func(t *testing.T) {
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			updated3 := []byte("updated value for key 3")
+
+			err = b.Delete(key2)
+			require.Nil(t, err)
+
+			err = b.Put(key3, updated3)
+			require.Nil(t, err)
+		})
+
+		t.Run("verify control", func(t *testing.T) {
+			key1 := []byte("key-1")
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			orig1 := []byte("original value for key1")
+			updated3 := []byte("updated value for key 3")
+			res, err := b.Get(key1)
+			require.Nil(t, err)
+			assert.Equal(t, res, orig1)
+			res, err = b.Get(key2)
+			require.Nil(t, err)
+			assert.Nil(t, res)
+			res, err = b.Get(key3)
+			require.Nil(t, err)
+			assert.Equal(t, res, updated3)
+		})
+
+		t.Run("make sure the WAL is flushed", func(t *testing.T) {
+			require.Nil(t, b.WriteWAL())
+		})
+
+		t.Run("copy state into recovery folder and destroy original", func(t *testing.T) {
+			t.Run("copy over wals", func(t *testing.T) {
+				cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.wal %s",
+					dirNameOriginal, dirNameRecovered))
+				var out bytes.Buffer
+				cmd.Stderr = &out
+				err := cmd.Run()
+				if err != nil {
+					fmt.Println(out.String())
+					t.Fatal(err)
+				}
+			})
+
+			t.Run("copy over segments", func(t *testing.T) {
+				cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.db %s",
+					dirNameOriginal, dirNameRecovered))
+				var out bytes.Buffer
+				cmd.Stderr = &out
+				err := cmd.Run()
+				if err != nil {
+					fmt.Println(out.String())
+					t.Fatal(err)
+				}
+			})
+			b = nil
+			require.Nil(t, os.RemoveAll(dirNameOriginal))
+		})
+
+		var bRec *Bucket
+
+		t.Run("create new bucket from existing state", func(t *testing.T) {
+			b, err := NewBucketCreator().NewBucket(testCtx(), dirNameRecovered, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyReplace), WithMinWalThreshold(0))
+			require.Nil(t, err)
+
+			// so big it effectively never triggers as part of this test
+			b.SetMemtableThreshold(1e9)
+
+			bRec = b
+		})
+
+		t.Run("verify all data is present", func(t *testing.T) {
+			key1 := []byte("key-1")
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			orig1 := []byte("original value for key1")
+			updated3 := []byte("updated value for key 3")
+			res, err := bRec.Get(key1)
+			require.Nil(t, err)
+			assert.Equal(t, res, orig1)
+			res, err = bRec.Get(key2)
+			require.Nil(t, err)
+			assert.Nil(t, res)
+			res, err = bRec.Get(key3)
+			require.Nil(t, err)
+			assert.Equal(t, res, updated3)
+		})
+	})
+}
+
+func TestReplaceStrategy_RecoverFromWALWithCorruptLastElement(t *testing.T) {
+	dirNameOriginal := t.TempDir()
+	dirNameRecovered := t.TempDir()
+
+	t.Run("without previous state", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			WithStrategy(StrategyReplace))
+		require.Nil(t, err)
+
+		// so big it effectively never triggers as part of this test
+		b.SetMemtableThreshold(1e9)
+
+		t.Run("set original values", func(t *testing.T) {
+			key1 := []byte("key-1")
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			orig1 := []byte("original value for key1")
+			orig2 := []byte("original value for key2")
+			orig3 := []byte("original value for key3")
+
+			err = b.Put(key1, orig1)
+			require.Nil(t, err)
+			err = b.Put(key2, orig2)
+			require.Nil(t, err)
+			err = b.Put(key3, orig3)
+			require.Nil(t, err)
+		})
+
+		t.Run("delete one, update one", func(t *testing.T) {
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			updated3 := []byte("updated value for key 3")
+
+			err = b.Delete(key2)
+			require.Nil(t, err)
+
+			err = b.Put(key3, updated3)
+			require.Nil(t, err)
+		})
+
+		t.Run("verify control", func(t *testing.T) {
+			key1 := []byte("key-1")
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			orig1 := []byte("original value for key1")
+			updated3 := []byte("updated value for key 3")
+			res, err := b.Get(key1)
+			require.Nil(t, err)
+			assert.Equal(t, res, orig1)
+			res, err = b.Get(key2)
+			require.Nil(t, err)
+			assert.Nil(t, res)
+			res, err = b.Get(key3)
+			require.Nil(t, err)
+			assert.Equal(t, res, updated3)
+		})
+
+		t.Run("make sure the WAL is flushed", func(t *testing.T) {
+			require.Nil(t, b.WriteWAL())
+		})
+
+		t.Run("copy state into recovery folder and destroy original", func(t *testing.T) {
+			cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.wal %s",
+				dirNameOriginal, dirNameRecovered))
+			var out bytes.Buffer
+			cmd.Stderr = &out
+			err := cmd.Run()
+			if err != nil {
+				fmt.Println(out.String())
+				t.Fatal(err)
+			}
+			b = nil
+			require.Nil(t, os.RemoveAll(dirNameOriginal))
+		})
+
+		t.Run("corrupt WAL by removing some bytes at the very end", func(t *testing.T) {
+			entries, err := os.ReadDir(dirNameRecovered)
+			require.Nil(t, err)
+			require.Len(t, entries, 1, "there should be exactly one .wal file")
+
+			oldFileName := filepath.Join(dirNameRecovered, entries[0].Name())
+			tmpFileName := oldFileName + ".tmp"
+
+			err = os.Rename(oldFileName, tmpFileName)
+			require.Nil(t, err)
+
+			orig, err := os.Open(tmpFileName)
+			require.Nil(t, err)
+
+			correctLog, err := io.ReadAll(orig)
+			require.Nil(t, err)
+			err = orig.Close()
+			require.Nil(t, err)
+
+			corruptLog := correctLog[:len(correctLog)-6]
+
+			err = os.Remove(tmpFileName)
+			require.Nil(t, err)
+
+			corrupt, err := os.Create(oldFileName)
+			require.Nil(t, err)
+
+			_, err = corrupt.Write(corruptLog)
+			require.Nil(t, err)
+
+			err = corrupt.Close()
+			require.Nil(t, err)
+		})
+
+		var bRec *Bucket
+
+		t.Run("create new bucket from existing state", func(t *testing.T) {
+			b, err := NewBucketCreator().NewBucket(testCtx(), dirNameRecovered, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyReplace))
+			require.Nil(t, err)
+
+			// so big it effectively never triggers as part of this test
+			b.SetMemtableThreshold(1e9)
+
+			bRec = b
+		})
+
+		t.Run("verify all data prior to the corruption is present", func(t *testing.T) {
+			key1 := []byte("key-1")
+			key2 := []byte("key-2")
+			key3 := []byte("key-3")
+			orig1 := []byte("original value for key1")
+			notUpdated3 := []byte("original value for key3")
+
+			// the last operation we performed (that now got corrupted) was an update
+			// on key3. So now that we're expecting all state prior to the corruption
+			// to be present, we would expect the original value for key3
+
+			res, err := bRec.Get(key1)
+			require.Nil(t, err)
+			assert.Equal(t, res, orig1)
+			res, err = bRec.Get(key2)
+			require.Nil(t, err)
+			assert.Nil(t, res)
+			res, err = bRec.Get(key3)
+			require.Nil(t, err)
+			assert.Equal(t, res, notUpdated3)
+		})
+	})
+}
+
+func TestSetStrategy_RecoverFromWAL(t *testing.T) {
+	dirNameOriginal := t.TempDir()
+	dirNameRecovered := t.TempDir()
+
+	t.Run("without prior state", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			WithStrategy(StrategySetCollection))
+		require.Nil(t, err)
+
+		// so big it effectively never triggers as part of this test
+		b.SetMemtableThreshold(1e9)
+
+		key1 := []byte("test1-key-1")
+		key2 := []byte("test1-key-2")
+		key3 := []byte("test1-key-3")
+
+		t.Run("set original values and verify", func(t *testing.T) {
+			orig1 := [][]byte{[]byte("value 1.1"), []byte("value 1.2")}
+			orig2 := [][]byte{[]byte("value 2.1"), []byte("value 2.2")}
+			orig3 := [][]byte{[]byte("value 3.1"), []byte("value 3.2")}
+
+			err = b.SetAdd(key1, orig1)
+			require.Nil(t, err)
+			err = b.SetAdd(key2, orig2)
+			require.Nil(t, err)
+			err = b.SetAdd(key3, orig3)
+			require.Nil(t, err)
+
+			res, err := b.SetList(key1)
+			require.Nil(t, err)
+			assert.Equal(t, orig1, res)
+			res, err = b.SetList(key2)
+			require.Nil(t, err)
+			assert.Equal(t, orig2, res)
+			res, err = b.SetList(key3)
+			require.Nil(t, err)
+			assert.Equal(t, orig3, res)
+		})
+
+		t.Run("delete individual keys", func(t *testing.T) {
+			delete2 := []byte("value 2.1")
+			delete3 := []byte("value 3.2")
+
+			err = b.SetDeleteSingle(key2, delete2)
+			require.Nil(t, err)
+			err = b.SetDeleteSingle(key3, delete3)
+			require.Nil(t, err)
+		})
+
+		t.Run("re-add keys which were previously deleted and new ones", func(t *testing.T) {
+			readd2 := [][]byte{[]byte("value 2.1"), []byte("value 2.3")}
+			readd3 := [][]byte{[]byte("value 3.2"), []byte("value 3.3")}
+
+			err = b.SetAdd(key2, readd2)
+			require.Nil(t, err)
+			err = b.SetAdd(key3, readd3)
+			require.Nil(t, err)
+		})
+
+		t.Run("validate the results prior to recovery", func(t *testing.T) {
+			expected1 := [][]byte{[]byte("value 1.1"), []byte("value 1.2")} // unchanged
+			expected2 := [][]byte{
+				[]byte("value 2.2"), // from original import
+				[]byte("value 2.1"), // added again after initial deletion
+				[]byte("value 2.3"), // newly added
+			}
+			expected3 := [][]byte{
+				[]byte("value 3.1"), // form original import
+				[]byte("value 3.2"), // added again after initial deletion
+				[]byte("value 3.3"), // newly added
+			} // value2 deleted
+
+			res, err := b.SetList(key1)
+			require.Nil(t, err)
+			assert.Equal(t, expected1, res)
+			res, err = b.SetList(key2)
+			require.Nil(t, err)
+			assert.Equal(t, expected2, res)
+			res, err = b.SetList(key3)
+			require.Nil(t, err)
+			assert.Equal(t, expected3, res)
+		})
+
+		t.Run("make sure the WAL is flushed", func(t *testing.T) {
+			require.Nil(t, b.WriteWAL())
+		})
+
+		t.Run("copy state into recovery folder and destroy original", func(t *testing.T) {
+			cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.wal %s",
+				dirNameOriginal, dirNameRecovered))
+			var out bytes.Buffer
+			cmd.Stderr = &out
+			err := cmd.Run()
+			if err != nil {
+				fmt.Println(out.String())
+				t.Fatal(err)
+			}
+			b = nil
+			require.Nil(t, os.RemoveAll(dirNameOriginal))
+		})
+
+		var bRec *Bucket
+
+		t.Run("create new bucket from existing state", func(t *testing.T) {
+			b, err := NewBucketCreator().NewBucket(testCtx(), dirNameRecovered, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategySetCollection))
+			require.Nil(t, err)
+
+			// so big it effectively never triggers as part of this test
+			b.SetMemtableThreshold(1e9)
+
+			bRec = b
+		})
+
+		t.Run("validate the results after recovery", func(t *testing.T) {
+			expected1 := [][]byte{[]byte("value 1.1"), []byte("value 1.2")} // unchanged
+			expected2 := [][]byte{
+				[]byte("value 2.2"), // from original import
+				[]byte("value 2.1"), // added again after initial deletion
+				[]byte("value 2.3"), // newly added
+			}
+			expected3 := [][]byte{
+				[]byte("value 3.1"), // form original import
+				[]byte("value 3.2"), // added again after initial deletion
+				[]byte("value 3.3"), // newly added
+			} // value2 deleted
+
+			res, err := bRec.SetList(key1)
+			require.Nil(t, err)
+			assert.Equal(t, expected1, res)
+			res, err = bRec.SetList(key2)
+			require.Nil(t, err)
+			assert.Equal(t, expected2, res)
+			res, err = bRec.SetList(key3)
+			require.Nil(t, err)
+			assert.Equal(t, expected3, res)
+		})
+	})
+}
+
+func TestRoaringSetStrategy_RecoverFromWAL(t *testing.T) {
+	dirNameOriginal := t.TempDir()
+	dirNameRecovered := t.TempDir()
+
+	t.Run("without prior state", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			WithStrategy(StrategyRoaringSet), WithBitmapBufPool(roaringset.NewBitmapBufPoolNoop()))
+		require.Nil(t, err)
+
+		key1 := []byte("test1-key-1")
+		key2 := []byte("test1-key-2")
+		key3 := []byte("test1-key-3")
+
+		t.Run("set original values and verify", func(t *testing.T) {
+			orig1 := []uint64{11, 12}
+			orig2 := []uint64{21, 22}
+			orig3 := []uint64{31, 32}
+
+			err = b.RoaringSetAddList(key1, orig1)
+			require.NoError(t, err)
+			err = b.RoaringSetAddList(key2, orig2)
+			require.NoError(t, err)
+			err = b.RoaringSetAddList(key3, orig3)
+			require.NoError(t, err)
+
+			bm1, release, err := b.RoaringSetGet(key1)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, orig1, bm1.ToArray())
+
+			bm2, release, err := b.RoaringSetGet(key2)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, orig2, bm2.ToArray())
+
+			bm3, release, err := b.RoaringSetGet(key3)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, orig3, bm3.ToArray())
+		})
+
+		t.Run("delete individual keys", func(t *testing.T) {
+			delete2 := uint64(21)
+			delete3 := uint64(32)
+
+			err = b.RoaringSetRemoveOne(key2, delete2)
+			require.NoError(t, err)
+			err = b.RoaringSetRemoveOne(key3, delete3)
+			require.NoError(t, err)
+		})
+
+		t.Run("re-add keys which were previously deleted and new ones", func(t *testing.T) {
+			reAdd2 := []uint64{21, 23}
+			reAdd3 := []uint64{31, 33}
+
+			err = b.RoaringSetAddList(key2, reAdd2)
+			require.NoError(t, err)
+			err = b.RoaringSetAddList(key3, reAdd3)
+			require.NoError(t, err)
+		})
+
+		t.Run("validate the results prior to recovery", func(t *testing.T) {
+			expected1 := []uint64{11, 12} // unchanged
+			expected2 := []uint64{
+				22, // from original import
+				21, // added again after initial deletion
+				23, // newly added
+			}
+			expected3 := []uint64{
+				31, // form original import
+				33, // newly added
+			} // 32 deleted
+
+			bm1, release, err := b.RoaringSetGet(key1)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, expected1, bm1.ToArray())
+
+			bm2, release, err := b.RoaringSetGet(key2)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, expected2, bm2.ToArray())
+
+			bm3, release, err := b.RoaringSetGet(key3)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, expected3, bm3.ToArray())
+		})
+
+		t.Run("make sure the WAL is flushed", func(t *testing.T) {
+			require.Nil(t, b.WriteWAL())
+		})
+
+		t.Run("copy state into recovery folder and destroy original", func(t *testing.T) {
+			cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.wal %s",
+				dirNameOriginal, dirNameRecovered))
+			var out bytes.Buffer
+			cmd.Stderr = &out
+			err := cmd.Run()
+			if err != nil {
+				fmt.Println(out.String())
+				t.Fatal(err)
+			}
+			b = nil
+			require.Nil(t, os.RemoveAll(dirNameOriginal))
+		})
+
+		var bRec *Bucket
+
+		t.Run("create new bucket from existing state", func(t *testing.T) {
+			b, err := NewBucketCreator().NewBucket(testCtx(), dirNameRecovered, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyRoaringSet), WithBitmapBufPool(roaringset.NewBitmapBufPoolNoop()))
+			require.Nil(t, err)
+
+			bRec = b
+		})
+
+		t.Run("validate the results after recovery", func(t *testing.T) {
+			expected1 := []uint64{11, 12} // unchanged
+			expected2 := []uint64{
+				22, // from original import
+				21, // added again after initial deletion
+				23, // newly added
+			}
+			expected3 := []uint64{
+				31, // form original import
+				33, // newly added
+			} // 32 deleted
+
+			bm1, release, err := bRec.RoaringSetGet(key1)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, expected1, bm1.ToArray())
+
+			bm2, release, err := bRec.RoaringSetGet(key2)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, expected2, bm2.ToArray())
+
+			bm3, release, err := bRec.RoaringSetGet(key3)
+			require.NoError(t, err)
+			defer release()
+			assert.ElementsMatch(t, expected3, bm3.ToArray())
+		})
+	})
+}
+
+func TestRoaringSetRangeStrategy_RecoverFromWAL(t *testing.T) {
+	dirNameOriginal := t.TempDir()
+	dirNameRecovered := t.TempDir()
+
+	t.Run("without prior state", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			WithStrategy(StrategyRoaringSetRange))
+		require.Nil(t, err)
+
+		key1 := uint64(1)
+		key2 := uint64(2)
+		key3 := uint64(3)
+
+		t.Run("set original values and verify", func(t *testing.T) {
+			orig1 := []uint64{11, 12}
+			orig2 := []uint64{21, 22}
+			orig3 := []uint64{31, 32}
+
+			err = b.RoaringSetRangeAdd(key1, orig1...)
+			require.NoError(t, err)
+			err = b.RoaringSetRangeAdd(key2, orig2...)
+			require.NoError(t, err)
+			err = b.RoaringSetRangeAdd(key3, orig3...)
+			require.NoError(t, err)
+
+			reader := b.ReaderRoaringSetRange()
+			defer reader.Close()
+
+			bm1, release1, err := reader.Read(testCtx(), key1, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release1()
+			assert.ElementsMatch(t, orig1, bm1.ToArray())
+
+			bm2, release2, err := reader.Read(testCtx(), key2, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release2()
+			assert.ElementsMatch(t, orig2, bm2.ToArray())
+
+			bm3, release3, err := reader.Read(testCtx(), key3, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release3()
+			assert.ElementsMatch(t, orig3, bm3.ToArray())
+		})
+
+		t.Run("delete individual keys", func(t *testing.T) {
+			delete2 := uint64(21)
+			delete3 := uint64(32)
+
+			err = b.RoaringSetRangeRemove(key2, delete2)
+			require.NoError(t, err)
+			err = b.RoaringSetRangeRemove(key3, delete3)
+			require.NoError(t, err)
+		})
+
+		t.Run("re-add keys which were previously deleted and new ones", func(t *testing.T) {
+			reAdd2 := []uint64{21, 23}
+			reAdd3 := []uint64{31, 33}
+
+			err = b.RoaringSetRangeAdd(key2, reAdd2...)
+			require.NoError(t, err)
+			err = b.RoaringSetRangeAdd(key3, reAdd3...)
+			require.NoError(t, err)
+		})
+
+		t.Run("validate the results prior to recovery", func(t *testing.T) {
+			expected1 := []uint64{11, 12} // unchanged
+			expected2 := []uint64{
+				22, // from original import
+				21, // added again after initial deletion
+				23, // newly added
+			}
+			expected3 := []uint64{
+				31, // form original import
+				33, // newly added
+			} // 32 deleted
+
+			reader := b.ReaderRoaringSetRange()
+			defer reader.Close()
+
+			bm1, release1, err := reader.Read(testCtx(), key1, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release1()
+			assert.ElementsMatch(t, expected1, bm1.ToArray())
+
+			bm2, release2, err := reader.Read(testCtx(), key2, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release2()
+			assert.ElementsMatch(t, expected2, bm2.ToArray())
+
+			bm3, release3, err := reader.Read(testCtx(), key3, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release3()
+			assert.ElementsMatch(t, expected3, bm3.ToArray())
+		})
+
+		t.Run("make sure the WAL is flushed", func(t *testing.T) {
+			require.Nil(t, b.WriteWAL())
+		})
+
+		t.Run("copy state into recovery folder and destroy original", func(t *testing.T) {
+			cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.wal %s",
+				dirNameOriginal, dirNameRecovered))
+			var out bytes.Buffer
+			cmd.Stderr = &out
+			err := cmd.Run()
+			if err != nil {
+				fmt.Println(out.String())
+				t.Fatal(err)
+			}
+			b = nil
+			require.Nil(t, os.RemoveAll(dirNameOriginal))
+		})
+
+		var bRec *Bucket
+
+		t.Run("create new bucket from existing state", func(t *testing.T) {
+			b, err := NewBucketCreator().NewBucket(testCtx(), dirNameRecovered, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyRoaringSetRange))
+			require.Nil(t, err)
+
+			bRec = b
+		})
+
+		t.Run("validate the results after recovery", func(t *testing.T) {
+			expected1 := []uint64{11, 12} // unchanged
+			expected2 := []uint64{
+				22, // from original import
+				21, // added again after initial deletion
+				23, // newly added
+			}
+			expected3 := []uint64{
+				31, // form original import
+				33, // newly added
+			} // 32 deleted
+
+			reader := bRec.ReaderRoaringSetRange()
+			defer reader.Close()
+
+			bm1, release1, err := reader.Read(testCtx(), key1, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release1()
+			assert.ElementsMatch(t, expected1, bm1.ToArray())
+
+			bm2, release2, err := reader.Read(testCtx(), key2, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release2()
+			assert.ElementsMatch(t, expected2, bm2.ToArray())
+
+			bm3, release3, err := reader.Read(testCtx(), key3, filters.OperatorEqual)
+			require.NoError(t, err)
+			defer release3()
+			assert.ElementsMatch(t, expected3, bm3.ToArray())
+		})
+	})
+}
+
+func TestMapStrategy_RecoverFromWAL(t *testing.T) {
+	dirNameOriginal := t.TempDir()
+	dirNameRecovered := t.TempDir()
+
+	t.Run("without prior state", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(testCtx(), dirNameOriginal, "", nullLogger(), nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			WithStrategy(StrategyMapCollection))
+		require.Nil(t, err)
+
+		// so big it effectively never triggers as part of this test
+		b.SetMemtableThreshold(1e9)
+
+		rowKey1 := []byte("test1-key-1")
+		rowKey2 := []byte("test1-key-2")
+
+		t.Run("set original values and verify", func(t *testing.T) {
+			row1Map := []MapPair{
+				{
+					Key:   []byte("row1-key1"),
+					Value: []byte("row1-key1-value1"),
+				}, {
+					Key:   []byte("row1-key2"),
+					Value: []byte("row1-key2-value1"),
+				},
+			}
+
+			row2Map := []MapPair{
+				{
+					Key:   []byte("row2-key1"),
+					Value: []byte("row2-key1-value1"),
+				}, {
+					Key:   []byte("row2-key2"),
+					Value: []byte("row2-key2-value1"),
+				},
+			}
+
+			for _, pair := range row1Map {
+				err = b.MapSet(rowKey1, pair)
+				require.Nil(t, err)
+			}
+
+			for _, pair := range row2Map {
+				err = b.MapSet(rowKey2, pair)
+				require.Nil(t, err)
+			}
+
+			res, err := b.MapList(context.Background(), rowKey1)
+			require.Nil(t, err)
+			assert.Equal(t, row1Map, res)
+			res, err = b.MapList(context.Background(), rowKey2)
+			require.Nil(t, err)
+			assert.Equal(t, res, row2Map)
+		})
+
+		t.Run("replace an existing map key", func(t *testing.T) {
+			err = b.MapSet(rowKey1, MapPair{
+				Key:   []byte("row1-key1"),        // existing key
+				Value: []byte("row1-key1-value2"), // updated value
+			})
+			require.Nil(t, err)
+
+			row1Updated := []MapPair{
+				{
+					Key:   []byte("row1-key1"),
+					Value: []byte("row1-key1-value2"), // <--- updated, rest unchanged
+				}, {
+					Key:   []byte("row1-key2"),
+					Value: []byte("row1-key2-value1"),
+				},
+			}
+
+			row2Unchanged := []MapPair{
+				{
+					Key:   []byte("row2-key1"),
+					Value: []byte("row2-key1-value1"),
+				}, {
+					Key:   []byte("row2-key2"),
+					Value: []byte("row2-key2-value1"),
+				},
+			}
+
+			res, err := b.MapList(context.Background(), rowKey1)
+			require.Nil(t, err)
+			assert.Equal(t, row1Updated, res)
+			res, err = b.MapList(context.Background(), rowKey2)
+			require.Nil(t, err)
+			assert.Equal(t, res, row2Unchanged)
+		})
+
+		t.Run("validate the results prior to recovery", func(t *testing.T) {
+			rowKey1 := []byte("test1-key-1")
+			rowKey2 := []byte("test1-key-2")
+
+			expectedRow1 := []MapPair{
+				{
+					Key:   []byte("row1-key1"),
+					Value: []byte("row1-key1-value2"),
+				}, {
+					Key:   []byte("row1-key2"),
+					Value: []byte("row1-key2-value1"),
+				},
+			}
+
+			expectedRow2 := []MapPair{
+				{
+					Key:   []byte("row2-key1"),
+					Value: []byte("row2-key1-value1"),
+				}, {
+					Key:   []byte("row2-key2"),
+					Value: []byte("row2-key2-value1"),
+				},
+			}
+
+			res, err := b.MapList(context.Background(), rowKey1)
+			require.Nil(t, err)
+			assert.Equal(t, expectedRow1, res)
+			res, err = b.MapList(context.Background(), rowKey2)
+			require.Nil(t, err)
+			assert.Equal(t, expectedRow2, res)
+		})
+
+		t.Run("make sure the WAL is flushed", func(t *testing.T) {
+			require.Nil(t, b.WriteWAL())
+		})
+
+		t.Run("copy state into recovery folder and destroy original", func(t *testing.T) {
+			cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -r %s/*.wal %s",
+				dirNameOriginal, dirNameRecovered))
+			var out bytes.Buffer
+			cmd.Stderr = &out
+			err := cmd.Run()
+			if err != nil {
+				fmt.Println(out.String())
+				t.Fatal(err)
+			}
+			b = nil
+			require.Nil(t, os.RemoveAll(dirNameOriginal))
+		})
+
+		var bRec *Bucket
+
+		t.Run("create new bucket from existing state", func(t *testing.T) {
+			b, err := NewBucketCreator().NewBucket(testCtx(), dirNameRecovered, "", nullLogger(), nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyMapCollection))
+			require.Nil(t, err)
+
+			// so big it effectively never triggers as part of this test
+			b.SetMemtableThreshold(1e9)
+
+			bRec = b
+		})
+
+		t.Run("validate the results after  recovery", func(t *testing.T) {
+			rowKey1 := []byte("test1-key-1")
+			rowKey2 := []byte("test1-key-2")
+
+			expectedRow1 := []MapPair{
+				{
+					Key:   []byte("row1-key1"),
+					Value: []byte("row1-key1-value2"),
+				}, {
+					Key:   []byte("row1-key2"),
+					Value: []byte("row1-key2-value1"),
+				},
+			}
+
+			expectedRow2 := []MapPair{
+				{
+					Key:   []byte("row2-key1"),
+					Value: []byte("row2-key1-value1"),
+				}, {
+					Key:   []byte("row2-key2"),
+					Value: []byte("row2-key2-value1"),
+				},
+			}
+
+			res, err := bRec.MapList(context.Background(), rowKey1)
+			require.Nil(t, err)
+			assert.Equal(t, expectedRow1, res)
+			res, err = bRec.MapList(context.Background(), rowKey2)
+			require.Nil(t, err)
+			assert.Equal(t, expectedRow2, res)
+		})
+	})
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/red_black_tree_test.go

@@ -0,0 +1,424 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"crypto/rand"
+	"fmt"
+	"math"
+	"math/big"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/rbtree"
+)
+
+const (
+	R = true
+	B = false
+)
+
+// This test adds keys to the RB tree. Afterwards the same nodes are added in the expected order, eg in the way
+// the RB tree is expected to re-order the nodes
+var rbTests = []struct {
+	name           string
+	keys           []uint
+	ReorderedKeys  []uint
+	expectedColors []bool // with respect to the original keys
+}{
+	{
+		"Requires recoloring but no reordering",
+		[]uint{61, 52, 83, 93},
+		[]uint{61, 52, 83, 93},
+		[]bool{B, B, B, R},
+	},
+	{
+		"Requires left rotate around root",
+		[]uint{61, 83, 99},
+		[]uint{83, 61, 99},
+		[]bool{R, B, R},
+	},
+	{
+		"Requires left rotate with more nodes",
+		[]uint{61, 52, 85, 93, 99},
+		[]uint{61, 52, 93, 85, 99},
+		[]bool{B, B, R, B, R},
+	},
+	{
+		"Requires right and then left rotate",
+		[]uint{61, 52, 85, 93, 87},
+		[]uint{61, 52, 87, 85, 93},
+		[]bool{B, B, R, R, B},
+	},
+	{
+		"Requires right rotate around root",
+		[]uint{61, 30, 10},
+		[]uint{30, 10, 61},
+		[]bool{R, B, R},
+	},
+	{
+		"Requires right rotate with more nodes",
+		[]uint{61, 52, 85, 21, 10},
+		[]uint{61, 85, 21, 10, 52},
+		[]bool{B, R, B, B, R},
+	},
+	{
+		"Requires left and then right rotate",
+		[]uint{61, 52, 85, 21, 36},
+		[]uint{61, 85, 36, 21, 52},
+		[]bool{B, R, B, R, B},
+	},
+	{
+		"Require reordering for two nodes",
+		[]uint{61, 52, 40, 85, 105, 110},
+		[]uint{52, 40, 85, 61, 105, 110},
+		[]bool{B, B, B, R, B, R},
+	},
+	{
+		"Ordered nodes increasing",
+		[]uint{1, 2, 3, 4, 5, 6, 7, 8},
+		[]uint{4, 2, 6, 1, 3, 5, 7, 8},
+		[]bool{B, R, B, B, B, R, B, R},
+	},
+	{
+		"Ordered nodes decreasing",
+		[]uint{8, 7, 6, 5, 4, 3, 2, 1},
+		[]uint{5, 3, 7, 2, 4, 6, 8, 1},
+		[]bool{B, R, B, B, B, R, B, R},
+	},
+	{
+		"Multiple rotations along the tree and colour changes",
+		[]uint{166, 92, 33, 133, 227, 236, 71, 183, 18, 139, 245, 161},
+		[]uint{166, 92, 227, 33, 139, 183, 236, 18, 71, 133, 161, 245},
+		[]bool{B, R, B, R, R, B, R, B, R, B, R, R},
+	},
+}
+
+func TestRBTree(t *testing.T) {
+	for _, tt := range rbTests {
+		t.Run(tt.name, func(t *testing.T) {
+			tree := &binarySearchTree{}
+			for _, key := range tt.keys {
+				iByte := []byte{uint8(key)}
+				tree.insert(iByte, iByte, nil)
+				require.Empty(t, tree.root.parent)
+			}
+			validateRBTree(t, tree.root)
+
+			flattenTree := tree.flattenInOrder()
+			require.Equal(t, len(tt.keys), len(flattenTree)) // no entries got lost
+
+			// add tree with the same nodes in the "optimal" order to be able to compare their order afterwards
+			treeCorrectOrder := &binarySearchTree{}
+			for _, key := range tt.ReorderedKeys {
+				iByte := []byte{uint8(key)}
+				treeCorrectOrder.insert(iByte, iByte, nil)
+			}
+
+			flattenTreeInput := treeCorrectOrder.flattenInOrder()
+			for i := range flattenTree {
+				byteKey := flattenTree[i].key
+				originalIndex := getIndexInSlice(tt.keys, byteKey)
+				require.Equal(t, byteKey, flattenTreeInput[i].key)
+				require.Equal(t, flattenTree[i].colourIsRed, tt.expectedColors[originalIndex])
+			}
+		})
+	}
+}
+
+func TestRBTreeMap(t *testing.T) {
+	for _, tt := range rbTests {
+		t.Run(tt.name, func(t *testing.T) {
+			tree := &binarySearchTreeMap{}
+			for _, key := range tt.keys {
+				tree.insert([]byte{uint8(key)}, MapPair{
+					Key:   []byte("map-key-1"),
+					Value: []byte("map-value-1"),
+				})
+				require.Empty(t, tree.root.parent)
+			}
+			validateRBTree(t, tree.root)
+
+			flatten_tree := tree.flattenInOrder()
+			require.Equal(t, len(tt.keys), len(flatten_tree)) // no entries got lost
+
+			// add tree with the same nodes in the "optimal" order to be able to compare their order afterwards
+			treeCorrectOrder := &binarySearchTreeMap{}
+			for _, key := range tt.ReorderedKeys {
+				treeCorrectOrder.insert([]byte{uint8(key)}, MapPair{
+					Key:   []byte("map-key-1"),
+					Value: []byte("map-value-1"),
+				})
+			}
+
+			flatten_tree_input := treeCorrectOrder.flattenInOrder()
+			for i := range flatten_tree {
+				byte_key := flatten_tree[i].key
+				originalIndex := getIndexInSlice(tt.keys, byte_key)
+				require.Equal(t, byte_key, flatten_tree_input[i].key)
+				require.Equal(t, flatten_tree[i].colourIsRed, tt.expectedColors[originalIndex])
+			}
+		})
+	}
+}
+
+func TestRBTreeMulti(t *testing.T) {
+	for _, tt := range rbTests {
+		t.Run(tt.name, func(t *testing.T) {
+			tree := &binarySearchTreeMulti{}
+			for _, key := range tt.keys {
+				values := []value{}
+				for j := uint(0); j < 5; j++ {
+					values = append(values, value{value: []byte{uint8(key * j)}, tombstone: false})
+				}
+				tree.insert([]byte{uint8(key)}, values)
+				require.Empty(t, tree.root.parent)
+			}
+			validateRBTree(t, tree.root)
+
+			flatten_tree := tree.flattenInOrder()
+			require.Equal(t, len(tt.keys), len(flatten_tree)) // no entries got lost
+
+			// add tree with the same nodes in the "optimal" order to be able to compare their order afterwards
+			treeCorrectOrder := &binarySearchTreeMulti{}
+			for _, key := range tt.ReorderedKeys {
+				values := []value{}
+				for j := uint(0); j < 5; j++ {
+					values = append(values, value{value: []byte{uint8(key * j)}, tombstone: false})
+				}
+				treeCorrectOrder.insert([]byte{uint8(key)}, values)
+			}
+
+			flatten_tree_input := treeCorrectOrder.flattenInOrder()
+			for i := range flatten_tree {
+				byte_key := flatten_tree[i].key
+				originalIndex := getIndexInSlice(tt.keys, byte_key)
+				require.Equal(t, byte_key, flatten_tree_input[i].key)
+				require.Equal(t, flatten_tree[i].colourIsRed, tt.expectedColors[originalIndex])
+			}
+		})
+	}
+}
+
+// add keys as a) normal keys b) tombstone keys and c) half tombstone, half normal.
+// The resulting (rebalanced) trees must have the same order and colors
+var tombstoneTests = []struct {
+	name string
+	keys []uint
+}{
+	{"Rotate left around root", []uint{61, 83, 99}},
+	{"Rotate right around root", []uint{61, 30, 10}},
+	{"Multiple rotations along the tree and colour changes", []uint{166, 92, 33, 133, 227, 236, 71, 183, 18, 139, 245, 161}},
+	{"Ordered nodes increasing", []uint{1, 2, 3, 4, 5, 6, 7, 8}},
+	{"Ordered nodes decreasing", []uint{8, 7, 6, 5, 4, 3, 2, 1}},
+}
+
+func TestRBTrees_Tombstones(t *testing.T) {
+	for _, tt := range tombstoneTests {
+		t.Run(tt.name, func(t *testing.T) {
+			treeNormal := &binarySearchTree{}
+			treeTombstone := &binarySearchTree{}
+			treeHalfHalf := &binarySearchTree{}
+			for i, key := range tt.keys {
+				iByte := []byte{uint8(key)}
+				treeNormal.insert(iByte, iByte, nil)
+				treeTombstone.setTombstone(iByte, nil, nil)
+				if i%2 == 0 {
+					treeHalfHalf.insert(iByte, iByte, nil)
+				} else {
+					treeHalfHalf.setTombstone(iByte, nil, nil)
+				}
+			}
+			validateRBTree(t, treeNormal.root)
+			validateRBTree(t, treeTombstone.root)
+			validateRBTree(t, treeHalfHalf.root)
+
+			treeNormalFlatten := treeNormal.flattenInOrder()
+			treeTombstoneFlatten := treeTombstone.flattenInOrder()
+			treeHalfHalfFlatten := treeHalfHalf.flattenInOrder()
+			require.Equal(t, len(tt.keys), len(treeNormalFlatten))
+			require.Equal(t, len(tt.keys), len(treeTombstoneFlatten))
+			require.Equal(t, len(tt.keys), len(treeHalfHalfFlatten))
+
+			for i := range treeNormalFlatten {
+				require.Equal(t, treeNormalFlatten[i].key, treeTombstoneFlatten[i].key)
+				require.Equal(t, treeNormalFlatten[i].key, treeHalfHalfFlatten[i].key)
+				require.Equal(t, treeNormalFlatten[i].colourIsRed, treeTombstoneFlatten[i].colourIsRed)
+				require.Equal(t, treeNormalFlatten[i].colourIsRed, treeHalfHalfFlatten[i].colourIsRed)
+			}
+		})
+	}
+}
+
+type void struct{}
+
+var member void
+
+func mustRandIntn(max int64) int {
+	randInt, err := rand.Int(rand.Reader, big.NewInt(max))
+	if err != nil {
+		panic(fmt.Sprintf("mustRandIntn error: %v", err))
+	}
+	return int(randInt.Int64())
+}
+
+func TestRBTrees_Random(t *testing.T) {
+	tree := &binarySearchTree{}
+	amount := mustRandIntn(100000)
+	keySize := mustRandIntn(100)
+	uniqueKeys := make(map[string]void)
+	for i := 0; i < amount; i++ {
+		key := make([]byte, keySize)
+		rand.Read(key)
+		uniqueKeys[string(key)] = member
+		if mustRandIntn(5) == 1 { // add 20% of all entries as tombstone
+			tree.setTombstone(key, nil, nil)
+		} else {
+			tree.insert(key, key, nil)
+		}
+	}
+
+	// all added keys are still part of the tree
+	treeFlattened := tree.flattenInOrder()
+	require.Equal(t, len(uniqueKeys), len(treeFlattened))
+	for _, entry := range treeFlattened {
+		_, ok := uniqueKeys[string(entry.key)]
+		require.True(t, ok)
+	}
+	validateRBTree(t, tree.root)
+}
+
+func TestRBTreesMap_Random(t *testing.T) {
+	tree := &binarySearchTreeMap{}
+	amount := mustRandIntn(100000)
+	keySize := mustRandIntn(100)
+	uniqueKeys := make(map[string]void)
+	for i := 0; i < amount; i++ {
+		key := make([]byte, keySize)
+		rand.Read(key)
+		uniqueKeys[string(key)] = member
+		tree.insert(key, MapPair{
+			Key:   []byte("map-key-1"),
+			Value: []byte("map-value-1"),
+		})
+	}
+
+	// all added keys are still part of the tree
+	treeFlattened := tree.flattenInOrder()
+	require.Equal(t, len(uniqueKeys), len(treeFlattened))
+	for _, entry := range treeFlattened {
+		_, ok := uniqueKeys[string(entry.key)]
+		require.True(t, ok)
+	}
+	validateRBTree(t, tree.root)
+}
+
+func TestRBTreesMulti_Random(t *testing.T) {
+	tree := &binarySearchTreeMulti{}
+	amount := mustRandIntn(100000)
+	keySize := mustRandIntn(100)
+	uniqueKeys := make(map[string]void)
+	for i := 0; i < amount; i++ {
+		key := make([]byte, keySize)
+		rand.Read(key)
+		uniqueKeys[string(key)] = member
+		values := []value{}
+		for j := 0; j < 5; j++ {
+			values = append(values, value{value: []byte{uint8(i * j)}, tombstone: false})
+		}
+		tree.insert(key, values)
+	}
+
+	// all added keys are still part of the tree
+	treeFlattened := tree.flattenInOrder()
+	require.Equal(t, len(uniqueKeys), len(treeFlattened))
+	for _, entry := range treeFlattened {
+		_, ok := uniqueKeys[string(entry.key)]
+		require.True(t, ok)
+	}
+	validateRBTree(t, tree.root)
+}
+
+func getIndexInSlice(reorderedKeys []uint, key []byte) int {
+	for i, v := range reorderedKeys {
+		if v == uint(key[0]) {
+			return i
+		}
+	}
+	return -1
+}
+
+// Checks if a tree is a RB tree
+//
+// There are several properties that valid RB trees follow:
+// 1) The root node is always black
+// 2) The max depth of a tree is 2* Log2(N+1), where N is the number of nodes
+// 3) Every path from root to leave has the same number of _black_ nodes
+// 4) Red nodes only have black (or nil) children
+//
+// In addition this also validates some general tree properties:
+//   - root has no parent
+//   - if node A is a child of B, B must be the parent of A)
+func validateRBTree(t *testing.T, rootNode rbtree.Node) {
+	require.False(t, rootNode.IsRed())
+	require.True(t, rootNode.Parent().IsNil())
+
+	treeDepth, nodeCount, _ := walkTree(t, rootNode)
+	maxDepth := 2 * math.Log2(float64(nodeCount)+1)
+	require.True(t, treeDepth <= int(maxDepth))
+}
+
+// Walks through the tree and counts the depth, number of nodes and number of black nodes
+func walkTree(t *testing.T, node rbtree.Node) (int, int, int) {
+	if reflect.ValueOf(node).IsNil() {
+		return 0, 0, 0
+	}
+	leftNode := node.Left()
+	leftNodeIsNil := reflect.ValueOf(leftNode).IsNil()
+	rightNode := node.Right()
+	rightNodeIsNil := reflect.ValueOf(rightNode).IsNil()
+
+	// validate parent/child connections
+	if !rightNodeIsNil {
+		require.Equal(t, rightNode.Parent(), node)
+	}
+	if !leftNodeIsNil {
+		require.Equal(t, leftNode.Parent(), node)
+	}
+
+	// red nodes need black (or nil) children
+	if node.IsRed() {
+		require.True(t, leftNodeIsNil || !node.Left().IsRed())
+		require.True(t, rightNodeIsNil || !node.Left().IsRed())
+	}
+
+	blackNode := int(1)
+	if node.IsRed() {
+		blackNode = 0
+	}
+
+	if node.Right().IsNil() && node.Left().IsNil() {
+		return 1, 1, blackNode
+	}
+
+	depthRight, nodeCountRight, blackNodesDepthRight := walkTree(t, node.Right())
+	depthLeft, nodeCountLeft, blackNodesDepthLeft := walkTree(t, node.Left())
+	require.Equal(t, blackNodesDepthRight, blackNodesDepthLeft)
+
+	nodeCount := nodeCountLeft + nodeCountRight + 1
+	if depthRight > depthLeft {
+		return depthRight + 1, nodeCount, blackNodesDepthRight + blackNode
+	} else {
+		return depthLeft + 1, nodeCount, blackNodesDepthRight + blackNode
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/search_segment.go

@@ -0,0 +1,370 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"sort"
+	"strconv"
+
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/adapters/repos/db/inverted/terms"
+	"github.com/weaviate/weaviate/adapters/repos/db/priorityqueue"
+)
+
+func DoBlockMaxWand(ctx context.Context, limit int, results Terms, averagePropLength float64, additionalExplanations bool,
+	termCount, minimumOrTokensMatch int, logger logrus.FieldLogger,
+) (*priorityqueue.Queue[[]*terms.DocPointerWithScore], error) {
+	var docInfos []*terms.DocPointerWithScore
+	topKHeap := priorityqueue.NewMinWithId[[]*terms.DocPointerWithScore](limit)
+	worstDist := float64(-10000) // tf score can be negative
+	sort.Sort(results)
+	iterations := 0
+	var firstNonExhausted int
+	pivotID := uint64(0)
+	var pivotPoint int
+	upperBound := float32(0)
+
+	for {
+		iterations++
+
+		if iterations%100000 == 0 && ctx != nil && ctx.Err() != nil {
+			segmentPath := ""
+			terms := ""
+			filterCardinality := -1
+			for _, r := range results {
+				if r == nil {
+					continue
+				}
+				if r.segment != nil {
+					segmentPath = r.segment.path
+					if r.filterDocIds != nil {
+						filterCardinality = r.filterDocIds.GetCardinality()
+					}
+				}
+				terms += r.QueryTerm() + ":" + strconv.Itoa(int(r.IdPointer())) + ":" + strconv.Itoa(r.Count()) + ", "
+			}
+			logger.WithFields(logrus.Fields{
+				"segment":           segmentPath,
+				"iterations":        iterations,
+				"pivotID":           pivotID,
+				"firstNonExhausted": firstNonExhausted,
+				"lenResults":        len(results),
+				"pivotPoint":        pivotPoint,
+				"upperBound":        upperBound,
+				"terms":             terms,
+				"filterCardinality": filterCardinality,
+				"limit":             limit,
+			}).Warnf("DoBlockMaxWand: search timed out, returning partial results")
+			return topKHeap, fmt.Errorf("DoBlockMaxWand: search timed out, returning partial results")
+		}
+
+		cumScore := float64(0)
+		firstNonExhausted = -1
+		pivotID = math.MaxUint64
+
+		for pivotPoint = 0; pivotPoint < len(results); pivotPoint++ {
+			if results[pivotPoint].exhausted {
+				continue
+			}
+			if firstNonExhausted == -1 {
+				firstNonExhausted = pivotPoint
+			}
+			cumScore += float64(results[pivotPoint].Idf())
+			if cumScore >= worstDist {
+				pivotID = results[pivotPoint].idPointer
+				for i := pivotPoint + 1; i < len(results); i++ {
+					if results[i].idPointer != pivotID {
+						break
+					}
+					pivotPoint = i
+				}
+				break
+			}
+		}
+		if firstNonExhausted == -1 || pivotID == math.MaxUint64 {
+			return topKHeap, nil
+		}
+
+		upperBound = float32(0)
+		for i := 0; i <= pivotPoint; i++ {
+			if results[i].exhausted {
+				continue
+			}
+			if results[i].currentBlockMaxId < pivotID {
+				results[i].AdvanceAtLeastShallow(pivotID)
+			}
+			upperBound += results[i].currentBlockImpact
+		}
+
+		if topKHeap.ShouldEnqueue(upperBound, limit) {
+			if additionalExplanations {
+				docInfos = make([]*terms.DocPointerWithScore, termCount)
+			}
+			if pivotID == results[firstNonExhausted].idPointer {
+				score := 0.0
+				termsMatched := 0
+				for _, term := range results {
+					if term.idPointer != pivotID {
+						break
+					}
+					termsMatched++
+					_, s, d := term.Score(averagePropLength, additionalExplanations)
+					score += s
+					upperBound -= term.currentBlockImpact - float32(s)
+
+					if additionalExplanations {
+						docInfos[term.QueryTermIndex()] = d
+					}
+
+				}
+				for _, term := range results {
+					if !term.exhausted && term.idPointer != pivotID {
+						break
+					}
+					term.Advance()
+				}
+				if topKHeap.ShouldEnqueue(float32(score), limit) && termsMatched >= minimumOrTokensMatch {
+					topKHeap.InsertAndPop(pivotID, score, limit, &worstDist, docInfos)
+				}
+
+				sort.Sort(results)
+
+			} else {
+				nextList := pivotPoint
+				for results[nextList].idPointer == pivotID {
+					nextList--
+				}
+				results[nextList].AdvanceAtLeast(pivotID)
+
+				// sort partial
+				for i := nextList + 1; i < len(results); i++ {
+					if results[i].idPointer < results[i-1].idPointer {
+						// swap
+						results[i], results[i-1] = results[i-1], results[i]
+					} else {
+						break
+					}
+				}
+
+			}
+		} else {
+			nextList := pivotPoint
+			maxWeight := results[nextList].Idf()
+
+			for i := 0; i < pivotPoint; i++ {
+				if results[i].Idf() > maxWeight {
+					nextList = i
+					maxWeight = results[i].Idf()
+				}
+			}
+
+			// max uint
+			next := uint64(math.MaxUint64)
+
+			for i := 0; i <= pivotPoint; i++ {
+				if results[i].currentBlockMaxId < next {
+					next = results[i].currentBlockMaxId
+				}
+			}
+
+			next += 1
+
+			if pivotPoint+1 < len(results) && results[pivotPoint+1].idPointer < next {
+				next = results[pivotPoint+1].idPointer
+			}
+
+			if next <= pivotID {
+				next = pivotID + 1
+			}
+			results[nextList].AdvanceAtLeast(next)
+
+			for i := nextList + 1; i < len(results); i++ {
+				if results[i].idPointer < results[i-1].idPointer {
+					// swap
+					results[i], results[i-1] = results[i-1], results[i]
+				} else if results[i].exhausted && i < len(results)-1 {
+					results[i], results[i+1] = results[i+1], results[i]
+				}
+			}
+
+		}
+
+	}
+}
+
+func DoBlockMaxAnd(ctx context.Context, limit int, resultsByTerm Terms, averagePropLength float64, additionalExplanations bool,
+	termCount int, minimumOrTokensMatch int, logger logrus.FieldLogger,
+) *priorityqueue.Queue[[]*terms.DocPointerWithScore] {
+	results := TermsBySize(resultsByTerm)
+	var docInfos []*terms.DocPointerWithScore
+	topKHeap := priorityqueue.NewMinWithId[[]*terms.DocPointerWithScore](limit)
+	worstDist := float64(-10000) // tf score can be negative
+	sort.Sort(results)
+	iterations := 0
+	pivotID := uint64(0)
+	upperBound := float32(0)
+
+	if minimumOrTokensMatch > len(results) {
+		return topKHeap
+	}
+
+	for {
+		iterations++
+
+		if iterations%100000 == 0 && ctx != nil && ctx.Err() != nil {
+			segmentPath := ""
+			terms := ""
+			filterCardinality := -1
+			for _, r := range results {
+				if r == nil {
+					continue
+				}
+				if r.segment != nil {
+					segmentPath = r.segment.path
+					if r.filterDocIds != nil {
+						filterCardinality = r.filterDocIds.GetCardinality()
+					}
+				}
+				terms += r.QueryTerm() + ":" + strconv.Itoa(int(r.IdPointer())) + ":" + strconv.Itoa(r.Count()) + ", "
+			}
+			logger.WithFields(logrus.Fields{
+				"segment":           segmentPath,
+				"iterations":        iterations,
+				"pivotID":           pivotID,
+				"lenResults":        len(results),
+				"upperBound":        upperBound,
+				"terms":             terms,
+				"filterCardinality": filterCardinality,
+				"limit":             limit,
+			}).Warnf("DoBlockMaxAnd: search timed out, returning partial results")
+			return topKHeap
+		}
+
+		for i := 0; i < len(results); i++ {
+			if results[i].exhausted {
+				return topKHeap
+			}
+		}
+
+		results[0].AdvanceAtLeast(pivotID)
+
+		if results[0].idPointer == math.MaxUint64 {
+			return topKHeap
+		}
+
+		pivotID = results[0].idPointer
+
+		for i := 1; i < len(results); i++ {
+			results[i].AdvanceAtLeastShallow(pivotID)
+		}
+
+		upperBound = float32(0)
+		for i := 0; i < len(results); i++ {
+			upperBound += results[i].currentBlockImpact
+		}
+
+		if topKHeap.ShouldEnqueue(upperBound, limit) {
+			isCandidate := true
+			for i := 1; i < len(results); i++ {
+				results[i].AdvanceAtLeast(pivotID)
+				if results[i].idPointer != pivotID {
+					isCandidate = false
+					break
+				}
+			}
+			if isCandidate {
+				score := 0.0
+				if additionalExplanations {
+					docInfos = make([]*terms.DocPointerWithScore, termCount)
+				}
+				for _, term := range results {
+					_, s, d := term.Score(averagePropLength, additionalExplanations)
+					score += s
+					if additionalExplanations {
+						docInfos[term.QueryTermIndex()] = d
+					}
+					term.Advance()
+				}
+				if topKHeap.ShouldEnqueue(float32(score), limit) {
+					topKHeap.InsertAndPop(pivotID, score, limit, &worstDist, docInfos)
+				}
+			} else {
+				pivotID += 1
+			}
+		} else {
+
+			// max uint
+			pivotID = uint64(math.MaxUint64)
+
+			for i := 0; i < len(results); i++ {
+				if results[i].currentBlockMaxId < pivotID {
+					pivotID = results[i].currentBlockMaxId
+				}
+			}
+
+			pivotID += 1
+		}
+	}
+}
+
+func DoWand(limit int, results *terms.Terms, averagePropLength float64, additionalExplanations bool,
+	minimumOrTokensMatch int,
+) *priorityqueue.Queue[[]*terms.DocPointerWithScore] {
+	topKHeap := priorityqueue.NewMinWithId[[]*terms.DocPointerWithScore](limit)
+	worstDist := float64(-10000) // tf score can be negative
+	sort.Sort(results)
+	for {
+
+		if results.CompletelyExhausted() || results.Pivot(worstDist) {
+			return topKHeap
+		}
+
+		id, score, additional, ok := results.ScoreNext(averagePropLength, additionalExplanations, minimumOrTokensMatch)
+		results.SortFull()
+		if topKHeap.ShouldEnqueue(float32(score), limit) && ok {
+			topKHeap.InsertAndPop(id, score, limit, &worstDist, additional)
+		}
+	}
+}
+
+type Terms []*SegmentBlockMax
+
+// provide sort interface for
+func (t Terms) Len() int {
+	return len(t)
+}
+
+func (t Terms) Less(i, j int) bool {
+	return t[i].idPointer < t[j].idPointer
+}
+
+func (t Terms) Swap(i, j int) {
+	t[i], t[j] = t[j], t[i]
+}
+
+type TermsBySize []*SegmentBlockMax
+
+// provide sort interface for
+func (t TermsBySize) Len() int {
+	return len(t)
+}
+
+func (t TermsBySize) Less(i, j int) bool {
+	return t[i].Count() < t[j].Count()
+}
+
+func (t TermsBySize) Swap(i, j int) {
+	t[i], t[j] = t[j], t[i]
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment.go

@@ -0,0 +1,683 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"sync"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+
+	"github.com/pkg/errors"
+
+	"github.com/bits-and-blooms/bloom/v3"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/sroar"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/entities/diskio"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+	entsentry "github.com/weaviate/weaviate/entities/sentry"
+	"github.com/weaviate/weaviate/usecases/memwatch"
+	"github.com/weaviate/weaviate/usecases/mmap"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+)
+
+type Segment interface {
+	getPath() string
+	setPath(path string)
+	getStrategy() segmentindex.Strategy
+	getSecondaryIndexCount() uint16
+	getLevel() uint16
+	getSize() int64
+	setSize(size int64)
+
+	PayloadSize() int
+	close() error
+	get(key []byte) ([]byte, error)
+	getBySecondaryIntoMemory(pos int, key []byte, buffer []byte) ([]byte, []byte, []byte, error)
+	getCollection(key []byte) ([]value, error)
+	getInvertedData() *segmentInvertedData
+	getSegment() *segment
+	isLoaded() bool
+	markForDeletion() error
+	MergeTombstones(other *sroar.Bitmap) (*sroar.Bitmap, error)
+	newCollectionCursor() *segmentCursorCollection
+	newCollectionCursorReusable() *segmentCursorCollectionReusable
+	newCursor() *segmentCursorReplace
+	newCursorWithSecondaryIndex(pos int) *segmentCursorReplace
+	newMapCursor() *segmentCursorMap
+	newNodeReader(offset nodeOffset, operation string) (*nodeReader, error)
+	newRoaringSetCursor() *roaringset.SegmentCursor
+	newRoaringSetRangeCursor() roaringsetrange.SegmentCursor
+	newRoaringSetRangeReader() *roaringsetrange.SegmentReader
+	quantileKeys(q int) [][]byte
+	ReadOnlyTombstones() (*sroar.Bitmap, error)
+	replaceStratParseData(in []byte) ([]byte, []byte, error)
+	roaringSetGet(key []byte, bitmapBufPool roaringset.BitmapBufPool) (roaringset.BitmapLayer, func(), error)
+	roaringSetMergeWith(key []byte, input roaringset.BitmapLayer, bitmapBufPool roaringset.BitmapBufPool) error
+}
+
+type segment struct {
+	path                string
+	metaPaths           []string
+	level               uint16
+	secondaryIndexCount uint16
+	version             uint16
+	segmentStartPos     uint64
+	segmentEndPos       uint64
+	dataStartPos        uint64
+	dataEndPos          uint64
+	contents            []byte
+	contentFile         *os.File
+	strategy            segmentindex.Strategy
+	index               diskIndex
+	secondaryIndices    []diskIndex
+	logger              logrus.FieldLogger
+	metrics             *Metrics
+	size                int64
+	readFromMemory      bool
+	unMapContents       bool
+
+	useBloomFilter        bool // see bucket for more datails
+	bloomFilter           *bloom.BloomFilter
+	secondaryBloomFilters []*bloom.BloomFilter
+	bloomFilterMetrics    *bloomFilterMetrics
+
+	// the net addition this segment adds with respect to all previous segments
+	calcCountNetAdditions bool // see bucket for more datails
+	countNetAdditions     int
+
+	invertedHeader *segmentindex.HeaderInverted
+	invertedData   *segmentInvertedData
+
+	observeMetaWrite diskio.MeteredWriterCallback // used for precomputing meta (cna + bloom)
+}
+
+type diskIndex interface {
+	// Get return lsmkv.NotFound in case no node can be found
+	Get(key []byte) (segmentindex.Node, error)
+
+	// Seek returns lsmkv.NotFound in case the seek value is larger than
+	// the highest value in the collection, otherwise it returns the next highest
+	// value (or the exact value if present)
+	Seek(key []byte) (segmentindex.Node, error)
+
+	Next(key []byte) (segmentindex.Node, error)
+
+	// AllKeys in no specific order, e.g. for building a bloom filter
+	AllKeys() ([][]byte, error)
+
+	// Size of the index in bytes
+	Size() int
+
+	QuantileKeys(q int) [][]byte
+}
+
+type segmentConfig struct {
+	mmapContents                 bool
+	useBloomFilter               bool
+	calcCountNetAdditions        bool
+	overwriteDerived             bool
+	enableChecksumValidation     bool
+	MinMMapSize                  int64
+	allocChecker                 memwatch.AllocChecker
+	fileList                     map[string]int64
+	precomputedCountNetAdditions *int
+	writeMetadata                bool
+}
+
+// newSegment creates a new segment structure, representing an LSM disk segment.
+//
+// This function is partially copied by a function called preComputeSegmentMeta.
+// Any changes made here should likely be made in preComputeSegmentMeta as well,
+// and vice versa. This is absolutely not ideal, but in the short time I was able
+// to consider this, I wasn't able to find a way to unify the two -- there are
+// subtle differences.
+func newSegment(path string, logger logrus.FieldLogger, metrics *Metrics,
+	existsLower existsOnLowerSegmentsFn, cfg segmentConfig,
+) (_ *segment, rerr error) {
+	defer func() {
+		p := recover()
+		if p == nil {
+			return
+		}
+		entsentry.Recover(p)
+		rerr = fmt.Errorf("unexpected error loading segment %q: %v", path, p)
+	}()
+
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("open file: %w", err)
+	}
+
+	// The lifetime of the `file` exceeds this constructor as we store the open file for later use in `contentFile`.
+	// invariant: We close **only** if any error happened after successfully opening the file. To avoid leaking open file descriptor.
+	// NOTE: This `defer` works even with `err` being shadowed in the whole function because defer checks for named `rerr` return value.
+	defer func() {
+		if rerr != nil {
+			file.Close()
+		}
+	}()
+
+	var size int64
+	if cfg.fileList != nil {
+		if fileSize, ok := cfg.fileList[file.Name()]; ok {
+			size = fileSize
+		}
+	}
+
+	// fallback to getting the filesize from disk in case it wasn't prefetched (for example, for new segments after compaction)
+	if size == 0 {
+		fileInfo, err := file.Stat()
+		if err != nil {
+			return nil, fmt.Errorf("stat file: %w", err)
+		}
+		size = fileInfo.Size()
+	}
+
+	// mmap has some overhead, we can read small files directly to memory
+	var contents []byte
+	var unMapContents bool
+	var allocCheckerErr error
+
+	if size <= cfg.MinMMapSize { // check if it is a candidate for full reading
+		if cfg.allocChecker == nil {
+			logger.WithFields(logrus.Fields{
+				"path":        path,
+				"size":        size,
+				"minMMapSize": cfg.MinMMapSize,
+			}).Info("allocChecker is nil, skipping memory pressure check for new segment")
+		} else {
+			allocCheckerErr = cfg.allocChecker.CheckAlloc(size) // check if we have enough memory
+			if allocCheckerErr != nil {
+				logger.Debugf("memory pressure: cannot fully read segment")
+			}
+		}
+	}
+
+	useBloomFilter := cfg.useBloomFilter
+	readFromMemory := cfg.mmapContents
+	if size > cfg.MinMMapSize || cfg.allocChecker == nil || allocCheckerErr != nil { // mmap the file if it's too large or if we have memory pressure
+		contents2, err := mmap.MapRegion(file, int(size), mmap.RDONLY, 0, 0)
+		if err != nil {
+			return nil, fmt.Errorf("mmap file: %w", err)
+		}
+		contents = contents2
+		unMapContents = true
+	} else { // read the file into memory if it's small enough and we have enough memory
+		meteredF := diskio.NewMeteredReader(file, diskio.MeteredReaderCallback(metrics.ReadObserver("readSegmentFile")))
+		bufio.NewReader(meteredF)
+		contents, err = io.ReadAll(meteredF)
+		if err != nil {
+			return nil, fmt.Errorf("read file: %w", err)
+		}
+		unMapContents = false
+		readFromMemory = true
+		useBloomFilter = false
+	}
+	header, err := segmentindex.ParseHeader(contents[:segmentindex.HeaderSize])
+	if err != nil {
+		return nil, fmt.Errorf("parse header: %w", err)
+	}
+
+	if err := segmentindex.CheckExpectedStrategy(header.Strategy); err != nil {
+		return nil, fmt.Errorf("unsupported strategy in segment: %w", err)
+	}
+
+	if header.Version >= segmentindex.SegmentV1 && cfg.enableChecksumValidation {
+		file.Seek(0, io.SeekStart)
+		headerSize := int64(segmentindex.HeaderSize)
+		if header.Strategy == segmentindex.StrategyInverted {
+			headerSize += int64(segmentindex.HeaderInvertedSize)
+		}
+		segmentFile := segmentindex.NewSegmentFile(segmentindex.WithReader(file))
+		if err := segmentFile.ValidateChecksum(size, headerSize); err != nil {
+			return nil, fmt.Errorf("validate segment %q: %w", path, err)
+		}
+	}
+
+	primaryIndex, err := header.PrimaryIndex(contents)
+	if err != nil {
+		return nil, fmt.Errorf("extract primary index position: %w", err)
+	}
+
+	// if there are no secondary indices and checksum validation is enabled,
+	// we need to remove the checksum bytes from the primary index
+	// See below for the same logic if there are secondary indices
+	if header.Version >= segmentindex.SegmentV1 && cfg.enableChecksumValidation && header.SecondaryIndices == 0 {
+		primaryIndex = primaryIndex[:len(primaryIndex)-segmentindex.ChecksumSize]
+	}
+
+	primaryDiskIndex := segmentindex.NewDiskTree(primaryIndex)
+
+	dataStartPos := uint64(segmentindex.HeaderSize)
+	dataEndPos := header.IndexStart
+
+	var invertedHeader *segmentindex.HeaderInverted
+	if header.Strategy == segmentindex.StrategyInverted {
+		invertedHeader, err = segmentindex.LoadHeaderInverted(contents[segmentindex.HeaderSize : segmentindex.HeaderSize+segmentindex.HeaderInvertedSize])
+		if err != nil {
+			return nil, errors.Wrap(err, "load inverted header")
+		}
+		dataStartPos = invertedHeader.KeysOffset
+		dataEndPos = invertedHeader.TombstoneOffset
+	}
+
+	stratLabel := header.Strategy.String()
+	observeWrite := monitoring.GetMetrics().FileIOWrites.With(prometheus.Labels{
+		"strategy":  stratLabel,
+		"operation": "segmentMetadata",
+	})
+
+	if unMapContents {
+		// a map was created, track it
+		monitoring.GetMetrics().MmapOperations.With(prometheus.Labels{
+			"operation": "mmap",
+			"strategy":  stratLabel,
+		}).Inc()
+	}
+
+	seg := &segment{
+		level:                 header.Level,
+		path:                  path,
+		contents:              contents,
+		version:               header.Version,
+		secondaryIndexCount:   header.SecondaryIndices,
+		segmentStartPos:       header.IndexStart,
+		segmentEndPos:         uint64(size),
+		strategy:              header.Strategy,
+		dataStartPos:          dataStartPos,
+		dataEndPos:            dataEndPos,
+		index:                 primaryDiskIndex,
+		logger:                logger,
+		metrics:               metrics,
+		size:                  size,
+		readFromMemory:        readFromMemory,
+		useBloomFilter:        useBloomFilter,
+		calcCountNetAdditions: cfg.calcCountNetAdditions,
+		invertedHeader:        invertedHeader,
+		invertedData: &segmentInvertedData{
+			tombstones: sroar.NewBitmap(),
+		},
+		unMapContents:    unMapContents,
+		observeMetaWrite: func(n int64) { observeWrite.Observe(float64(n)) },
+	}
+
+	// Using pread strategy requires file to remain open for segment lifetime
+	if seg.readFromMemory {
+		defer file.Close()
+	} else {
+		seg.contentFile = file
+	}
+
+	if seg.secondaryIndexCount > 0 {
+		seg.secondaryIndices = make([]diskIndex, seg.secondaryIndexCount)
+		for i := range seg.secondaryIndices {
+			secondary, err := header.SecondaryIndex(contents, uint16(i))
+			if err != nil {
+				return nil, fmt.Errorf("get position for secondary index at %d: %w", i, err)
+			}
+			// if we are on the last secondary index and checksum validation is enabled,
+			// we need to remove the checksum bytes from the secondary index
+			if header.Version >= segmentindex.SegmentV1 && cfg.enableChecksumValidation && i == int(seg.secondaryIndexCount-1) {
+				secondary = secondary[:len(secondary)-segmentindex.ChecksumSize]
+			}
+			seg.secondaryIndices[i] = segmentindex.NewDiskTree(secondary)
+		}
+	}
+
+	metadataRead, err := seg.initMetadata(metrics, cfg.overwriteDerived, existsLower, cfg.precomputedCountNetAdditions, cfg.fileList, cfg.writeMetadata)
+	if err != nil {
+		return nil, fmt.Errorf("init metadata: %w", err)
+	}
+
+	if !metadataRead {
+		if seg.useBloomFilter {
+			if err := seg.initBloomFilters(metrics, cfg.overwriteDerived, cfg.fileList); err != nil {
+				return nil, err
+			}
+		}
+		if seg.calcCountNetAdditions {
+			if err := seg.initCountNetAdditions(existsLower, cfg.overwriteDerived, cfg.precomputedCountNetAdditions, cfg.fileList); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	if seg.strategy == segmentindex.StrategyInverted {
+		_, err := seg.loadTombstones()
+		if err != nil {
+			return nil, fmt.Errorf("load tombstones: %w", err)
+		}
+
+		_, err = seg.loadPropertyLengths()
+		if err != nil {
+			return nil, fmt.Errorf("load property lengths: %w", err)
+		}
+
+	}
+
+	return seg, nil
+}
+
+func (s *segment) close() error {
+	var munmapErr, fileCloseErr error
+	if s.unMapContents {
+		m := mmap.MMap(s.contents)
+		munmapErr = m.Unmap()
+		stratLabel := s.strategy.String()
+		monitoring.GetMetrics().MmapOperations.With(prometheus.Labels{
+			"operation": "munmap",
+			"strategy":  stratLabel,
+		}).Inc()
+	}
+	if s.contentFile != nil {
+		fileCloseErr = s.contentFile.Close()
+	}
+
+	if munmapErr != nil || fileCloseErr != nil {
+		return fmt.Errorf("close segment: munmap: %w, close contents file: %w", munmapErr, fileCloseErr)
+	}
+
+	return nil
+}
+
+func (s *segment) dropImmediately() error {
+	// support for persisting bloom filters and cnas was added in v1.17,
+	// therefore the files may not be present on segments created with previous
+	// versions. By using RemoveAll, which does not error on NotExists, these
+	// drop calls are backward-compatible:
+	if err := os.RemoveAll(s.bloomFilterPath()); err != nil {
+		return fmt.Errorf("drop bloom filter: %w", err)
+	}
+
+	for i := 0; i < int(s.secondaryIndexCount); i++ {
+		if err := os.RemoveAll(s.bloomFilterSecondaryPath(i)); err != nil {
+			return fmt.Errorf("drop bloom filter: %w", err)
+		}
+	}
+
+	if err := os.RemoveAll(s.countNetPath()); err != nil {
+		return fmt.Errorf("drop count net additions file: %w", err)
+	}
+
+	if err := os.RemoveAll(s.metadataPath()); err != nil {
+		return fmt.Errorf("drop metadata file: %w", err)
+	}
+
+	// for the segment itself, we're not using RemoveAll, but Remove. If there
+	// was a NotExists error here, something would be seriously wrong, and we
+	// don't want to ignore it.
+	if err := os.Remove(s.path); err != nil {
+		return fmt.Errorf("drop segment: %w", err)
+	}
+
+	return nil
+}
+
+func (s *segment) dropMarked() error {
+	// support for persisting bloom filters and cnas was added in v1.17,
+	// therefore the files may not be present on segments created with previous
+	// versions. By using RemoveAll, which does not error on NotExists, these
+	// drop calls are backward-compatible:
+	if err := os.RemoveAll(s.bloomFilterPath() + DeleteMarkerSuffix); err != nil {
+		return fmt.Errorf("drop previously marked bloom filter: %w", err)
+	}
+
+	for i := 0; i < int(s.secondaryIndexCount); i++ {
+		if err := os.RemoveAll(s.bloomFilterSecondaryPath(i) + DeleteMarkerSuffix); err != nil {
+			return fmt.Errorf("drop previously marked secondary bloom filter: %w", err)
+		}
+	}
+
+	if err := os.RemoveAll(s.countNetPath() + DeleteMarkerSuffix); err != nil {
+		return fmt.Errorf("drop previously marked count net additions file: %w", err)
+	}
+
+	if err := os.RemoveAll(s.metadataPath() + DeleteMarkerSuffix); err != nil {
+		return fmt.Errorf("drop previously marked metadata file: %w", err)
+	}
+
+	// for the segment itself, we're not using RemoveAll, but Remove. If there
+	// was a NotExists error here, something would be seriously wrong, and we
+	// don't want to ignore it.
+	if err := os.Remove(s.path + DeleteMarkerSuffix); err != nil {
+		return fmt.Errorf("drop previously marked segment: %w", err)
+	}
+
+	return nil
+}
+
+const DeleteMarkerSuffix = ".deleteme"
+
+func markDeleted(path string) error {
+	return os.Rename(path, path+DeleteMarkerSuffix)
+}
+
+func (s *segment) markForDeletion() error {
+	// support for persisting bloom filters and cnas was added in v1.17,
+	// therefore the files may not be present on segments created with previous
+	// versions. If we get a not exist error, we ignore it.
+	if err := markDeleted(s.bloomFilterPath()); err != nil {
+		if !os.IsNotExist(err) {
+			return fmt.Errorf("mark bloom filter deleted: %w", err)
+		}
+	}
+
+	for i := 0; i < int(s.secondaryIndexCount); i++ {
+		if err := markDeleted(s.bloomFilterSecondaryPath(i)); err != nil {
+			if !os.IsNotExist(err) {
+				return fmt.Errorf("mark secondary bloom filter deleted: %w", err)
+			}
+		}
+	}
+
+	if err := markDeleted(s.countNetPath()); err != nil {
+		if !os.IsNotExist(err) {
+			return fmt.Errorf("mark count net additions file deleted: %w", err)
+		}
+	}
+
+	if err := markDeleted(s.metadataPath()); err != nil {
+		if !os.IsNotExist(err) {
+			return fmt.Errorf("mark metadata file deleted: %w", err)
+		}
+	}
+
+	// for the segment itself, we're not accepting a NotExists error. If there
+	// was a NotExists error here, something would be seriously wrong, and we
+	// don't want to ignore it.
+	if err := markDeleted(s.path); err != nil {
+		return fmt.Errorf("mark segment deleted: %w", err)
+	}
+
+	return nil
+}
+
+// Size returns the total size of the segment in bytes, including the header
+// and index
+func (s *segment) Size() int {
+	return int(s.size)
+}
+
+func (s *segment) getPath() string {
+	return s.path
+}
+
+func (s *segment) setPath(path string) {
+	s.path = path
+}
+
+func (s *segment) getStrategy() segmentindex.Strategy {
+	return s.strategy
+}
+
+func (s *segment) getSecondaryIndexCount() uint16 {
+	return s.secondaryIndexCount
+}
+
+func (s *segment) getCountNetAdditions() int {
+	return s.countNetAdditions
+}
+
+func (s *segment) getLevel() uint16 {
+	return s.level
+}
+
+func (s *segment) getSize() int64 {
+	return s.size
+}
+
+func (s *segment) setSize(size int64) {
+	s.size = size
+}
+
+func (s *segment) getInvertedData() *segmentInvertedData {
+	return s.invertedData
+}
+
+func (s *segment) getSegment() *segment {
+	return s
+}
+
+func (s *segment) isLoaded() bool {
+	return true
+}
+
+// PayloadSize is only the payload of the index, excluding the index
+func (s *segment) PayloadSize() int {
+	return int(s.dataEndPos)
+}
+
+type nodeReader struct {
+	r         io.Reader
+	releaseFn func()
+}
+
+func (n *nodeReader) Read(b []byte) (int, error) {
+	if n.r == nil {
+		panic("nodeReader.Read called after Release")
+	}
+	return n.r.Read(b)
+}
+
+func (n *nodeReader) Release() {
+	n.r = nil
+	n.releaseFn()
+}
+
+type nodeOffset struct {
+	start, end uint64
+}
+
+func (s *segment) newNodeReader(offset nodeOffset, operation string) (*nodeReader, error) {
+	var (
+		r       io.Reader
+		err     error
+		release = func() {} // no-op function for un-pooled readers
+	)
+
+	if s.readFromMemory {
+		contents := s.contents[offset.start:]
+		if offset.end != 0 {
+			contents = s.contents[offset.start:offset.end]
+		}
+		r, err = s.bytesReaderFrom(contents)
+	} else {
+		r, release, err = s.bufferedReaderAt(offset.start, "ReadFromSegment"+operation)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("new nodeReader: %w", err)
+	}
+	return &nodeReader{r: r, releaseFn: release}, nil
+}
+
+func (s *segment) copyNode(b []byte, offset nodeOffset) error {
+	if s.readFromMemory {
+		copy(b, s.contents[offset.start:offset.end])
+		return nil
+	}
+	n, err := s.newNodeReader(offset, "copyNode")
+	if err != nil {
+		return fmt.Errorf("copy node: %w", err)
+	}
+	defer n.Release()
+
+	_, err = io.ReadFull(n, b)
+	return err
+}
+
+func (s *segment) bytesReaderFrom(in []byte) (*bytes.Reader, error) {
+	if len(in) == 0 {
+		return nil, lsmkv.NotFound
+	}
+	return bytes.NewReader(in), nil
+}
+
+func (s *segment) bufferedReaderAt(offset uint64, operation string) (io.Reader, func(), error) {
+	if s.contentFile == nil {
+		return nil, nil, fmt.Errorf("nil contentFile for segment at %s", s.path)
+	}
+
+	meteredF := diskio.NewMeteredReader(s.contentFile, diskio.MeteredReaderCallback(readObserver.GetOrCreate(operation, s.metrics)))
+	r := io.NewSectionReader(meteredF, int64(offset), s.size)
+
+	bufioR := bufReaderPool.Get().(*bufio.Reader)
+	bufioR.Reset(r)
+
+	releaseFn := func() {
+		bufReaderPool.Put(bufioR)
+	}
+
+	return bufioR, releaseFn, nil
+}
+
+var (
+	bufReaderPool *sync.Pool
+	readObserver  *readObserverCache
+)
+
+func init() {
+	bufReaderPool = &sync.Pool{
+		New: func() interface{} {
+			return bufio.NewReader(nil)
+		},
+	}
+
+	readObserver = &readObserverCache{}
+}
+
+type readObserverCache struct {
+	sync.Map
+}
+
+// GetOrCreate returns a BytesReadObserver for the given key if it exists or
+// creates one if it doesn't.
+//
+// Note that the design is not atomic, so it is possible that a single key will
+// be initialize multiple times. This is not a problem, it only adds a slight
+// re-allocation penalty, but does not alter the behavior
+func (c *readObserverCache) GetOrCreate(key string, metrics *Metrics) BytesReadObserver {
+	if v, ok := c.Load(key); ok {
+		return v.(BytesReadObserver)
+	}
+
+	observer := metrics.ReadObserver(key)
+	c.Store(key, observer)
+	return observer
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_blockmax.go

@@ -0,0 +1,603 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"encoding/binary"
+	"io"
+	"math"
+
+	"github.com/weaviate/sroar"
+	"github.com/weaviate/weaviate/adapters/repos/db/helpers"
+	"github.com/weaviate/weaviate/adapters/repos/db/inverted/terms"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/varenc"
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+var blockMaxBufferSize = 4096
+
+func (s *segment) loadBlockEntries(node segmentindex.Node) ([]*terms.BlockEntry, uint64, *terms.BlockDataDecoded, error) {
+	var buf []byte
+	if s.readFromMemory {
+		buf = s.contents[node.Start : node.Start+uint64(8+12*terms.ENCODE_AS_FULL_BYTES)]
+	} else {
+		// read first 8 bytes to get
+		buf = make([]byte, 8+12*terms.ENCODE_AS_FULL_BYTES)
+		r, err := s.newNodeReader(nodeOffset{node.Start, node.Start + uint64(8+12*terms.ENCODE_AS_FULL_BYTES)}, "loadBMW")
+		if err != nil {
+			return nil, 0, nil, err
+		}
+		defer r.Release()
+
+		_, err = r.Read(buf)
+		if err != nil {
+			return nil, 0, nil, err
+		}
+	}
+
+	docCount := binary.LittleEndian.Uint64(buf)
+
+	if docCount <= uint64(terms.ENCODE_AS_FULL_BYTES) {
+		data := convertFixedLengthFromMemory(buf, int(docCount))
+		entries := make([]*terms.BlockEntry, 1)
+		propLength := s.invertedData.propertyLengths[data.DocIds[0]]
+		tf := data.Tfs[0]
+		entries[0] = &terms.BlockEntry{
+			Offset:              0,
+			MaxId:               data.DocIds[len(data.DocIds)-1],
+			MaxImpactTf:         uint32(tf),
+			MaxImpactPropLength: uint32(propLength),
+		}
+
+		return entries, docCount, data, nil
+	}
+
+	blockCount := (docCount + uint64(terms.BLOCK_SIZE-1)) / uint64(terms.BLOCK_SIZE)
+
+	entries := make([]*terms.BlockEntry, blockCount)
+	if s.readFromMemory {
+		buf = s.contents[node.Start+16 : node.Start+16+uint64(blockCount*20)]
+	} else {
+		r, err := s.newNodeReader(nodeOffset{node.Start + 16, node.Start + 16 + uint64(blockCount*20)}, "loadBMW")
+		if err != nil {
+			return nil, 0, nil, err
+		}
+		defer r.Release()
+
+		buf = make([]byte, blockCount*20)
+		_, err = r.Read(buf)
+		if err != nil {
+			return nil, 0, nil, err
+		}
+	}
+
+	for i := 0; i < int(blockCount); i++ {
+		entries[i] = terms.DecodeBlockEntry(buf[i*20 : (i+1)*20])
+	}
+
+	return entries, docCount, nil, nil
+}
+
+// todo: check if there is a performance impact of starting to sectionReader at offset and not have to pass offset here
+func (s *segment) loadBlockDataReusable(sectionReader *io.SectionReader, blockDataBufferOffset, offset, offsetStart, offsetEnd uint64, buf []byte, encoded *terms.BlockData) (uint64, error) {
+	if s.readFromMemory {
+		terms.DecodeBlockDataReusable(s.contents[offsetStart:offsetEnd], encoded)
+		return offsetStart, nil
+	} else {
+		if offsetStart < blockDataBufferOffset || offsetEnd > blockDataBufferOffset+uint64(len(buf)) {
+			sectionReader.Seek(int64(offsetStart-offset), io.SeekStart)
+			_, err := sectionReader.Read(buf)
+			// EOF is expected when the last block + tree are smaller than the buffer
+			if err != nil && err.Error() != "EOF" {
+				return 0, err
+			}
+			// readBytes += int64(n)
+			// readCounts++
+			blockDataBufferOffset = offsetStart
+		}
+
+		bufOffsetStart := offsetStart - blockDataBufferOffset
+		bufOffsetEnd := offsetEnd - blockDataBufferOffset
+		terms.DecodeBlockDataReusable(buf[bufOffsetStart:bufOffsetEnd], encoded)
+		return blockDataBufferOffset, nil
+	}
+}
+
+type BlockMetrics struct {
+	BlockCountTotal         uint64
+	BlockCountDecodedDocIds uint64
+	BlockCountDecodedFreqs  uint64
+	DocCountTotal           uint64
+	DocCountDecodedDocIds   uint64
+	DocCountDecodedFreqs    uint64
+	DocCountScored          uint64
+	QueryCount              uint64
+	LastAddedBlock          int
+}
+
+type SegmentBlockMax struct {
+	segment               *segment
+	node                  segmentindex.Node
+	docCount              uint64
+	blockEntries          []*terms.BlockEntry
+	blockEntryIdx         int
+	blockDataBufferOffset uint64
+	blockDataBuffer       []byte
+	blockDataEncoded      *terms.BlockData
+	blockDataDecoded      *terms.BlockDataDecoded
+	blockDataIdx          int
+	blockDataSize         int
+	blockDataStartOffset  uint64
+	blockDataEndOffset    uint64
+	idPointer             uint64
+	idf                   float64
+	exhausted             bool
+	decoded               bool
+	freqDecoded           bool
+	queryTermIndex        int
+	Metrics               BlockMetrics
+	averagePropLength     float64
+	b                     float64
+	k1                    float64
+	propertyBoost         float64
+
+	currentBlockImpact float32
+	currentBlockMaxId  uint64
+	tombstones         *sroar.Bitmap
+	filterDocIds       *sroar.Bitmap
+
+	// at position 0 we have the doc ids decoder, at position 1 is the tfs decoder
+	decoders []varenc.VarEncEncoder[uint64]
+
+	propLengths    map[uint64]uint32
+	blockDatasTest []*terms.BlockData
+
+	sectionReader *io.SectionReader
+}
+
+func generateSingleFilter(tombstones *sroar.Bitmap, filterDocIds helpers.AllowList) (*sroar.Bitmap, *sroar.Bitmap) {
+	if tombstones != nil && tombstones.IsEmpty() {
+		tombstones = nil
+	}
+
+	var filterSroar *sroar.Bitmap
+	// if we don't have an allow list filter, tombstones are the only needed filter
+	if filterDocIds != nil {
+		// the ok check should always succeed, but we keep it for safety
+		bm, ok := filterDocIds.(*helpers.BitmapAllowList)
+		// if we have a (allow list) filter and a (block list) tombstones filter, we can combine them into a single allowlist filter filter
+		if ok && tombstones != nil {
+			filterSroar = bm.Bm.AndNot(tombstones)
+			tombstones = nil
+		} else if ok && tombstones == nil {
+			filterSroar = bm.Bm
+		}
+	}
+	return tombstones, filterSroar
+}
+
+func NewSegmentBlockMax(s *segment, key []byte, queryTermIndex int, idf float64, propertyBoost float32, tombstones *sroar.Bitmap, filterDocIds helpers.AllowList, averagePropLength float64, config schema.BM25Config) *SegmentBlockMax {
+	node, err := s.index.Get(key)
+	if err != nil {
+		return nil
+	}
+
+	tombstones, filterSroar := generateSingleFilter(tombstones, filterDocIds)
+
+	// if filter is empty after checking for tombstones,
+	// we can skip it and return nil for the segment
+	if filterSroar != nil && filterSroar.IsEmpty() {
+		return nil
+	}
+
+	codecs := s.invertedHeader.DataFields
+	decoders := make([]varenc.VarEncEncoder[uint64], len(codecs))
+
+	for i, codec := range codecs {
+		decoders[i] = varenc.GetVarEncEncoder64(codec)
+		decoders[i].Init(terms.BLOCK_SIZE)
+	}
+
+	var sectionReader *io.SectionReader
+
+	if !s.readFromMemory {
+		sectionReader = io.NewSectionReader(s.contentFile, int64(node.Start), int64(node.End))
+	}
+
+	output := &SegmentBlockMax{
+		segment:           s,
+		node:              node,
+		idf:               idf,
+		queryTermIndex:    queryTermIndex,
+		averagePropLength: averagePropLength,
+
+		b:             config.B,
+		k1:            config.K1,
+		decoders:      decoders,
+		propertyBoost: float64(propertyBoost),
+		filterDocIds:  filterSroar,
+		tombstones:    tombstones,
+		sectionReader: sectionReader,
+	}
+
+	err = output.reset()
+	if err != nil {
+		return nil
+	}
+	output.Metrics.BlockCountTotal += uint64(len(output.blockEntries))
+	output.Metrics.DocCountTotal += output.docCount
+	output.Metrics.LastAddedBlock = -1
+
+	return output
+}
+
+func NewSegmentBlockMaxTest(docCount uint64, blockEntries []*terms.BlockEntry, blockDatas []*terms.BlockData, propLengths map[uint64]uint32, key []byte, queryTermIndex int, idf float64, propertyBoost float32, tombstones *sroar.Bitmap, filterDocIds helpers.AllowList, averagePropLength float64, config schema.BM25Config, codecs []varenc.VarEncDataType) *SegmentBlockMax {
+	decoders := make([]varenc.VarEncEncoder[uint64], len(codecs))
+
+	for i, codec := range codecs {
+		decoders[i] = varenc.GetVarEncEncoder64(codec)
+	}
+
+	tombstones, filterSroar := generateSingleFilter(tombstones, filterDocIds)
+
+	// if filter is empty after checking for tombstones,
+	// we can skip it and return nil for the segment
+	if filterSroar != nil && filterSroar.IsEmpty() {
+		return nil
+	}
+
+	output := &SegmentBlockMax{
+		blockEntries:      blockEntries,
+		node:              segmentindex.Node{Key: key},
+		idf:               idf,
+		queryTermIndex:    queryTermIndex,
+		averagePropLength: averagePropLength,
+		b:                 config.B,
+		k1:                config.K1,
+		decoders:          decoders,
+		propertyBoost:     float64(propertyBoost),
+		filterDocIds:      filterSroar,
+		tombstones:        tombstones,
+		propLengths:       propLengths,
+		blockDatasTest:    blockDatas,
+		blockEntryIdx:     0,
+		blockDataIdx:      0,
+		docCount:          docCount,
+		blockDataDecoded: &terms.BlockDataDecoded{
+			DocIds: make([]uint64, terms.BLOCK_SIZE),
+			Tfs:    make([]uint64, terms.BLOCK_SIZE),
+		},
+	}
+
+	output.decodeBlock()
+
+	output.advanceOnTombstoneOrFilter()
+
+	output.Metrics.BlockCountTotal += uint64(len(output.blockEntries))
+	output.Metrics.DocCountTotal += output.docCount
+	output.Metrics.LastAddedBlock = -1
+
+	return output
+}
+
+func NewSegmentBlockMaxDecoded(key []byte, queryTermIndex int, propertyBoost float32, filterDocIds helpers.AllowList, averagePropLength float64, config schema.BM25Config) *SegmentBlockMax {
+	_, filterSroar := generateSingleFilter(nil, filterDocIds)
+
+	output := &SegmentBlockMax{
+		queryTermIndex:    queryTermIndex,
+		node:              segmentindex.Node{Key: key},
+		averagePropLength: averagePropLength,
+		b:                 config.B,
+		k1:                config.K1,
+		propertyBoost:     float64(propertyBoost),
+		filterDocIds:      filterSroar,
+		blockEntryIdx:     0,
+		blockDataIdx:      0,
+		decoded:           true,
+		freqDecoded:       true,
+		exhausted:         true,
+	}
+
+	output.Metrics.BlockCountTotal += uint64(len(output.blockEntries))
+	output.Metrics.DocCountTotal += output.docCount
+	output.Metrics.LastAddedBlock = -1
+
+	return output
+}
+
+func (s *SegmentBlockMax) advanceOnTombstoneOrFilter() {
+	if (s.filterDocIds == nil && s.tombstones == nil) || s.exhausted {
+		if !s.exhausted {
+			s.idPointer = s.blockDataDecoded.DocIds[s.blockDataIdx]
+		}
+		return
+	}
+
+	for (s.filterDocIds != nil && !s.filterDocIds.Contains(s.blockDataDecoded.DocIds[s.blockDataIdx])) ||
+		(s.tombstones != nil && s.tombstones.Contains(s.blockDataDecoded.DocIds[s.blockDataIdx])) {
+		s.blockDataIdx++
+		if s.blockDataIdx > s.blockDataSize-1 {
+			if s.blockEntryIdx >= len(s.blockEntries)-1 {
+				s.exhaust()
+				return
+			}
+			s.blockEntryIdx++
+			s.blockDataIdx = 0
+			s.decodeBlock()
+		}
+	}
+
+	if !s.exhausted {
+		s.idPointer = s.blockDataDecoded.DocIds[s.blockDataIdx]
+	}
+}
+
+func (s *SegmentBlockMax) reset() error {
+	var err error
+
+	s.propLengths, err = s.segment.GetPropertyLengths()
+	if err != nil {
+		return err
+	}
+
+	s.blockEntries, s.docCount, s.blockDataDecoded, err = s.segment.loadBlockEntries(s.node)
+	if err != nil {
+		return err
+	}
+
+	if s.blockDataDecoded == nil {
+		s.blockDataBuffer = make([]byte, blockMaxBufferSize)
+		s.blockDataDecoded = &terms.BlockDataDecoded{
+			DocIds: make([]uint64, terms.BLOCK_SIZE),
+			Tfs:    make([]uint64, terms.BLOCK_SIZE),
+		}
+		s.blockDataEncoded = &terms.BlockData{}
+	}
+
+	s.blockEntryIdx = 0
+	s.blockDataIdx = 0
+	s.blockDataStartOffset = s.node.Start + 16 + uint64(len(s.blockEntries)*20)
+	s.blockDataEndOffset = s.node.End - uint64(len(s.node.Key)+4)
+
+	s.blockDataBufferOffset = s.blockDataStartOffset + 1
+	s.decodeBlock()
+
+	s.advanceOnTombstoneOrFilter()
+
+	return nil
+}
+
+func (s *SegmentBlockMax) decodeBlock() error {
+	if s.exhausted {
+		return nil
+	}
+
+	var err error
+	if s.blockEntries == nil {
+		return nil
+	}
+
+	if s.blockEntryIdx >= len(s.blockEntries) {
+		s.exhaust()
+		return nil
+	}
+
+	s.blockDataIdx = 0
+	if s.docCount <= uint64(terms.ENCODE_AS_FULL_BYTES) {
+		s.idPointer = s.blockDataDecoded.DocIds[s.blockDataIdx]
+		s.blockDataSize = int(s.docCount)
+		s.freqDecoded = true
+		s.decoded = true
+		s.Metrics.BlockCountDecodedDocIds++
+		s.Metrics.DocCountDecodedDocIds += uint64(s.blockDataSize)
+		return nil
+	}
+	if s.segment != nil {
+		startOffset := uint64(s.blockEntries[s.blockEntryIdx].Offset) + s.blockDataStartOffset
+		endOffset := s.blockDataEndOffset
+
+		if s.blockEntryIdx < len(s.blockEntries)-1 {
+			endOffset = uint64(s.blockEntries[s.blockEntryIdx+1].Offset) + s.blockDataStartOffset
+		}
+		s.blockDataBufferOffset, err = s.segment.loadBlockDataReusable(s.sectionReader, s.blockDataBufferOffset, s.node.Start, startOffset, endOffset, s.blockDataBuffer, s.blockDataEncoded)
+		if err != nil {
+			return err
+		}
+	} else {
+		s.blockDataEncoded = s.blockDatasTest[s.blockEntryIdx]
+	}
+
+	s.blockDataSize = terms.BLOCK_SIZE
+	if s.blockEntryIdx == len(s.blockEntries)-1 {
+		s.blockDataSize = int(s.docCount) - terms.BLOCK_SIZE*s.blockEntryIdx
+	}
+	s.decoders[0].DecodeReusable(s.blockDataEncoded.DocIds, s.blockDataDecoded.DocIds[:s.blockDataSize])
+	s.Metrics.BlockCountDecodedDocIds++
+	s.Metrics.DocCountDecodedDocIds += uint64(s.blockDataSize)
+	s.idPointer = s.blockDataDecoded.DocIds[s.blockDataIdx]
+	s.freqDecoded = false
+	s.decoded = true
+	s.currentBlockImpact = s.computeCurrentBlockImpact()
+	s.currentBlockMaxId = s.blockEntries[s.blockEntryIdx].MaxId
+	return nil
+}
+
+func (s *SegmentBlockMax) AdvanceAtLeast(docId uint64) {
+	if s.exhausted {
+		return
+	}
+
+	for s.blockEntryIdx < len(s.blockEntries) && docId > s.blockEntries[s.blockEntryIdx].MaxId {
+		s.blockEntryIdx++
+		s.decoded = false
+		s.freqDecoded = false
+	}
+
+	if (s.blockEntryIdx == len(s.blockEntries)-1 && docId > s.blockEntries[s.blockEntryIdx].MaxId) || s.blockEntryIdx >= len(s.blockEntries) {
+		s.exhaust()
+		return
+	}
+
+	if !s.decoded {
+		s.decodeBlock()
+	}
+
+	for s.blockDataIdx < s.blockDataSize-1 && docId > s.blockDataDecoded.DocIds[s.blockDataIdx] {
+		s.blockDataIdx++
+	}
+
+	s.advanceOnTombstoneOrFilter()
+}
+
+func (s *SegmentBlockMax) AdvanceAtLeastShallow(docId uint64) {
+	if s.exhausted {
+		return
+	}
+	if docId <= s.blockEntries[s.blockEntryIdx].MaxId {
+		return
+	}
+
+	for s.blockEntryIdx < len(s.blockEntries) && docId > s.blockEntries[s.blockEntryIdx].MaxId {
+
+		s.blockEntryIdx++
+		s.blockDataIdx = 0
+		s.decoded = false
+		s.freqDecoded = false
+		if s.blockEntryIdx >= len(s.blockEntries) {
+			s.exhaust()
+			return
+		}
+	}
+
+	if (s.blockEntryIdx == len(s.blockEntries)-1 && docId > s.blockEntries[s.blockEntryIdx].MaxId) || s.blockEntryIdx >= len(s.blockEntries) {
+		s.exhaust()
+		return
+	}
+	s.idPointer = s.blockEntries[s.blockEntryIdx-1].MaxId
+	s.currentBlockMaxId = s.blockEntries[s.blockEntryIdx].MaxId
+	s.currentBlockImpact = s.computeCurrentBlockImpact()
+}
+
+func (s *SegmentBlockMax) Idf() float64 {
+	return s.idf
+}
+
+func (s *SegmentBlockMax) IdPointer() uint64 {
+	return s.idPointer
+}
+
+func (s *SegmentBlockMax) Exhausted() bool {
+	return s.exhausted
+}
+
+func (s *SegmentBlockMax) Count() int {
+	return int(s.docCount)
+}
+
+func (s *SegmentBlockMax) QueryTermIndex() int {
+	return s.queryTermIndex
+}
+
+func (s *SegmentBlockMax) QueryTerm() string {
+	return string(s.node.Key)
+}
+
+func (s *SegmentBlockMax) Score(averagePropLength float64, additionalExplanation bool) (uint64, float64, *terms.DocPointerWithScore) {
+	if s.exhausted {
+		return 0, 0, nil
+	}
+
+	var doc *terms.DocPointerWithScore
+
+	if !s.freqDecoded {
+		s.decoders[1].DecodeReusable(s.blockDataEncoded.Tfs, s.blockDataDecoded.Tfs[:s.blockDataSize])
+		s.freqDecoded = true
+	}
+
+	freq := float64(s.blockDataDecoded.Tfs[s.blockDataIdx])
+	propLength := s.propLengths[s.idPointer]
+	tf := freq / (freq + s.k1*((1-s.b)+s.b*(float64(propLength)/s.averagePropLength)))
+	s.Metrics.DocCountScored++
+	if s.blockEntryIdx != s.Metrics.LastAddedBlock {
+		s.Metrics.BlockCountDecodedFreqs++
+		s.Metrics.DocCountDecodedFreqs += uint64(s.blockDataSize)
+		s.Metrics.LastAddedBlock = s.blockEntryIdx
+	}
+
+	if additionalExplanation {
+		doc = &terms.DocPointerWithScore{
+			Id:         s.idPointer,
+			Frequency:  float32(freq),
+			PropLength: float32(propLength),
+		}
+	}
+	score := tf * s.idf * s.propertyBoost
+	return s.idPointer, score, doc
+}
+
+func (s *SegmentBlockMax) Advance() {
+	if s.exhausted {
+		return
+	}
+
+	if !s.decoded {
+		s.decodeBlock()
+		return
+	}
+
+	s.blockDataIdx++
+	if s.blockDataIdx >= s.blockDataSize {
+		s.blockEntryIdx++
+		s.blockDataIdx = 0
+		s.decodeBlock()
+		if s.exhausted {
+			return
+		}
+	}
+
+	s.advanceOnTombstoneOrFilter()
+}
+
+func (s *SegmentBlockMax) computeCurrentBlockImpact() float32 {
+	if s.exhausted {
+		return 0
+	}
+	// for the fully decode blocks return the idf
+	if len(s.blockEntries) == 0 {
+		return float32(s.idf)
+	}
+	freq := float64(s.blockEntries[s.blockEntryIdx].MaxImpactTf)
+	propLength := float64(s.blockEntries[s.blockEntryIdx].MaxImpactPropLength)
+	return float32(s.idf * (freq / (freq + s.k1*(1-s.b+s.b*(propLength/s.averagePropLength)))) * s.propertyBoost)
+}
+
+func (s *SegmentBlockMax) CurrentBlockImpact() float32 {
+	return s.currentBlockImpact
+}
+
+func (s *SegmentBlockMax) CurrentBlockMaxId() uint64 {
+	return s.currentBlockMaxId
+}
+
+func (s *SegmentBlockMax) exhaust() {
+	s.idPointer = math.MaxUint64
+	s.currentBlockImpact = 0
+	s.idf = 0
+	s.currentBlockMaxId = math.MaxUint64
+	s.exhausted = true
+}
+
+func (s *SegmentBlockMax) SetIdf(idf float64) {
+	s.idf = idf
+	s.currentBlockImpact = s.computeCurrentBlockImpact()
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_blockmax_test.go

@@ -0,0 +1,47 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/weaviate/weaviate/entities/schema"
+)
+
+func TestSerializeAndParseInvertedNodeTest(t *testing.T) {
+	t.Skip()
+	path := "/Users/amourao/code/weaviate/weaviate/data-weaviate-0/" +
+		"msmarco/6Jx2gaSLtsnd/lsm/property_text_searchable/segment-1729794337023372000.db"
+	cfg := segmentConfig{
+		mmapContents:             false,
+		useBloomFilter:           false,
+		calcCountNetAdditions:    false,
+		overwriteDerived:         true,
+		enableChecksumValidation: false,
+	}
+	seg, err := newSegment(path, nil, nil, nil, cfg)
+	if err != nil {
+		t.Fatalf("error creating segment: %v", err)
+	}
+
+	sbm := NewSegmentBlockMax(seg, []byte("and"), 0, 1, 1, nil, nil, 10, schema.BM25Config{K1: 1.2, B: 0.75})
+
+	sbm.AdvanceAtLeast(100)
+	id, score, pair := sbm.Score(1, false)
+	sbm.Advance()
+	fmt.Println(id, score, pair)
+	sbm.AdvanceAtLeast(16000)
+	sbm.AdvanceAtLeast(160000000)
+
+	fmt.Println(sbm)
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_bloom_filters.go

@@ -0,0 +1,331 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/weaviate/weaviate/usecases/byteops"
+
+	"github.com/bits-and-blooms/bloom/v3"
+	"github.com/pkg/errors"
+	"github.com/weaviate/weaviate/entities/diskio"
+)
+
+func (s *segment) buildPath(template string) string {
+	isTmpFile := filepath.Ext(s.path) == ".tmp"
+
+	extless := strings.TrimSuffix(s.path, filepath.Ext(s.path))
+	if isTmpFile { // remove second extension
+		extless = strings.TrimSuffix(extless, filepath.Ext(extless))
+	}
+
+	path := fmt.Sprintf(template, extless)
+	if isTmpFile {
+		path = fmt.Sprintf("%s.tmp", path)
+	}
+	return path
+}
+
+func (s *segment) bloomFilterPath() string {
+	return s.buildPath("%s.bloom")
+}
+
+func (s *segment) bloomFilterSecondaryPath(pos int) string {
+	posTemplate := fmt.Sprintf(".%d.bloom", pos)
+	return s.buildPath("%s.secondary" + posTemplate)
+}
+
+func (s *segment) initBloomFilters(metrics *Metrics, overwrite bool, existingFilesList map[string]int64) error {
+	if err := s.initBloomFilter(overwrite, existingFilesList); err != nil {
+		return fmt.Errorf("init bloom filter for primary index: %w", err)
+	}
+	if s.secondaryIndexCount > 0 {
+		s.secondaryBloomFilters = make([]*bloom.BloomFilter, s.secondaryIndexCount)
+		for i := range s.secondaryBloomFilters {
+			if err := s.initSecondaryBloomFilter(i, overwrite, existingFilesList); err != nil {
+				return fmt.Errorf("init bloom filter for secondary index at %d: %w", i, err)
+			}
+		}
+	}
+	s.bloomFilterMetrics = newBloomFilterMetrics(metrics)
+	return nil
+}
+
+func (s *segment) initBloomFilter(overwrite bool, existingFilesList map[string]int64) error {
+	path := s.bloomFilterPath()
+	s.metaPaths = append(s.metaPaths, path)
+
+	loadFromDisk, err := fileExistsInList(existingFilesList, filepath.Base(path))
+	if err != nil {
+		return err
+	}
+	if loadFromDisk {
+		if overwrite {
+			err := os.Remove(path)
+			if err != nil {
+				return fmt.Errorf("delete existing bloom filter %s: %w", path, err)
+			}
+		} else {
+			err = s.loadBloomFilterFromDisk()
+			if err == nil {
+				return nil
+			}
+
+			if !errors.Is(err, ErrInvalidChecksum) {
+				// not a recoverable error
+				return err
+			}
+
+			// now continue re-calculating
+		}
+	}
+
+	before := time.Now()
+
+	if err := s.computeAndStoreBloomFilter(path); err != nil {
+		return err
+	}
+
+	took := time.Since(before)
+
+	s.logger.WithField("action", "lsm_init_disk_segment_build_bloom_filter_primary").
+		WithField("path", s.path).
+		WithField("took", took).
+		Debugf("building bloom filter took %s\n", took)
+
+	return nil
+}
+
+func (s *segment) computeAndStoreBloomFilter(path string) error {
+	keys, err := s.index.AllKeys()
+	if err != nil {
+		return err
+	}
+
+	s.bloomFilter = bloom.NewWithEstimates(uint(len(keys)), 0.001)
+	for _, key := range keys {
+		s.bloomFilter.Add(key)
+	}
+
+	if err := s.storeBloomFilterOnDisk(path); err != nil {
+		return fmt.Errorf("store bloom filter on disk: %w", err)
+	}
+
+	return nil
+}
+
+func (s *segment) storeBloomFilterOnDisk(path string) error {
+	bfSize := getBloomFilterSize(s.bloomFilter)
+
+	rw := byteops.NewReadWriter(make([]byte, bfSize+byteops.Uint32Len))
+	rw.MoveBufferPositionForward(byteops.Uint32Len) // leave space for checksum
+	_, err := s.bloomFilter.WriteTo(&rw)
+	if err != nil {
+		return fmt.Errorf("write bloom filter: %w", err)
+	}
+
+	return writeWithChecksum(rw, path, s.observeMetaWrite)
+}
+
+func (s *segment) loadBloomFilterFromDisk() error {
+	data, err := loadWithChecksum(s.bloomFilterPath(), -1, s.metrics.ReadObserver("loadBloomfilter"))
+	if err != nil {
+		return err
+	}
+
+	s.bloomFilter = new(bloom.BloomFilter)
+	_, err = s.bloomFilter.ReadFrom(bytes.NewReader(data))
+	if err != nil {
+		return fmt.Errorf("read bloom filter from disk: %w", err)
+	}
+
+	return nil
+}
+
+func (s *segment) initSecondaryBloomFilter(pos int, overwrite bool, existingFilesList map[string]int64) error {
+	before := time.Now()
+
+	path := s.bloomFilterSecondaryPath(pos)
+	s.metaPaths = append(s.metaPaths, path)
+
+	loadFromDisk, err := fileExistsInList(existingFilesList, filepath.Base(path))
+	if err != nil {
+		return err
+	}
+	if loadFromDisk {
+		if overwrite {
+			err := os.Remove(path)
+			if err != nil {
+				return fmt.Errorf("deleting existing secondary bloom filter %s: %w", path, err)
+			}
+		} else {
+			err = s.loadBloomFilterSecondaryFromDisk(pos)
+			if err == nil {
+				return nil
+			}
+
+			if !errors.Is(err, ErrInvalidChecksum) {
+				// not a recoverable error
+				return err
+			}
+
+			// now continue re-calculating
+		}
+	}
+
+	if err := s.computeAndStoreSecondaryBloomFilter(path, pos); err != nil {
+		return err
+	}
+
+	took := time.Since(before)
+
+	s.logger.WithField("action", "lsm_init_disk_segment_build_bloom_filter_secondary").
+		WithField("secondary_index_position", pos).
+		WithField("path", s.path).
+		WithField("took", took).
+		Debugf("building bloom filter took %s\n", took)
+
+	return nil
+}
+
+func (s *segment) computeAndStoreSecondaryBloomFilter(path string, pos int) error {
+	keys, err := s.secondaryIndices[pos].AllKeys()
+	if err != nil {
+		return err
+	}
+
+	s.secondaryBloomFilters[pos] = bloom.NewWithEstimates(uint(len(keys)), 0.001)
+	for _, key := range keys {
+		s.secondaryBloomFilters[pos].Add(key)
+	}
+
+	if err := s.storeBloomFilterSecondaryOnDisk(path, pos); err != nil {
+		return fmt.Errorf("store secondary bloom filter on disk: %w", err)
+	}
+
+	return nil
+}
+
+func (s *segment) storeBloomFilterSecondaryOnDisk(path string, pos int) error {
+	bfSize := getBloomFilterSize(s.bloomFilter)
+
+	rw := byteops.NewReadWriter(make([]byte, bfSize+byteops.Uint32Len))
+	rw.MoveBufferPositionForward(byteops.Uint32Len) // leave space for checksum
+	_, err := s.secondaryBloomFilters[pos].WriteTo(&rw)
+	if err != nil {
+		return fmt.Errorf("write bloom filter: %w", err)
+	}
+
+	return writeWithChecksum(rw, path, s.observeMetaWrite)
+}
+
+func (s *segment) loadBloomFilterSecondaryFromDisk(pos int) error {
+	data, err := loadWithChecksum(s.bloomFilterSecondaryPath(pos), -1, s.metrics.ReadObserver("loadSecondaryBloomFilter"))
+	if err != nil {
+		return err
+	}
+
+	s.secondaryBloomFilters[pos] = new(bloom.BloomFilter)
+	_, err = s.secondaryBloomFilters[pos].ReadFrom(bytes.NewReader(data))
+	if err != nil {
+		return fmt.Errorf("read bloom filter from disk: %w", err)
+	}
+
+	return nil
+}
+
+func fileExistsInList(nameList map[string]int64, filePath string) (bool, error) {
+	if nameList != nil {
+		_, ok := nameList[filePath]
+		return ok, nil
+	} else {
+		return fileExists(filePath)
+	}
+}
+
+// writeWithChecksum expects the data in the buffer to start at position byteops.Uint32Len so the
+// checksum can be added into the same buffer at its start and everything can be written to the file
+// in one go
+func writeWithChecksum(bufWriter byteops.ReadWriter, path string, observeFileWriter diskio.MeteredWriterCallback) error {
+	// checksum needs to be at the start of the file
+	chksm := crc32.ChecksumIEEE(bufWriter.Buffer[byteops.Uint32Len:])
+	bufWriter.MoveBufferToAbsolutePosition(0)
+	bufWriter.WriteUint32(chksm)
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("open file for writing: %w", err)
+	}
+
+	meteredW := diskio.NewMeteredWriter(f, observeFileWriter)
+
+	if _, err := meteredW.Write(bufWriter.Buffer); err != nil {
+		// ignoring f.Close() error here, as we don't care about whether the file
+		// was flushed, the call is mainly intended to prevent a file descriptor
+		// leak.  We still want to return the original error below.
+		f.Close()
+		return fmt.Errorf("write bloom filter to disk: %w", err)
+	}
+
+	if err := f.Close(); err != nil {
+		return fmt.Errorf("close bloom filter file: %w", err)
+	}
+
+	return nil
+}
+
+// use negative length check to indicate that no length check should be
+// performed
+func loadWithChecksum(path string, lengthCheck int, observeFileReader BytesReadObserver) ([]byte, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	meteredF := diskio.NewMeteredReader(f, diskio.MeteredReaderCallback(observeFileReader))
+
+	data, err := io.ReadAll(meteredF)
+	if err != nil {
+		return nil, err
+	}
+	if lengthCheck > 0 && len(data) != lengthCheck {
+		return nil, ErrInvalidChecksum
+	}
+
+	if len(data) < 4 {
+		// the file does not even contain the full checksum, we must consider it corrupt
+		return nil, ErrInvalidChecksum
+	}
+
+	chcksm := binary.LittleEndian.Uint32(data[:4])
+	actual := crc32.ChecksumIEEE(data[4:])
+	if chcksm != actual {
+		return nil, ErrInvalidChecksum
+	}
+
+	return data[4:], nil
+}
+
+func getBloomFilterSize(bf *bloom.BloomFilter) int {
+	// size of the bloom filter is size of the underlying bitSet and two uint64 parameters
+	bs := bf.BitSet()
+	bsSize := bs.BinaryStorageSize()
+	return bsSize + 2*byteops.Uint64Len
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_bloom_filters_test.go

@@ -0,0 +1,642 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"math/rand"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaviate/weaviate/entities/cyclemanager"
+)
+
+func TestCreateBloomOnFlush(t *testing.T) {
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world"),
+		WithSecondaryKey(0, []byte("bonjour"))))
+	require.Nil(t, b.FlushMemtable())
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+
+	_, ok := findFileWithExt(files, ".bloom")
+	assert.True(t, ok)
+
+	_, ok = findFileWithExt(files, "secondary.0.bloom")
+	assert.True(t, ok)
+	// on Windows we have to shutdown the bucket before opening it again
+	require.Nil(t, b.Shutdown(ctx))
+
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	valuePrimary, err := b2.Get([]byte("hello"))
+	require.Nil(t, err)
+	valueSecondary, err := b2.GetBySecondary(0, []byte("bonjour"))
+	require.Nil(t, err)
+
+	assert.Equal(t, []byte("world"), valuePrimary)
+	assert.Equal(t, []byte("world"), valueSecondary)
+}
+
+func TestCreateBloomInit(t *testing.T) {
+	// this test deletes the initial bloom and makes sure it gets recreated after
+	// the bucket is initialized
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+	defer b.Shutdown(ctx)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world"),
+		WithSecondaryKey(0, []byte("bonjour"))))
+	require.Nil(t, b.FlushMemtable())
+
+	for _, ext := range []string{".secondary.0.bloom", ".bloom"} {
+		files, err := os.ReadDir(dirName)
+		require.Nil(t, err)
+		fname, ok := findFileWithExt(files, ext)
+		require.True(t, ok)
+
+		err = os.RemoveAll(path.Join(dirName, fname))
+		require.Nil(t, err)
+
+		files, err = os.ReadDir(dirName)
+		require.Nil(t, err)
+		_, ok = findFileWithExt(files, ext)
+		require.False(t, ok, "verify the file is really gone")
+	}
+
+	require.Nil(t, b.Shutdown(ctx))
+
+	// now create a new bucket and assert that the file is re-created on init
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	// just to ensure segments are loaded
+	cursor := b2.Cursor()
+	cursor.Close()
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+	_, ok := findFileWithExt(files, ".bloom")
+	require.True(t, ok)
+	_, ok = findFileWithExt(files, ".secondary.0.bloom")
+	require.True(t, ok)
+}
+
+func TestRepairCorruptedBloomOnInit(t *testing.T) {
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace))
+	require.Nil(t, err)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world")))
+	require.Nil(t, b.FlushMemtable())
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+	fname, ok := findFileWithExt(files, ".bloom")
+	require.True(t, ok)
+
+	// now corrupt the bloom filter by randomly overriding data
+	require.Nil(t, corruptBloomFile(path.Join(dirName, fname)))
+	// on Windows we have to shutdown the bucket before opening it again
+	require.Nil(t, b.Shutdown(ctx))
+
+	// now create a new bucket and assert that the file is ignored, re-created on
+	// init, and the count matches
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	value, err := b2.Get([]byte("hello"))
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("world"), value)
+}
+
+func TestRepairTooShortBloomOnInit(t *testing.T) {
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace))
+	require.Nil(t, err)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world")))
+	require.Nil(t, b.FlushMemtable())
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+	fname, ok := findFileWithExt(files, ".bloom")
+	require.True(t, ok)
+	b.Shutdown(ctx)
+
+	// now corrupt the bloom filter by randomly overriding data
+	require.Nil(t, corruptBloomFileByTruncatingIt(path.Join(dirName, fname)))
+
+	// now create a new bucket and assert that the file is ignored, re-created on
+	// init, and the count matches
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	value, err := b2.Get([]byte("hello"))
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("world"), value)
+}
+
+func TestRepairCorruptedBloomSecondaryOnInit(t *testing.T) {
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world"),
+		WithSecondaryKey(0, []byte("bonjour"))))
+	require.Nil(t, b.FlushMemtable())
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+	fname, ok := findFileWithExt(files, "secondary.0.bloom")
+	require.True(t, ok)
+
+	// now corrupt the file by replacing the count value without adapting the checksum
+	require.Nil(t, corruptBloomFile(path.Join(dirName, fname)))
+	// on Windows we have to shutdown the bucket before opening it again
+	require.Nil(t, b.Shutdown(ctx))
+
+	// now create a new bucket and assert that the file is ignored, re-created on
+	// init, and the count matches
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	value := make([]byte, 5)
+	value, _, err = b2.GetBySecondaryIntoMemory(0, []byte("bonjour"), value)
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("world"), value)
+
+	err = b2.Delete([]byte("hello"))
+	assert.Nil(t, err)
+
+	v, err := b2.Get([]byte("hello"))
+	assert.Nil(t, err)
+	assert.Nil(t, v)
+
+	value, _, err = b2.GetBySecondaryIntoMemory(0, []byte("bonjour"), value)
+	assert.Nil(t, err)
+	assert.Nil(t, value)
+}
+
+func TestRepairCorruptedBloomSecondaryOnInitIntoMemory(t *testing.T) {
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world"),
+		WithSecondaryKey(0, []byte("bonjour"))))
+	require.Nil(t, b.FlushMemtable())
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+	fname, ok := findFileWithExt(files, "secondary.0.bloom")
+	require.True(t, ok)
+
+	b.Shutdown(ctx)
+
+	// now corrupt the file by replacing the count value without adapting the checksum
+	require.Nil(t, corruptBloomFile(path.Join(dirName, fname)))
+
+	// now create a new bucket and assert that the file is ignored, re-created on
+	// init, and the count matches
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	value, err := b2.GetBySecondary(0, []byte("bonjour"))
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("world"), value)
+}
+
+func TestRepairTooShortBloomSecondaryOnInit(t *testing.T) {
+	ctx := context.Background()
+	dirName := t.TempDir()
+
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+
+	require.Nil(t, b.Put([]byte("hello"), []byte("world"),
+		WithSecondaryKey(0, []byte("bonjour"))))
+	require.Nil(t, b.FlushMemtable())
+
+	files, err := os.ReadDir(dirName)
+	require.Nil(t, err)
+	fname, ok := findFileWithExt(files, "secondary.0.bloom")
+	require.True(t, ok)
+
+	b.Shutdown(ctx)
+	// now corrupt the file by replacing the count value without adapting the checksum
+	require.Nil(t, corruptBloomFileByTruncatingIt(path.Join(dirName, fname)))
+
+	// now create a new bucket and assert that the file is ignored, re-created on
+	// init, and the count matches
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		WithStrategy(StrategyReplace), WithSecondaryIndices(1))
+	require.Nil(t, err)
+	defer b2.Shutdown(ctx)
+
+	value, err := b2.GetBySecondary(0, []byte("bonjour"))
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("world"), value)
+}
+
+func TestLoadWithChecksumErrorCases(t *testing.T) {
+	t.Run("file does not exist", func(t *testing.T) {
+		dirName := t.TempDir()
+		_, err := loadWithChecksum(path.Join(dirName, "my-file"), -1, nil)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("file has incorrect length", func(t *testing.T) {
+		dirName := t.TempDir()
+		fName := path.Join(dirName, "my-file")
+		f, err := os.Create(fName)
+		require.Nil(t, err)
+
+		_, err = f.Write(make([]byte, 13))
+		require.Nil(t, err)
+
+		require.Nil(t, f.Close())
+
+		_, err = loadWithChecksum(path.Join(dirName, "my-file"), 17, nil)
+		assert.NotNil(t, err)
+	})
+}
+
+func BenchmarkLoading(b *testing.B) {
+	for _, val := range []int{10, 100, 1000, 10000} {
+		b.Run(fmt.Sprintf("%d", val), func(b *testing.B) {
+			dirName := b.TempDir()
+			fName := path.Join(dirName, fmt.Sprintf("my-file-%d", val))
+			f, err := os.Create(fName)
+			require.Nil(b, err)
+			data := make([]byte, val)
+			for i := 0; i < len(data); i++ {
+				data[i] = byte(rand.Intn(100))
+			}
+			chmsum := crc32.ChecksumIEEE(data[4:])
+			binary.LittleEndian.PutUint32(data[:4], chmsum)
+			_, err = f.Write(data)
+			require.NoError(b, err)
+
+			require.NoError(b, f.Sync())
+			require.NoError(b, f.Close())
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				loadedData, err := loadWithChecksum(fName, len(data), nil)
+				require.NoError(b, err)
+				require.Equal(b, loadedData, data[4:])
+			}
+		})
+	}
+}
+
+func TestBloom_OFF(t *testing.T) {
+	ctx := context.Background()
+	tests := bucketTests{
+		{
+			name: "dontCreateBloom",
+			f:    dontCreateBloom,
+			opts: []BucketOption{
+				WithStrategy(StrategyReplace),
+				WithSecondaryIndices(1),
+				WithUseBloomFilter(false),
+			},
+		},
+		{
+			name: "dontRecreateBloom",
+			f:    dontRecreateBloom,
+			opts: []BucketOption{
+				WithStrategy(StrategyReplace),
+				WithSecondaryIndices(1),
+				WithUseBloomFilter(false),
+			},
+		},
+		{
+			name: "dontPrecomputeBloom",
+			f:    dontPrecomputeBloom,
+			opts: []BucketOption{
+				WithStrategy(StrategyReplace),
+				WithSecondaryIndices(1),
+				WithUseBloomFilter(false),
+			},
+		},
+	}
+	tests.run(ctx, t)
+}
+
+func dontCreateBloom(ctx context.Context, t *testing.T, opts []BucketOption) {
+	dirName := t.TempDir()
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		opts...)
+	require.NoError(t, err)
+	defer b.Shutdown(ctx)
+
+	t.Run("populate", func(t *testing.T) {
+		require.NoError(t, b.Put([]byte("hello"), []byte("world"),
+			WithSecondaryKey(0, []byte("bonjour"))))
+		require.NoError(t, b.FlushMemtable())
+	})
+
+	t.Run("check files", func(t *testing.T) {
+		files, err := os.ReadDir(dirName)
+		require.NoError(t, err)
+
+		_, ok := findFileWithExt(files, ".bloom")
+		assert.False(t, ok)
+		_, ok = findFileWithExt(files, "secondary.0.bloom")
+		assert.False(t, ok)
+	})
+
+	t.Run("search", func(t *testing.T) {
+		valuePrimary, err := b.Get([]byte("hello"))
+		require.NoError(t, err)
+		valueSecondary, err := b.GetBySecondary(0, []byte("bonjour"))
+		require.NoError(t, err)
+
+		assert.Equal(t, []byte("world"), valuePrimary)
+		assert.Equal(t, []byte("world"), valueSecondary)
+	})
+}
+
+func dontRecreateBloom(ctx context.Context, t *testing.T, opts []BucketOption) {
+	dirName := t.TempDir()
+	logger, _ := test.NewNullLogger()
+
+	t.Run("create, populate, shutdown", func(t *testing.T) {
+		b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+			cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+			opts...)
+		require.NoError(t, err)
+		defer b.Shutdown(ctx)
+
+		require.NoError(t, b.Put([]byte("hello"), []byte("world"),
+			WithSecondaryKey(0, []byte("bonjour"))))
+		require.NoError(t, b.FlushMemtable())
+	})
+
+	b2, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		opts...)
+	require.NoError(t, err)
+	defer b2.Shutdown(ctx)
+
+	t.Run("check files", func(t *testing.T) {
+		files, err := os.ReadDir(dirName)
+		require.NoError(t, err)
+
+		_, ok := findFileWithExt(files, ".bloom")
+		assert.False(t, ok)
+		_, ok = findFileWithExt(files, "secondary.0.bloom")
+		assert.False(t, ok)
+	})
+
+	t.Run("search", func(t *testing.T) {
+		valuePrimary, err := b2.Get([]byte("hello"))
+		require.NoError(t, err)
+		valueSecondary, err := b2.GetBySecondary(0, []byte("bonjour"))
+		require.NoError(t, err)
+
+		assert.Equal(t, []byte("world"), valuePrimary)
+		assert.Equal(t, []byte("world"), valueSecondary)
+	})
+}
+
+func dontPrecomputeBloom(ctx context.Context, t *testing.T, opts []BucketOption) {
+	dirName := t.TempDir()
+	logger, _ := test.NewNullLogger()
+
+	b, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+		cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+		opts...)
+	require.NoError(t, err)
+	defer b.Shutdown(ctx)
+
+	t.Run("populate, compact", func(t *testing.T) {
+		require.NoError(t, b.Put([]byte("hello"), []byte("world"),
+			WithSecondaryKey(0, []byte("bonjour"))))
+		require.NoError(t, b.FlushMemtable())
+
+		require.NoError(t, b.Put([]byte("hello2"), []byte("world2"),
+			WithSecondaryKey(0, []byte("bonjour2"))))
+		require.NoError(t, b.FlushMemtable())
+
+		compacted, err := b.disk.compactOnce()
+		require.NoError(t, err)
+		require.True(t, compacted)
+	})
+
+	t.Run("check files", func(t *testing.T) {
+		files, err := os.ReadDir(dirName)
+		require.NoError(t, err)
+
+		_, ok := findFileWithExt(files, ".bloom")
+		assert.False(t, ok)
+		_, ok = findFileWithExt(files, "secondary.0.bloom")
+		assert.False(t, ok)
+	})
+
+	t.Run("search", func(t *testing.T) {
+		valuePrimary, err := b.Get([]byte("hello"))
+		require.NoError(t, err)
+		valueSecondary, err := b.GetBySecondary(0, []byte("bonjour"))
+		require.NoError(t, err)
+		value2Primary, err := b.Get([]byte("hello2"))
+		require.NoError(t, err)
+		value2Secondary, err := b.GetBySecondary(0, []byte("bonjour2"))
+		require.NoError(t, err)
+
+		assert.Equal(t, []byte("world"), valuePrimary)
+		assert.Equal(t, []byte("world"), valueSecondary)
+		assert.Equal(t, []byte("world2"), value2Primary)
+		assert.Equal(t, []byte("world2"), value2Secondary)
+	})
+}
+
+func corruptBloomFile(fname string) error {
+	f, err := os.Open(fname)
+	if err != nil {
+		return err
+	}
+
+	data, err := io.ReadAll(f)
+	if err != nil {
+		return err
+	}
+
+	if err := f.Close(); err != nil {
+		return err
+	}
+
+	// corrupt it by setting all data bytes to 0x01
+	for i := 5; i < len(data); i++ {
+		data[i] = 0x01
+	}
+
+	f, err = os.Create(fname)
+	if err != nil {
+		return err
+	}
+
+	_, err = f.Write(data)
+	if err != nil {
+		return err
+	}
+
+	return f.Close()
+}
+
+func corruptBloomFileByTruncatingIt(fname string) error {
+	f, err := os.Open(fname)
+	if err != nil {
+		return err
+	}
+
+	data, err := io.ReadAll(f)
+	if err != nil {
+		return err
+	}
+
+	if err := f.Close(); err != nil {
+		return err
+	}
+
+	data = data[:2]
+
+	f, err = os.Create(fname)
+	if err != nil {
+		return err
+	}
+
+	_, err = f.Write(data)
+	if err != nil {
+		return err
+	}
+
+	return f.Close()
+}
+
+func BenchmarkName(b *testing.B) {
+	logger, _ := test.NewNullLogger()
+	fn := func(key []byte) (bool, error) { return true, nil }
+
+	for _, val := range []int{10, 100, 1000, 10000} {
+		b.Run(fmt.Sprintf("%d", val), func(b *testing.B) {
+			dirName := b.TempDir()
+			ctx := context.Background()
+			bu, err := NewBucketCreator().NewBucket(ctx, dirName, "", logger, nil,
+				cyclemanager.NewCallbackGroupNoop(), cyclemanager.NewCallbackGroupNoop(),
+				WithStrategy(StrategyReplace))
+			require.Nil(b, err)
+
+			for i := 0; i < val; i++ {
+				require.Nil(b, bu.Put([]byte(fmt.Sprintf("hello-%v", i)), []byte(fmt.Sprintf("world-%v", i))))
+			}
+
+			require.Nil(b, bu.FlushMemtable())
+			bu.Shutdown(ctx)
+
+			files, err := os.ReadDir(dirName)
+			require.NoError(b, err)
+
+			fnames, ok := findFileWithExt(files, ".db")
+			assert.True(b, ok)
+			assert.NotNil(b, fnames)
+
+			b.ResetTimer()
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				_, err := newSegment(path.Join(dirName, fnames), logger, nil, fn, segmentConfig{
+					mmapContents:     false,
+					useBloomFilter:   true,
+					overwriteDerived: true,
+				})
+				require.NoError(b, err)
+			}
+		})
+	}
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_cleaner_replace.go

@@ -0,0 +1,201 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/entities/cyclemanager"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+	"github.com/weaviate/weaviate/usecases/monitoring"
+)
+
+type segmentCleanerReplace struct {
+	w                        io.WriteSeeker
+	bufw                     *bufio.Writer
+	cursor                   *segmentCursorReplace
+	keyExistsFn              keyExistsOnUpperSegmentsFunc
+	version                  uint16
+	level                    uint16
+	secondaryIndexCount      uint16
+	scratchSpacePath         string
+	enableChecksumValidation bool
+}
+
+func newSegmentCleanerReplace(w io.WriteSeeker, cursor *segmentCursorReplace,
+	keyExistsFn keyExistsOnUpperSegmentsFunc, level, secondaryIndexCount uint16,
+	scratchSpacePath string, enableChecksumValidation bool,
+) *segmentCleanerReplace {
+	return &segmentCleanerReplace{
+		w:                        w,
+		bufw:                     bufio.NewWriterSize(w, 256*1024),
+		cursor:                   cursor,
+		keyExistsFn:              keyExistsFn,
+		version:                  segmentindex.ChooseHeaderVersion(enableChecksumValidation),
+		level:                    level,
+		secondaryIndexCount:      secondaryIndexCount,
+		scratchSpacePath:         scratchSpacePath,
+		enableChecksumValidation: enableChecksumValidation,
+	}
+}
+
+func (p *segmentCleanerReplace) do(shouldAbort cyclemanager.ShouldAbortCallback) error {
+	if err := p.init(); err != nil {
+		return fmt.Errorf("init: %w", err)
+	}
+
+	segmentFile := segmentindex.NewSegmentFile(
+		segmentindex.WithBufferedWriter(p.bufw),
+		segmentindex.WithChecksumsDisabled(!p.enableChecksumValidation),
+	)
+
+	indexKeys, err := p.writeKeys(segmentFile, shouldAbort)
+	if err != nil {
+		return fmt.Errorf("write keys: %w", err)
+	}
+
+	if err := p.writeIndexes(segmentFile, indexKeys); err != nil {
+		return fmt.Errorf("write indices: %w", err)
+	}
+
+	// flush buffered, so we can safely seek on underlying writer
+	if err := p.bufw.Flush(); err != nil {
+		return fmt.Errorf("flush buffered: %w", err)
+	}
+
+	var dataEnd uint64 = segmentindex.HeaderSize
+	if l := len(indexKeys); l > 0 {
+		dataEnd = uint64(indexKeys[l-1].ValueEnd)
+	}
+
+	if err := p.writeHeader(segmentFile, dataEnd); err != nil {
+		return fmt.Errorf("write header: %w", err)
+	}
+
+	if _, err := segmentFile.WriteChecksum(); err != nil {
+		return fmt.Errorf("write compactorSet segment checksum: %w", err)
+	}
+
+	return nil
+}
+
+func (p *segmentCleanerReplace) init() error {
+	// write a dummy header as its contents are not known yet.
+	// file will be sought to the beginning and overwritten with actual header
+	// at the very end
+
+	if _, err := p.bufw.Write(make([]byte, segmentindex.HeaderSize)); err != nil {
+		return fmt.Errorf("write empty header: %w", err)
+	}
+	return nil
+}
+
+func (p *segmentCleanerReplace) writeKeys(f *segmentindex.SegmentFile,
+	shouldAbort cyclemanager.ShouldAbortCallback,
+) ([]segmentindex.Key, error) {
+	// the (dummy) header was already written, this is our initial offset
+	offset := segmentindex.HeaderSize
+
+	var indexKeys []segmentindex.Key
+	var indexKey segmentindex.Key
+	var node segmentReplaceNode
+	var err error
+	var keyExists bool
+
+	i := 0
+	for node, err = p.cursor.firstWithAllKeys(); err == nil || errors.Is(err, lsmkv.Deleted); node, err = p.cursor.nextWithAllKeys() {
+		i++
+		if i%100 == 0 && shouldAbort() {
+			return nil, fmt.Errorf("should abort requested")
+		}
+
+		keyExists, err = p.keyExistsFn(node.primaryKey)
+		if err != nil {
+			break
+		}
+		if keyExists {
+			continue
+		}
+		nodeCopy := node
+		nodeCopy.offset = offset
+		indexKey, err = nodeCopy.KeyIndexAndWriteTo(f.BodyWriter())
+		if err != nil {
+			break
+		}
+		offset = indexKey.ValueEnd
+		indexKeys = append(indexKeys, indexKey)
+	}
+
+	if !errors.Is(err, lsmkv.NotFound) {
+		return nil, err
+	}
+	return indexKeys, nil
+}
+
+func (p *segmentCleanerReplace) writeIndexes(f *segmentindex.SegmentFile,
+	keys []segmentindex.Key,
+) error {
+	indexes := &segmentindex.Indexes{
+		Keys:                keys,
+		SecondaryIndexCount: p.secondaryIndexCount,
+		ScratchSpacePath:    p.scratchSpacePath,
+		ObserveWrite: monitoring.GetMetrics().FileIOWrites.With(prometheus.Labels{
+			"strategy":  StrategyReplace,
+			"operation": "cleanupWriteIndices",
+		}),
+	}
+	_, err := f.WriteIndexes(indexes, math.MaxInt64) // segment cleaner only runs for big files
+	return err
+}
+
+// writeHeader assumes that everything has been written to the underlying
+// writer and it is now safe to seek to the beginning and override the initial
+// header
+func (p *segmentCleanerReplace) writeHeader(f *segmentindex.SegmentFile,
+	startOfIndex uint64,
+) error {
+	if _, err := p.w.Seek(0, io.SeekStart); err != nil {
+		return fmt.Errorf("seek to beginning to write header: %w", err)
+	}
+
+	h := &segmentindex.Header{
+		Level:            p.level,
+		Version:          p.version,
+		SecondaryIndices: p.secondaryIndexCount,
+		Strategy:         segmentindex.StrategyReplace,
+		IndexStart:       startOfIndex,
+	}
+	// We have to write directly to compactor writer,
+	// since it has seeked back to start. The following
+	// call to f.WriteHeader will not write again.
+	if _, err := h.WriteTo(p.w); err != nil {
+		return err
+	}
+
+	if _, err := f.WriteHeader(h); err != nil {
+		return err
+	}
+
+	if _, err := p.w.Seek(0, io.SeekEnd); err != nil {
+		return fmt.Errorf("seek to end after writing header: %w", err)
+	}
+
+	p.bufw.Reset(p.w)
+
+	return nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_collection_strategy.go

@@ -0,0 +1,118 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+)
+
+func (s *segment) getCollection(key []byte) ([]value, error) {
+	if s.strategy != segmentindex.StrategySetCollection &&
+		s.strategy != segmentindex.StrategyMapCollection &&
+		s.strategy != segmentindex.StrategyInverted {
+		return nil, fmt.Errorf("get only possible for strategies %q, %q and %q, got %q",
+			StrategySetCollection, StrategyMapCollection, StrategyInverted, s.strategy)
+	}
+
+	if s.useBloomFilter && !s.bloomFilter.Test(key) {
+		return nil, lsmkv.NotFound
+	}
+
+	node, err := s.index.Get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	// We need to copy the data we read from the segment exactly once in this
+	// place. This means that future processing can share this memory as much as
+	// it wants to, as it can now be considered immutable. If we didn't copy in
+	// this place it would only be safe to hold this data while still under the
+	// protection of the segmentGroup.maintenanceLock. This lock makes sure that
+	// no compaction is started during an ongoing read. However, as we could show
+	// as part of https://github.com/weaviate/weaviate/issues/1837
+	// further processing, such as map-decoding and eventually map-merging would
+	// happen inside the bucket.MapList() method. This scope has its own lock,
+	// but that lock can only protecting against flushing (i.e. changing the
+	// active/flushing memtable), not against removing the disk segment. If a
+	// compaction completes and the old segment is removed, we would be accessing
+	// invalid memory without the copy, thus leading to a SEGFAULT.
+	contentsCopy := make([]byte, node.End-node.Start)
+	if err = s.copyNode(contentsCopy, nodeOffset{node.Start, node.End}); err != nil {
+		return nil, err
+	}
+	if s.strategy == segmentindex.StrategyInverted {
+		return s.collectionStratParseDataInverted(contentsCopy)
+	}
+
+	return s.collectionStratParseData(contentsCopy)
+}
+
+func (s *segment) collectionStratParseData(in []byte) ([]value, error) {
+	if len(in) == 0 {
+		return nil, lsmkv.NotFound
+	}
+
+	offset := 0
+
+	valuesLen := binary.LittleEndian.Uint64(in[offset : offset+8])
+	offset += 8
+
+	values := make([]value, valuesLen)
+	valueIndex := 0
+	for valueIndex < int(valuesLen) {
+		values[valueIndex].tombstone = in[offset] == 0x01
+		offset += 1
+
+		valueLen := binary.LittleEndian.Uint64(in[offset : offset+8])
+		offset += 8
+
+		values[valueIndex].value = in[offset : offset+int(valueLen)]
+		offset += int(valueLen)
+
+		valueIndex++
+	}
+
+	return values, nil
+}
+
+func (s *segment) collectionStratParseDataInverted(in []byte) ([]value, error) {
+	if len(in) == 0 {
+		return nil, lsmkv.NotFound
+	}
+
+	offset := 0
+
+	valuesLen := binary.LittleEndian.Uint64(in[offset : offset+8])
+	// offset += 8
+
+	values := make([]value, valuesLen)
+
+	nodes, _ := decodeAndConvertFromBlocks(in)
+
+	valueIndex := 0
+	for _, node := range nodes {
+		buf := make([]byte, 16)
+		copy(buf, node.Key)
+		copy(buf[8:], node.Value)
+		values[valueIndex].tombstone = node.Tombstone
+		values[valueIndex].value = buf
+
+		valueIndex++
+
+	}
+
+	return values, nil
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_group.go

@@ -0,0 +1,1052 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/weaviate/weaviate/adapters/repos/db/lsmkv/segmentindex"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringset"
+	"github.com/weaviate/weaviate/adapters/repos/db/roaringsetrange"
+	"github.com/weaviate/weaviate/entities/cyclemanager"
+	"github.com/weaviate/weaviate/entities/diskio"
+	"github.com/weaviate/weaviate/entities/lsmkv"
+	"github.com/weaviate/weaviate/entities/models"
+	"github.com/weaviate/weaviate/entities/schema"
+	"github.com/weaviate/weaviate/entities/storagestate"
+	"github.com/weaviate/weaviate/usecases/memwatch"
+)
+
+type SegmentGroup struct {
+	segments []Segment
+
+	// Lock() for changing the currently active segments, RLock() for normal
+	// operation
+	maintenanceLock sync.RWMutex
+	dir             string
+
+	cursorsLock      sync.RWMutex
+	activeCursors    int
+	enqueuedSegments []Segment
+
+	// flushVsCompactLock is a simple synchronization mechanism between the
+	// compaction and flush cycle. In general, those are independent, however,
+	// there are parts of it that are not. See the comments of the routines
+	// interacting with this lock for more details.
+	flushVsCompactLock sync.Mutex
+
+	strategy string
+
+	compactionCallbackCtrl cyclemanager.CycleCallbackCtrl
+
+	logger logrus.FieldLogger
+
+	// for backward-compatibility with states where the disk state for maps was
+	// not guaranteed to be sorted yet
+	mapRequiresSorting bool
+
+	status     storagestate.Status
+	statusLock sync.Mutex
+	metrics    *Metrics
+
+	// all "replace" buckets support counting through net additions, but not all
+	// produce a meaningful count. Typically, the only count we're interested in
+	// is that of the bucket that holds objects
+	monitorCount bool
+
+	mmapContents             bool
+	keepTombstones           bool // see bucket for more details
+	useBloomFilter           bool // see bucket for more details
+	calcCountNetAdditions    bool // see bucket for more details
+	compactLeftOverSegments  bool // see bucket for more details
+	enableChecksumValidation bool
+	MinMMapSize              int64
+	keepLevelCompaction      bool // see bucket for more details
+
+	allocChecker   memwatch.AllocChecker
+	maxSegmentSize int64
+
+	segmentCleaner     segmentCleaner
+	cleanupInterval    time.Duration
+	lastCleanupCall    time.Time
+	lastCompactionCall time.Time
+
+	roaringSetRangeSegmentInMemory *roaringsetrange.SegmentInMemory
+	bitmapBufPool                  roaringset.BitmapBufPool
+	bm25config                     *schema.BM25Config
+	writeSegmentInfoIntoFileName   bool
+	writeMetadata                  bool
+}
+
+type sgConfig struct {
+	dir                          string
+	strategy                     string
+	mapRequiresSorting           bool
+	monitorCount                 bool
+	mmapContents                 bool
+	keepTombstones               bool
+	useBloomFilter               bool
+	calcCountNetAdditions        bool
+	forceCompaction              bool
+	keepLevelCompaction          bool
+	maxSegmentSize               int64
+	cleanupInterval              time.Duration
+	enableChecksumValidation     bool
+	keepSegmentsInMemory         bool
+	MinMMapSize                  int64
+	bm25config                   *models.BM25Config
+	writeSegmentInfoIntoFileName bool
+	writeMetadata                bool
+}
+
+func newSegmentGroup(ctx context.Context, logger logrus.FieldLogger, metrics *Metrics, cfg sgConfig,
+	compactionCallbacks cyclemanager.CycleCallbackGroup, b *Bucket, files map[string]int64,
+) (*SegmentGroup, error) {
+	now := time.Now()
+	sg := &SegmentGroup{
+		segments:                     make([]Segment, len(files)),
+		dir:                          cfg.dir,
+		logger:                       logger,
+		metrics:                      metrics,
+		monitorCount:                 cfg.monitorCount,
+		mapRequiresSorting:           cfg.mapRequiresSorting,
+		strategy:                     cfg.strategy,
+		mmapContents:                 cfg.mmapContents,
+		keepTombstones:               cfg.keepTombstones,
+		useBloomFilter:               cfg.useBloomFilter,
+		calcCountNetAdditions:        cfg.calcCountNetAdditions,
+		compactLeftOverSegments:      cfg.forceCompaction,
+		maxSegmentSize:               cfg.maxSegmentSize,
+		cleanupInterval:              cfg.cleanupInterval,
+		enableChecksumValidation:     cfg.enableChecksumValidation,
+		allocChecker:                 b.allocChecker,
+		lastCompactionCall:           now,
+		lastCleanupCall:              now,
+		MinMMapSize:                  cfg.MinMMapSize,
+		writeSegmentInfoIntoFileName: cfg.writeSegmentInfoIntoFileName,
+		writeMetadata:                cfg.writeMetadata,
+		bitmapBufPool:                b.bitmapBufPool,
+	}
+
+	segmentIndex := 0
+
+	segmentsAlreadyRecoveredFromCompaction := make(map[string]struct{})
+
+	// Note: it's important to process first the compacted segments
+	// TODO: a single iteration may be possible
+
+	for entry := range files {
+		if filepath.Ext(entry) != ".tmp" {
+			continue
+		}
+
+		potentialCompactedSegmentFileName := strings.TrimSuffix(entry, ".tmp")
+
+		if filepath.Ext(potentialCompactedSegmentFileName) != ".db" {
+			// another kind of temporal file, ignore at this point but it may need to be deleted...
+			continue
+		}
+
+		jointSegments := segmentID(potentialCompactedSegmentFileName)
+		jointSegmentsIDs := strings.Split(jointSegments, "_")
+
+		if len(jointSegmentsIDs) == 1 {
+			// cleanup leftover, to be removed
+			if err := os.Remove(filepath.Join(sg.dir, entry)); err != nil {
+				return nil, fmt.Errorf("delete partially cleaned segment %q: %w", entry, err)
+			}
+			continue
+		}
+
+		if len(jointSegmentsIDs) != 2 {
+			logger.WithField("action", "lsm_segment_init").
+				WithField("path", filepath.Join(sg.dir, entry)).
+				Warn("ignored (partially written) LSM compacted segment generated with a version older than v1.24.0")
+
+			continue
+		}
+
+		// jointSegmentsIDs[0] is the left segment, jointSegmentsIDs[1] is the right segment
+		leftSegmentFound, _ := segmentExistsWithID(jointSegmentsIDs[0], files)
+		rightSegmentFound, rightSegmentFilename := segmentExistsWithID(jointSegmentsIDs[1], files)
+
+		rightSegmentPath := filepath.Join(sg.dir, rightSegmentFilename)
+
+		if leftSegmentFound && rightSegmentFound {
+			delete(files, entry)
+			if err := os.Remove(filepath.Join(sg.dir, entry)); err != nil {
+				return nil, fmt.Errorf("delete partially compacted segment %q: %w", entry, err)
+			}
+			continue
+		}
+
+		if leftSegmentFound && !rightSegmentFound {
+			return nil, fmt.Errorf("missing right segment %q", rightSegmentFilename)
+		}
+
+		var rightSegmentMetadata *struct {
+			Level    uint16
+			Strategy segmentindex.Strategy
+		}
+		if !leftSegmentFound && rightSegmentFound {
+			// segment is initialized just to be erased
+			// there is no need of bloom filters nor net addition counter re-calculation
+			rightSegment, err := newSegment(rightSegmentPath, logger,
+				metrics, sg.makeExistsOn(nil),
+				segmentConfig{
+					mmapContents:             sg.mmapContents,
+					useBloomFilter:           sg.useBloomFilter,
+					calcCountNetAdditions:    sg.calcCountNetAdditions,
+					overwriteDerived:         false,
+					enableChecksumValidation: sg.enableChecksumValidation,
+					MinMMapSize:              sg.MinMMapSize,
+					allocChecker:             sg.allocChecker,
+					fileList:                 make(map[string]int64), // empty to not check if bloom/cna files already exist
+					writeMetadata:            sg.writeMetadata,
+				})
+			if err != nil {
+				return nil, fmt.Errorf("init already compacted right segment %s: %w", rightSegmentFilename, err)
+			}
+
+			rightSegmentMetadata = &struct {
+				Level    uint16
+				Strategy segmentindex.Strategy
+			}{
+				Level:    rightSegment.getLevel(),
+				Strategy: rightSegment.getStrategy(),
+			}
+
+			err = rightSegment.close()
+			if err != nil {
+				return nil, fmt.Errorf("close already compacted right segment %s: %w", rightSegmentFilename, err)
+			}
+
+			// https://github.com/weaviate/weaviate/pull/6128 introduces the ability
+			// to drop segments delayed by renaming them first and then dropping them
+			// later.
+			//
+			// The existing functionality (previously .drop) was renamed to
+			// .dropImmediately. We are keeping the old behavior in this mainly for
+			// backward compatbility, but also because the motivation behind the
+			// delayed deletion does not apply here:
+			//
+			// The new behavior is meant to split the deletion into two steps, to
+			// reduce the time that an expensive lock – which could block readers -
+			// is held. In this scenario, the segment has not been initialized yet,
+			// so there is no one we could be blocking.
+			//
+			// The total time is the same, so we can also just drop it immediately.
+			err = rightSegment.dropImmediately()
+			if err != nil {
+				return nil, fmt.Errorf("delete already compacted right segment %s: %w", rightSegmentFilename, err)
+			}
+			delete(files, rightSegmentFilename)
+
+			err = diskio.Fsync(sg.dir)
+			if err != nil {
+				return nil, fmt.Errorf("fsync segment directory %s: %w", sg.dir, err)
+			}
+		}
+
+		var newRightSegmentFileName string
+		if cfg.writeSegmentInfoIntoFileName && rightSegmentMetadata != nil {
+			newRightSegmentFileName = fmt.Sprintf("segment-%s%s.db", jointSegmentsIDs[1], segmentExtraInfo(rightSegmentMetadata.Level, rightSegmentMetadata.Strategy))
+		} else {
+			newRightSegmentFileName = fmt.Sprintf("segment-%s.db", jointSegmentsIDs[1])
+		}
+		newRightSegmentPath := filepath.Join(sg.dir, newRightSegmentFileName)
+
+		if err := os.Rename(filepath.Join(sg.dir, entry), newRightSegmentPath); err != nil {
+			return nil, fmt.Errorf("rename compacted segment file %q as %q: %w", entry, newRightSegmentFileName, err)
+		}
+
+		var segment Segment
+		var err error
+		sgConf := segmentConfig{
+			mmapContents:             sg.mmapContents,
+			useBloomFilter:           sg.useBloomFilter,
+			calcCountNetAdditions:    sg.calcCountNetAdditions,
+			overwriteDerived:         true,
+			enableChecksumValidation: sg.enableChecksumValidation,
+			MinMMapSize:              sg.MinMMapSize,
+			allocChecker:             sg.allocChecker,
+			fileList:                 files,
+			writeMetadata:            sg.writeMetadata,
+		}
+		if b.lazySegmentLoading {
+			segment, err = newLazySegment(newRightSegmentPath, logger,
+				metrics, sg.makeExistsOn(sg.segments[:segmentIndex]), sgConf,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("init lazy segment %s: %w", newRightSegmentFileName, err)
+			}
+		} else {
+			segment, err = newSegment(newRightSegmentPath, logger,
+				metrics, sg.makeExistsOn(sg.segments[:segmentIndex]), sgConf,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("init segment %s: %w", newRightSegmentFileName, err)
+			}
+		}
+
+		sg.segments[segmentIndex] = segment
+		segmentIndex++
+
+		segmentsAlreadyRecoveredFromCompaction[newRightSegmentFileName] = struct{}{}
+	}
+
+	for entry := range files {
+		if filepath.Ext(entry) == DeleteMarkerSuffix {
+			// marked for deletion, but never actually deleted. Delete now.
+			if err := os.Remove(filepath.Join(sg.dir, entry)); err != nil {
+				// don't abort if the delete fails, we can still continue (albeit
+				// without freeing disk space that should have been freed)
+				sg.logger.WithError(err).WithFields(logrus.Fields{
+					"action": "lsm_segment_init_deleted_previously_marked_files",
+					"file":   entry,
+				}).Error("failed to delete file already marked for deletion")
+			}
+			continue
+
+		}
+
+		if filepath.Ext(entry) != ".db" {
+			// skip, this could be commit log, etc.
+			continue
+		}
+
+		_, alreadyRecoveredFromCompaction := segmentsAlreadyRecoveredFromCompaction[entry]
+		if alreadyRecoveredFromCompaction {
+			// the .db file was already removed and restored from a compacted segment
+			continue
+		}
+
+		// before we can mount this file, we need to check if a WAL exists for it.
+		// If yes, we must assume that the flush never finished, as otherwise the
+		// WAL would have been deleted. Thus we must remove it.
+		walFileName, _, _ := strings.Cut(entry, ".")
+		walFileName += ".wal"
+		_, ok := files[walFileName]
+		if ok {
+			// the segment will be recovered from the WAL
+			err := os.Remove(filepath.Join(sg.dir, entry))
+			if err != nil {
+				return nil, fmt.Errorf("delete partially written segment %s: %w", entry, err)
+			}
+
+			logger.WithField("action", "lsm_segment_init").
+				WithField("path", filepath.Join(sg.dir, entry)).
+				WithField("wal_path", walFileName).
+				Info("discarded (partially written) LSM segment, because an active WAL for " +
+					"the same segment was found. A recovery from the WAL will follow.")
+
+			continue
+		}
+
+		var segment Segment
+		segConf := segmentConfig{
+			mmapContents:             sg.mmapContents,
+			useBloomFilter:           sg.useBloomFilter,
+			calcCountNetAdditions:    sg.calcCountNetAdditions,
+			overwriteDerived:         false,
+			enableChecksumValidation: sg.enableChecksumValidation,
+			MinMMapSize:              sg.MinMMapSize,
+			allocChecker:             sg.allocChecker,
+			fileList:                 files,
+			writeMetadata:            sg.writeMetadata,
+		}
+		var err error
+		if b.lazySegmentLoading {
+			segment, err = newLazySegment(filepath.Join(sg.dir, entry), logger,
+				metrics, sg.makeExistsOn(sg.segments[:segmentIndex]), segConf,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("init lazy segment %s: %w", filepath.Join(sg.dir, entry), err)
+			}
+		} else {
+			segment, err = newSegment(filepath.Join(sg.dir, entry), logger,
+				metrics, sg.makeExistsOn(sg.segments[:segmentIndex]), segConf,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("init segment %s: %w", filepath.Join(sg.dir, entry), err)
+			}
+		}
+		sg.segments[segmentIndex] = segment
+		segmentIndex++
+	}
+
+	sg.segments = sg.segments[:segmentIndex]
+
+	// segment load order is as follows:
+	// - find .tmp files and recover them first
+	// - find .db files and load them
+	//   - if there is a .wal file exists for a .db, remove the .db file
+	// - find .wal files and load them into a memtable
+	//   - flush the memtable to a segment file
+	// Thus, files may be loaded in a different order than they were created,
+	// and we need to re-sort them to ensure the order is correct, as compations
+	// and other operations are based on the creation order of the segments
+	sort.Slice(sg.segments, func(i, j int) bool {
+		return sg.segments[i].getPath() < sg.segments[j].getPath()
+	})
+
+	// Actual strategy is stored in segment files. In case it is SetCollection,
+	// while new implementation uses bitmaps and supposed to be RoaringSet,
+	// bucket and segmentgroup strategy is changed back to SetCollection
+	// (memtables will be created later on, with already modified strategy)
+	// TODO what if only WAL files exists, and there is no segment to get actual strategy?
+	if b.strategy == StrategyRoaringSet && len(sg.segments) > 0 &&
+		sg.segments[0].getStrategy() == segmentindex.StrategySetCollection {
+		b.strategy = StrategySetCollection
+		b.desiredStrategy = StrategyRoaringSet
+		sg.strategy = StrategySetCollection
+	}
+	// As of v1.19 property's IndexInterval setting is replaced with
+	// IndexFilterable (roaring set) + IndexSearchable (map) and enabled by default.
+	// Buckets for text/text[] inverted indexes created before 1.19 have strategy
+	// map and name that since 1.19 is used by filterable indeverted index.
+	// Those buckets (roaring set by configuration, but in fact map) have to be
+	// renamed on startup by migrator. Here actual strategy is set based on
+	// data found in segment files
+	if b.strategy == StrategyRoaringSet && len(sg.segments) > 0 &&
+		sg.segments[0].getStrategy() == segmentindex.StrategyMapCollection {
+		b.strategy = StrategyMapCollection
+		b.desiredStrategy = StrategyRoaringSet
+		sg.strategy = StrategyMapCollection
+	}
+
+	// Inverted segments share a lot of their logic as the MapCollection,
+	// and the main difference is in the way they store their data.
+	// Setting the desired strategy to Inverted will make sure that we can
+	// distinguish between the two strategies for search.
+	// The changes only apply when we have segments on disk,
+	// as the memtables will always be created with the MapCollection strategy.
+	if b.strategy == StrategyInverted && len(sg.segments) > 0 &&
+		sg.segments[0].getStrategy() == segmentindex.StrategyMapCollection {
+		b.strategy = StrategyMapCollection
+		b.desiredStrategy = StrategyInverted
+		sg.strategy = StrategyMapCollection
+	} else if b.strategy == StrategyMapCollection && len(sg.segments) > 0 &&
+		sg.segments[0].getStrategy() == segmentindex.StrategyInverted {
+		// TODO amourao: blockmax "else" to be removed before final release
+		// in case bucket was created as inverted and default strategy was reverted to map
+		// by unsetting corresponding env variable
+		b.strategy = StrategyInverted
+		b.desiredStrategy = StrategyMapCollection
+		sg.strategy = StrategyInverted
+	}
+
+	if err := b.mayRecoverFromCommitLogs(ctx, sg, files); err != nil {
+		return nil, err
+	}
+
+	if sg.monitorCount {
+		sg.metrics.ObjectCount(sg.count())
+	}
+
+	sc, err := newSegmentCleaner(sg)
+	if err != nil {
+		return nil, err
+	}
+	sg.segmentCleaner = sc
+
+	// if a segment exists of the map collection strategy, we need to
+	// convert the inverted strategy to a map collection strategy
+	// as it is done on the bucket level
+	if sg.strategy == StrategyInverted && len(sg.segments) > 0 &&
+		sg.segments[0].getStrategy() == segmentindex.StrategyMapCollection {
+		sg.strategy = StrategyMapCollection
+	}
+
+	switch sg.strategy {
+	case StrategyInverted:
+		// start with last but one segment, as the last one doesn't need tombstones for now
+		for i := len(sg.segments) - 2; i >= 0; i-- {
+			// avoid crashing if segment has no tombstones
+			tombstonesNext, err := sg.segments[i+1].ReadOnlyTombstones()
+			if err != nil {
+				return nil, fmt.Errorf("init segment %s: load tombstones %w", sg.segments[i+1].getPath(), err)
+			}
+			if _, err := sg.segments[i].MergeTombstones(tombstonesNext); err != nil {
+				return nil, fmt.Errorf("init segment %s: merge tombstones %w", sg.segments[i].getPath(), err)
+			}
+		}
+
+	case StrategyRoaringSetRange:
+		if cfg.keepSegmentsInMemory {
+			t := time.Now()
+			sg.roaringSetRangeSegmentInMemory = roaringsetrange.NewSegmentInMemory()
+			for _, seg := range sg.segments {
+				cursor := seg.newRoaringSetRangeCursor()
+				if err := sg.roaringSetRangeSegmentInMemory.MergeSegmentByCursor(cursor); err != nil {
+					return nil, fmt.Errorf("build segment-in-memory of strategy '%s': %w", sg.strategy, err)
+				}
+			}
+			logger.WithFields(logrus.Fields{
+				"took":    time.Since(t).String(),
+				"bucket":  filepath.Base(cfg.dir),
+				"size_mb": fmt.Sprintf("%.3f", float64(sg.roaringSetRangeSegmentInMemory.Size())/1024/1024),
+			}).Debug("rangeable segment-in-memory built")
+		}
+	}
+
+	id := "segmentgroup/compaction/" + sg.dir
+	sg.compactionCallbackCtrl = compactionCallbacks.Register(id, sg.compactOrCleanup)
+
+	return sg, nil
+}
+
+func (sg *SegmentGroup) makeExistsOn(segments []Segment) existsOnLowerSegmentsFn {
+	return func(key []byte) (bool, error) {
+		if len(segments) == 0 {
+			// this is already the lowest possible segment, we can guarantee that
+			// any key in this segment is previously unseen.
+			return false, nil
+		}
+
+		v, err := sg.getWithUpperSegmentBoundary(key, segments)
+		if err != nil {
+			return false, fmt.Errorf("check exists on segments: %w", err)
+		}
+
+		return v != nil, nil
+	}
+}
+
+func (sg *SegmentGroup) add(path string) error {
+	sg.maintenanceLock.Lock()
+	defer sg.maintenanceLock.Unlock()
+
+	segment, err := newSegment(path, sg.logger,
+		sg.metrics, sg.makeExistsOn(sg.segments),
+		segmentConfig{
+			mmapContents:             sg.mmapContents,
+			useBloomFilter:           sg.useBloomFilter,
+			calcCountNetAdditions:    sg.calcCountNetAdditions,
+			overwriteDerived:         true,
+			enableChecksumValidation: sg.enableChecksumValidation,
+			MinMMapSize:              sg.MinMMapSize,
+			allocChecker:             sg.allocChecker,
+			writeMetadata:            sg.writeMetadata,
+		})
+	if err != nil {
+		return fmt.Errorf("init segment %s: %w", path, err)
+	}
+
+	sg.segments = append(sg.segments, segment)
+	return nil
+}
+
+func (sg *SegmentGroup) getAndLockSegments() (segments []Segment, release func()) {
+	sg.cursorsLock.RLock()
+	sg.maintenanceLock.RLock()
+
+	if len(sg.enqueuedSegments) == 0 {
+		return sg.segments, func() {
+			sg.cursorsLock.RUnlock()
+			sg.maintenanceLock.RUnlock()
+		}
+	}
+
+	segments = make([]Segment, 0, len(sg.segments)+len(sg.enqueuedSegments))
+
+	segments = append(segments, sg.segments...)
+	segments = append(segments, sg.enqueuedSegments...)
+
+	return segments, func() {
+		sg.cursorsLock.RUnlock()
+		sg.maintenanceLock.RUnlock()
+	}
+}
+
+func (sg *SegmentGroup) addInitializedSegment(segment *segment) error {
+	sg.cursorsLock.Lock()
+	defer sg.cursorsLock.Unlock()
+
+	if sg.activeCursors > 0 {
+		sg.enqueuedSegments = append(sg.enqueuedSegments, segment)
+		return nil
+	}
+
+	sg.maintenanceLock.Lock()
+	defer sg.maintenanceLock.Unlock()
+
+	sg.segments = append(sg.segments, segment)
+	return nil
+}
+
+func (sg *SegmentGroup) get(key []byte) ([]byte, error) {
+	beforeMaintenanceLock := time.Now()
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	if time.Since(beforeMaintenanceLock) > 100*time.Millisecond {
+		sg.logger.WithField("duration", time.Since(beforeMaintenanceLock)).
+			WithField("action", "lsm_segment_group_get_obtain_maintenance_lock").
+			Debug("waited over 100ms to obtain maintenance lock in segment group get()")
+	}
+
+	return sg.getWithUpperSegmentBoundary(key, segments)
+}
+
+// not thread-safe on its own, as the assumption is that this is called from a
+// lockholder, e.g. within .get()
+func (sg *SegmentGroup) getWithUpperSegmentBoundary(key []byte, segments []Segment) ([]byte, error) {
+	// assumes "replace" strategy
+
+	// start with latest and exit as soon as something is found, thus making sure
+	// the latest takes presence
+	for i := len(segments) - 1; i >= 0; i-- {
+		beforeSegment := time.Now()
+		v, err := segments[i].get(key)
+		if time.Since(beforeSegment) > 100*time.Millisecond {
+			sg.logger.WithField("duration", time.Since(beforeSegment)).
+				WithField("action", "lsm_segment_group_get_individual_segment").
+				WithError(err).
+				WithField("segment_pos", i).
+				Debug("waited over 100ms to get result from individual segment")
+		}
+		if err != nil {
+			if errors.Is(err, lsmkv.NotFound) {
+				continue
+			}
+
+			if errors.Is(err, lsmkv.Deleted) {
+				return nil, nil
+			}
+
+			panic(fmt.Sprintf("unsupported error in segmentGroup.get(): %v", err))
+		}
+
+		return v, nil
+	}
+
+	return nil, nil
+}
+
+func (sg *SegmentGroup) getErrDeleted(key []byte) ([]byte, error) {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	return sg.getWithUpperSegmentBoundaryErrDeleted(key, segments)
+}
+
+func (sg *SegmentGroup) getWithUpperSegmentBoundaryErrDeleted(key []byte, segments []Segment) ([]byte, error) {
+	// assumes "replace" strategy
+
+	// start with latest and exit as soon as something is found, thus making sure
+	// the latest takes presence
+	for i := len(segments) - 1; i >= 0; i-- {
+		v, err := segments[i].get(key)
+		if err != nil {
+			if errors.Is(err, lsmkv.NotFound) {
+				continue
+			}
+
+			if errors.Is(err, lsmkv.Deleted) {
+				return nil, err
+			}
+
+			panic(fmt.Sprintf("unsupported error in segmentGroup.get(): %v", err))
+		}
+
+		return v, nil
+	}
+
+	return nil, lsmkv.NotFound
+}
+
+func (sg *SegmentGroup) getBySecondaryIntoMemory(pos int, key []byte, buffer []byte) ([]byte, []byte, []byte, error) {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	// assumes "replace" strategy
+
+	// start with latest and exit as soon as something is found, thus making sure
+	// the latest takes presence
+	for i := len(segments) - 1; i >= 0; i-- {
+		k, v, allocatedBuff, err := segments[i].getBySecondaryIntoMemory(pos, key, buffer)
+		if err != nil {
+			if errors.Is(err, lsmkv.NotFound) {
+				continue
+			}
+
+			if errors.Is(err, lsmkv.Deleted) {
+				return nil, nil, nil, nil
+			}
+
+			panic(fmt.Sprintf("unsupported error in segmentGroup.get(): %v", err))
+		}
+
+		return k, v, allocatedBuff, nil
+	}
+
+	return nil, nil, nil, nil
+}
+
+func (sg *SegmentGroup) getCollection(key []byte) ([]value, error) {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	var out []value
+
+	// start with first and do not exit
+	for _, segment := range segments {
+		v, err := segment.getCollection(key)
+		if err != nil {
+			if errors.Is(err, lsmkv.NotFound) {
+				continue
+			}
+
+			return nil, err
+		}
+
+		if len(out) == 0 {
+			out = v
+		} else {
+			out = append(out, v...)
+		}
+	}
+
+	return out, nil
+}
+
+func (sg *SegmentGroup) getCollectionAndSegments(key []byte) ([][]value, []Segment, func(), error) {
+	segments, release := sg.getAndLockSegments()
+
+	out := make([][]value, len(segments))
+	outSegments := make([]Segment, len(segments))
+
+	i := 0
+	// start with first and do not exit
+	for _, segment := range segments {
+		v, err := segment.getCollection(key)
+		if err != nil {
+			if !errors.Is(err, lsmkv.NotFound) {
+				release()
+				return nil, nil, func() {}, err
+			}
+			// inverted segments need to be loaded anyway, even if they don't have
+			// the key, as we need to know if they have tombstones
+			if segment.getStrategy() != segmentindex.StrategyInverted {
+				continue
+			}
+		}
+
+		out[i] = v
+		outSegments[i] = segment
+		i++
+	}
+
+	return out[:i], outSegments[:i], release, nil
+}
+
+func (sg *SegmentGroup) roaringSetGet(key []byte) (out roaringset.BitmapLayers, release func(), err error) {
+	segments, sgRelease := sg.getAndLockSegments()
+	defer sgRelease()
+
+	ln := len(segments)
+	if ln == 0 {
+		return nil, noopRelease, nil
+	}
+
+	release = noopRelease
+	// use bigger buffer for first layer, to make space for further merges
+	// with following layers
+	bitmapBufPool := roaringset.NewBitmapBufPoolFactorWrapper(sg.bitmapBufPool, 1.25)
+
+	i := 0
+	for ; i < ln; i++ {
+		layer, layerRelease, err := segments[i].roaringSetGet(key, bitmapBufPool)
+		if err == nil {
+			out = append(out, layer)
+			release = layerRelease
+			i++
+			break
+		}
+		if !errors.Is(err, lsmkv.NotFound) {
+			return nil, noopRelease, err
+		}
+	}
+	defer func() {
+		if err != nil {
+			release()
+		}
+	}()
+
+	for ; i < ln; i++ {
+		if err := segments[i].roaringSetMergeWith(key, out[0], sg.bitmapBufPool); err != nil {
+			return nil, noopRelease, err
+		}
+	}
+
+	return out, release, nil
+}
+
+func (sg *SegmentGroup) count() int {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	count := 0
+	for _, seg := range segments {
+		count += seg.getSegment().getCountNetAdditions()
+	}
+
+	return count
+}
+
+func (sg *SegmentGroup) Size() int64 {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	totalSize := int64(0)
+	for _, seg := range segments {
+		totalSize += int64(seg.getSize())
+	}
+
+	return totalSize
+}
+
+// MetadataSize returns the total size of metadata files (.bloom and .cna) from segments in memory
+// MetadataSize returns the total size of metadata files for all segments.
+// The calculation differs based on the writeMetadata setting:
+//
+// When writeMetadata is enabled:
+//   - Counts the actual file size of .metadata files on disk
+//   - Each .metadata file contains: header + bloom filters + count net additions
+//   - Header includes: checksum (4 bytes) + version (1 byte) + bloom len (4 bytes) + cna len (4 bytes) = 13 bytes
+//   - Bloom filters are serialized and stored inline
+//   - CNA data includes: uint64 count (8 bytes) + length indicator (4 bytes) = 12 bytes
+//
+// When writeMetadata is disabled:
+//   - Counts bloom filters in memory (getBloomFilterSize)
+//   - Counts .cna files separately (12 bytes each: 8 bytes data + 4 bytes checksum)
+//   - This represents the legacy behavior where metadata was stored separately
+//
+// The total size should be equivalent between both modes, accounting for the
+// metadata file header overhead when writeMetadata is enabled.
+func (sg *SegmentGroup) MetadataSize() int64 {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	var totalSize int64
+	for _, segment := range segments {
+		if sg.writeMetadata {
+			// When writeMetadata is enabled, count .metadata files
+			// Each .metadata file contains bloom filters + count net additions
+			if seg := segment.getSegment(); seg != nil {
+				// Check if segment has metadata file
+				metadataPath := seg.metadataPath()
+				if metadataPath != "" {
+					exists, err := fileExists(metadataPath)
+					if err == nil && exists {
+						// Get the actual file size of the metadata file
+						if info, err := os.Stat(metadataPath); err == nil {
+							totalSize += info.Size()
+						}
+					}
+				}
+			}
+		} else {
+			// When writeMetadata is disabled, count bloom filters and .cna files separately
+			if seg := segment.getSegment(); seg != nil {
+				// Count bloom filters in memory
+				if seg.bloomFilter != nil {
+					totalSize += int64(getBloomFilterSize(seg.bloomFilter))
+				}
+				// Count secondary bloom filters
+				for _, bf := range seg.secondaryBloomFilters {
+					if bf != nil {
+						totalSize += int64(getBloomFilterSize(bf))
+					}
+				}
+			}
+
+			// Count .cna files (12 bytes each)
+			if segment.getSegment().countNetPath() != "" {
+				// .cna files: uint64 count (8 bytes) + uint32 checksum (4 bytes) = 12 bytes
+				totalSize += 12
+			}
+		}
+	}
+
+	return totalSize
+}
+
+func (sg *SegmentGroup) shutdown(ctx context.Context) error {
+	if err := sg.compactionCallbackCtrl.Unregister(ctx); err != nil {
+		return fmt.Errorf("long-running compaction in progress: %w", ctx.Err())
+	}
+	if err := sg.segmentCleaner.close(); err != nil {
+		return err
+	}
+
+	sg.cursorsLock.Lock()
+	defer sg.cursorsLock.Unlock()
+
+	for _, seg := range sg.enqueuedSegments {
+		seg.close()
+	}
+
+	// Lock acquirement placed after compaction cycle stop request, due to occasional deadlock,
+	// because compaction logic used in cycle also requires maintenance lock.
+	//
+	// If lock is grabbed by shutdown method and compaction in cycle loop starts right after,
+	// it is blocked waiting for the same lock, eventually blocking entire cycle loop and preventing to read stop signal.
+	// If stop signal can not be read, shutdown will not receive stop result and will not proceed with further execution.
+	// Maintenance lock will then never be released.
+	sg.maintenanceLock.Lock()
+	defer sg.maintenanceLock.Unlock()
+
+	for _, seg := range sg.segments {
+		if err := seg.close(); err != nil {
+			return err
+		}
+	}
+
+	// make sure the segment list itself is set to nil. In case a memtable will
+	// still flush after closing, it might try to read from a disk segment list
+	// otherwise and run into nil-pointer problems.
+	sg.segments = nil
+
+	return nil
+}
+
+func (sg *SegmentGroup) UpdateStatus(status storagestate.Status) {
+	sg.statusLock.Lock()
+	defer sg.statusLock.Unlock()
+
+	sg.status = status
+}
+
+func (sg *SegmentGroup) isReadyOnly() bool {
+	sg.statusLock.Lock()
+	defer sg.statusLock.Unlock()
+
+	return sg.status == storagestate.StatusReadOnly
+}
+
+func fileExists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+
+	if errors.Is(err, fs.ErrNotExist) {
+		return false, nil
+	}
+
+	return false, err
+}
+
+func segmentExistsWithID(segmentID string, files map[string]int64) (bool, string) {
+	// segment file format is "segment-{segmentID}.EXT" where EXT is either
+	// - ".db" if extra infos in filename are not used
+	// - ".{extra_infos}.db" if extra infos in filename are used
+	match := fmt.Sprintf("segment-%s.", segmentID)
+	for fileName := range files {
+		if strings.HasPrefix(fileName, match) && strings.HasSuffix(fileName, ".db") {
+			return true, fileName
+		}
+	}
+	return false, ""
+}
+
+func (sg *SegmentGroup) compactOrCleanup(shouldAbort cyclemanager.ShouldAbortCallback) bool {
+	sg.monitorSegments()
+
+	compact := func() bool {
+		sg.lastCompactionCall = time.Now()
+		compacted, err := sg.compactOnce()
+		if err != nil {
+			sg.logger.WithField("action", "lsm_compaction").
+				WithField("path", sg.dir).
+				WithError(err).
+				Errorf("compaction failed")
+		} else if !compacted {
+			sg.logger.WithField("action", "lsm_compaction").
+				WithField("path", sg.dir).
+				Trace("no segments eligible for compaction")
+		}
+		return compacted
+	}
+	cleanup := func() bool {
+		sg.lastCleanupCall = time.Now()
+		cleaned, err := sg.segmentCleaner.cleanupOnce(shouldAbort)
+		if err != nil {
+			sg.logger.WithField("action", "lsm_cleanup").
+				WithField("path", sg.dir).
+				WithError(err).
+				Errorf("cleanup failed")
+		}
+		return cleaned
+	}
+
+	// alternatively run compaction or cleanup first
+	// if 1st one called succeeds, 2nd one is skipped, otherwise 2nd one is called as well
+	//
+	// compaction has the precedence over cleanup, however if cleanup
+	// was not called for over [forceCleanupInterval], force at least one execution
+	// in between compactions.
+	// (ignore if compaction was not called within that time either)
+	forceCleanupInterval := time.Hour * 12
+
+	if time.Since(sg.lastCleanupCall) > forceCleanupInterval && sg.lastCleanupCall.Before(sg.lastCompactionCall) {
+		return cleanup() || compact()
+	}
+	return compact() || cleanup()
+}
+
+func (sg *SegmentGroup) Len() int {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	return len(segments)
+}
+
+func (sg *SegmentGroup) GetAveragePropertyLength() (float64, uint64) {
+	segments, release := sg.getAndLockSegments()
+	defer release()
+
+	if len(segments) == 0 {
+		return 0, 0
+	}
+
+	totalDocCount := uint64(0)
+	for _, segment := range segments {
+		invertedData := segment.getInvertedData()
+		totalDocCount += invertedData.avgPropertyLengthsCount
+	}
+
+	if totalDocCount == 0 {
+		return defaultAveragePropLength, 0
+	}
+
+	weightedAverage := 0.0
+	for _, segment := range segments {
+		invertedData := segment.getInvertedData()
+		weightedAverage += float64(invertedData.avgPropertyLengthsCount) / float64(totalDocCount) * invertedData.avgPropertyLengthsAvg
+	}
+
+	return weightedAverage, totalDocCount
+}

platform/dbops/binaries/weaviate-src/adapters/repos/db/lsmkv/segment_group_cleanup.go

@@ -0,0 +1,681 @@
+//                           _       _
+// __      _____  __ ___   ___  __ _| |_ ___
+// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
+//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
+//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
+//
+//  Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
+//
+//  CONTACT: hello@weaviate.io
+//
+
+package lsmkv
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+
+	"github.com/sirupsen/logrus"
+	"github.com/weaviate/weaviate/entities/cyclemanager"
+	"github.com/weaviate/weaviate/entities/diskio"
+	bolt "go.etcd.io/bbolt"
+)
+
+const (
+	cleanupDbFileName     = "cleanup.db.bolt"
+	emptyIdx              = -1
+	minCleanupSizePercent = 10
+)
+
+var (
+	cleanupDbBucketSegments       = []byte("segments")
+	cleanupDbBucketMeta           = []byte("meta")
+	cleanupDbKeyMetaNextAllowedTs = []byte("nextAllowedTs")
+)
+
+type segmentCleaner interface {
+	close() error
+	cleanupOnce(shouldAbort cyclemanager.ShouldAbortCallback) (cleaned bool, err error)
+}
+
+func newSegmentCleaner(sg *SegmentGroup) (segmentCleaner, error) {
+	if sg.cleanupInterval <= 0 {
+		return &segmentCleanerNoop{}, nil
+	}
+
+	switch sg.strategy {
+	case StrategyReplace:
+		cleaner := &segmentCleanerCommon{sg: sg}
+		if err := cleaner.init(); err != nil {
+			return nil, err
+		}
+		return cleaner, nil
+	case StrategyMapCollection,
+		StrategySetCollection,
+		StrategyRoaringSet,
+		StrategyRoaringSetRange,
+		StrategyInverted:
+		return &segmentCleanerNoop{}, nil
+	default:
+		return nil, fmt.Errorf("unrecognized strategy %q", sg.strategy)
+	}
+}
+
+// ================================================================
+
+type segmentCleanerNoop struct{}
+
+func (c *segmentCleanerNoop) close() error {
+	return nil
+}
+
+func (c *segmentCleanerNoop) cleanupOnce(shouldAbort cyclemanager.ShouldAbortCallback) (bool, error) {
+	return false, nil
+}
+
+// ================================================================
+
+// segmentCleanerCommon uses bolt db to persist data relevant to cleanup
+// progress.
+// db is stored in file named [cleanupDbFileName] in bucket directory, next to
+// segment files.
+//
+// db uses 2 buckets:
+// - [cleanupDbBucketMeta] to store global cleanup data
+// - [cleanupDbBucketSegments] to store each segments cleanup data
+//
+// [cleanupDbBucketMeta] holds single key [cleanupDbKeyMetaNextAllowedTs] with value of
+// timestamp of earliest of last segments' cleanups or last execution timestamp of findCandidate
+// if no eligible cleanup candidate was found.
+// [cleanupDbBucketSegments] holds multiple keys (being segment ids) with values being combined:
+// - timestamp of current segment's cleanup
+// - segmentId of last segment used in current segment's cleanup
+// - size of current segment after cleanup
+// Entries of segmentIds of segments that were removed (left segments after compaction)
+// are regularly removed from cleanup db while next cleanup candidate is searched.
+//
+// cleanupInterval indicates minimal interval that have to pass for segment to be cleaned again.
+// Each segment has stored its last cleanup timestamp in cleanup bolt db.
+// Additionally "global" earliest cleanup timestamp is stored ([cleanupDbKeyMetaNextAllowedTs])
+// or last execution timestamp of findCandiate method. This timeout is used to quickly exit
+// findCandidate method without necessity to verify if interval passed for each segment.
+type segmentCleanerCommon struct {
+	sg *SegmentGroup
+	db *bolt.DB
+}
+
+func (c *segmentCleanerCommon) init() error {
+	path := filepath.Join(c.sg.dir, cleanupDbFileName)
+	var db *bolt.DB
+	var err error
+
+	if db, err = bolt.Open(path, 0o600, nil); err != nil {
+		return fmt.Errorf("open cleanup bolt db %q: %w", path, err)
+	}
+
+	if err = db.Update(func(tx *bolt.Tx) error {
+		if _, err := tx.CreateBucketIfNotExists(cleanupDbBucketSegments); err != nil {
+			return err
+		}
+		if _, err := tx.CreateBucketIfNotExists(cleanupDbBucketMeta); err != nil {
+			return err
+		}
+		return nil
+	}); err != nil {
+		return fmt.Errorf("create bucket cleanup bolt db %q: %w", path, err)
+	}
+
+	c.db = db
+	return nil
+}
+
+func (c *segmentCleanerCommon) close() error {
+	if err := c.db.Close(); err != nil {
+		return fmt.Errorf("close cleanup bolt db %q: %w", c.db.Path(), err)
+	}
+	return nil
+}
+
+// findCandidate returns index of segment that should be cleaned as next one,
+// index of first newer segment to start cleanup from, index of last newer segment
+// to finish cleanup on, callback to be executed after cleanup is successfully completed
+// and error in case of issues occurred while finding candidate
+func (c *segmentCleanerCommon) findCandidate() (int, int, int, onCompletedFunc, error) {
+	nowTs := time.Now().UnixNano()
+	nextAllowedTs := nowTs - int64(c.sg.cleanupInterval)
+	nextAllowedStoredTs := c.readNextAllowed()
+
+	if nextAllowedStoredTs > nextAllowedTs {
+		// too soon for next cleanup
+		return emptyIdx, emptyIdx, emptyIdx, nil, nil
+	}
+
+	ids, sizes, err := c.getSegmentIdsAndSizes()
+	if err != nil {
+		return emptyIdx, emptyIdx, emptyIdx, nil, err
+	}
+	if count := len(ids); count <= 1 {
+		// too few segments for cleanup, update next allowed timestamp for cleanup to now
+		if err := c.storeNextAllowed(nowTs); err != nil {
+			return emptyIdx, emptyIdx, emptyIdx, nil, err
+		}
+		return emptyIdx, emptyIdx, emptyIdx, nil, nil
+	}
+
+	// get idx and cleanup timestamp of earliest cleaned segment,
+	// take the opportunity to find obsolete segment keys to be deleted later from cleanup db
+	candidateIdx, startIdx, lastIdx, earliestCleanedTs, nonExistentSegmentKeys := c.readEarliestCleaned(ids, sizes, nowTs)
+
+	if err := c.deleteSegmentMetas(nonExistentSegmentKeys); err != nil {
+		return emptyIdx, emptyIdx, emptyIdx, nil, err
+	}
+
+	if candidateIdx != emptyIdx && earliestCleanedTs <= nextAllowedTs {
+		// candidate found and ready for cleanup
+		id := ids[candidateIdx]
+		lastProcessedId := ids[len(ids)-1]
+		onCompleted := func(size int64) error {
+			return c.storeSegmentMeta(id, lastProcessedId, size, nowTs)
+		}
+		return candidateIdx, startIdx, lastIdx, onCompleted, nil
+	}
+
+	// candidate not found or not ready for cleanup, update next allowed timestamp to earliest cleaned segment
+	// (which is "now" if candidate was not found)
+	if err := c.storeNextAllowed(earliestCleanedTs); err != nil {
+		return emptyIdx, emptyIdx, emptyIdx, nil, err
+	}
+
+	return emptyIdx, emptyIdx, emptyIdx, nil, nil
+}
+
+func (c *segmentCleanerCommon) getSegmentIdsAndSizes() ([]int64, []int64, error) {
+	segments, release := c.sg.getAndLockSegments()
+	defer release()
+
+	var ids []int64
+	var sizes []int64
+	if count := len(segments); count > 1 {
+		ids = make([]int64, count)
+		sizes = make([]int64, count)
+
+		for i, seg := range segments {
+			idStr := segmentID(seg.getPath())
+			id, err := strconv.ParseInt(idStr, 10, 64)
+			if err != nil {
+				return nil, nil, fmt.Errorf("parse segment id %q: %w", idStr, err)
+			}
+			ids[i] = id
+			sizes[i] = seg.getSize()
+		}
+	}
+
+	return ids, sizes, nil
+}
+
+func (c *segmentCleanerCommon) readNextAllowed() int64 {
+	ts := int64(0)
+	c.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket(cleanupDbBucketMeta)
+		v := b.Get(cleanupDbKeyMetaNextAllowedTs)
+		if v != nil {
+			ts = int64(binary.BigEndian.Uint64(v))
+		}
+		return nil
+	})
+	return ts
+}
+
+func (c *segmentCleanerCommon) storeNextAllowed(ts int64) error {
+	if err := c.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket(cleanupDbBucketMeta)
+		bufV := make([]byte, 8)
+
+		binary.BigEndian.PutUint64(bufV, uint64(ts))
+		return b.Put(cleanupDbKeyMetaNextAllowedTs, bufV)
+	}); err != nil {
+		return fmt.Errorf("updating cleanup bolt db %q: %w", c.db.Path(), err)
+	}
+	return nil
+}
+
+func (c *segmentCleanerCommon) deleteSegmentMetas(segIds [][]byte) error {
+	if len(segIds) > 0 {
+		if err := c.db.Update(func(tx *bolt.Tx) error {
+			b := tx.Bucket(cleanupDbBucketSegments)
+			for _, k := range segIds {
+				if err := b.Delete(k); err != nil {
+					return err
+				}
+			}
+			return nil
+		}); err != nil {
+			return fmt.Errorf("deleting from cleanup bolt db %q: %w", c.db.Path(), err)
+		}
+	}
+	return nil
+}
+
+// based of data stored in cleanup bolt db and existing segments in filesystem
+// method returns:
+// - index of candidate segment best suitable for cleanup,
+// - index of segment, cleanup of candidate should be started from,
+// - index of segment, cleanup of candidate should be finished on,
+// - time of previous candidate's cleanup,
+// - list of segmentIds stored in cleanup bolt db that no longer exist in filesystem
+// - error (if occurred).
+//
+// First candidate to be returned is segment that was not cleaned before (if multiple
+// uncleaned segments exist - the oldest one is returned).
+// If there is no unclean segment, segment that was cleaned as the earliest is returned.
+// For segment already cleaned before to be returned, new segments must have been created
+// after previous cleanup and sum of their sizes should be greater than [minCleanupSizePercent]
+// percent of size of cleaned segment, to increase the chance of segment being actually cleaned,
+// not just copied.
+func (c *segmentCleanerCommon) readEarliestCleaned(ids, sizes []int64, nowTs int64,
+) (int, int, int, int64, [][]byte) {
+	earliestCleanedTs := nowTs
+	candidateIdx := emptyIdx
+	startIdx := emptyIdx
+	lastIdx := emptyIdx
+
+	count := len(ids)
+	nonExistentSegmentKeys := [][]byte{}
+	emptyId := int64(-1)
+
+	c.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket(cleanupDbBucketSegments)
+		cur := b.Cursor()
+
+		// Loop through all segmentIds, the ones stored in cleanup db (cur)
+		// and ones currently existing in filesystem (ids).
+		// Note: both sets of segmentIds may have unique elements:
+		// - cursor can contain segmentIds of segments already removed (by compaction)
+		// - ids can contain segmentIds of newly created segments
+		// Note: both sets are ordered, therefore in case of one element is missing
+		// in set, only this set advances to next element
+		idx := 0
+		key, val := cur.First()
+		for idx < count-1 || key != nil {
+			id := emptyId
+			storedId := emptyId
+
+			if idx < count-1 {
+				id = ids[idx]
+			}
+			if key != nil {
+				storedId = int64(binary.BigEndian.Uint64(key))
+			}
+
+			// segment with segmentId stored in cleanup db (storedId) no longer exists,
+			if id == emptyId || (storedId != emptyId && id > storedId) {
+				// entry to be deleted
+				nonExistentSegmentKeys = append(nonExistentSegmentKeys, key)
+				// advance cursor
+				key, val = cur.Next()
+				continue
+			}
+
+			// segment with segmentId in filesystem (id) has no entry in cleanup db,
+			if storedId == emptyId || (id != emptyId && id < storedId) {
+				// as segment was not cleaned before (timestamp == 0), it becomes best
+				// candidate for next cleanup.
+				// (if there are more segments not yet cleaned, 1st one is selected)
+				if earliestCleanedTs > 0 {
+					earliestCleanedTs = 0
+					candidateIdx = idx
+					startIdx = idx + 1
+					lastIdx = count - 1
+				}
+				// advance index
+				idx++
+				continue
+			}
+
+			// segmentId present in both sets, had to be cleaned before
+			// id == cid
+
+			storedCleanedTs := int64(binary.BigEndian.Uint64(val[0:8]))
+			// check if cleaned before current candidate
+			if earliestCleanedTs > storedCleanedTs {
+				lastId := ids[count-1]
+				storedLastId := int64(binary.BigEndian.Uint64(val[8:16]))
+				// check if new segments created after last cleanup
+				if storedLastId < lastId {
+					// last segment's id in filesystem is higher than last id used for cleanup
+					size := sizes[idx]
+					storedSize := int64(binary.BigEndian.Uint64(val[16:24]))
+
+					// In general segment could be cleaned considering only segments created
+					// after its last cleanup. One exception is when segment was compacted
+					// (previous and current sizes differ).
+					// As after compaction cleanup db will contain only entry of right segment,
+					// not the left one, it is unknown what was last segment used for cleanup of removed
+					// left segment, therefore compacted segment will be cleaned again using all newer segments.
+					possibleStartIdx := idx + 1
+					// in case of using segments that were already used for cleanup, process them in reverse
+					// order starting with newest ones, to maximize the chance of finding redundant entries
+					// as soon as possible (leaving segments that were already used for cleanup as last ones)
+					reverseOrder := true
+					if size == storedSize {
+						reverseOrder = false
+						// size not changed (not compacted), clean using only newly created segments,
+						// skipping segments already processed in previous cleanup
+						for i := idx + 1; i < count; i++ {
+							possibleStartIdx = i
+							if ids[i] > storedLastId {
+								break
+							}
+						}
+					}
+
+					// segment should be cleaned only if sum of sizes of segments to be cleaned
+					// with exceeds [minCleanupSizePercent] of its current size, to increase
+					// probability of redunand keys.
+					sumSize := int64(0)
+					for i := possibleStartIdx; i < count; i++ {
+						sumSize += sizes[i]
+					}
+					if size*minCleanupSizePercent/100 <= sumSize {
+						earliestCleanedTs = storedCleanedTs
+						candidateIdx = idx
+						startIdx = possibleStartIdx
+						lastIdx = count - 1
+
+						if reverseOrder {
+							startIdx, lastIdx = lastIdx, startIdx
+						}
+					}
+				}
+			}
+			// advance cursor and index
+			key, val = cur.Next()
+			idx++
+		}
+		return nil
+	})
+	return candidateIdx, startIdx, lastIdx, earliestCleanedTs, nonExistentSegmentKeys
+}
+
+func (c *segmentCleanerCommon) storeSegmentMeta(id, lastProcessedId, size, cleanedTs int64) error {
+	bufK := make([]byte, 8)
+	binary.BigEndian.PutUint64(bufK, uint64(id))
+
+	bufV := make([]byte, 24)
+	binary.BigEndian.PutUint64(bufV[0:8], uint64(cleanedTs))
+	binary.BigEndian.PutUint64(bufV[8:16], uint64(lastProcessedId))
+	binary.BigEndian.PutUint64(bufV[16:24], uint64(size))
+
+	if err := c.db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket(cleanupDbBucketSegments)
+		return b.Put(bufK, bufV)
+	}); err != nil {
+		return fmt.Errorf("updating cleanup bolt db %q: %w", c.db.Path(), err)
+	}
+	return nil
+}
+
+func (c *segmentCleanerCommon) cleanupOnce(shouldAbort cyclemanager.ShouldAbortCallback,
+) (bool, error) {
+	if c.sg.isReadyOnly() {
+		return false, nil
+	}
+
+	var err error
+	candidateIdx, startIdx, lastIdx, onCompleted, err := c.findCandidate()
+	if err != nil {
+		return false, err
+	}
+	if candidateIdx == emptyIdx {
+		return false, nil
+	}
+
+	if c.sg.allocChecker != nil {
+		// allocChecker is optional
+		if err := c.sg.allocChecker.CheckAlloc(100 * 1024 * 1024); err != nil {
+			// if we don't have at least 100MB to spare, don't start a cleanup. A
+			// cleanup does not actually need a 100MB, but it will create garbage
+			// that needs to be cleaned up. If we're so close to the memory limit, we
+			// can increase stability by preventing anything that's not strictly
+			// necessary. Cleanup can simply resume when the cluster has been
+			// scaled.
+			c.sg.logger.WithFields(logrus.Fields{
+				"action": "lsm_cleanup",
+				"event":  "cleanup_skipped_oom",
+				"path":   c.sg.dir,
+			}).WithError(err).
+				Warnf("skipping cleanup due to memory pressure")
+
+			return false, nil
+		}
+	}
+
+	if shouldAbort() {
+		c.sg.logger.WithFields(logrus.Fields{
+			"action": "lsm_cleanup",
+			"path":   c.sg.dir,
+		}).Warnf("skipping cleanup due to shouldAbort")
+		return false, nil
+	}
+
+	oldSegment := c.sg.segmentAtPos(candidateIdx)
+	segmentId := segmentID(oldSegment.path)
+	tmpSegmentPath := filepath.Join(c.sg.dir, "segment-"+segmentId+segmentExtraInfo(oldSegment.level, oldSegment.strategy)+".db.tmp")
+	scratchSpacePath := oldSegment.path + "cleanup.scratch.d"
+
+	start := time.Now()
+	c.sg.logger.WithFields(logrus.Fields{
+		"action":       "lsm_cleanup",
+		"path":         c.sg.dir,
+		"candidateIdx": candidateIdx,
+		"startIdx":     startIdx,
+		"lastIdx":      lastIdx,
+		"segmentId":    segmentId,
+	}).Info("cleanup started with candidate")
+	defer func() {
+		l := c.sg.logger.WithFields(logrus.Fields{
+			"action":    "lsm_cleanup",
+			"path":      c.sg.dir,
+			"segmentId": segmentId,
+			"took":      time.Since(start),
+		})
+		if err == nil {
+			l.Info("clenaup finished")
+		} else {
+			l.WithError(err).Error("cleanup failed")
+		}
+	}()
+
+	file, err := os.Create(tmpSegmentPath)
+	if err != nil {
+		return false, err
+	}
+
+	switch c.sg.strategy {
+	case StrategyReplace:
+		c := newSegmentCleanerReplace(file, oldSegment.newCursor(),
+			c.sg.makeKeyExistsOnUpperSegments(startIdx, lastIdx), oldSegment.level,
+			oldSegment.secondaryIndexCount, scratchSpacePath, c.sg.enableChecksumValidation)
+		if err = c.do(shouldAbort); err != nil {
+			return false, err
+		}
+	default:
+		err = fmt.Errorf("unsported strategy %q", c.sg.strategy)
+		return false, err
+	}
+
+	if err = file.Sync(); err != nil {
+		err = fmt.Errorf("fsync cleaned segment file: %w", err)
+		return false, err
+	}
+	if err = file.Close(); err != nil {
+		err = fmt.Errorf("close cleaned segment file: %w", err)
+		return false, err
+	}
+
+	segment, err := c.sg.replaceSegment(candidateIdx, tmpSegmentPath)
+	if err != nil {
+		err = fmt.Errorf("replace compacted segments: %w", err)
+		return false, err
+	}
+	if err = onCompleted(segment.size); err != nil {
+		err = fmt.Errorf("callback cleaned segment file: %w", err)
+		return false, err
+	}
+
+	return true, nil
+}
+
+type onCompletedFunc func(size int64) error
+
+// ================================================================
+
+type keyExistsOnUpperSegmentsFunc func(key []byte) (bool, error)
+
+func (sg *SegmentGroup) makeKeyExistsOnUpperSegments(startIdx, lastIdx int) keyExistsOnUpperSegmentsFunc {
+	return func(key []byte) (bool, error) {
+		// asc order by default
+		i := startIdx
+		updateI := func() { i++ }
+		if startIdx > lastIdx {
+			// dest order
+			i = lastIdx
+			updateI = func() { i-- }
+		}
+
+		segAtPos := func() *segment {
+			segments, release := sg.getAndLockSegments()
+			defer release()
+
+			if i >= startIdx && i <= lastIdx {
+				j := i
+				updateI()
+				return segments[j].getSegment()
+			}
+			return nil
+		}
+
+		for seg := segAtPos(); seg != nil; seg = segAtPos() {
+			if exists, err := seg.exists(key); err != nil {
+				return false, err
+			} else if exists {
+				return true, nil
+			}
+		}
+		return false, nil
+	}
+}
+
+func (sg *SegmentGroup) replaceSegment(segmentIdx int, tmpSegmentPath string,
+) (*segment, error) {
+	oldSegment := sg.segmentAtPos(segmentIdx)
+	countNetAdditions := oldSegment.countNetAdditions
+
+	// as a guardrail validate that the segment is considered a .tmp segment.
+	// This way we can be sure that we're not accidentally operating on a live
+	// segment as the segment group completely ignores .tmp segment files
+	if !strings.HasSuffix(tmpSegmentPath, ".tmp") {
+		return nil, fmt.Errorf("pre computing a segment expects a .tmp segment path")
+	}
+
+	seg, err := newSegment(tmpSegmentPath, sg.logger, sg.metrics, nil,
+		segmentConfig{
+			mmapContents:                 sg.mmapContents,
+			useBloomFilter:               sg.useBloomFilter,
+			calcCountNetAdditions:        sg.calcCountNetAdditions,
+			overwriteDerived:             true,
+			enableChecksumValidation:     sg.enableChecksumValidation,
+			MinMMapSize:                  sg.MinMMapSize,
+			allocChecker:                 sg.allocChecker,
+			precomputedCountNetAdditions: &countNetAdditions,
+			writeMetadata:                sg.writeMetadata,
+		})
+	if err != nil {
+		return nil, fmt.Errorf("precompute segment meta: %w", err)
+	}
+
+	newSegment, err := sg.replaceSegmentBlocking(segmentIdx, oldSegment, seg)
+	if err != nil {
+		return nil, fmt.Errorf("replace segment (blocking): %w", err)
+	}
+
+	if err := sg.deleteOldSegmentsNonBlocking(oldSegment); err != nil {
+		// don't abort if the delete fails, we can still continue (albeit
+		// without freeing disk space that should have been freed). The
+		// compaction itself was successful.
+		sg.logger.WithError(err).WithFields(logrus.Fields{
+			"action": "lsm_replace_segments_delete_file",
+			"file":   oldSegment.path,
+		}).Error("failed to delete file already marked for deletion")
+	}
+
+	return newSegment, nil
+}
+
+func (sg *SegmentGroup) replaceSegmentBlocking(
+	segmentIdx int, oldSegment *segment, newSegment *segment,
+) (*segment, error) {
+	sg.maintenanceLock.Lock()
+	defer sg.maintenanceLock.Unlock()
+
+	start := time.Now()
+
+	if err := oldSegment.close(); err != nil {
+		return nil, fmt.Errorf("close disk segment %q: %w", oldSegment.path, err)
+	}
+	if err := oldSegment.markForDeletion(); err != nil {
+		return nil, fmt.Errorf("drop disk segment %q: %w", oldSegment.path, err)
+	}
+	if err := diskio.Fsync(sg.dir); err != nil {
+		return nil, fmt.Errorf("fsync segment directory %q: %w", sg.dir, err)
+	}
+
+	segmentId := segmentID(oldSegment.path)
+	newPath, err := sg.stripTmpExtension(newSegment.path, segmentId, segmentId)
+	if err != nil {
+		return nil, errors.Wrap(err, "strip .tmp extension of new segment")
+	}
+	newSegment.path = newPath
+
+	// the old segment have been deleted, we can now safely remove the .tmp
+	// extension from the new segment itself and the pre-computed files
+	for i, tmpPath := range newSegment.metaPaths {
+		path, err := sg.stripTmpExtension(tmpPath, segmentId, segmentId)
+		if err != nil {
+			return nil, fmt.Errorf("strip .tmp extension of new segment %q: %w", tmpPath, err)
+		}
+		newSegment.metaPaths[i] = path
+	}
+
+	sg.segments[segmentIdx] = newSegment
+
+	sg.observeReplaceDuration(start, segmentIdx, oldSegment, newSegment)
+	return newSegment, nil
+}
+
+func (sg *SegmentGroup) observeReplaceDuration(
+	start time.Time, segmentIdx int, oldSegment, newSegment *segment,
+) {
+	// observe duration - warn if it took too long
+	took := time.Since(start)
+	fields := sg.logger.WithFields(logrus.Fields{
+		"action":        "lsm_replace_segment_blocking",
+		"segment_index": segmentIdx,
+		"path_old":      oldSegment.path,
+		"path_new":      newSegment.path,
+		"took":          took,
+	})
+	msg := fmt.Sprintf("replacing segment took %s", took)
+	if took > replaceSegmentWarnThreshold {
+		fields.Warn(msg)
+	} else {
+		fields.Debug(msg)
+	}
+}