feat(qwp): recycle the symbol dictionary at a threshold to lift the cardinality cap

.gitignore

@@ -26,6 +26,7 @@ core/CMakeCache.txt
 **/.project
 **/.settings
 **/.classpath
+**/.factorypath
 **/build
 **/CMakeFiles
 .envrc

core/src/main/java/io/questdb/client/SenderConnectionEvent.java

@@ -193,15 +193,19 @@ public enum Kind {
 
         /**
          * The active wire connection dropped and the reconnect loop is about
-         * to start. Fired once per outage, before any retry attempts.
+         * to start. Fired once per outage, before any retry attempts. Not
+         * fired for the deliberate reconnect a symbol-dictionary recycle
+         * performs.
          */
         DISCONNECTED,
 
         /**
          * A reconnect attempt succeeded against the same endpoint that was
          * previously active. Fired once per successful reconnect to the same
          * endpoint; {@link Kind#FAILED_OVER} is fired instead when the new
-         * endpoint differs.
+         * endpoint differs. Also fired — without a preceding
+         * {@link #DISCONNECTED} — for the reconnect that follows a
+         * symbol-dictionary recycle, which is deliberate, not an outage.
          */
         RECONNECTED,
 

core/src/main/java/io/questdb/client/SenderConnectionListener.java

@@ -49,7 +49,11 @@
  * ({@link SenderConnectionEvent.Kind#CONNECTED},
  * {@link SenderConnectionEvent.Kind#FAILED_OVER},
  * {@link SenderConnectionEvent.Kind#RECONNECTED}) are guaranteed to fire on
- * each transition. Failure events ({@code ENDPOINT_ATTEMPT_FAILED},
+ * each transition. A symbol-dictionary recycle tears the wire connection down
+ * and reconnects deliberately; that reconnect reports {@code RECONNECTED}
+ * (or {@code FAILED_OVER}) with no {@code DISCONNECTED} before it, so a
+ * listener pairing the two must not assume every success follows an outage.
+ * Failure events ({@code ENDPOINT_ATTEMPT_FAILED},
  * {@code ALL_ENDPOINTS_UNREACHABLE}) may be coalesced under inbox pressure.
  * The terminal event {@code AUTH_FAILED}
  * fires before the producer-thread {@code LineSenderException} is observable on

core/src/main/java/io/questdb/client/SenderError.java

@@ -42,7 +42,10 @@
  *
  * <p>The {@code [fromFsn, toFsn]} span is the load-bearing correlation key — join it to
  * whatever the producer thread logged alongside the published-sequence value returned by
- * the sender to identify the rejected data. Background orphan-drainer reports use
+ * the same sender instance to identify the rejected data. Both bounds are on the reporting
+ * sender's own FSN scale (see {@link Sender#flushAndGetSequence()}): a sender restarted on
+ * the same store-and-forward slot reports replayed frames on its own scale, not on the
+ * closed process's. Background orphan-drainer reports use
  * {@link #NO_MESSAGE_SEQUENCE} for both bounds because those FSNs belong to another sender
  * engine and must not be joined to the live producer's rows.
  *

core/src/main/java/io/questdb/client/SenderErrorHandler.java

@@ -33,11 +33,16 @@
  *
  * <h2>Threading</h2>
  * Handlers normally run on a dedicated daemon dispatcher thread, never on the
- * I/O thread or the producer thread. One exception: a build()-time quarantine
+ * I/O thread or the producer thread. One exception: a slot quarantine
  * ({@link SenderError.Category#DATA_LOSS}) is dispatched synchronously on the
- * thread calling {@code build()} — the async dispatcher belongs to the
- * connected sender, which does not exist yet at build time. Handlers must not
- * block: for the build-time case, {@code build()} is waiting.
+ * calling thread — at {@code build()} time because the async dispatcher does
+ * not exist yet, and during a symbol-dictionary recycle rebuild (on the
+ * producer thread: inside the {@code table(...)} call that triggered the
+ * recycle or, when an earlier attempt failed transiently, inside the
+ * {@code table(...)}, {@code flush()} or {@code drain(...)} call that
+ * resumes it) because a data-loss notice must
+ * not be dropped under inbox pressure. Handlers must not block or call back
+ * into the sender: in both cases the caller is waiting.
  * Slow handlers cannot stall publishing; if the bounded
  * inbox fills up, surplus notifications are dropped (visible via
  * {@code QwpWebSocketSender.getDroppedErrorNotifications()}).

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

@@ -155,7 +155,11 @@ public int getOrAddSymbol(CharSequence symbol) {
                             + ". Rows using already-registered symbol values continue to work. To start a fresh "
                             + "dictionary, close this sender and build a new one (with store-and-forward the "
                             + "buffered backlog drains first). For unbounded-cardinality data use varchar "
-                            + "columns instead of symbol");
+                            + "columns instead of symbol. The automatic dictionary reset "
+                            + "(symbol_dict_reset, symbol_dict_reset_threshold) and "
+                            + "Sender.resetSymbolDictionary() avoid this cap, but both act only "
+                            + "on senders created via Sender.build()/fromConfig(), and the reset "
+                            + "itself runs at a table() call once the backlog is acknowledged.");
         }
 
         // Assign new ID — toString() only for new symbols that must be stored