@matheusbsbs / matheus-bagliano / commits / e08f49a4f5

reftable/merged: split up initialization and seeking of records

To initialize a `struct merged_iter`, we need to seek all subiterators to the wanted record and then add their results to the priority queue used to sort the records. This logic is split up across two functions, `merged_table_seek_record()` and `merged_iter_init()`. The scope of these functions is somewhat weird though, where `merged_iter_init()` is only responsible for adding the records of the subiterators to the priority queue. Clarify the scope of those functions such that `merged_iter_init()` is only responsible for initializing the iterator's structure. Performing the subiterator seeks are now part of `merged_table_seek_record()`. This step is required to move seeking of records into the generic `struct reftable_iterator` infrastructure. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Patrick Steinhardt committed May 13, 2024 at 10:47 UTC e08f49a4f58e91cdcbc04190b501363fc568f0bf
1 file changed +22 -37
reftable/merged.c
+22 -37
@@ -25,34 +25,18 @@ struct merged_subiter {
25 struct merged_iter {
26 struct merged_subiter *subiters;
27 struct merged_iter_pqueue pq;
28 - uint32_t hash_id;
28 size_t stack_len;
30 - uint8_t typ;
29 int suppress_deletions;
30 ssize_t advance_index;
31 };
32
35 -static int merged_iter_init(struct merged_iter *mi)
33 +static void merged_iter_init(struct merged_iter *mi,
34 + struct reftable_merged_table *mt)
35 {
37 - for (size_t i = 0; i < mi->stack_len; i++) {
38 - struct pq_entry e = {
39 - .index = i,
40 - .rec = &mi->subiters[i].rec,
41 - };
42 - int err;
43 -
44 - reftable_record_init(&mi->subiters[i].rec, mi->typ);
45 - err = iterator_next(&mi->subiters[i].iter,
46 - &mi->subiters[i].rec);
47 - if (err < 0)
48 - return err;
49 - if (err > 0)
50 - continue;
51 -
52 - merged_iter_pqueue_add(&mi->pq, &e);
53 - }
54 -
55 - return 0;
36 + memset(mi, 0, sizeof(*mi));
37 + mi->advance_index = -1;
38 + mi->suppress_deletions = mt->suppress_deletions;
39 + REFTABLE_CALLOC_ARRAY(mi->subiters, mt->stack_len);
40 }
41
42 static void merged_iter_close(void *p)
@@ -246,32 +230,33 @@ static int merged_table_seek_record(struct reftable_merged_table *mt,
230 struct reftable_iterator *it,
231 struct reftable_record *rec)
232 {
249 - struct merged_iter merged = {
250 - .typ = reftable_record_type(rec),
251 - .hash_id = mt->hash_id,
252 - .suppress_deletions = mt->suppress_deletions,
253 - .advance_index = -1,
254 - };
255 - struct merged_iter *p;
233 + struct merged_iter merged, *p;
234 int err;
235
258 - REFTABLE_CALLOC_ARRAY(merged.subiters, mt->stack_len);
236 + merged_iter_init(&merged, mt);
237 +
238 for (size_t i = 0; i < mt->stack_len; i++) {
239 + reftable_record_init(&merged.subiters[merged.stack_len].rec,
240 + reftable_record_type(rec));
241 +
242 err = reftable_table_seek_record(&mt->stack[i],
243 &merged.subiters[merged.stack_len].iter, rec);
244 if (err < 0)
245 goto out;
264 - if (!err)
265 - merged.stack_len++;
266 - }
246 + if (err > 0)
247 + continue;
248
268 - err = merged_iter_init(&merged);
269 - if (err < 0)
270 - goto out;
249 + err = merged_iter_advance_subiter(&merged, merged.stack_len);
250 + if (err < 0)
251 + goto out;
252 +
253 + merged.stack_len++;
254 + }
255
272 - p = reftable_malloc(sizeof(struct merged_iter));
256 + p = reftable_malloc(sizeof(*p));
257 *p = merged;
258 iterator_from_merged_iter(it, p);
259 + err = 0;
260
261 out:
262 if (err < 0)