feat(ilp): binary wire protocol

[mtopolnik]

TODO in run_tests_pipeline.yaml! Change before merging!

# TODO: remove branch once jh_experiment_new_ilp is merged
- script: git clone --depth 1 -b jh_experiment_new_ilp https://github.com/questdb/questdb.git ./questdb

Change to

- script: git clone --depth 1 https://github.com/questdb/questdb.git ./questdb

---

Summary

This PR adds a new WebSocket-based ingestion path to the Java client using QWP (QuestDB Wire Protocol), a binary protocol that replaces text-based ILP for higher-throughput data ingestion. The existing HTTP and TCP ILP senders remain unchanged.

Users select the new transport via Sender.builder(Transport.WEBSOCKET). The builder accepts WebSocket-specific options such as asyncMode, autoFlushBytes, autoFlushIntervalMillis, and inFlightWindowSize.

Architecture

The implementation follows a layered design:

Protocol layer (cutlass/qwp/protocol/)

• QwpTableBuffer stores rows in columnar format using off-heap memory (zero-GC on the data path).
• QwpSchemaHash computes XXHash64 over column names and types, enabling server-side schema caching. The client sends a full schema on the first batch and a hash reference on subsequent batches if the schema has not changed.
• QwpGorillaEncoder applies delta-of-delta compression to timestamp columns.
• QwpBitWriter handles bit-level packing for booleans and null bitmaps.
• QwpConstants defines the wire format: "QWP1" magic bytes, type codes, feature flags, status codes.

Client layer (cutlass/qwp/client/)

• QwpWebSocketSender implements the Sender interface. It uses a double-buffering scheme: the user thread writes rows into an active MicrobatchBuffer, which is sealed and handed to an I/O thread when an auto-flush trigger fires (row count, byte size, or time interval).
• QwpWebSocketEncoder serializes QwpTableBuffer contents into binary QWP frames, including delta symbol dictionaries (only new symbols since the last acknowledged batch).
• InFlightWindow implements a lock-free sliding window protocol that tracks batches awaiting server ACKs, providing backpressure from the server to the user thread.
• WebSocketSendQueue runs the dedicated I/O thread, managing frame transmission and ACK/NACK response parsing.
• GlobalSymbolDictionary assigns sequential integer IDs to symbol strings and supports delta encoding across batches.

WebSocket transport (cutlass/http/client/, cutlass/qwp/websocket/)

• WebSocketClient is a zero-GC WebSocket implementation with platform-specific subclasses for Linux (epoll), macOS (kqueue), and Windows (select).
• WebSocketFrameParser and WebSocketFrameWriter handle RFC 6455 frame serialization, including fragmentation, close-frame echo, and ping/pong.
• WebSocketSendBuffer builds masked WebSocket frames directly in native memory.

Bug fixes and robustness improvements

The PR fixes a number of issues found during development and testing:

• Fix native memory leaks in WebSocketClient constructor and on allocation failure.
• Fix sendQueue leak on close when flush fails.
• Fix integer overflows in buffer growth (WebSocketClient, WebSocketSendBuffer, QwpTableBuffer), array dimension products, and putBlockOfBytes().
• Fix lone surrogate hash mismatch between schema hashing and wire encoding.
• Fix receiveFrame() throwing instead of returning false, which masked I/O errors as timeouts.
• Fix pong/close frames clobbering an in-progress send buffer.
• Fix delta dictionary corruption on send failure by rolling back symbol IDs.
• Fix stale array offsets after cancelRow() truncation.
• Fix case-insensitive header validation in WebSocket handshake.
• Cap receive buffer growth to prevent OOM.
• Use SecureRnd (ChaCha20-based CSPRNG) for WebSocket masking keys instead of java.util.Random.
• Validate table names, column names, WebSocket payload lengths, and UTF-8 low surrogates.

Code cleanup

The PR removes ~11,000 lines of dead code:

• Delete unused utility classes: ConcurrentHashMap (3,791 lines), ConcurrentIntHashMap (3,612 lines), GenericLexer, Base64Helper, LongObjHashMap, FilesFacade, and others.
• Remove unused methods from Numbers, Chars, Utf8s, Rnd, and ColumnType.
• Delete obsolete classes: ParanoiaState, GeoHashes, BorrowedArray, HttpCookie.
• Modernize code style: enhanced switch expressions, pattern variables in instanceof checks.
• Upgrade minimum Java version from 11 to 17.

CI changes

• Add a ClientIntegrationTests CI stage that starts a QuestDB server and runs the client's integration tests against it (both default and authenticated configurations).
• Cache Maven dependencies in CI to speed up builds.
• Fix sed portability for macOS CI runners.
• Enable the HTTP server in CI test configurations (required for WebSocket).

Test plan

• Unit tests cover all protocol building blocks: bit writer, Gorilla encoder, schema hash, column definitions, constants, table buffer, native buffer writer, off-heap memory
• Unit tests cover WebSocket frame parsing/writing, send buffer, send queue, in-flight window, microbatch buffer, delta/global symbol dictionaries
• QwpSenderTest (8,346 lines) exercises the full Sender API surface for all column types, null handling, cancelRow, schema changes, and error paths
• QwpWebSocketSenderTest tests WebSocket-specific sender behavior including async mode
• QwpWebSocketEncoderTest validates binary encoding for all column types and encoding modes
• LineSenderBuilderWebSocketTest covers builder validation and configuration for the WebSocket transport
• Integration tests run the client against a real QuestDB server in CI (default and authenticated)
• assertMemoryLeak wrappers added to client tests to detect native memory leaks