sort

h := &Entries{}
heap.Push(h, HeapEntry{sstable.Entry{
	Key:   []byte("key3"),
	Value: []byte("value"),
}, 1})
heap.Push(h, HeapEntry{sstable.Entry{
	Key:   []byte("key1"),
	Value: []byte("value"),
}, 2})
heap.Push(h, HeapEntry{sstable.Entry{
	Key:   []byte("key4"),
	Value: []byte("value"),
}, 3})
heap.Push(h, HeapEntry{sstable.Entry{
	Key:   []byte("key2"),
	Value: []byte("value2"),
}, 4})
heap.Push(h, HeapEntry{sstable.Entry{
	Key:   []byte("key2"),
	Value: []byte("value"),
}, 5})
fmt.Println(heap.Pop(h))
fmt.Println(heap.Pop(h))
fmt.Println(heap.Pop(h))
fmt.Println(heap.Pop(h))
fmt.Println(heap.Pop(h))

Output:

{{[107 101 121 49] [118 97 108 117 101]} 2}
{{[107 101 121 50] [118 97 108 117 101]} 5}
{{[107 101 121 50] [118 97 108 117 101 50]} 4}
{{[107 101 121 51] [118 97 108 117 101]} 1}
{{[107 101 121 52] [118 97 108 117 101]} 3}

c := &SliceCursor{
	sstable.Entry{Key: []byte{3}},
	sstable.Entry{Key: []byte{2}},
	sstable.Entry{Key: []byte{4}},
	sstable.Entry{Key: []byte{1}},
}

var files []*os.File
defer func() { //nolint:wsl
	for _, f := range files {
		f.Close()
	}
}()

for !c.Done() {
	f, _ := ioutil.TempFile("", "")

	name := f.Name()
	defer os.Remove(name)

	w := sstable.NewWriter(f)
	defer w.Close()

	fmt.Println(SortEntries(c, 20, w))
	fmt.Println("Cursor is done:", c.Done())

	r, _ := os.Open(name)
	files = append(files, r)
}

cursors := make([]sstable.Cursor, 0, len(files))

for _, f := range files {
	s, _ := sstable.NewSSTable(f)

	c := s.ScanFrom(nil)
	if c == nil {
		fmt.Println(c)
		return
	}

	cursors = append(cursors, c)
}

f, _ := ioutil.TempFile("", "")

name := f.Name()
defer os.Remove(name)

w := sstable.NewWriter(f)
if err := Merge(cursors, w); err != nil {
	fmt.Println(err)
	return
}

w.Close()

f2, _ := os.Open(name)
s, _ := sstable.NewSSTable(f2)

results := s.ScanFrom(nil)
if results == nil {
	fmt.Println(results)
	return
}

for !results.Done() {
	fmt.Println(results.Entry())
	results.Next()
}

Output:

3 <nil>
Cursor is done: false
1 <nil>
Cursor is done: true
&{[1] []}
&{[2] []}
&{[3] []}
&{[4] []}