Remove last piece of code that assumes merge = two segments

Author: lalinsky

src/Index.zig

@@ -285,11 +285,9 @@ fn doCheckpoint(self: *Self) !bool {
     self.file_segments_lock.lock();
     defer self.file_segments_lock.unlock();
 
-    var ids = try self.getFileSegmentIds();
+    var ids = try self.file_segments.getIdsAfterAppend(dest, self.allocator);
     defer ids.deinit();
 
-    try ids.append(dest.data.id);
-
     try filefmt.writeIndexFile(self.data_dir, ids.items);
 
     self.segments_lock.lock();
@@ -424,32 +422,12 @@ fn finishFileSegmentMerge(self: *Self, merge: FileSegmentList.PreparedMerge) !vo
     errdefer self.file_segments.destroySegment(merge.target);
     errdefer merge.target.data.delete(self.data_dir);
 
-    var ids = try self.getFileSegmentIds();
+    var ids = try self.file_segments.getIdsAfterAppliedMerge(merge, self.allocator);
     defer ids.deinit();
 
-    var index1: usize = 0;
-    var index2: usize = 0;
-
-    std.debug.assert(merge.sources.num_segments == 2);
-
-    var i: usize = 0;
-    while (i < ids.items.len) : (i += 1) {
-        if (SegmentID.eq(ids.items[i], merge.sources.start.data.id)) {
-            index1 = i;
-        }
-        if (SegmentID.eq(ids.items[i], merge.sources.end.data.id)) {
-            index2 = i;
-        }
-    }
-
-    std.debug.assert(index1 + 1 == index2);
-
-    try ids.replaceRange(index1, 2, &[_]SegmentID{merge.target.data.id});
-
-    std.debug.assert(std.sort.isSorted(SegmentID, ids.items, {}, SegmentID.cmp));
-
     try filefmt.writeIndexFile(self.data_dir, ids.items);
 
+    // we want to do this outside of segments_lock to avoid blocking searches more than necessary
     defer self.file_segments.cleanupAfterMerge(merge, .{self.data_dir});
 
     self.segments_lock.lock();
@@ -537,18 +515,6 @@ fn readyForCheckpoint(self: *Self) !?*MemorySegmentNode {
     return null;
 }
 
-fn getFileSegmentIds(self: *Self) !std.ArrayList(SegmentID) {
-    var segment_ids = std.ArrayList(SegmentID).init(self.allocator);
-    errdefer segment_ids.deinit();
-
-    self.segments_lock.lockShared();
-    defer self.segments_lock.unlockShared();
-
-    try self.file_segments.getIds(&segment_ids);
-
-    return segment_ids;
-}
-
 pub fn update(self: *Self, changes: []const Change) !void {
     //const t1 = std.time.milliTimestamp();
     if (try self.maybeMergeMemorySegments()) {

src/segment_list.zig

@@ -57,12 +57,44 @@ pub fn SegmentList(Segment: type) type {
             self.segments.append(node);
         }
 
-        pub fn getIds(self: *Self, ids: *std.ArrayList(common.SegmentID)) !void {
-            try ids.ensureTotalCapacity(self.segments.len);
+        pub fn getIdsAfterAppend(self: *Self, new_segment: *List.Node, allocator: std.mem.Allocator) !std.ArrayList(common.SegmentID) {
+            var ids = std.ArrayList(common.SegmentID).init(allocator);
+            errdefer ids.deinit();
+
+            try ids.ensureTotalCapacity(self.segments.len + 1);
+
             var it = self.segments.first;
             while (it) |node| : (it = node.next) {
-                try ids.append(node.data.id);
+                ids.appendAssumeCapacity(node.data.id);
             }
+
+            ids.appendAssumeCapacity(new_segment.data.id);
+
+            return ids;
+        }
+
+        pub fn getIdsAfterAppliedMerge(self: *Self, merge: PreparedMerge, allocator: std.mem.Allocator) !std.ArrayList(common.SegmentID) {
+            var ids = std.ArrayList(common.SegmentID).init(allocator);
+            errdefer ids.deinit();
+
+            try ids.ensureTotalCapacity(self.segments.len - merge.sources.num_segments + 1);
+
+            var it = self.segments.first;
+            var inside_merge = false;
+            while (it) |node| : (it = node.next) {
+                if (it == merge.sources.start) {
+                    inside_merge = true;
+                }
+                if (!inside_merge) {
+                    ids.appendAssumeCapacity(node.data.id);
+                }
+                if (it == merge.sources.end) {
+                    inside_merge = false;
+                    ids.appendAssumeCapacity(merge.target.data.id);
+                }
+            }
+
+            return ids;
         }
 
         pub fn getMaxCommitId(self: *const Self) u64 {