Fix Windows QWP client test failures

Author: glasstiger

core/src/main/java/io/questdb/client/cutlass/qwp/client/QwpWebSocketSender.java

@@ -1796,6 +1796,38 @@ public long getPendingBytes() {
         return pendingBytes;
     }
 
+    /**
+     * Snapshot of the producer's symbol prefix whose persisted-dictionary chunks
+     * have committed. The persisted size advances only after the chunk CRC and
+     * payload have been written, so this observes the write-ahead boundary without
+     * reopening the live mmap-backed dictionary (which would attempt recovery-tail
+     * truncation and is not supported while the producer owns the file on Windows).
+     * Returns {@code null} in memory mode or when the persisted dictionary is
+     * unavailable.
+     */
+    @TestOnly
+    public ObjList<String> getPersistedSymbolsForTest() {
+        CursorSendEngine engine = cursorEngine;
+        if (engine == null) {
+            return null;
+        }
+        PersistedSymbolDict persisted = engine.getPersistedSymbolDict();
+        if (persisted == null) {
+            return null;
+        }
+        int persistedSize = persisted.size();
+        int globalSize = globalSymbolDictionary.size();
+        if (persistedSize > globalSize) {
+            throw new IllegalStateException("persisted symbol dictionary exceeds producer dictionary"
+                    + " [persisted=" + persistedSize + ", producer=" + globalSize + ']');
+        }
+        ObjList<String> snapshot = new ObjList<>(persistedSize);
+        for (int i = 0; i < persistedSize; i++) {
+            snapshot.add(globalSymbolDictionary.getSymbol(i));
+        }
+        return snapshot;
+    }
+
     /**
      * Server-advertised cap on the per-batch raw byte size. Zero before the
      * first connect; updated by every successful reconnect via

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

@@ -31,6 +31,8 @@
 import io.questdb.client.std.Unsafe;
 
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 
 /**
  * Advisory exclusive locks for a single SF slot.
@@ -101,13 +103,15 @@ public static SlotLock acquire(String slotDir) {
      */
     public static SlotLock acquireLogical(String slotDir) {
         validateSlotDir(slotDir);
-        int separator = slotDir.lastIndexOf('/');
-        if (separator < 1 || separator == slotDir.length() - 1) {
+        Path slotPath = Paths.get(slotDir);
+        Path parentPath = slotPath.getParent();
+        Path slotNamePath = slotPath.getFileName();
+        if (parentPath == null || slotNamePath == null || slotNamePath.toString().isEmpty()) {
             throw new IllegalArgumentException(
                     "slotDir must contain a parent and slot name: " + slotDir);
         }
-        String parentDir = slotDir.substring(0, separator);
-        String slotName = slotDir.substring(separator + 1);
+        String parentDir = parentPath.toString();
+        String slotName = slotNamePath.toString();
         String logicalLockDir = parentDir + "/" + LOGICAL_LOCK_DIR_NAME;
         ensureDirectory(logicalLockDir, "logical slot lock dir");
         String lockPath = logicalLockDir + "/" + slotName + ".lock";

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/DeltaDictRecoveryTest.java

@@ -877,15 +877,11 @@ public void testFailedPublishDoesNotDuplicatePersistedSymbols() throws Exception
 
                     // The persisted dictionary must hold "s0" EXACTLY ONCE.
                     // Pre-fix, the retry duplicated it (size == 2).
-                    PersistedSymbolDict pd = PersistedSymbolDict.open(Paths.get(sfDir, "default").toString());
-                    Assert.assertNotNull(pd);
-                    try {
-                        Assert.assertEquals("failed-publish retry must not duplicate the persisted symbol",
-                                1, pd.size());
-                        Assert.assertEquals("s0", pd.readLoadedSymbols().getQuick(0));
-                    } finally {
-                        pd.close();
-                    }
+                    ObjList<String> persisted = ((QwpWebSocketSender) sender).getPersistedSymbolsForTest();
+                    Assert.assertNotNull(persisted);
+                    Assert.assertEquals("failed-publish retry must not duplicate the persisted symbol",
+                            1, persisted.size());
+                    Assert.assertEquals("s0", persisted.getQuick(0));
                 } finally {
                     try {
                         sender.close();
@@ -942,16 +938,12 @@ public void testFailedPublishThenNewSymbolPersistsSuffixWithoutDuplicating() thr
                     // The else branch persisted ONLY s1 (the suffix). The dictionary holds
                     // s0, s1 exactly once each. Pre-fix (appendSymbols from
                     // sentMaxSymbolId+1) re-appended s0, giving size 3.
-                    PersistedSymbolDict pd = PersistedSymbolDict.open(Paths.get(sfDir, "default").toString());
-                    Assert.assertNotNull(pd);
-                    try {
-                        Assert.assertEquals("re-encode suffix must not duplicate the persisted prefix",
-                                2, pd.size());
-                        Assert.assertEquals("s0", pd.readLoadedSymbols().getQuick(0));
-                        Assert.assertEquals("s1", pd.readLoadedSymbols().getQuick(1));
-                    } finally {
-                        pd.close();
-                    }
+                    ObjList<String> persisted = ((QwpWebSocketSender) sender).getPersistedSymbolsForTest();
+                    Assert.assertNotNull(persisted);
+                    Assert.assertEquals("re-encode suffix must not duplicate the persisted prefix",
+                            2, persisted.size());
+                    Assert.assertEquals("s0", persisted.getQuick(0));
+                    Assert.assertEquals("s1", persisted.getQuick(1));
                 } finally {
                     try {
                         sender.close();

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/SelfSufficientFramesTest.java

@@ -26,8 +26,8 @@
 
 import io.questdb.client.Sender;
 import io.questdb.client.cutlass.line.LineSenderException;
+import io.questdb.client.cutlass.qwp.client.QwpWebSocketSender;
 import io.questdb.client.std.ObjList;
-import io.questdb.client.cutlass.qwp.client.sf.cursor.PersistedSymbolDict;
 import io.questdb.client.test.cutlass.qwp.websocket.TestWebSocketServer;
 import io.questdb.client.test.tools.TestUtils;
 import org.junit.Assert;
@@ -389,18 +389,13 @@ public void testFileModeSplitPersistsDictBeforeAFAILEDPublish() throws Exception
                         // The write-ahead already ran: both of the batch's new symbols are
                         // durable even though the frame that references them never
                         // published. Move the persist after sealAndSwapBuffer and this is 0.
-                        PersistedSymbolDict pd = PersistedSymbolDict.open(
-                                sfDir.resolve("default").toString());
-                        Assert.assertNotNull(pd);
-                        try {
-                            Assert.assertEquals("the split path must persist its new symbols BEFORE "
-                                    + "publishing the frame that references them", 2, pd.size());
-                            ObjList<String> symbols = pd.readLoadedSymbols();
-                            Assert.assertEquals("alpha", symbols.getQuick(0));
-                            Assert.assertEquals("bravo", symbols.getQuick(1));
-                        } finally {
-                            pd.close();
-                        }
+                        ObjList<String> persisted =
+                                ((QwpWebSocketSender) sender).getPersistedSymbolsForTest();
+                        Assert.assertNotNull(persisted);
+                        Assert.assertEquals("the split path must persist its new symbols BEFORE "
+                                + "publishing the frame that references them", 2, persisted.size());
+                        Assert.assertEquals("alpha", persisted.getQuick(0));
+                        Assert.assertEquals("bravo", persisted.getQuick(1));
                     } finally {
                         try {
                             sender.close();

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

@@ -106,8 +106,10 @@ public void testCloseReleasesLock() throws Exception {
     @Test
     public void testLogicalLockRemainsContendedAcrossSlotRenameAndRecreate() throws Exception {
         TestUtils.assertMemoryLeak(() -> {
-            String slot = parentDir + "/rename";
-            String moved = parentDir + "/rename.quarantined";
+            // Use the platform-native separator. In particular, this exercises
+            // acquireLogical with a backslash-only path on Windows.
+            String slot = Paths.get(parentDir, "rename").toString();
+            String moved = Paths.get(parentDir, "rename.quarantined").toString();
             assertEquals(0, Files.mkdir(slot, Files.DIR_MODE_DEFAULT));
 
             try (SlotLock ignored = SlotLock.acquireLogical(slot)) {