/
iterator.go
112 lines (105 loc) · 2.38 KB
/
iterator.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package db
import (
"github.com/cockroachdb/pebble"
"github.com/LiskHQ/lisk-engine/pkg/collection/bytes"
)
func iterateRange(iter *pebble.Iterator, start, end []byte, limit int, reverse bool) []KeyValue {
var data []KeyValue
count := 0
if !reverse {
for iter.SeekGE(start); iter.Valid(); iter.Next() {
key := iter.Key()
if bytes.Compare(key, end) > 0 {
break
}
kv := &keyValue{
key: bytes.Copy(key),
value: bytes.Copy(iter.Value()),
}
data = append(data, kv)
count++
if limit != -1 && count >= limit {
break
}
}
} else {
for iter.SeekLT(upperBound(end)); iter.Valid(); iter.Prev() {
key := iter.Key()
if bytes.Compare(key, start) < 0 {
break
}
kv := &keyValue{
key: bytes.Copy(key),
value: bytes.Copy(iter.Value()),
}
data = append(data, kv)
count++
if limit != -1 && count >= limit {
break
}
}
}
return data
}
func iteratePrefix(iter *pebble.Iterator, prefix []byte, limit int, reverse bool) []KeyValue {
var data []KeyValue
count := 0
if !reverse {
for iter.First(); iter.Valid(); iter.Next() {
kv := &keyValue{
key: bytes.Copy(iter.Key()),
value: bytes.Copy(iter.Value()),
}
data = append(data, kv)
count++
if limit != -1 && count >= limit {
break
}
}
} else {
for iter.Last(); iter.Valid(); iter.Prev() {
kv := &keyValue{
key: bytes.Copy(iter.Key()),
value: bytes.Copy(iter.Value()),
}
data = append(data, kv)
count++
if limit != -1 && count >= limit {
break
}
}
}
if err := iter.Close(); err != nil {
// iter.Close should never fail. if it fails here, there is a problem in underlying DB which cannot be recovered.
panic(err)
}
return data
}
func iterateKeyPrefix(iter *pebble.Iterator, prefix []byte, limit int, reverse bool) [][]byte {
var data [][]byte
count := 0
if !reverse {
for iter.First(); iter.Valid(); iter.Next() {
key := bytes.Copy(iter.Key())
data = append(data, key)
count++
if limit != -1 && count >= limit {
break
}
}
} else {
for iter.Last(); iter.Valid(); iter.Prev() {
key := bytes.Copy(iter.Key())
data = append(data, key)
count++
if limit != -1 && count >= limit {
break
}
}
}
if err := iter.Close(); err != nil {
// iter.Close should never fail. if it fails here, there is a problem in underlying DB which cannot be recovered.
panic(err)
}
return data
}