perf(ilp): replace O(N²) SF segment sort at open

SegmentLog.scanDirectory used insertion sort over the segments list. At
the documented sf_max_total_bytes / sf_max_bytes ceiling (1 TiB / 64
MiB ≈ 16K segments) that is ~268M comparisons + array shifts → multi-
second wall time before the I/O thread can start.

Replaced with an in-place quicksort with median-of-three pivot. O(N log
N) average, no allocation (matching the surrounding code's discipline),
recursion depth bounded by ~2 log₂(N) by always recursing into the
smaller partition and looping on the larger.

Median-of-three is required because the insertion sort's only saving
grace was O(N) on already-sorted input, which is the common case from
readdir on filesystems that return entries in lexicographic (and
therefore baseSeq-hex) order. A naive first-element-pivot quicksort
would degrade back to O(N²) in exactly that scenario.

Tests:
- testLargeSegmentCountReopensInOrder (SegmentLogTortureTest):
  generates 1024 sealed segments, reopens, asserts the replay returns
  every appended seq exactly once in order, and that reopen+replay
  completes within a generous wall-clock bound that catches a
  regression back to O(N²) at the production ceiling.
- Full SF + adjacent suite: 117/117 pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: bluestreak01

core/src/main/java/io/questdb/client/cutlass/qwp/client/sf/SegmentLog.java

@@ -404,18 +404,13 @@ private void scanDirectory() {
             ff.findClose(find);
         }
 
-        // Insertion sort by baseSeq. Open-time only and N is typically small
-        // (one active segment plus a handful of unacked sealed segments), so
-        // the O(N^2) is irrelevant and avoids the java.util.Comparator alloc.
-        for (int i = 1, n = segments.size(); i < n; i++) {
-            Segment x = segments.getQuick(i);
-            int j = i - 1;
-            while (j >= 0 && Long.compareUnsigned(segments.getQuick(j).baseSeq, x.baseSeq) > 0) {
-                segments.setQuick(j + 1, segments.getQuick(j));
-                j--;
-            }
-            segments.setQuick(j + 1, x);
-        }
+        // Open-time sort by baseSeq. Worst case is `sf_max_total_bytes /
+        // sf_max_bytes` segments — at the documented limit (1 TiB / 64 MiB)
+        // that is ~16K entries, where the previous insertion sort spent
+        // multiple seconds in O(N²) compares + array shifts. In-place
+        // quicksort with median-of-three pivot keeps the no-allocation
+        // discipline of the surrounding code.
+        sortSegmentsByBaseSeq(0, segments.size());
 
         // Validate: at most one active segment, and only as the last entry.
         for (int i = 0, n = segments.size(); i < n; i++) {
@@ -698,6 +693,59 @@ private void ensureOpen() {
         }
     }
 
+    /**
+     * In-place quicksort over {@code segments[lo, hi)} keyed by unsigned
+     * {@code baseSeq}. Median-of-three pivot selection avoids the
+     * pathological O(N²) on already-sorted input that {@code readdir} on
+     * many filesystems produces. Recursion depth is bounded by ~2 log₂(N);
+     * for the documented 16K-segment ceiling that is well under the JVM
+     * default stack.
+     */
+    private void sortSegmentsByBaseSeq(int lo, int hi) {
+        while (hi - lo > 1) {
+            int mid = (lo + hi) >>> 1;
+            long a = segments.getQuick(lo).baseSeq;
+            long b = segments.getQuick(mid).baseSeq;
+            long c = segments.getQuick(hi - 1).baseSeq;
+            // Median of {a, b, c} → pivot index.
+            int pivotIdx;
+            if (Long.compareUnsigned(a, b) < 0) {
+                if (Long.compareUnsigned(b, c) < 0) pivotIdx = mid;
+                else if (Long.compareUnsigned(a, c) < 0) pivotIdx = hi - 1;
+                else pivotIdx = lo;
+            } else {
+                if (Long.compareUnsigned(a, c) < 0) pivotIdx = lo;
+                else if (Long.compareUnsigned(b, c) < 0) pivotIdx = hi - 1;
+                else pivotIdx = mid;
+            }
+            long pivot = segments.getQuick(pivotIdx).baseSeq;
+            swapSegments(pivotIdx, hi - 1);
+            int store = lo;
+            for (int i = lo; i < hi - 1; i++) {
+                if (Long.compareUnsigned(segments.getQuick(i).baseSeq, pivot) < 0) {
+                    swapSegments(i, store++);
+                }
+            }
+            swapSegments(store, hi - 1);
+            // Recurse on the smaller partition; loop on the larger to keep
+            // recursion depth bounded by log₂(N).
+            if (store - lo < hi - store - 1) {
+                sortSegmentsByBaseSeq(lo, store);
+                lo = store + 1;
+            } else {
+                sortSegmentsByBaseSeq(store + 1, hi);
+                hi = store;
+            }
+        }
+    }
+
+    private void swapSegments(int i, int j) {
+        if (i == j) return;
+        Segment tmp = segments.getQuick(i);
+        segments.setQuick(i, segments.getQuick(j));
+        segments.setQuick(j, tmp);
+    }
+
     /** Parse `<baseSeq>.sfa` or `<baseSeq>-<lastSeq>.sfs`. Returns null for unrecognized names. */
     private Segment parseFilename(String name) {
         try {

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/sf/SegmentLogTortureTest.java

@@ -479,6 +479,71 @@ public void testTruncationAcrossMultipleSegments() throws Exception {
         });
     }
 
+    /**
+     * Open-time sort regression: at the documented {@code sf_max_total_bytes
+     * / sf_max_bytes} ceiling (~16K segments) the previous insertion sort
+     * over {@code segments} ran in O(N²) and burnt multi-second wall time
+     * before the I/O thread could even start. The test creates 1024 sealed
+     * segments by forcing one-frame-per-segment via a tiny per-segment cap,
+     * reopens, and asserts:
+     * <ul>
+     *   <li>every appended sequence is replayed exactly once, in order;</li>
+     *   <li>{@code nextSeq()} matches the total appended frame count;</li>
+     *   <li>reopen + replay completes within a generous wall-clock bound
+     *     that the old O(N²) sort would still satisfy at this scale, but
+     *     that catches a regression pushing back into multi-second land
+     *     for the documented production ceiling (~16K segments).</li>
+     * </ul>
+     */
+    @Test
+    public void testLargeSegmentCountReopensInOrder() throws Exception {
+        TestUtils.assertMemoryLeak(() -> {
+            // maxBytes = HEADER_SIZE + FRAME_HEADER_SIZE + payload = 24+8+16 = 48.
+            // First frame fits in segment 0; every subsequent frame triggers
+            // rotation. 1024 frames → ~1023 sealed + 1 active = 1024 segments.
+            final int frameCount = 1024;
+            final int payloadSize = 16;
+            final long maxBytes = 48;
+
+            long buf = Unsafe.malloc(payloadSize, MemoryTag.NATIVE_DEFAULT);
+            try {
+                for (int i = 0; i < payloadSize; i++) {
+                    Unsafe.getUnsafe().putByte(buf + i, (byte) (i & 0xff));
+                }
+                try (SegmentLog log = SegmentLog.open(tmpDir, maxBytes)) {
+                    long lastSeq = -1;
+                    for (int i = 0; i < frameCount; i++) {
+                        lastSeq = log.append(buf, payloadSize);
+                    }
+                    assertEquals(frameCount - 1, lastSeq);
+                    log.fsync();
+                }
+            } finally {
+                Unsafe.free(buf, payloadSize, MemoryTag.NATIVE_DEFAULT);
+            }
+
+            long startMs = System.currentTimeMillis();
+            try (SegmentLog log2 = SegmentLog.open(tmpDir, maxBytes)) {
+                assertEquals(frameCount, log2.nextSeq());
+                final long[] expected = {0L};
+                final int[] count = {0};
+                log2.replay((seq, addr, len) -> {
+                    assertEquals("frame seq out of order at index " + count[0],
+                            expected[0], seq);
+                    expected[0]++;
+                    count[0]++;
+                    return true;
+                });
+                assertEquals("replayed " + count[0] + " frames, expected " + frameCount,
+                        frameCount, count[0]);
+            }
+            long elapsedMs = System.currentTimeMillis() - startMs;
+            assertTrue("reopen+replay took " + elapsedMs + "ms (expected < 5000ms); " +
+                            "regression suggests scanDirectory's segment sort is back to O(N²)",
+                    elapsedMs < 5_000);
+        });
+    }
+
     private static void appendBytes(SegmentLog log, byte[] bytes) {
         long buf = Unsafe.malloc(bytes.length, MemoryTag.NATIVE_DEFAULT);
         try {