Line data Source code
1 : // Copyright 2024 The LevelDB-Go and Pebble Authors. All rights reserved. Use
2 : // of this source code is governed by a BSD-style license that can be found in
3 : // the LICENSE file.
4 :
5 : package base
6 :
7 : import (
8 : "context"
9 : "io"
10 : "strconv"
11 : "strings"
12 : )
13 :
14 : // NewDeletableSumValueMerger return a ValueMerger which computes the sum of its
15 : // arguments, but transforms a zero sum into a non-existent entry.
16 1 : func NewDeletableSumValueMerger(key, value []byte) (ValueMerger, error) {
17 1 : m := &deletableSumValueMerger{}
18 1 : return m, m.MergeNewer(value)
19 1 : }
20 :
21 : type deletableSumValueMerger struct {
22 : sum int64
23 : }
24 :
25 1 : func (m *deletableSumValueMerger) parseAndCalculate(value []byte) error {
26 1 : v, err := strconv.ParseInt(string(value), 10, 64)
27 1 : if err == nil {
28 1 : m.sum += v
29 1 : }
30 1 : return err
31 : }
32 :
33 1 : func (m *deletableSumValueMerger) MergeNewer(value []byte) error {
34 1 : return m.parseAndCalculate(value)
35 1 : }
36 :
37 1 : func (m *deletableSumValueMerger) MergeOlder(value []byte) error {
38 1 : return m.parseAndCalculate(value)
39 1 : }
40 :
41 1 : func (m *deletableSumValueMerger) Finish(includesBase bool) ([]byte, io.Closer, error) {
42 1 : if m.sum == 0 {
43 1 : return nil, nil, nil
44 1 : }
45 1 : return []byte(strconv.FormatInt(m.sum, 10)), nil, nil
46 : }
47 :
48 : func (m *deletableSumValueMerger) DeletableFinish(
49 : includesBase bool,
50 1 : ) ([]byte, bool, io.Closer, error) {
51 1 : value, closer, err := m.Finish(includesBase)
52 1 : return value, len(value) == 0, closer, err
53 1 : }
54 :
55 : // FakeKVs constructs InternalKVs from the given key strings, in the format
56 : // "key:seq-num". The values are empty.
57 1 : func FakeKVs(keys ...string) []InternalKV {
58 1 : kvs := make([]InternalKV, len(keys))
59 1 : for i, k := range keys {
60 1 : kvs[i] = InternalKV{K: fakeIkey(k)}
61 1 : }
62 1 : return kvs
63 : }
64 :
65 1 : func fakeIkey(s string) InternalKey {
66 1 : j := strings.Index(s, ":")
67 1 : seqNum, err := strconv.Atoi(s[j+1:])
68 1 : if err != nil {
69 0 : panic(err)
70 : }
71 1 : return MakeInternalKey([]byte(s[:j]), uint64(seqNum), InternalKeyKindSet)
72 : }
73 :
74 : // NewFakeIter returns an iterator over the given KVs.
75 1 : func NewFakeIter(kvs []InternalKV) *FakeIter {
76 1 : return &FakeIter{
77 1 : kvs: kvs,
78 1 : index: 0,
79 1 : valid: len(kvs) > 0,
80 1 : }
81 1 : }
82 :
83 : // FakeIter is an iterator over a fixed set of KVs.
84 : type FakeIter struct {
85 : lower []byte
86 : upper []byte
87 : kvs []InternalKV
88 : index int
89 : valid bool
90 : closeErr error
91 : }
92 :
93 : // FakeIter implements the InternalIterator interface.
94 : var _ InternalIterator = (*FakeIter)(nil)
95 :
96 : // SetCloseErr causes future calls to Error() and Close() to return this error.
97 1 : func (f *FakeIter) SetCloseErr(closeErr error) {
98 1 : f.closeErr = closeErr
99 1 : }
100 :
101 0 : func (f *FakeIter) String() string {
102 0 : return "fake"
103 0 : }
104 :
105 : // SeekGE is part of the InternalIterator interface.
106 1 : func (f *FakeIter) SeekGE(key []byte, flags SeekGEFlags) *InternalKV {
107 1 : f.valid = false
108 1 : for f.index = 0; f.index < len(f.kvs); f.index++ {
109 1 : if DefaultComparer.Compare(key, f.key().UserKey) <= 0 {
110 1 : if f.upper != nil && DefaultComparer.Compare(f.upper, f.key().UserKey) <= 0 {
111 1 : return nil
112 1 : }
113 1 : f.valid = true
114 1 : return f.KV()
115 : }
116 : }
117 1 : return nil
118 : }
119 :
120 : // SeekPrefixGE is part of the InternalIterator interface.
121 1 : func (f *FakeIter) SeekPrefixGE(prefix, key []byte, flags SeekGEFlags) *InternalKV {
122 1 : return f.SeekGE(key, flags)
123 1 : }
124 :
125 : // SeekLT is part of the InternalIterator interface.
126 1 : func (f *FakeIter) SeekLT(key []byte, flags SeekLTFlags) *InternalKV {
127 1 : f.valid = false
128 1 : for f.index = len(f.kvs) - 1; f.index >= 0; f.index-- {
129 1 : if DefaultComparer.Compare(key, f.key().UserKey) > 0 {
130 1 : if f.lower != nil && DefaultComparer.Compare(f.lower, f.key().UserKey) > 0 {
131 1 : return nil
132 1 : }
133 1 : f.valid = true
134 1 : return f.KV()
135 : }
136 : }
137 1 : return nil
138 : }
139 :
140 : // First is part of the InternalIterator interface.
141 1 : func (f *FakeIter) First() *InternalKV {
142 1 : f.valid = false
143 1 : f.index = -1
144 1 : if kv := f.Next(); kv == nil {
145 1 : return nil
146 1 : }
147 1 : if f.upper != nil && DefaultComparer.Compare(f.upper, f.key().UserKey) <= 0 {
148 0 : return nil
149 0 : }
150 1 : f.valid = true
151 1 : return f.KV()
152 : }
153 :
154 : // Last is part of the InternalIterator interface.
155 1 : func (f *FakeIter) Last() *InternalKV {
156 1 : f.valid = false
157 1 : f.index = len(f.kvs)
158 1 : if kv := f.Prev(); kv == nil {
159 0 : return nil
160 0 : }
161 1 : if f.lower != nil && DefaultComparer.Compare(f.lower, f.key().UserKey) > 0 {
162 0 : return nil
163 0 : }
164 1 : f.valid = true
165 1 : return f.KV()
166 : }
167 :
168 : // Next is part of the InternalIterator interface.
169 1 : func (f *FakeIter) Next() *InternalKV {
170 1 : f.valid = false
171 1 : if f.index == len(f.kvs) {
172 1 : return nil
173 1 : }
174 1 : f.index++
175 1 : if f.index == len(f.kvs) {
176 1 : return nil
177 1 : }
178 1 : if f.upper != nil && DefaultComparer.Compare(f.upper, f.key().UserKey) <= 0 {
179 1 : return nil
180 1 : }
181 1 : f.valid = true
182 1 : return f.KV()
183 : }
184 :
185 : // Prev is part of the InternalIterator interface.
186 1 : func (f *FakeIter) Prev() *InternalKV {
187 1 : f.valid = false
188 1 : if f.index < 0 {
189 0 : return nil
190 0 : }
191 1 : f.index--
192 1 : if f.index < 0 {
193 1 : return nil
194 1 : }
195 1 : if f.lower != nil && DefaultComparer.Compare(f.lower, f.key().UserKey) > 0 {
196 1 : return nil
197 1 : }
198 1 : f.valid = true
199 1 : return f.KV()
200 : }
201 :
202 : // NextPrefix is part of the InternalIterator interface.
203 0 : func (f *FakeIter) NextPrefix(succKey []byte) *InternalKV {
204 0 : return f.SeekGE(succKey, SeekGEFlagsNone)
205 0 : }
206 :
207 : // key returns the current Key the iterator is positioned at regardless of the
208 : // value of f.valid.
209 1 : func (f *FakeIter) key() *InternalKey {
210 1 : return &f.kvs[f.index].K
211 1 : }
212 :
213 : // KV is part of the InternalIterator interface.
214 1 : func (f *FakeIter) KV() *InternalKV {
215 1 : if f.valid {
216 1 : return &f.kvs[f.index]
217 1 : }
218 : // It is invalid to call Key() when Valid() returns false. Rather than
219 : // returning nil here which would technically be more correct, return a
220 : // non-nil key which is the behavior of some InternalIterator
221 : // implementations. This provides better testing of users of
222 : // InternalIterators.
223 0 : if f.index < 0 {
224 0 : return &f.kvs[0]
225 0 : }
226 0 : return &f.kvs[len(f.kvs)-1]
227 : }
228 :
229 : // Valid is part of the InternalIterator interface.
230 0 : func (f *FakeIter) Valid() bool {
231 0 : return f.index >= 0 && f.index < len(f.kvs) && f.valid
232 0 : }
233 :
234 : // Error is part of the InternalIterator interface.
235 1 : func (f *FakeIter) Error() error {
236 1 : return f.closeErr
237 1 : }
238 :
239 : // Close is part of the InternalIterator interface.
240 1 : func (f *FakeIter) Close() error {
241 1 : return f.closeErr
242 1 : }
243 :
244 : // SetBounds is part of the InternalIterator interface.
245 1 : func (f *FakeIter) SetBounds(lower, upper []byte) {
246 1 : f.lower = lower
247 1 : f.upper = upper
248 1 : }
249 :
250 : // SetContext is part of the InternalIterator interface.
251 0 : func (f *FakeIter) SetContext(_ context.Context) {}
|
