Creates a new HttpTransport instance using Node.js HTTP modules.
-Sender configuration object containing connection details
-Protected ReadonlysecureProtected ReadonlyhostProtected ReadonlyportProtected ReadonlyusernameProtected ReadonlypasswordProtected ReadonlytokenProtected ReadonlytlsProtected ReadonlytlsProtected ReadonlyrequestProtected ReadonlyrequestProtected ReadonlyretryProtected ReadonlylogHTTP transport does not require explicit connection closure.
-Promise that resolves immediately
-Gets the default auto-flush row count for HTTP transport.
-Default number of rows that trigger auto-flush
-Sends data to QuestDB using HTTP POST.
-Buffer containing the data to send
-Internal parameter for tracking retry start time
-Internal parameter for tracking retry intervals
-Promise resolving to true if data was sent successfully
-The QuestDB client's API provides methods to connect to the database, ingest data, and close the connection.
-The client supports multiple transport protocols.
-Transport Options: -
-The client supports authentication.
-Authentication details can be passed to the Sender in its configuration options.
-The client supports Basic username/password and Bearer token authentication methods when used with HTTP protocol,
-and JWK token authentication when ingesting data via TCP.
-Please, note that authentication is enabled by default in QuestDB Enterprise only.
-Details on how to configure authentication in the open source version of
-QuestDB: https://questdb.io/docs/reference/api/ilp/authenticate
-
-The client also supports TLS encryption for both, HTTP and TCP transports to provide a secure connection.
-Please, note that the open source version of QuestDB does not support TLS, and requires an external reverse-proxy,
-such as Nginx to enable encryption.
-
-The client supports multiple protocol versions for data serialization. Protocol version 1 uses text-based -serialization, while version 2 uses binary encoding for doubles and supports array columns for improved -performance. The client can automatically negotiate the protocol version with the server when using HTTP/HTTPS -by setting the protocol_version to 'auto' (default behavior). -
--The client uses a buffer to store data. It automatically flushes the buffer by sending its content to the server. -Auto flushing can be disabled via configuration options to gain control over transactions. Initial and maximum -buffer sizes can also be set. -
-
-It is recommended that the Sender is created by using one of the static factory methods,
-Sender.fromConfig(configString, extraOptions) or Sender.fromEnv(extraOptions).
-If the Sender is created via its constructor, at least the SenderOptions configuration object should be
-initialized from a configuration string to make sure that the parameters are validated.
-Detailed description of the Sender's configuration options can be found in
-the SenderOptions documentation.
-
-Transport Configuration Examples: -
-HTTP Transport Implementation:
-By default, HTTP/HTTPS transport uses the high-performance Undici library for connection management and request handling.
-For compatibility or specific requirements, you can enable the standard HTTP transport using Node.js built-in modules
-by setting stdlib_http=on in the configuration string. The standard HTTP transport provides the same functionality
-but uses Node.js http/https modules instead of Undici.
-
-Extra options can be provided to the Sender in the extraOptions configuration object.
-A custom logging function and a custom HTTP(S) agent can be passed to the Sender in this object.
-The logger implementation provides the option to direct log messages to the same place where the host application's
-log is saved. The default logger writes to the console.
-The custom HTTP(S) agent option becomes handy if there is a need to modify the default options set for the
-HTTP(S) connections. A popular setting would be disabling persistent connections, in this case an agent can be
-passed to the Sender with keepAlive set to false.
-For example: Sender.fromConfig(`http::addr=host:port`, { agent: new undici.Agent({ connect: { keepAlive: false } })})
-If no custom agent is configured, the Sender will use its own agent which overrides some default values
-of undici.Agent. The Sender's own agent uses persistent connections with 1 minute idle timeout, pipelines requests default to 1.
-
Creates an instance of Sender.
-Sender configuration object.
-See SenderOptions documentation for detailed description of configuration options.
StaticfromCreates a Sender object by parsing the provided configuration string.
-Configuration string.
OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender object initialized from the provided configuration string.
-StaticfromCreates a Sender object by parsing the configuration string set in the QDB_CLIENT_CONF environment variable.
-OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender object initialized from the QDB_CLIENT_CONF environment variable.
-Resets the sender's buffer, data sitting in the buffer will be lost.
-In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this sender.
-Creates a TCP connection to the database.
-Resolves to true if the client is connected.
-Sends the content of the sender's buffer to the database and compacts the buffer. -If the last row is not finished it stays in the sender's buffer.
-Resolves to true when there was data in the buffer to send, and it was sent successfully.
-Closes the connection to the database.
-Data sitting in the Sender's buffer will be lost unless flush() is called before close().
Writes the table name into the buffer of the sender of the sender.
-Table name.
-Returns with a reference to this sender.
-Writes a symbol name and value into the buffer of the sender.
-Use it to insert into SYMBOL columns.
Symbol name.
-Symbol value, toString() is called to extract the actual symbol value from the parameter.
-Returns with a reference to this sender.
-Writes a string column with its value into the buffer of the sender.
-Use it to insert into VARCHAR and STRING columns.
Column name.
-Column value, accepts only string values.
-Returns with a reference to this sender.
-Writes a boolean column with its value into the buffer of the sender.
-Use it to insert into BOOLEAN columns.
Column name.
-Column value, accepts only boolean values.
-Returns with a reference to this sender.
-Writes a 64-bit floating point value into the buffer of the sender.
-Use it to insert into DOUBLE or FLOAT database columns.
Column name.
-Column value, accepts only number values.
-Returns with a reference to this sender.
-Writes an array column with its values into the buffer of the sender.
-Column name
-Array values to write (currently supports double arrays)
-Returns with a reference to this sender.
-Writes a 64-bit signed integer into the buffer of the sender.
-Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
-Column value, accepts only number values.
-Returns with a reference to this sender.
-Writes a timestamp column and its value into the buffer of the sender.
-Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.The column name.
-The epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Writes a decimal value into the buffer using the text format.
-Use it to insert into DECIMAL database columns.
-Column name.
-Column value, accepts only number/string values.
-Returns with a reference to this buffer.
-Writes a decimal value into the buffer using the binary format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The unscaled value of the decimal in two's -complement representation and big-endian byte order. -An empty array represents the NULL value.
-The scale of the decimal value.
-Returns with a reference to this buffer.
-Closes the row after writing the designated timestamp into the buffer of the sender.
-Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Closes the row without writing designated timestamp into the buffer of the sender.
-Designated timestamp will be populated by the server on this record.
Buffer implementation for protocol version 1.
-Sends floating point numbers in their text form.
Creates a new SenderBufferV1 instance.
-Sender configuration object.
-See SenderOptions documentation for detailed description of configuration options.
Resets the buffer, data sitting in the buffer will be lost.
-In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this buffer.
-Returns a cropped buffer, or null if there is nothing to send.
-The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated.
-Used only in tests to assert the buffer's content.
Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
-The returned buffer is a copy of this buffer.
-It also compacts the buffer.
Writes the table name into the buffer.
-Table name.
-Returns with a reference to this buffer.
-Writes a symbol name and value into the buffer.
-Use it to insert into SYMBOL columns.
Symbol name.
-Symbol value, toString() is called to extract the actual symbol value from the parameter.
-Returns with a reference to this buffer.
-Writes a string column with its value into the buffer.
-Use it to insert into VARCHAR and STRING columns.
Column name.
-Column value, accepts only string values.
-Returns with a reference to this buffer.
-Writes a boolean column with its value into the buffer.
-Use it to insert into BOOLEAN columns.
Column name.
-Column value, accepts only boolean values.
-Returns with a reference to this buffer.
-Writes a 64-bit signed integer into the buffer.
-Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
-Column value, accepts only number values.
-Returns with a reference to this buffer.
-Writes a timestamp column and its value into the buffer.
-Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.The column name.
-The epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Closes the row after writing the designated timestamp into the buffer.
-Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Closes the row without writing designated timestamp into the buffer.
-Designated timestamp will be populated by the server on this record.
Returns the current position of the buffer.
-New data will be written into the buffer starting from this position.
ProtectedcheckChecks if the buffer has sufficient capacity for additional data and resizes if needed.
-Array of strings to calculate the required capacity for
-Base number of bytes to add to the calculation
-Writes a decimal value into the buffer using its text format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The decimal value to write.
-number or a string containing a valid decimal representation."123.45" or "-0.001").Returns with a reference to this buffer.
-Writes a decimal value into the buffer using its binary format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The unscaled integer portion of the decimal value.
-bigint is provided, it will be converted automatically.Int8Array is provided, it must contain the two’s complement representation
-of the unscaled value in big-endian byte order.Int8Array represents a NULL value.The number of fractional digits (the scale) of the decimal value.
-Returns with a reference to this buffer.
-Writes a 64-bit floating point value into the buffer using v1 serialization (text format).
-Use it to insert into DOUBLE or FLOAT database columns.
Column name.
-Column value, accepts only number values.
-Returns with a reference to this sender.
-ProtectedwriteArray columns are not supported in protocol v1.
-Buffer implementation for protocol version 2.
-Sends floating point numbers in binary form, and provides support for arrays.
Creates a new SenderBufferV2 instance.
-Sender configuration object.
-See SenderOptions documentation for detailed description of configuration options.
Resets the buffer, data sitting in the buffer will be lost.
-In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this buffer.
-Returns a cropped buffer, or null if there is nothing to send.
-The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated.
-Used only in tests to assert the buffer's content.
Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
-The returned buffer is a copy of this buffer.
-It also compacts the buffer.
Writes the table name into the buffer.
-Table name.
-Returns with a reference to this buffer.
-Writes a symbol name and value into the buffer.
-Use it to insert into SYMBOL columns.
Symbol name.
-Symbol value, toString() is called to extract the actual symbol value from the parameter.
-Returns with a reference to this buffer.
-Writes a string column with its value into the buffer.
-Use it to insert into VARCHAR and STRING columns.
Column name.
-Column value, accepts only string values.
-Returns with a reference to this buffer.
-Writes a boolean column with its value into the buffer.
-Use it to insert into BOOLEAN columns.
Column name.
-Column value, accepts only boolean values.
-Returns with a reference to this buffer.
-Writes a 64-bit signed integer into the buffer.
-Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
-Column value, accepts only number values.
-Returns with a reference to this buffer.
-Writes a timestamp column and its value into the buffer.
-Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.The column name.
-The epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Closes the row after writing the designated timestamp into the buffer.
-Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Closes the row without writing designated timestamp into the buffer.
-Designated timestamp will be populated by the server on this record.
Returns the current position of the buffer.
-New data will be written into the buffer starting from this position.
ProtectedcheckChecks if the buffer has sufficient capacity for additional data and resizes if needed.
-Array of strings to calculate the required capacity for
-Base number of bytes to add to the calculation
-Writes a decimal value into the buffer using its text format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The decimal value to write.
-number or a string containing a valid decimal representation."123.45" or "-0.001").Returns with a reference to this buffer.
-Writes a decimal value into the buffer using its binary format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The unscaled integer portion of the decimal value.
-bigint is provided, it will be converted automatically.Int8Array is provided, it must contain the two’s complement representation
-of the unscaled value in big-endian byte order.Int8Array represents a NULL value.The number of fractional digits (the scale) of the decimal value.
-Returns with a reference to this buffer.
-Writes a 64-bit floating point value into the buffer using v2 serialization (binary format).
-Use it to insert into DOUBLE or FLOAT database columns.
Column name.
-Column value, accepts only number values.
-Returns with a reference to this buffer.
-ProtectedwriteWrite an array column with its values into the buffer using v2 format.
-Column name
-Array values to write (currently supports double arrays)
-Returns with a reference to this buffer.
-Sender configuration options.
-
-Properties of the object are initialized through a configuration string.
-The configuration string has the following format: protocol::key=value;key=value...
-The keys are case-sensitive, the trailing semicolon is optional.
-The values are validated and an error is thrown if the format is invalid.
-
-Connection and protocol options
Creates a Sender options object by parsing the provided configuration string.
-Configuration string.
OptionalextraOptions: ExtraOptionsOptional extra configuration.
Optionalprotocol_OptionaladdrOptionalhostOptionalportOptionalusernameOptionalpasswordOptionaltokenOptionaltoken_Optionaltoken_Optionalauto_Optionalauto_Optionalauto_Optionalrequest_Optionalrequest_Optionalretry_Optionalinit_Optionalmax_Optionaltls_Optionaltls_Optionaltls_Optionaltls_Optionalmax_OptionallogOptionalagentOptionalstdlib_OptionalauthOptionaljwkStaticresolveResolves the protocol version, if it is set to 'auto'.
-If TCP transport is used, the protocol version will default to 1.
-In case of HTTP transport the /settings endpoint of the database is used to find the protocol versions
-supported by the server, and the highest will be selected.
-When calling the /settings endpoint the timeout and TLS options are used from the options object.
SenderOptions instance needs resolving protocol version
-StaticresolveStaticfromCreates a Sender options object by parsing the provided configuration string.
-Configuration string.
OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender configuration object initialized from the provided configuration string.
-StaticfromCreates a Sender options object by parsing the configuration string set in the QDB_CLIENT_CONF environment variable.
-OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender configuration object initialized from the QDB_CLIENT_CONF environment variable.
-TCP transport implementation.
-Supports both plain TCP or secure TLS-encrypted connections with configurable JWK token authentication.
Creates a new TcpTransport instance.
-Sender configuration object containing connection and authentication details
-HTTP transport implementation using the Undici library.
-Provides high-performance HTTP requests with connection pooling and retry logic.
-Supports both HTTP and HTTPS protocols with configurable authentication.
Creates a new UndiciTransport instance.
-Sender configuration object containing connection and retry settings
-Protected ReadonlysecureProtected ReadonlyhostProtected ReadonlyportProtected ReadonlyusernameProtected ReadonlypasswordProtected ReadonlytokenProtected ReadonlytlsProtected ReadonlytlsProtected ReadonlyrequestProtected ReadonlyrequestProtected ReadonlyretryProtected ReadonlylogBrowser-safe typed positional bind encoder.
+Setters must be called in ascending zero-based index order. SQL placeholders
+are one-based, so index 0 binds $1, index 1 binds $2, and so on.
Binds a DATE expressed as milliseconds since the Unix epoch.
+Binds a TIMESTAMP expressed as microseconds since the Unix epoch.
+Binds a TIMESTAMP_NS expressed as nanoseconds since the Unix epoch.
+An HTTP rejection while creating a browser qdb_session cookie.
Optional ReadonlycauseOptional ReadonlycloseReadonlykindReadonlyresponseOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlA bounds-checked, runtime-neutral little-endian byte reader.
+A growable, runtime-neutral little-endian byte writer.
+Browser-safe facade owning bounded ingress and egress connection pools. +Borrowed handles are exclusive; separate query leases execute concurrently.
+Borrows one exclusive egress connection for one or more serial queries.
+Borrows an exclusive fluent sender; close() flushes and returns its slot.
+Rejects new borrows and closes idle resources. Borrowed query sessions are +cancelled and closed; borrowed senders retain ownership during a bounded +drain and own their teardown if they outlive it.
+Pre-connects the configured minimum sender and query pool sizes.
+The owning QWP client, or one of its returned lease handles, is closed.
+A requested durable-ACK capability was not confirmed by the server.
+Optional ReadonlycauseOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlOne QWP query/statement and its stream of materialized result batches.
+OptionalviewHandler: QwpResultBatchViewHandlerInternalWhether the consumer has retired while the wire still drains.
+InternalInternalStarts the deadline after QUERY_REQUEST reaches the transport.
+Waits for completion without changing the query lifecycle. A finite wait +returns false on expiry; the query remains active until it completes, is +cancelled explicitly, or its configured query deadline expires.
+InternalInternalPreserves batch/callback order before a wire query error.
+Whether the query has reached any terminal outcome.
+InternalCredit needed to discard a late batch while cancellation drains.
+InternalPublishes a batch after reserveMaterializedBatch().
+InternalQueues a decoded view after reserveViewBatch().
+InternalReleases a reservation when decoding fails.
+InternalReleases a reservation when zero-copy decoding fails.
+InternalWaits for one decoded materialized-batch slot.
+InternalWaits for one reusable zero-copy view slot.
+InternalInternalDiscards queued results and retires the consumer immediately.
+InternalWaits until all callback-scoped views have been released.
+Result iteration ended before the server completed the query.
+The server did not terminate a cancelled query within the drain deadline.
+A client-side query deadline expired and a QWP CANCEL was sent.
+OptionalrequestId: bigintBrowser-safe QWP egress session.
+The server currently executes one query at a time per connection, so this +session deliberately rejects overlapping query calls. A completed query's +materialized batches may still be consumed while the next query runs.
+ReadonlyreadyInitial SERVER_INFO; use serverInfo for the current post-failover snapshot.
+Effective codec and level echoed by the server on the active endpoint.
+Effective Zstd level, or zero for raw or unknown negotiation.
+Cached immutable SERVER_INFO for the currently bound endpoint. Reading it +never initiates a connection or failover walk. It is undefined before the +initial bind and refreshes after every successful reconnect.
+InternalCancels and drains an active operation before a pooled lease is returned. +False means the physical session is no longer safe to reuse.
+Executes a query through a bounded, reusable, zero-copy batch callback. +Callbacks run serially and are awaited before their batch is invalidated +and flow-control credit is replenished. The receive loop decodes ahead +into the remaining reusable slots, up to bufferPoolSize.
+InternalBest-effort cancellation followed by physical connection teardown for +facade shutdown. Unlike pooled lease return, this does not wait for the +server to finish draining the cancelled query.
+StaticconnectOptionalsignal: AbortSignalCancels a connection or SERVER_INFO handshake still in progress.
+OptionalcloseInfo: QwpConnectionCloseInfoEvery eligible QWP endpoint in one connection sweep failed.
+A recovered frame was deliberately retired without a server ACK.
+The ingress ACK watermark did not reach the requested frame in time.
+Connection-scoped ingress sequencer.
+One promise is registered before each WebSocket send, preventing a fast ACK +from racing its waiter. Calls are serialized to preserve the server's +zero-based wire sequence. Successful ACKs are cumulative, so an ACK for +sequence N resolves every outstanding send through N.
+Highest cumulative ACK watermark. When durable ACK is being tracked this +advances only after durability; otherwise it follows ordinary OK ACKs.
+Highest stable frame sequence published by this session/transport.
+Prompts the server to publish its latest durable-ingress watermarks. +Node transports use a WebSocket PING; browsers send the protocol-level +table-less durable-ACK poll frame. Browser completion means the control +frame was published; durable progress arrives independently because the +server may withhold its cumulative OK while a transaction remains open.
+Publishes one pre-encoded frame without allocating an ACK waiter. +Applications can observe later acceptance through progress callbacks.
+Encodes and publishes tables without waiting for their server ACK. With +Node store-and-forward this resolves only after every frame is durable in +the local journal; browser and non-persistent transports resolve after the +WebSocket accepts the frames.
+Publishes tables with the automatic connection-scoped symbol dictionary. +After a replay dictionary persistence error, retries use full inline +symbols and no longer depend on the failed sidecar.
+InternalRegisters runtime-specific cleanup owned by this session.
+Starts one pre-encoded frame with independent publication and ACKs.
+Sends tables using the session's connection-scoped symbol dictionary. +String symbol values are assigned stable IDs automatically. +If a replay dictionary append fails, that call rejects with +QwpReplayDictionaryPersistenceError; retrying uses full inline symbols.
+Delta-dictionary variant of sendTablesWithPublication().
+Starts an ingress batch and exposes local publication separately from its +server ACK. High-level senders use this boundary to retain retryable rows +until a persistent replay journal owns the complete logical batch.
+Waits independently for the cumulative frame ACK watermark. A negative +target is already satisfied, but still surfaces a latched session error.
+Waits until a durable ACK covers every table transaction in an OK ACK. +Durable tracking must have been enabled with durableAckKeepaliveMs.
+StaticconnectOptionalsignal: AbortSignalCancels a first connect that is still negotiating. The reconnect loop
+owns its own controller, but the initial attempt bypasses it -- it is
+either handed in as initialConnection or awaited directly below -- so
+without this a close() during the first connect left the socket and its
+deadline alive for the full connect/auth timeout.
OptionalcloseInfo: QwpConnectionCloseInfoACK-driven trimming did not free in-memory replay capacity in time.
+One logical batch can never fit in the configured in-memory replay budget.
+One frame can never fit in the configured in-memory replay budget.
+A bounded QWP pool could not provide a connection before its deadline.
+A pooled resource failed while a new slot was being connected.
+Raised when a QWP payload is malformed, truncated, or unsupported.
+One exclusively borrowed egress session from a QwpClient query pool.
+InternalReadonlyreadyInitial SERVER_INFO; use serverInfo for the current post-failover snapshot.
+Cached immutable SERVER_INFO for this lease's currently bound endpoint. +Reading it does not drive failover; a successful query replay refreshes it.
+A configured QWP reconnect policy exhausted its retry boundary.
+A replay store cannot preserve the dictionary required by delta frames.
+Optionalcause: unknownA replay dictionary sidecar rejected an append before its delta frame was +published. The reconnecting transport has permanently switched to full, +self-contained symbol encoding; retrying the logical batch is safe.
+A replayed ingress frame was rejected and remains in persistent storage.
+Optionalmessage: stringReadonlybatchReadonlycolumnsReadonlyrequestReadonlyrowReadonlytableStateful decoder for connection-scoped QWP result batches.
+OptionalmaxUpper bound on a batch's declared row count, taken from the client's own
+maxBatchRows request.
That request only ever reached the wire -- an upgrade header on Node, a +query parameter in the browser -- and nothing checked the answer against +it. Scratch arrays are sized from the declared row count and deliberately +retained per pool slot for reuse, so a peer that ignores the request, or a +hostile one, sets this session's memory floor for its lifetime: bounded +only by QWP_MAX_CELLS_PER_BATCH times the pool size, which the cap's own +comment puts at roughly half a gigabyte per slot.
+Left undefined the batch is bounded by the cell cap alone, as before.
+Applies the delta symbol dictionary carried by a batch whose rows are +being discarded, without touching any per-query state.
+The dictionary is connection-scoped and cumulative: the server numbers
+entries from where the previous batch left off, on the connection rather
+than on the query. A batch dropped because its query was retired -- by a
+break out of the async iterator, a query deadline, or a throwing
+queryViews callback -- still carries the entries the server has since
+assigned, so skipping it entirely left this dictionary behind the
+server's. resetQuerySchema() deliberately does not clear the dictionary,
+so the gap survived into the next query and surfaced there as
+"delta symbol dictionary is out of sync", naming data the caller never
+asked for.
The dictionary sits at the front of the body, so this reads only as far as +it needs to and never decodes the rows it is throwing away.
+Decodes into one slot from a reusable batch/column-view pool without +materializing a JavaScript value array. Reusing the same slot invalidates +its prior view; callers must not reuse a slot until its consumer releases +the preceding batch.
+InternalDrops frame-backed references after a failed slot decode.
+Batch-owned reusable view delivered by QwpEgressSession.queryViews(). +Access is invalid after the callback returns. materialize() creates an +independently owned QwpResultBatch when retention is required.
+Visits rows in index order with one re-pointed row view. The callback is +synchronous; copy values that must survive the current invocation.
+InternalInvalidates the view. Normally called automatically after queryViews().
+Returns the batch-owned reusable row view pinned to rowIndex. Every call +returns the same object re-pointed at the requested row.
+Reusable, zero-copy view over one QWP result column.
+The view and every byte slice returned from it are valid only while the +surrounding queryViews() callback is running. Copy data that must outlive +the callback.
+Fixed-width stride, zero for bit-packed BOOLEAN, or -1 when variable.
+Lazily materializes one cell; prefer typed/raw accessors on hot paths.
+Zero-copy encoded ARRAY row, including dimension header.
+Zero-copy BINARY bytes.
+Zero-copy UTF-8 bytes for a VARCHAR value.
+Reusable dense-index table; only the first rowCount entries are valid.
+Raw per-row NULL bitmap, without copying. Undefined means no NULLs.
+Concatenated VARCHAR/BINARY payload bytes, without copying.
+Reusable per-row SYMBOL IDs; NULL-row entries are unspecified.
+Raw packed non-null values. Fixed-width values use QWP little-endian +layout; booleans are bit-packed and variable-width columns contain their +uint32 offset table. SYMBOL returns undefined because IDs are varints.
+Reusable row-pinned facade over a QwpResultBatchView.
+The batch owns one instance and re-points it in place. It is valid only +while the surrounding queryViews() callback is running, and must not be +retained across forEachRow() iterations. Byte and array views returned by +its accessors remain zero-copy and have the same lifetime.
+Parent batch, primarily for column metadata.
+Zero-based row currently pinned by this reusable view.
+Zero-copy encoded ARRAY row, including its dimension header.
+Zero-copy BINARY bytes.
+Zero-copy UTF-8 bytes for a VARCHAR value.
+Re-points this flyweight at a row and returns the same instance.
+A connected endpoint advertised a role that does not satisfy target.
Optionalurl: string | URLOptionalserverZone: stringOptional ReadonlycauseOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusReadonlytargetOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlA QWP send was rejected because its WebSocket closed.
+OptionalcloseInfo: QwpConnectionCloseInfoA failure while handing a QWP frame to the WebSocket transport.
+Optionalcause: unknownThe WebSocket did not drain a QWP frame before its send deadline.
+OptionalbufferedAmountBytes: numberBrowser-safe high-level QWP ingress API.
+Applications normally obtain this class through create/connectQwpNodeSender +or create/connectQwpBrowserSender, rather than constructing sessions and +QwpTableBuffer instances themselves.
+Highest cumulative ACK watermark, or -1n before acknowledgement.
+Highest stable frame sequence published by this sender.
+Adds a QuestDB DOUBLE[] value with between 1 and 32 dimensions.
+Discards the row in progress, including its table selection, so the next +row starts from table() again. Rows already completed stay staged.
+Commits rows previously sent by transactional auto-flush. This is an +ergonomic alias for flush(); pending local rows are included in the same +group-closing frame.
+Adds a QuestDB DATE column value in milliseconds since the epoch.
+-9_223_372_036_854_775_808n is QuestDB's DATE NULL sentinel: it is
+stored as NULL and cannot be stored as an ordinary value.
Publishes completed rows to the local ingress/replay boundary. This does +not wait for a server ACK unless awaitServerAck or awaitDurableAck is set.
+Publishes pending rows without waiting for their server ACK and returns +the highest frame sequence produced by this call, or -1n when empty. +Pass the result to waitForAcknowledged() when an explicit delivery +barrier is needed.
+Adds a QuestDB INT column value. -2_147_483_648 is QuestDB's INT NULL
+sentinel: it is stored as NULL and cannot be stored as an ordinary value.
Adds a protocol LONG[] column value with between 1 and 32 dimensions.
+Current QuestDB servers reject LONG-array ingestion with long arrays are not supported, only double arrays. This method remains available for
+Java-client and protocol parity.
Adds a QuestDB LONG column value. -9_223_372_036_854_775_808n is
+QuestDB's LONG NULL sentinel: it is stored as NULL and cannot be stored as
+an ordinary value.
InternalFlushes completed rows and resets borrower-local staging without closing +the physical session. Used by the pooled QWP client when a lease returns.
+Independently waits until the cumulative ACK watermark covers a frame.
+OptionaltimeoutMs: numberCompiles an immutable table schema into an atomic object-row writer. +The returned writer remains usable after this sender is reset.
+close() could not publish and acknowledge all committed ingress frames.
+Connection-scoped QWP symbol dictionary. IDs are dense from zero.
+Appends positionally without de-duplicating recovered entries.
+Rolls back entries added while preparing a frame that was not published.
+Mutable columnar staging area for one QWP ingress table.
+Returns null when the current row already contains this column. The first +value wins, matching the existing Sender API.
+Closes the current row and back-fills missing columns with nulls.
+Truncates every column back to the last completed row.
+Copies a completed half-open row range into an independent table buffer. +Compact column values and their null bitmaps are sliced together, so the +result can be encoded without materialising rows first.
+A reusable table-bound writer compiled from a QWP schema.
+InternalConstruct table writers with QwpSender.writer().
+Validates and atomically appends one complete object row.
+Appends a synchronous or asynchronous stream of complete object rows.
+Recovered delta frames depend on symbol IDs that neither the durable +dictionary prefix nor the surviving frames can reconstruct.
+Optionalcause: unknownA failure while establishing or validating a QWP WebSocket upgrade.
+Optional ReadonlycauseOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlA complete object row failed compiled-writer validation.
+HTTP transport implementation using Node.js built-in http/https modules.
+Supports both HTTP and HTTPS protocols with configurable authentication.
Creates a new HttpTransport instance using Node.js HTTP modules.
+Sender configuration object containing connection details
+Protected ReadonlyhostProtected ReadonlylogProtected ReadonlypasswordProtected ReadonlyportProtected ReadonlyrequestProtected ReadonlyrequestProtected ReadonlyretryProtected ReadonlysecureProtected ReadonlytlsProtected ReadonlytlsProtected ReadonlytokenProtected ReadonlyusernameHTTP transport does not require explicit connection closure.
+Promise that resolves immediately
+Gets the default auto-flush row count for HTTP transport.
+Default number of rows that trigger auto-flush
+Sends data to QuestDB using HTTP POST.
+Buffer containing the data to send
+Internal parameter for tracking retry start time
+Internal parameter for tracking retry intervals
+Promise resolving to true if data was sent successfully
+ReadonlybatchOptionalcauseReadonlymaxOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareBrowser-safe typed positional bind encoder.
+Setters must be called in ascending zero-based index order. SQL placeholders
+are one-based, so index 0 binds $1, index 1 binds $2, and so on.
Binds a DATE expressed as milliseconds since the Unix epoch.
+Binds a TIMESTAMP expressed as microseconds since the Unix epoch.
+Binds a TIMESTAMP_NS expressed as nanoseconds since the Unix epoch.
+A bounds-checked, runtime-neutral little-endian byte reader.
+A growable, runtime-neutral little-endian byte writer.
+Browser-safe facade owning bounded ingress and egress connection pools. +Borrowed handles are exclusive; separate query leases execute concurrently.
+Borrows one exclusive egress connection for one or more serial queries.
+Borrows an exclusive fluent sender; close() flushes and returns its slot.
+Rejects new borrows and closes idle resources. Borrowed query sessions are +cancelled and closed; borrowed senders retain ownership during a bounded +drain and own their teardown if they outlive it.
+Pre-connects the configured minimum sender and query pool sizes.
+The owning QWP client, or one of its returned lease handles, is closed.
+OptionalcauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA requested durable-ACK capability was not confirmed by the server.
+Optional ReadonlycauseOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+True for a 421 response from a read-only replica.
+True for a 421 response from a primary still completing catch-up.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOne QWP query/statement and its stream of materialized result batches.
+OptionalviewHandler: QwpResultBatchViewHandlerInternalWhether the consumer has retired while the wire still drains.
+InternalInternalStarts the deadline after QUERY_REQUEST reaches the transport.
+Waits for completion without changing the query lifecycle. A finite wait +returns false on expiry; the query remains active until it completes, is +cancelled explicitly, or its configured query deadline expires.
+InternalInternalPreserves batch/callback order before a wire query error.
+Whether the query has reached any terminal outcome.
+InternalCredit needed to discard a late batch while cancellation drains.
+InternalPublishes a batch after reserveMaterializedBatch().
+InternalQueues a decoded view after reserveViewBatch().
+InternalReleases a reservation when decoding fails.
+InternalReleases a reservation when zero-copy decoding fails.
+InternalWaits for one decoded materialized-batch slot.
+InternalWaits for one reusable zero-copy view slot.
+InternalInternalDiscards queued results and retires the consumer immediately.
+InternalWaits until all callback-scoped views have been released.
+Result iteration ended before the server completed the query.
+OptionalcauseReadonlyrequestOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareThe server did not terminate a cancelled query within the drain deadline.
+OptionalcauseReadonlyrequestOptionalstackReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptionalcauseReadonlyrequestOptionalstackReadonlystatusStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA client-side query deadline expired and a QWP CANCEL was sent.
+OptionalcauseReadonlyrequestOptionalstackReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptionalrequestId: bigintOptionalcauseOptional ReadonlyrequestOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareBrowser-safe QWP egress session.
+The server currently executes one query at a time per connection, so this +session deliberately rejects overlapping query calls. A completed query's +materialized batches may still be consumed while the next query runs.
+ReadonlyreadyInitial SERVER_INFO; use serverInfo for the current post-failover snapshot.
+Effective codec and level echoed by the server on the active endpoint.
+Effective Zstd level, or zero for raw or unknown negotiation.
+Cached immutable SERVER_INFO for the currently bound endpoint. Reading it +never initiates a connection or failover walk. It is undefined before the +initial bind and refreshes after every successful reconnect.
+InternalCancels and drains an active operation before a pooled lease is returned. +False means the physical session is no longer safe to reuse.
+Executes a query through a bounded, reusable, zero-copy batch callback. +Callbacks run serially and are awaited before their batch is invalidated +and flow-control credit is replenished. The receive loop decodes ahead +into the remaining reusable slots, up to bufferPoolSize.
+InternalBest-effort cancellation followed by physical connection teardown for +facade shutdown. Unlike pooled lease return, this does not wait for the +server to finish draining the cancelled query.
+StaticconnectOptionalsignal: AbortSignalCancels a connection or SERVER_INFO handshake still in progress.
+OptionalcloseInfo: QwpConnectionCloseInfoOptionalcauseOptional ReadonlycloseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareEvery eligible QWP endpoint in one connection sweep failed.
+ReadonlyattemptsOptional ReadonlycauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA recovered frame was deliberately retired without a server ACK.
+OptionalcauseReadonlyfromOptionalstackReadonlytargetReadonlytoStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareThe ingress ACK watermark did not reach the requested frame in time.
+ReadonlyacknowledgedOptionalcauseOptionalstackReadonlytargetReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptionalcauseReadonlyresponseReadonlysenderOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareConnection-scoped ingress sequencer.
+One promise is registered before each WebSocket send, preventing a fast ACK +from racing its waiter. Calls are serialized to preserve the server's +zero-based wire sequence. Successful ACKs are cumulative, so an ACK for +sequence N resolves every outstanding send through N.
+Highest cumulative ACK watermark. When durable ACK is being tracked this +advances only after durability; otherwise it follows ordinary OK ACKs.
+Highest stable frame sequence published by this session/transport.
+Prompts the server to publish its latest durable-ingress watermarks. +Node transports use a WebSocket PING; browsers send the protocol-level +table-less durable-ACK poll frame. Browser completion means the control +frame was published; durable progress arrives independently because the +server may withhold its cumulative OK while a transaction remains open.
+Publishes one pre-encoded frame without allocating an ACK waiter. +Applications can observe later acceptance through progress callbacks.
+Encodes and publishes tables without waiting for their server ACK. With +Node store-and-forward this resolves only after every frame is durable in +the local journal; browser and non-persistent transports resolve after the +WebSocket accepts the frames.
+Publishes tables with the automatic connection-scoped symbol dictionary. +After a replay dictionary persistence error, retries use full inline +symbols and no longer depend on the failed sidecar.
+InternalRegisters runtime-specific cleanup owned by this session.
+Starts one pre-encoded frame with independent publication and ACKs.
+Sends tables using the session's connection-scoped symbol dictionary. +String symbol values are assigned stable IDs automatically. +If a replay dictionary append fails, that call rejects with +QwpReplayDictionaryPersistenceError; retrying uses full inline symbols.
+Delta-dictionary variant of sendTablesWithPublication().
+Starts an ingress batch and exposes local publication separately from its +server ACK. High-level senders use this boundary to retain retryable rows +until a persistent replay journal owns the complete logical batch.
+Waits independently for the cumulative frame ACK watermark. A negative +target is already satisfied, but still surfaces a latched session error.
+Waits until a durable ACK covers every table transaction in an OK ACK. +Durable tracking must have been enabled with durableAckKeepaliveMs.
+StaticconnectOptionalsignal: AbortSignalCancels a first connect that is still negotiating. The reconnect loop
+owns its own controller, but the initial attempt bypasses it -- it is
+either handed in as initialConnection or awaited directly below -- so
+without this a close() during the first connect left the socket and its
+deadline alive for the full connect/auth timeout.
OptionalcloseInfo: QwpConnectionCloseInfoOptionalcauseOptional ReadonlycloseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareACK-driven trimming did not free in-memory replay capacity in time.
+OptionalcauseReadonlymaxReadonlyrequiredOptionalstackReadonlytimeoutReadonlyusedStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOne logical batch can never fit in the configured in-memory replay budget.
+OptionalcauseReadonlyframeReadonlymaxReadonlyrequiredOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOne frame can never fit in the configured in-memory replay budget.
+OptionalcauseReadonlymaxReadonlypayloadReadonlyrequiredOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareNode store-and-forward journal with configurable local durability.
+The active fixed-size segment and one hot spare remain open for positional
+writes. append fsyncs each frame, periodic batches barriers, and memory
+relies on OS writeback. An ACK persists its cursor before bounded background
+trimming. A crash between the server ACK and local deletion can cause
+at-least-once replay. An exclusive, lifetime lock prevents another process
+from recovering or mutating the same directory.
Persists new dense entries before a delta frame is made replayable.
+InternalRemoves a local prefix without representing it as a server ACK. +Persistent stores should provide this when recovery can abandon frames.
+"Without representing it as a server ACK" is about the transport's public
+watermark, which the caller leaves alone. The removal itself must be as
+durable as acknowledgeThrough's: a discarded prefix that a later load()
+can still see is a prefix this client reported abandoned and then sent
+anyway.
Opens and validates the journal without materializing every payload.
+Implementations that provide this must also provide readPayload.
Loads the durable, dense symbol prefix used by persisted delta frames.
+InternalWaits until every payload in one logical batch can be appended +without an ACK between frames. Implementations must not mutate the journal.
+Reads one previously loaded durable payload on demand.
+Atomically replaces an unusable dictionary after surviving committed +frames prove that its complete ID space can be reconstructed.
+Bounded Node-only scanner and background drainer for replay slots left by +terminated producer processes. Each adopted slot uses its own connection.
+Node-only, fire-and-forget QWP v1 ingress session over IPv4 UDP.
+Each datagram is self-contained: it carries one table, an inline schema and +local symbol dictionaries. There are no ACKs, retries, transactions, +authentication, compression, or store-and-forward semantics.
+StaticconnectA bounded QWP pool could not provide a connection before its deadline.
+OptionalcauseReadonlyresourceOptionalstackReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA pooled resource failed while a new slot was being connected.
+ReadonlycauseReadonlyresourceOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareRaised when a QWP payload is malformed, truncated, or unsupported.
+OptionalcauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOne exclusively borrowed egress session from a QwpClient query pool.
+InternalReadonlyreadyInitial SERVER_INFO; use serverInfo for the current post-failover snapshot.
+Cached immutable SERVER_INFO for this lease's currently bound endpoint. +Reading it does not drive failover; a successful query replay refreshes it.
+A configured QWP reconnect policy exhausted its retry boundary.
+ReadonlyattemptsReadonlycauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA replay store cannot preserve the dictionary required by delta frames.
+Optionalcause: unknownOptional ReadonlycauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA replay dictionary sidecar rejected an append before its delta frame was +published. The reconnecting transport has permanently switched to full, +self-contained symbol encoding; retrying the logical batch is safe.
+Optional ReadonlycauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA replayed ingress frame was rejected and remains in persistent storage.
+Optionalmessage: stringOptionalcauseReadonlyframeOptionalstackReadonlystatusStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptional ReadonlycauseReadonlymaxReadonlyrequiredReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptionalcause: unknownOptional ReadonlycauseReadonlydirectoryReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareDurable journal bytes are structurally corrupt and cannot be replayed.
+Optionalcause: unknownOptional ReadonlycauseReadonlyretryableCorrupt bytes read the same way on every attempt.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptionalcause: unknownOptional ReadonlycauseReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptional ReadonlycauseReadonlymaxReadonlyrequiredReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareThe advisory-lock owner record changed while this journal was open, so this +store may no longer write to it. A lapsed heartbeat alone does not transfer +ownership: a live holder revalidates its acquisition token before resuming.
+Once the token changes, whatever this store does next must not be an append: +the new owner appends at offsets this store still believes are free, and +because a frame's sequence is derived from its position, an overwrite of the +same width leaves a journal that reopens as intact with the new owner's +frames gone. Failing the append is what keeps that loss impossible.
+Optional ReadonlycauseReadonlydirectoryReadonlyretryableRetrying is precisely what must not happen: the slot belongs to another +process now, so replaying out of it would race that owner's appends.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOwnership of the advisory lock could not be re-proved right now. Nothing was
+taken: reading the owner record is the only heartbeat step that needs a file
+descriptor, so process-wide descriptor pressure, an EIO, or an NFS
+ESTALE fails precisely it while stat and utimes keep succeeding.
Reported separately from QwpReplayStoreLockLostError because the two
+demand opposite responses. A takeover is terminal; this is transient and
+self-healing, so it stays retryable: the append backpressure loop parks on
+it until appendDeadlineMs, and the reconnect loop retries rather than
+ending the session. Collapsing them terminated a producer -- permanently,
+with the transport healthy throughout -- because the host process briefly
+ran out of descriptors, and blamed a second process that did not exist.
Optional ReadonlycauseReadonlydirectoryReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptionalholderPid: numberOptional ReadonlycauseReadonlydirectoryOptional ReadonlyholderReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA terminal replay slot was preserved under a quarantine pathname.
+Optional ReadonlycauseReadonlydirectoryReadonlyquarantineReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareOptional ReadonlycauseReadonlymaxReadonlypayloadReadonlyretryableWhether reconnecting and replaying can plausibly clear this failure.
+Background maintenance and checkpoint faults are parked and cleared on the +next successful batch, so a briefly full, read-only or descriptor-starved +filesystem is retryable. Structural corruption and a slot lock taken over +by another process are verdicts on the journal itself and are not. The +ingress connection lives in the browser-safe layer and cannot reference +these classes, so it reads this flag structurally.
+OptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareReadonlybatchReadonlycolumnsReadonlyrequestReadonlyrowReadonlytableStateful decoder for connection-scoped QWP result batches.
+OptionalmaxUpper bound on a batch's declared row count, taken from the client's own
+maxBatchRows request.
That request only ever reached the wire -- an upgrade header on Node, a +query parameter in the browser -- and nothing checked the answer against +it. Scratch arrays are sized from the declared row count and deliberately +retained per pool slot for reuse, so a peer that ignores the request, or a +hostile one, sets this session's memory floor for its lifetime: bounded +only by QWP_MAX_CELLS_PER_BATCH times the pool size, which the cap's own +comment puts at roughly half a gigabyte per slot.
+Left undefined the batch is bounded by the cell cap alone, as before.
+Applies the delta symbol dictionary carried by a batch whose rows are +being discarded, without touching any per-query state.
+The dictionary is connection-scoped and cumulative: the server numbers
+entries from where the previous batch left off, on the connection rather
+than on the query. A batch dropped because its query was retired -- by a
+break out of the async iterator, a query deadline, or a throwing
+queryViews callback -- still carries the entries the server has since
+assigned, so skipping it entirely left this dictionary behind the
+server's. resetQuerySchema() deliberately does not clear the dictionary,
+so the gap survived into the next query and surfaced there as
+"delta symbol dictionary is out of sync", naming data the caller never
+asked for.
The dictionary sits at the front of the body, so this reads only as far as +it needs to and never decodes the rows it is throwing away.
+Decodes into one slot from a reusable batch/column-view pool without +materializing a JavaScript value array. Reusing the same slot invalidates +its prior view; callers must not reuse a slot until its consumer releases +the preceding batch.
+InternalDrops frame-backed references after a failed slot decode.
+Batch-owned reusable view delivered by QwpEgressSession.queryViews(). +Access is invalid after the callback returns. materialize() creates an +independently owned QwpResultBatch when retention is required.
+Visits rows in index order with one re-pointed row view. The callback is +synchronous; copy values that must survive the current invocation.
+InternalInvalidates the view. Normally called automatically after queryViews().
+Returns the batch-owned reusable row view pinned to rowIndex. Every call +returns the same object re-pointed at the requested row.
+Reusable, zero-copy view over one QWP result column.
+The view and every byte slice returned from it are valid only while the +surrounding queryViews() callback is running. Copy data that must outlive +the callback.
+Fixed-width stride, zero for bit-packed BOOLEAN, or -1 when variable.
+Lazily materializes one cell; prefer typed/raw accessors on hot paths.
+Zero-copy encoded ARRAY row, including dimension header.
+Zero-copy BINARY bytes.
+Zero-copy UTF-8 bytes for a VARCHAR value.
+Reusable dense-index table; only the first rowCount entries are valid.
+Raw per-row NULL bitmap, without copying. Undefined means no NULLs.
+Concatenated VARCHAR/BINARY payload bytes, without copying.
+Reusable per-row SYMBOL IDs; NULL-row entries are unspecified.
+Raw packed non-null values. Fixed-width values use QWP little-endian +layout; booleans are bit-packed and variable-width columns contain their +uint32 offset table. SYMBOL returns undefined because IDs are varints.
+Reusable row-pinned facade over a QwpResultBatchView.
+The batch owns one instance and re-points it in place. It is valid only +while the surrounding queryViews() callback is running, and must not be +retained across forEachRow() iterations. Byte and array views returned by +its accessors remain zero-copy and have the same lifetime.
+Parent batch, primarily for column metadata.
+Zero-based row currently pinned by this reusable view.
+Zero-copy encoded ARRAY row, including its dimension header.
+Zero-copy BINARY bytes.
+Zero-copy UTF-8 bytes for a VARCHAR value.
+Re-points this flyweight at a row and returns the same instance.
+A connected endpoint advertised a role that does not satisfy target.
Optionalurl: string | URLOptionalserverZone: stringOptional ReadonlycauseOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusReadonlytargetOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+True for a 421 response from a read-only replica.
+True for a 421 response from a primary still completing catch-up.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA QWP send was rejected because its WebSocket closed.
+OptionalcloseInfo: QwpConnectionCloseInfoOptional ReadonlycauseOptional ReadonlycloseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA failure while handing a QWP frame to the WebSocket transport.
+Optionalcause: unknownOptional ReadonlycauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareThe WebSocket did not drain a QWP frame before its send deadline.
+OptionalbufferedAmountBytes: numberOptional ReadonlybufferedOptional ReadonlycauseOptionalstackReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareBrowser-safe high-level QWP ingress API.
+Applications normally obtain this class through create/connectQwpNodeSender +or create/connectQwpBrowserSender, rather than constructing sessions and +QwpTableBuffer instances themselves.
+Highest cumulative ACK watermark, or -1n before acknowledgement.
+Highest stable frame sequence published by this sender.
+Adds a QuestDB DOUBLE[] value with between 1 and 32 dimensions.
+Discards the row in progress, including its table selection, so the next +row starts from table() again. Rows already completed stay staged.
+Commits rows previously sent by transactional auto-flush. This is an +ergonomic alias for flush(); pending local rows are included in the same +group-closing frame.
+Adds a QuestDB DATE column value in milliseconds since the epoch.
+-9_223_372_036_854_775_808n is QuestDB's DATE NULL sentinel: it is
+stored as NULL and cannot be stored as an ordinary value.
Publishes completed rows to the local ingress/replay boundary. This does +not wait for a server ACK unless awaitServerAck or awaitDurableAck is set.
+Publishes pending rows without waiting for their server ACK and returns +the highest frame sequence produced by this call, or -1n when empty. +Pass the result to waitForAcknowledged() when an explicit delivery +barrier is needed.
+Adds a QuestDB INT column value. -2_147_483_648 is QuestDB's INT NULL
+sentinel: it is stored as NULL and cannot be stored as an ordinary value.
Adds a protocol LONG[] column value with between 1 and 32 dimensions.
+Current QuestDB servers reject LONG-array ingestion with long arrays are not supported, only double arrays. This method remains available for
+Java-client and protocol parity.
Adds a QuestDB LONG column value. -9_223_372_036_854_775_808n is
+QuestDB's LONG NULL sentinel: it is stored as NULL and cannot be stored as
+an ordinary value.
InternalFlushes completed rows and resets borrower-local staging without closing +the physical session. Used by the pooled QWP client when a lease returns.
+Independently waits until the cumulative ACK watermark covers a frame.
+OptionaltimeoutMs: numberCompiles an immutable table schema into an atomic object-row writer. +The returned writer remains usable after this sender is reset.
+close() could not publish and acknowledge all committed ingress frames.
+ReadonlyacknowledgedOptionalcauseOptionalstackReadonlytargetReadonlytimeoutStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareConnection-scoped QWP symbol dictionary. IDs are dense from zero.
+Appends positionally without de-duplicating recovered entries.
+Rolls back entries added while preparing a frame that was not published.
+Mutable columnar staging area for one QWP ingress table.
+Returns null when the current row already contains this column. The first +value wins, matching the existing Sender API.
+Closes the current row and back-fills missing columns with nulls.
+Truncates every column back to the last completed row.
+Copies a completed half-open row range into an independent table buffer. +Compact column values and their null bitmaps are sliced together, so the +result can be encoded without materialising rows first.
+A reusable table-bound writer compiled from a QWP schema.
+InternalConstruct table writers with QwpSender.writer().
+Validates and atomically appends one complete object row.
+Appends a synchronous or asynchronous stream of complete object rows.
+A single encoded row cannot fit into the configured UDP datagram.
+OptionalcauseReadonlydatagramReadonlymaxReadonlyrowOptionalstackReadonlytableStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareRecovered delta frames depend on symbol IDs that neither the durable +dictionary prefix nor the surviving frames can reconstruct.
+Optionalcause: unknownOptional ReadonlycauseOptionalstackStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA failure while establishing or validating a QWP WebSocket upgrade.
+Optional ReadonlycauseOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+True for a 421 response from a read-only replica.
+True for a 421 response from a primary still completing catch-up.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA failure while establishing or validating a QWP WebSocket upgrade.
+Optionalurl: string | URLOptional ReadonlycauseReadonlyclientOptional ReadonlycloseReadonlykindOptional ReadonlyretryableOptional ReadonlyserverReadonlyserverOptional ReadonlyserverOptionalstackOptional ReadonlystatusOptional ReadonlystatusOptional ReadonlytimeoutNode opening phase that exceeded its deadline.
+Optional ReadonlytryOptional ReadonlyurlStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+True for a 421 response from a read-only replica.
+True for a 421 response from a primary still completing catch-up.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareA complete object row failed compiled-writer validation.
+ReadonlycauseReadonlycolumnReadonlyrowOptionalstackReadonlytableStaticstackThe Error.stackTraceLimit property specifies the number of stack frames
+collected by a stack trace (whether generated by new Error().stack or
+Error.captureStackTrace(obj)).
The default value is 10 but may be set to any valid JavaScript number. Changes
+will affect any stack trace captured after the value has been changed.
If set to a non-number value, or set to a negative number, stack traces will +not capture any frames.
+StaticcaptureCreates a .stack property on targetObject, which when accessed returns
+a string representing the location in the code at which
+Error.captureStackTrace() was called.
const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // Similar to `new Error().stack`
+The first line of the trace will be prefixed with
+${myObject.name}: ${myObject.message}.
The optional constructorOpt argument accepts a function. If given, all frames
+above constructorOpt, including constructorOpt, will be omitted from the
+generated stack trace.
The constructorOpt argument is useful for hiding implementation
+details of error generation from the user. For instance:
function a() {
b();
}
function b() {
c();
}
function c() {
// Create an error without stack trace to avoid calculating the stack trace twice.
const { stackTraceLimit } = Error;
Error.stackTraceLimit = 0;
const error = new Error();
Error.stackTraceLimit = stackTraceLimit;
// Capture the stack trace above function b
Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
throw error;
}
a();
+OptionalconstructorOpt: FunctionStaticprepareThe QuestDB client's API provides methods to connect to the database, ingest data, and close the connection.
+The client supports multiple transport protocols.
+Transport Options: +
+The client supports authentication.
+Authentication details can be passed to the Sender in its configuration options.
+The client supports Basic username/password and Bearer token authentication methods when used with HTTP protocol,
+and JWK token authentication when ingesting data via TCP.
+Please, note that authentication is enabled by default in QuestDB Enterprise only.
+Details on how to configure authentication in the open source version of
+QuestDB: https://questdb.io/docs/reference/api/ilp/authenticate
+
+The client also supports TLS encryption for both, HTTP and TCP transports to provide a secure connection.
+Please, note that the open source version of QuestDB does not support TLS, and requires an external reverse-proxy,
+such as Nginx to enable encryption.
+
+The client supports multiple protocol versions for data serialization. Protocol version 1 uses text-based +serialization, while version 2 uses binary encoding for doubles and supports array columns for improved +performance. The client can automatically negotiate the protocol version with the server when using HTTP/HTTPS +by setting the protocol_version to 'auto' (default behavior). +
++The client uses a buffer to store data. It automatically flushes the buffer by sending its content to the server. +Auto flushing can be disabled via configuration options to gain control over transactions. Initial and maximum +buffer sizes can also be set. +
+
+It is recommended that the Sender is created by using one of the static factory methods,
+Sender.fromConfig(configString, extraOptions) or Sender.fromEnv(extraOptions).
+If the Sender is created via its constructor, at least the SenderOptions configuration object should be
+initialized from a configuration string to make sure that the parameters are validated.
+Detailed description of the Sender's configuration options can be found in
+the SenderOptions documentation.
+
+Transport Configuration Examples: +
+HTTP Transport Implementation:
+By default, HTTP/HTTPS transport uses the high-performance Undici library for connection management and request handling.
+For compatibility or specific requirements, you can enable the standard HTTP transport using Node.js built-in modules
+by setting stdlib_http=on in the configuration string. The standard HTTP transport provides the same functionality
+but uses Node.js http/https modules instead of Undici.
+
+Extra options can be provided to the Sender in the extraOptions configuration object.
+A custom logging function and a custom HTTP(S) agent can be passed to the Sender in this object.
+The logger implementation provides the option to direct log messages to the same place where the host application's
+log is saved. The default logger writes to the console.
+The custom HTTP(S) agent option becomes handy if there is a need to modify the default options set for the
+HTTP(S) connections. A popular setting would be disabling persistent connections, in this case an agent can be
+passed to the Sender with keepAlive set to false.
+For example: Sender.fromConfig(`http::addr=host:port`, { agent: new undici.Agent({ connect: { keepAlive: false } })})
+An undici.Agent applies only to the default HTTP(S) transport. QWP WS/WSS uses the ws package and requires
+a Node.js http.Agent/https.Agent; an incompatible top-level agent is ignored with a warning.
+If no custom agent is configured, the Sender will use its own agent which overrides some default values
+of undici.Agent. The Sender's own agent uses persistent connections with 1 minute idle timeout, pipelines requests default to 1.
+
+QWP authenticates the WebSocket upgrade with HTTP Basic (username and password) or Bearer +(token); it has no JWK path, so auth, jwk, token_x and token_y are rejected +rather than ignored. tls_verify and tls_ca apply to wss only. Supplying +qwp.webSocket.authorization alongside username/password or token is rejected as +ambiguous, the same way a custom agent cannot be combined with tls_verify/tls_ca. +
Creates an instance of Sender.
+Sender configuration object.
+See SenderOptions documentation for detailed description of configuration options.
Highest cumulative QWP ACK watermark, or -1n when unavailable.
+Highest stable QWP frame sequence published, or -1n when unavailable.
+Writes an array column with its values into the buffer of the sender.
+Column name
+Array values to write (currently supports double arrays). A null or undefined value omits the column entirely when arrays are supported; protocol v1 rejects the call for every value.
+Returns with a reference to this sender.
+Closes the row after writing the designated timestamp.
+On ILP, a row is discarded -- its columns and its table selection alike --
+only when it can never be closed, which means it carries no symbol and no
+column; rows completed earlier remain staged, and the next row starts from
+table again. Every other rejection leaves the row open and this
+call retryable: an invalid designated timestamp, its unit or its value, is
+caught before closing begins, so a corrected argument closes the same row,
+and a row that does not fit max_buf_size has its partial close rewound,
+so the same call succeeds once a flush() frees space. A rejected column
+or symbol call likewise writes nothing. If this call triggers an
+auto-flush that fails, ILP transports have already removed the entire
+staged batch from the sender buffer. Applications that need to retry ILP
+rows must retain and resubmit them. QWP retains successfully closed rows
+for its retry and replay path.
Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsResolves after the row is closed and any triggered auto-flush completes.
+Closes the row without writing a designated timestamp.
+Designated timestamp will be populated by the server on this record.
+On ILP, a row is discarded -- its columns and its table selection alike --
+only when it can never be closed, which means it carries no symbol and no
+column; rows completed earlier remain staged, and the next row starts from
+table again. Every other rejection leaves the row open and this
+call retryable: a row that does not fit max_buf_size has its partial
+close rewound, so the same call succeeds once a flush() frees space, and
+a rejected column or symbol call writes nothing. If this call triggers an
+auto-flush that fails, ILP transports have already removed the entire
+staged batch from the sender buffer. Applications that need to retry ILP
+rows must retain and resubmit them. QWP retains successfully closed rows
+for its retry and replay path.
Resolves after the row is closed and any triggered auto-flush completes.
+Writes a boolean column with its value into the buffer of the sender.
+Use it to insert into BOOLEAN columns.
Column name.
+Column value, accepts only boolean values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this sender.
+Closes the connection to the database. QWP publishes completed rows and +performs a bounded acknowledgement drain first. Other transports retain +their legacy behavior and require an explicit flush().
+Establishes the transport connection for TCP, TCPS, WS, WSS, and UDP. +HTTP and HTTPS connect per request and reject this call because no explicit +connection step is required.
+Resolves to true if the client is connected.
+Writes a decimal value into the buffer using the binary format.
+Use it to insert into DECIMAL database columns.
+Column name.
+The unscaled value of the decimal in two's +complement representation and big-endian byte order. +A null or undefined value omits the column entirely when decimals are +supported; ILP protocol v1/v2 reject the call for every value. +An empty array also represents NULL, but the two are not encoded alike: +on the ILP transports an empty array writes an explicit NULL decimal +field, while the QWP transports omit the column exactly as they do for +null. QuestDB records NULL either way for a column that already exists.
+The scale of the decimal value.
+Returns with a reference to this buffer.
+Writes a decimal value into the buffer using the text format.
+Use it to insert into DECIMAL database columns.
+Column name.
+Column value, accepts only number/string values. A null or undefined value omits the column entirely when decimals are supported; ILP protocol v1/v2 reject the call for every value.
+Returns with a reference to this buffer.
+Writes a 64-bit floating point value into the buffer of the sender.
+Use it to insert into DOUBLE or FLOAT database columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this sender.
+Sends the content of the sender's buffer to the database and compacts the buffer. +If the last row is not finished it stays in the sender's buffer.
+Resolves to true when there was data in the buffer to send, and it was sent successfully.
+Flushes pending rows and returns the highest QWP frame sequence published +by this call. Non-QWP transports flush normally and return -1n because +they do not expose frame sequences.
+Writes a 64-bit signed integer into the buffer of the sender.
+Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this sender.
+Resets the sender's buffer, data sitting in the buffer will be lost.
+In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this sender.
+Writes a string column with its value into the buffer of the sender.
+Use it to insert into VARCHAR and STRING columns.
Column name.
+Column value, accepts only string values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this sender.
+Writes a symbol name and value into the buffer of the sender.
+Use it to insert into SYMBOL columns.
Symbol name.
+Symbol value, toString() is called to extract the actual symbol value from the parameter. A null or undefined value omits the symbol entirely (stored as NULL).
+Returns with a reference to this sender.
+Writes the table name into the buffer of the sender of the sender.
+Table name.
+Returns with a reference to this sender.
+Writes a timestamp column and its value into the buffer of the sender.
+Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.The column name.
+The epoch timestamp. Must be an integer or a BigInt. A null or undefined value omits the column entirely (stored as NULL).
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+Waits independently for a cumulative QWP ACK watermark.
+OptionaltimeoutMs: numberCompiles a table-bound object-row writer for QWP transports. +Legacy ILP transports continue to use the fluent row API.
+StaticfromCreates a Sender object by parsing the provided configuration string.
+Configuration string.
OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender object initialized from the provided configuration string.
+StaticfromCreates a Sender object by parsing the configuration string set in the QDB_CLIENT_CONF environment variable.
+OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender object initialized from the QDB_CLIENT_CONF environment variable.
+Buffer implementation for protocol version 1.
+Sends floating point numbers in their text form.
Creates a new SenderBufferV1 instance.
+Sender configuration object.
+See SenderOptions documentation for detailed description of configuration options.
Array columns are not supported in protocol v1.
+The capability check applies even when the value is null or undefined.
Column name.
+Array values.
+Returns with a reference to this buffer.
+Closes the row after writing the designated timestamp into the buffer.
+Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+If unit is not one of 'ns', 'us', or 'ms'.
+Argument validation -- the unit and the timestamp alike -- runs before the
+close touches the row, so it leaves the open row unchanged and the call
+can be retried with a corrected argument.
Closes the row without writing designated timestamp into the buffer.
+Designated timestamp will be populated by the server on this record.
Writes a boolean column with its value into the buffer.
+Use it to insert into BOOLEAN columns.
Column name.
+Column value, accepts only boolean values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+ProtectedcheckChecks if the buffer has sufficient capacity for additional data and resizes if needed.
+Array of strings to calculate the required capacity for
+Base number of bytes to add to the calculation
+Returns the current position of the buffer.
+New data will be written into the buffer starting from this position.
Writes a decimal value into the buffer using its binary format.
+Use it to insert into DECIMAL database columns.
+Decimals are not supported by protocol v1/v2, so this base implementation +rejects the call even when the value is null or undefined. Protocol v3 +overrides this with a validating implementation.
+Column name.
+The unscaled +integer portion of the decimal value.
+The number of fractional digits (the scale) of the decimal value.
+Returns with a reference to this buffer.
+Writes a decimal value into the buffer using its text format.
+Use it to insert into DECIMAL database columns.
+Decimals are not supported by protocol v1/v2, so this base implementation +rejects the call even when the value is null or undefined. Protocol v3 +overrides this with a validating implementation.
+Column name.
+The decimal value to +write.
+Returns with a reference to this buffer.
+Writes a 64-bit floating point value into the buffer using v1 serialization (text format).
+Use it to insert into DOUBLE or FLOAT database columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this sender.
+Writes a 64-bit signed integer into the buffer.
+Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Resets the buffer, data sitting in the buffer will be lost.
+In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this buffer.
+Writes a string column with its value into the buffer.
+Use it to insert into VARCHAR and STRING columns.
Column name.
+Column value, accepts only string values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a symbol name and value into the buffer.
+Use it to insert into SYMBOL columns.
Symbol name.
+Symbol value, toString() is called to extract the actual symbol value from the parameter. A null or undefined value omits the symbol entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes the table name into the buffer.
+Table name.
+Returns with a reference to this buffer.
+Writes a timestamp column and its value into the buffer.
+Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.The column name.
+The epoch timestamp. Must be an integer or a BigInt. A null or undefined value omits the column entirely (stored as NULL).
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
+The returned buffer is a copy of this buffer.
+It also compacts the buffer.
Returns a cropped buffer, or null if there is nothing to send.
+The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated.
+Used only in tests to assert the buffer's content.
ProtectedwriteBuffer implementation for protocol version 2.
+Sends floating point numbers in binary form, and provides support for arrays.
Creates a new SenderBufferV2 instance.
+Sender configuration object.
+See SenderOptions documentation for detailed description of configuration options.
Write an array column with its values into the buffer using v2 format.
+Column name
+Array values to write (currently supports double arrays). A null or undefined value omits the column entirely, storing NULL.
+Returns with a reference to this buffer.
+Closes the row after writing the designated timestamp into the buffer.
+Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+If unit is not one of 'ns', 'us', or 'ms'.
+Argument validation -- the unit and the timestamp alike -- runs before the
+close touches the row, so it leaves the open row unchanged and the call
+can be retried with a corrected argument.
Closes the row without writing designated timestamp into the buffer.
+Designated timestamp will be populated by the server on this record.
Writes a boolean column with its value into the buffer.
+Use it to insert into BOOLEAN columns.
Column name.
+Column value, accepts only boolean values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+ProtectedcheckChecks if the buffer has sufficient capacity for additional data and resizes if needed.
+Array of strings to calculate the required capacity for
+Base number of bytes to add to the calculation
+Returns the current position of the buffer.
+New data will be written into the buffer starting from this position.
Writes a decimal value into the buffer using its binary format.
+Use it to insert into DECIMAL database columns.
+Decimals are not supported by protocol v1/v2, so this base implementation +rejects the call even when the value is null or undefined. Protocol v3 +overrides this with a validating implementation.
+Column name.
+The unscaled +integer portion of the decimal value.
+The number of fractional digits (the scale) of the decimal value.
+Returns with a reference to this buffer.
+Writes a decimal value into the buffer using its text format.
+Use it to insert into DECIMAL database columns.
+Decimals are not supported by protocol v1/v2, so this base implementation +rejects the call even when the value is null or undefined. Protocol v3 +overrides this with a validating implementation.
+Column name.
+The decimal value to +write.
+Returns with a reference to this buffer.
+Writes a 64-bit floating point value into the buffer using v2 serialization (binary format).
+Use it to insert into DOUBLE or FLOAT database columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a 64-bit signed integer into the buffer.
+Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Resets the buffer, data sitting in the buffer will be lost.
+In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this buffer.
+Writes a string column with its value into the buffer.
+Use it to insert into VARCHAR and STRING columns.
Column name.
+Column value, accepts only string values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a symbol name and value into the buffer.
+Use it to insert into SYMBOL columns.
Symbol name.
+Symbol value, toString() is called to extract the actual symbol value from the parameter. A null or undefined value omits the symbol entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes the table name into the buffer.
+Table name.
+Returns with a reference to this buffer.
+Writes a timestamp column and its value into the buffer.
+Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.The column name.
+The epoch timestamp. Must be an integer or a BigInt. A null or undefined value omits the column entirely (stored as NULL).
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
+The returned buffer is a copy of this buffer.
+It also compacts the buffer.
Returns a cropped buffer, or null if there is nothing to send.
+The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated.
+Used only in tests to assert the buffer's content.
ProtectedwriteBuffer implementation for protocol version 3.
+Provides support for decimals.
+Creates a new SenderBufferV3 instance.
+Sender configuration object.
+See SenderOptions documentation for detailed description of configuration options.
+Write an array column with its values into the buffer using v2 format.
+Column name
+Array values to write (currently supports double arrays). A null or undefined value omits the column entirely, storing NULL.
+Returns with a reference to this buffer.
+Closes the row after writing the designated timestamp into the buffer.
+Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+If unit is not one of 'ns', 'us', or 'ms'.
+Argument validation -- the unit and the timestamp alike -- runs before the
+close touches the row, so it leaves the open row unchanged and the call
+can be retried with a corrected argument.
Closes the row without writing designated timestamp into the buffer.
+Designated timestamp will be populated by the server on this record.
Writes a boolean column with its value into the buffer.
+Use it to insert into BOOLEAN columns.
Column name.
+Column value, accepts only boolean values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+ProtectedcheckChecks if the buffer has sufficient capacity for additional data and resizes if needed.
+Array of strings to calculate the required capacity for
+Base number of bytes to add to the calculation
+Returns the current position of the buffer.
+New data will be written into the buffer starting from this position.
Writes a decimal value into the buffer using its binary format.
+Use it to insert into DECIMAL database columns.
+Column name.
+The unscaled integer portion of the decimal value.
+bigint is provided, it will be converted automatically.Int8Array is provided, it must contain the two’s complement representation
+of the unscaled value in big-endian byte order.Int8Array represents a NULL value.The number of fractional digits (the scale) of the decimal value.
+Returns with a reference to this buffer.
+Writes a decimal value into the buffer using its text format.
+Use it to insert into DECIMAL database columns.
+Column name.
+The decimal value to write.
+number or a string containing a valid decimal representation."123.45" or "-0.001").Returns with a reference to this buffer.
+Writes a 64-bit floating point value into the buffer using v2 serialization (binary format).
+Use it to insert into DOUBLE or FLOAT database columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a 64-bit signed integer into the buffer.
+Use it to insert into LONG, INT, SHORT and BYTE columns.
Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Resets the buffer, data sitting in the buffer will be lost.
+In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
Returns with a reference to this buffer.
+Writes a string column with its value into the buffer.
+Use it to insert into VARCHAR and STRING columns.
Column name.
+Column value, accepts only string values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a symbol name and value into the buffer.
+Use it to insert into SYMBOL columns.
Symbol name.
+Symbol value, toString() is called to extract the actual symbol value from the parameter. A null or undefined value omits the symbol entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes the table name into the buffer.
+Table name.
+Returns with a reference to this buffer.
+Writes a timestamp column and its value into the buffer.
+Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.The column name.
+The epoch timestamp. Must be an integer or a BigInt. A null or undefined value omits the column entirely (stored as NULL).
Optionalunit: TimestampUnit = "us"The time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+Returns a cropped buffer ready to send to the server, or null if there is nothing to send.
+The returned buffer is a copy of this buffer.
+It also compacts the buffer.
Returns a cropped buffer, or null if there is nothing to send.
+The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated.
+Used only in tests to assert the buffer's content.
ProtectedwriteSender configuration options.
+
+Properties of the object are initialized through a configuration string.
+The configuration string has the following format: protocol::key=value;key=value...
+The keys are case-sensitive, the trailing semicolon is optional.
+The values are validated and an error is thrown if the format is invalid.
+
+Connection and protocol options
Creates a Sender options object by parsing the provided configuration string.
+Configuration string.
OptionalextraOptions: ExtraOptionsOptional extra configuration.
OptionaladdrOptionalagentOptionalauthOptionalauto_Optionalauto_Optionalauto_Optionalauto_OptionalhostOptionalinit_OptionaljwkOptionallogOptionalmax_Optionalmax_Optionalmax_Optionalmulticast_OptionalpasswordOptionalportOptionalprotocol_OptionalqwpOptionalrequest_Optionalrequest_Optionalretry_Optionalstdlib_Optionaltls_Optionaltls_Optionaltls_Optionaltls_OptionaltokenOptionaltoken_Optionaltoken_OptionalusernameStaticfromCreates a Sender options object by parsing the provided configuration string.
+Configuration string.
OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender configuration object initialized from the provided configuration string.
+StaticfromCreates a Sender options object by parsing the configuration string set in the QDB_CLIENT_CONF environment variable.
+OptionalextraOptions: ExtraOptionsOptional extra configuration.
A Sender configuration object initialized from the QDB_CLIENT_CONF environment variable.
+StaticresolveResolves the protocol version, if it is set to 'auto'.
+If TCP transport is used, the protocol version will default to 1.
+In case of HTTP transport the /settings endpoint of the database is used to find the protocol versions
+supported by the server, and the highest will be selected.
+When calling the /settings endpoint the timeout and TLS options are used from the options object.
SenderOptions instance needs resolving protocol version
+StaticresolveTCP transport implementation.
+Supports both plain TCP or secure TLS-encrypted connections with configurable JWK token authentication.
Creates a new TcpTransport instance.
+Sender configuration object containing connection and authentication details
+HTTP transport implementation using the Undici library.
+Provides high-performance HTTP requests with connection pooling and retry logic.
+Supports both HTTP and HTTPS protocols with configurable authentication.
Creates a new UndiciTransport instance.
+Sender configuration object containing connection and retry settings
+Protected ReadonlyhostProtected ReadonlylogProtected ReadonlypasswordProtected ReadonlyportProtected ReadonlyrequestProtected ReadonlyrequestProtected ReadonlyretryProtected ReadonlysecureProtected ReadonlytlsProtected ReadonlytlsProtected ReadonlytokenProtected ReadonlyusernameDefines a QuestDB BINARY column. Inputs are copied on append.
+Defines a QuestDB BOOLEAN column.
+Authenticates over REST and asks QuestDB to issue the HttpOnly cookies a
+browser needs before opening QWP WebSockets. REST and OIDC tokens both use
+Bearer authentication. When serviceAccount is present the same request
+also creates Enterprise's qdbServiceAccount impersonation cookie.
Defines a signed 8-bit QuestDB BYTE column.
+Defines a QuestDB CHAR column. Inputs are one UTF-16 code unit.
+Creates and prewarms a combined browser QWP ingress/egress client.
+Opens a browser WebSocket and waits for the egress SERVER_INFO handshake.
+Optionalsignal: AbortSignalCancels an opening connection during pooled-client shutdown.
+Opens a browser WebSocket and starts an ingress ACK/NACK session.
+Optionalsignal: AbortSignalCancels a first connect still negotiating; see QwpIngressSession.connect.
+Opens a browser QWP connection and returns a fluent sender.
+Opens a QWP-capable browser WebSocket.
+Browsers cannot set Authorization or X-QWP-* upgrade headers. QuestDB accepts +browser upgrades when Origin and Host have the same authority, so serve the +app from the QuestDB origin or route QWP through a same-origin reverse proxy. +When authentication is enabled, pass sessionBootstrap or call +bootstrapQwpBrowserSession first so the browser can attach qdb_session.
+Creates a lazy browser QWP client with bounded sender and query pools.
+Creates a stateful browser endpoint walker suitable for session reconnects.
+Creates a browser-safe fluent QWP sender without opening the WebSocket yet. +Call connect(), or let the first flush connect lazily.
+OptionalquarantinedPath: stringOmitted when the bytes were abandoned rather than preserved on disk.
+OptionalfromFsn: bigintDefines a QuestDB DATE column. Inputs are milliseconds since the epoch.
+-9_223_372_036_854_775_808n is QuestDB's DATE NULL sentinel: it is stored
+as NULL and cannot be stored as an ordinary DATE value.
Defines a QuestDB DECIMAL128 column of fixed scale, up to 38.
+Defines a QuestDB DECIMAL256 column of fixed scale, up to 76.
+Defines a QuestDB DECIMAL64 column of fixed scale, up to 18.
+Parses the server's X-QWP-Content-Encoding response. Unknown values remain
+observable but do not claim that Zstd was negotiated; RESULT_BATCH flags
+remain authoritative for each individual batch.
Decodes one QWP-framed server-to-client egress message.
+Decodes an ingress ACK, durable ACK, or NACK WebSocket payload.
+Reads the connection-scoped dictionary prefix from a delta ingress frame.
+Browser-safe fallback for asynchronous ingress rejections and abandoned
+persistent data. Applications can replace it with onSenderError.
Defines the writer's required designated timestamp field.
+Defines a 64-bit QuestDB DOUBLE column. Alias of float64.
+Defines a QuestDB DOUBLE[] column with between 1 and 32 dimensions.
+Builds the Node upgrade header for an egress compression preference.
+Runs a setter callback and returns the exact QUERY_REQUEST bind section.
+Optionaldictionary: QwpSymbolDictionaryEncodes one QWP v1 ingress message.
+Encodes the unframed client-to-server QUERY_REQUEST payload.
+Defines a 32-bit QuestDB FLOAT column.
+Defines a 64-bit QuestDB DOUBLE column.
+Defines a QuestDB GEOHASH column of fixed precision.
+Precision in bits, 1 through 60. Base-32 text inputs
+carry five bits per character, so geohash(20) accepts four characters.
Defines a signed 32-bit QuestDB INT column.
+-2_147_483_648 is QuestDB's INT NULL sentinel: it is stored as NULL and
+cannot be stored as an ordinary INT value.
Defines a signed 64-bit QuestDB LONG column. Inputs must be bigint.
+-9_223_372_036_854_775_808n is QuestDB's LONG NULL sentinel: it is stored
+as NULL and cannot be stored as an ordinary LONG value.
Defines a QuestDB IPV4 column. 0.0.0.0 is the NULL sentinel.
Defines a signed 64-bit QuestDB LONG column. Alias of int64.
+Defines a QuestDB LONG256 column.
+Defines a protocol LONG[] column with between 1 and 32 dimensions.
+Current QuestDB servers reject LONG-array ingestion with long arrays are not supported, only double arrays. This descriptor remains available for
+Java-client and protocol parity.
Defines a signed 16-bit QuestDB SHORT column.
+Defines a string-valued QuestDB SYMBOL column.
+Defines a regular timestamp column with an explicit input unit.
+Defines a QuestDB UUID column.
+Defines a string-valued QuestDB VARCHAR column.
+Writes an unsigned LEB128 uint64.
+Converts a bigint into a two's complement big-endian byte array. +Produces the minimal-width representation that preserves the sign.
+The value to serialise
+Byte array in big-endian order
+Defines a QuestDB BINARY column. Inputs are copied on append.
+Defines a QuestDB BOOLEAN column.
+Defines a signed 8-bit QuestDB BYTE column.
+Defines a QuestDB CHAR column. Inputs are one UTF-16 code unit.
+Creates and prewarms a combined Node QWP ingress/egress client.
+Creates and prewarms a combined Node QWP ingress/egress client.
+OptionalextraOptions: QwpNodeClientConfigOptionsOpens a Node WebSocket and waits for the egress SERVER_INFO handshake.
+Optionalsignal: AbortSignalCancels an opening connection during pooled-client shutdown.
+Opens a Node WebSocket and starts an ingress ACK/NACK session.
+Optionalsignal: AbortSignalCancels a first connect still negotiating; see QwpIngressSession.connect.
+Opens a Node QWP connection and returns a fluent sender.
+Opens a Node IPv4 UDP socket for fire-and-forget QWP ingress.
+Opens a Node UDP socket and returns a fluent fire-and-forget QWP sender.
+Opens a Node QWP WebSocket with the upgrade headers required by QuestDB.
+Factory function to create a SenderBuffer instance based on the protocol version.
+Sender configuration object. +See SenderOptions documentation for detailed description of configuration options.
+A SenderBuffer instance appropriate for the specified protocol version
+OptionalquarantinedPath: stringOmitted when the bytes were abandoned rather than preserved on disk.
+Creates a lazy Node QWP client with bounded sender and query pools.
+Creates a lazy Node QWP client with bounded sender and query pools.
+OptionalextraOptions: QwpNodeClientConfigOptionsCreates a stateful Node endpoint walker suitable for session reconnects.
+Creates a fluent Node QWP sender without opening the WebSocket yet. +Call connect(), or let the first flush connect lazily.
+Creates a fluent Node QWP-over-UDP sender without opening its socket yet. +UDP has no authentication, server ACK, durable ACK, transaction, retry, or +store-and-forward semantics.
+OptionalfromFsn: bigintFactory function to create appropriate transport instance based on configuration.
+Sender configuration options including protocol and connection details
+Transport instance appropriate for the specified protocol
+Defines a QuestDB DATE column. Inputs are milliseconds since the epoch.
+-9_223_372_036_854_775_808n is QuestDB's DATE NULL sentinel: it is stored
+as NULL and cannot be stored as an ordinary DATE value.
Defines a QuestDB DECIMAL128 column of fixed scale, up to 38.
+Defines a QuestDB DECIMAL256 column of fixed scale, up to 76.
+Defines a QuestDB DECIMAL64 column of fixed scale, up to 18.
+Parses the server's X-QWP-Content-Encoding response. Unknown values remain
+observable but do not claim that Zstd was negotiated; RESULT_BATCH flags
+remain authoritative for each individual batch.
Decodes one QWP-framed server-to-client egress message.
+Decodes an ingress ACK, durable ACK, or NACK WebSocket payload.
+Reads the connection-scoped dictionary prefix from a delta ingress frame.
+Browser-safe fallback for asynchronous ingress rejections and abandoned
+persistent data. Applications can replace it with onSenderError.
Defines the writer's required designated timestamp field.
+Defines a 64-bit QuestDB DOUBLE column. Alias of float64.
+Defines a QuestDB DOUBLE[] column with between 1 and 32 dimensions.
+Builds the Node upgrade header for an egress compression preference.
+Runs a setter callback and returns the exact QUERY_REQUEST bind section.
+Optionaldictionary: QwpSymbolDictionaryEncodes one QWP v1 ingress message.
+Encodes the unframed client-to-server QUERY_REQUEST payload.
+Defines a 32-bit QuestDB FLOAT column.
+Defines a 64-bit QuestDB DOUBLE column.
+Defines a QuestDB GEOHASH column of fixed precision.
+Precision in bits, 1 through 60. Base-32 text inputs
+carry five bits per character, so geohash(20) accepts four characters.
Defines a signed 32-bit QuestDB INT column.
+-2_147_483_648 is QuestDB's INT NULL sentinel: it is stored as NULL and
+cannot be stored as an ordinary INT value.
Defines a signed 64-bit QuestDB LONG column. Inputs must be bigint.
+-9_223_372_036_854_775_808n is QuestDB's LONG NULL sentinel: it is stored
+as NULL and cannot be stored as an ordinary LONG value.
Defines a QuestDB IPV4 column. 0.0.0.0 is the NULL sentinel.
Defines a signed 64-bit QuestDB LONG column. Alias of int64.
+Defines a QuestDB LONG256 column.
+Defines a protocol LONG[] column with between 1 and 32 dimensions.
+Current QuestDB servers reject LONG-array ingestion with long arrays are not supported, only double arrays. This descriptor remains available for
+Java-client and protocol parity.
Resolves and validates one ws/wss configuration string for both QWP sides.
+Returns child replay slots containing unacknowledged records.
+The scan is deliberately read-only and does not inspect lock ownership. +Adoption obtains the replay store's exclusive lock, closing the race with a +live foreground producer or another drainer.
+OptionalexcludeSlot: (slotName: string) => booleanDefines a signed 16-bit QuestDB SHORT column.
+Defines a string-valued QuestDB SYMBOL column.
+Defines a regular timestamp column with an explicit input unit.
+Defines a QuestDB UUID column.
+Defines a string-valued QuestDB VARCHAR column.
+Writes an unsigned LEB128 uint64.
+Converts a bigint into a two's complement big-endian byte array. -Produces the minimal-width representation that preserves the sign.
-The value to serialise
-Byte array in big-endian order
-Factory function to create a SenderBuffer instance based on the protocol version.
-Sender configuration object. -See SenderOptions documentation for detailed description of configuration options.
-A SenderBuffer instance appropriate for the specified protocol version
-Factory function to create appropriate transport instance based on configuration.
-Sender configuration options including protocol and connection details
-Transport instance appropriate for the specified protocol
-# With npm
npm i -s @questdb/nodejs-client
# With yarn
yarn add @questdb/nodejs-client
# With pnpm
pnpm add @questdb/nodejs-client
+QuestDB JavaScript Client - v4.2.0 QuestDB JavaScript Client - v4.2.0
QuestDB JavaScript Client
This repository builds two runtime-specific npm packages from a shared private
+core: @questdb/nodejs-client for Node.js and @questdb/browser-client for
+browsers. The browser package exposes its complete API from its package root and
+does not include Node.js transports or dependencies.
+Installation
# With npm
npm i -s @questdb/nodejs-client
# With yarn
yarn add @questdb/nodejs-client
# With pnpm
pnpm add @questdb/nodejs-client
+
+
+For browser applications:
+npm install @questdb/browser-client
Compatibility table
@@ -12,7 +20,7 @@ Compatibility table
^4.0.0
-v20 and above
+v20.18.1 and above
Undici Http Agent
@@ -22,31 +30,267 @@ Compatibility table
+^4.0.0 depends on undici, which declares node >=20.18.1; installing on an
+earlier v20 warns with EBADENGINE and fails outright under engine-strict.
The current version of the client requires Node.js v20 or newer version.
Versions up to and including 3.0.0 are compatible with Node.js v16 and above.
The Undici HTTP agent was introduced in 4.0.0, and it is the default HTTP transport.
The standard HTTP/HTTPS modules of Node.js are still supported for backwards compatibility.
Use the stdlib_http option to switch to the standard HTTP/HTTPS modules.
Configuration options
Detailed description of the client's configuration options can be found in
-the SenderOptions documentation.
+the SenderOptions documentation.
Examples
The examples below demonstrate how to use the client.
-For more details, please, check the Sender's documentation.
+For more details, see the Sender documentation.
Basic API usage
import { Sender } from "@questdb/nodejs-client";
async function run() {
// create a sender using HTTP protocol
const sender = await Sender.fromConfig("http::addr=127.0.0.1:9000");
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "BTC-USD")
.symbol("side", "sell")
.floatColumn("price", 39269.98)
.floatColumn("amount", 0.011)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
// the buffer is cleared after the data is sent, and the sender is ready to accept new data
await sender.flush();
// close the connection after all rows ingested
// unflushed data will be lost
await sender.close();
}
run().then(console.log).catch(console.error);
-Authentication and secure connection
Username and password authentication with HTTP transport
import { Sender } from "@questdb/nodejs-client";
async function run() {
// authentication details
const USER = "admin";
const PWD = "quest";
// pass the authentication details to the sender
// for secure connection use 'https' protocol instead of 'http'
const sender = await Sender.fromConfig(
`http::addr=127.0.0.1:9000;username=${USER};password=${PWD}`
);
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.symbol("side", "sell")
.floatColumn("price", 2615.54)
.floatColumn("amount", 0.00044)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
await sender.flush();
// close the connection after all rows ingested
await sender.close();
}
run().catch(console.error);
+Null and undefined values
Passing null or undefined as a column or symbol value omits that column from
+the row, and QuestDB records the omission as NULL. This is the model the QuestDB
+clients share — the Java client puts it as "to mark the value NULL, omit the
+column from the row" — with the JavaScript client doing the omission for you, so a
+record with optional fields needs no branching:
+const trade: { side?: string; amount?: number } = { amount: 0.011 };
await sender
.table("trades")
.symbol("symbol", "BTC-USD")
.symbol("side", trade.side) // undefined -> column omitted -> NULL
.floatColumn("price", 39269.98)
.floatColumn("amount", trade.amount)
.at(Date.now(), "ms");
// wire: trades,symbol=BTC-USD price=39269.98,amount=0.011 <timestamp>
+
+
+The eight column methods on Sender follow this rule for both ILP
+(http/https/tcp/tcps) and QWP (ws/wss/udp) transports, subject to
+protocol support. The broader direct QwpSender API and compiled QWP writers
+follow the same omission rule for their additional column types. Capability
+checks still run for nullish values: ILP v1 always rejects arrayColumn, and ILP
+v1/v2 always reject the decimal column methods. The QWP-only
+QwpSender.long256Column method spreads one value over four arguments; it omits
+the column when all four words are nullish and rejects a partial set rather
+than treating it as NULL.
+Three consequences are worth knowing:
+
+- An omitted column is not created on a table that does not already have it. The
+omission carries no type, so schema-on-write has nothing to infer from.
+- A row in which every value is nullish behaves differently per protocol. ILP
+has no way to encode a row with no fields, so
at()/atNow() rejects it with
+"The row must have a symbol or column set before it is closed". QWP is
+columnar and can express it, so the row is sent with no columns — carrying
+only its designated timestamp.
+- ILP discards a row only when it can never be closed -- when every value on it
+was nullish, so it carries no symbol and no column. That discard takes the
+table name with it and leaves rows already in the buffer alone: catch the
+error and start the next row from
table(); there is no need to reset()
+and nothing already buffered is lost. Every other rejection leaves the row
+open and the call retryable: an invalid designated timestamp -- either its
+unit or its value, both caught before closing begins -- can be retried with a
+corrected argument; a row that does not fit max_buf_size has its partial
+close rewound, so the same call succeeds once a flush() frees space; and a
+rejected column or symbol call writes nothing at all, leaving the row exactly
+as it was. If an ILP auto-flush send fails, the
+completed batch has already been removed from the sender buffer; applications
+that need to retry must retain and resubmit those rows. QWP keeps successfully
+closed rows for its retry and replay path.
+
+Changed in this release. Earlier versions threw a type error for most
+nullish values, and protocol v2 encoded arrayColumn(name, null) as an explicit
+NULL array marker. Supported column methods now omit the column instead. If your
+code relied on the throw as a data-quality guard, validate before calling the
+sender.
+QWP ingress from Node.js or a browser
See the complete QWP guide for ingress and egress APIs, the combined
+pooled client, browser authentication, delivery semantics, migration guidance, and
+the public API policy.
+Node.js applications can select QWP through the regular Sender API:
+import { Sender } from "@questdb/nodejs-client";
const sender = await Sender.fromConfig("ws::addr=127.0.0.1:9000");
await sender.connect();
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.floatColumn("price", 2615.54)
.at(Date.now(), "ms");
await sender.flush();
await sender.close();
+
+
+For repeated object rows, compile the table schema once. The resulting writer
+validates each complete row before changing sender state and accepts both individual
+rows and synchronous or asynchronous iterables:
+import * as qwp from "@questdb/nodejs-client";
const trades = sender.writer("trades", {
symbol: qwp.symbol(),
side: qwp.symbol(),
price: qwp.double(),
quantity: qwp.long(),
timestamp: qwp.designatedTimestamp("ns"),
});
await trades.row({
symbol: "ETH-USD",
side: "sell",
price: 2615.54,
quantity: 42n,
timestamp: 1_723_000_000_000_000_000n,
});
await trades.rows(moreTrades);
+
+
+The schema vocabulary covers every QuestDB column type the fluent row API can write,
+including date(), char(), binary(), uuid(), long256(), ipv4(),
+geohash(precisionBits), decimal64/128/256(scale), doubleArray(), and
+longArray(). See QWP.md for the accepted value
+forms of each field.
+The regular Sender accepts the same unified QWP configuration vocabulary as
+the pooled Node client. Use comma-separated or repeated addr values for
+failover; standalone ingress validates but otherwise ignores egress- and
+pool-only keys.
+Node.js also supports fire-and-forget QWP-over-UDP through the same API:
+const sender = await Sender.fromConfig(
"udp::addr=239.1.2.3:9007;max_datagram_size=1400;multicast_ttl=1",
);
await sender.connect();
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.floatColumn("price", 2615.54)
.atNow();
await sender.close();
+
+
+UDP datagrams are self-contained and split at row boundaries. UDP has no
+authentication, acknowledgements, transactions, retry, or store-and-forward and is
+not available in browsers. See the QWP guide for the lower-level Node UDP API.
+QWP flush() resolves at the local publication boundary by default in both
+Node.js and browsers, matching the Java QWP sender. Set
+qwp.sender.awaitServerAck: true to wait for QuestDB's protocol ACK instead,
+or awaitDurableAck: true to wait through durable upload. When Node QWP is
+configured with qwp.webSocket.storeAndForward, the publication boundary is
+the local durable journal, so the sender can accept flushes while QuestDB is
+offline and a background drainer reconnects and sends them in order.
+Set initialConnectMode to "off" (the default), "sync", or "async" to
+choose fail-fast, bounded blocking, or background startup. Supplying reconnect
+budget settings without an explicit mode promotes initial startup to "sync",
+matching the Java client. The configuration-string
+equivalent is initial_connect_retry, used together with the store-and-forward
+options in extraOptions.qwp.
+Persistent frames are coalesced into fixed-size 4 MiB .sfa segments by default,
+using the shared Java/Rust/Python SFA envelope, manifest, ACK watermark, and symbol
+dictionary formats. The active segment and a pre-sized temporary hot spare keep open
+handles. A shared worker provisions spares, checkpoints files, and trims acknowledged
+segments. Recovery keeps only frame offsets in memory and reads payloads from disk as
+they are sent, so a large persisted backlog is not duplicated on the JavaScript heap.
+Set drainOrphans: true when sibling journal directories share a dedicated parent:
+the Node client scans and drains slots left by failed producer processes with bounded
+concurrency. Pooled QWP clients recover idle in-range and out-of-range sender-N
+slots automatically without raising senderPoolMin, including leftovers after
+senderPoolMax is reduced. Terminally bad slots are marked .failed for inspection
+and can be re-enabled with
+retryQwpNodeOrphanSlot(). This persistent mode is Node-only; browser senders
+use the in-memory replay boundary.
+Browser applications use the browser entry point, which has no Node.js
+dependencies. Cookies are supplied by the browser during a same-origin
+WebSocket upgrade. Browser and non-persistent Node ingress reconnect by default and
+retain unacknowledged frames in memory; set reconnect: false in the session options
+for a fixed connection. Only Node store-and-forward survives process failure.
+import { connectQwpBrowserSender } from "@questdb/browser-client";
const url = new URL("/write/v4", location.href);
url.protocol = location.protocol === "https:" ? "wss:" : "ws:";
const sender = await connectQwpBrowserSender({ url }, { autoFlush: false });
await sender.table("events").longColumn("value", 42n).atNow();
await sender.flush();
await sender.close();
+
+
+For batches larger than the automatic flush threshold, transactional mode
+keeps each auto-flushed frame in an open server-side transaction. An explicit
+flush() (or its commit() alias) publishes the group-closing frame. Set
+awaitServerAck: true, or wait on the sequence returned by
+flushAndGetSequence(), when the call must also observe the cumulative ACK.
+QuestDB guarantees this atomicity per table; a flush that contains multiple
+tables is not one cross-table transaction.
+const sender = await connectQwpBrowserSender(
{ url },
{
autoFlushRows: 10_000,
autoFlushBytes: 4 * 1024 * 1024,
transactional: true,
},
);
for (const event of events) {
await sender
.table("events")
.symbol("source", event.source)
.longColumn("value", event.value)
.at(event.timestamp, "ms");
}
await sender.commit();
await sender.close();
+
+
+QWP close() publishes completed rows and waits up to 5 seconds for their
+committed-frame ACK watermark. Configure closeFlushTimeoutMs (or
+close_flush_timeout_millis in a ws:: string); 0 publishes without waiting.
+An unfinished row is not completed implicitly.
+The server intentionally withholds ACKs for deferred frames until commit. The
+sender pipelines transactional auto-flushes without waiting for those ACKs,
+then publishes the group-closing frame at flush()/commit(). With
+awaitServerAck or awaitDurableAck, that call also waits for all covered
+ACKs; durable waiting starts only after the transaction commits. Closing
+without an explicit commit abandons the open transaction and logs a warning;
+QuestDB rolls it back when the WebSocket disconnects.
+Ingress sessions expose browser-safe progress/error callbacks and immutable
+metrics snapshots. Reconnect events remain on reconnect.onEvent, keeping
+connection topology separate from batch acceptance and durable progress.
+import {
QWP_INGRESS_PROGRESS_KIND,
createQwpBrowserSender,
} from "@questdb/browser-client";
const sender = createQwpBrowserSender(
{ url },
{ autoFlush: false },
{
reconnect: {
onEvent: (event) => console.info("QWP connection", event),
},
onProgress: (event) => {
if (event.kind === QWP_INGRESS_PROGRESS_KIND.ACKNOWLEDGED) {
console.info("accepted through", event.sequence);
}
},
onError: (event) => console.error("QWP ingress", event.error),
onSenderError: (error) =>
console.error(
"QWP rejection",
error.category,
error.appliedPolicy,
error.fromFsn,
error.toFsn,
),
},
);
await sender.connect();
const snapshot = sender.metrics;
console.info(
snapshot.totalRowsPublished,
snapshot.ingress?.totalFramesReplayed,
);
+
+
+Snapshots distinguish the client-session acceptance sequence from persistent
+replay watermarks. With durable ACKs, replayAcknowledgedFrameSequence
+advances only after the durable watermark covers a frame. Observer callbacks are
+dispatched asynchronously through bounded, drop-oldest inboxes, so they do not run
+inside ACK or reconnect protocol stacks. The metrics snapshot exposes delivered and
+dropped progress, connection, and error notification counters.
+connectionListenerInboxCapacity and errorInboxCapacity tune the Java-compatible
+64/256 defaults. onSenderError receives typed category/policy, wire status, message
+sequence, stable frame-sequence range, and quarantine context. If it is omitted,
+retriable rejections are logged at warn and terminal rejections or abandoned data at
+error; general asynchronous ingress failures are also logged when onError is
+omitted. Observer exceptions are contained, but CPU-bound callbacks should still move
+work to a Worker because browser and Node JavaScript share the event loop.
+When QuestDB authentication is enabled, establish the browser's HttpOnly
+qdb_session cookie over REST before opening a QWP WebSocket. A QuestDB REST
+token and an OIDC access token both use the bearer form. The application is
+responsible for obtaining an OIDC token from its identity provider; the client
+does not run an interactive OIDC authorization flow.
+import {
bootstrapQwpBrowserSession,
connectQwpBrowserSender,
} from "@questdb/browser-client";
await bootstrapQwpBrowserSession({
url: new URL("/exec", location.href),
authentication: { type: "bearer", token: oidcOrRestAccessToken },
// QuestDB Enterprise only; omit to use the authenticated principal.
serviceAccount: "market_data_writer",
});
const sender = await connectQwpBrowserSender({ url }, { autoFlush: false });
+
+
+The bootstrap can also be attached to the connection options. It then runs
+before each initial, reconnect, or failover WebSocket attempt:
+const sender = await connectQwpBrowserSender(
{
url,
sessionBootstrap: {
authentication: {
type: "basic",
username: "admin",
password: "quest",
},
},
},
{ autoFlush: false },
);
+
+
+The REST request uses credentials: "include". The default bootstrap URL is
+/exec beside /write/v4 or /read/v1; set sessionBootstrap.url explicitly
+when a reverse proxy exposes a different REST path. The REST and WebSocket
+routes should be served from the same browser origin (or configured with
+credentialed CORS), otherwise the browser may decline to store or send the
+HttpOnly cookies. JavaScript deliberately never reads qdb_session or the
+Enterprise qdbServiceAccount cookie.
+Browsers can request durable ingress acknowledgements without custom HTTP
+headers. The client offers a QWP WebSocket subprotocol and verifies that the
+server selected it before sending data. Browser keepalives use side-effect-free,
+table-less QWP poll frames because the WebSocket API does not expose
+protocol-level PING frames. A poll completes once published: durable progress
+arrives independently, and an open deferred transaction may intentionally
+prevent the server from sending a cumulative OK for that poll. Supplying
+durableAckKeepaliveMs requires durable negotiation (requestDurableAck: true,
+either explicit or implied by awaitDurableAck); manual polls and durable waits
+reject locally when the capability was not negotiated.
+const sender = await connectQwpBrowserSender(
{ url, requestDurableAck: true },
{ autoFlush: false, awaitDurableAck: true },
);
+
+
+Browser durable ACKs are an in-memory delivery confirmation only. Persistent
+store-and-forward remains available exclusively through the Node.js entry
+point. In-memory ingress replay targets a 128 MiB cap and waits at most 30 seconds
+for ACK-driven trimming by default. A commit-bearing logical batch may temporarily
+raise usage to at most twice that target so a retained deferred prefix cannot deadlock;
+tune memoryReplayMaxBytes and
+memoryReplayAppendDeadlineMs in the ingress session options when needed.
+Zstd-compressed QWP egress
Node.js egress clients can opt into compressed result batches during the
+WebSocket upgrade. Raw batches remain the default for compatibility.
+import { connectQwpNodeEgress } from "@questdb/nodejs-client";
const session = await connectQwpNodeEgress(
{
url: "ws://127.0.0.1:9000/read/v1",
compression: "zstd",
compressionLevel: 3,
},
{
queryTimeoutMs: 30_000,
},
);
try {
const query = await session.query("select * from trades", {
initialCredit: 1024 * 1024,
});
console.log("effective Zstd level", session.negotiatedZstdLevel);
for await (const batch of query) {
for (const row of batch.rows()) console.log(row);
}
await query.completion;
} finally {
await session.close();
}
+
+
+Zstd decoding and negotiation are also included in the browser entry point.
+Because browsers cannot set the X-QWP-Accept-Encoding upgrade header, the
+client sends the same preference through the WebSocket URL's
+qwp_accept_encoding parameter. No proxy-injected compression header is
+required. Older servers ignore the parameter and safely continue with raw
+batches.
+Level 1 is the lowest-CPU default and is usually the right starting point.
+Higher values trade server CPU for wire size; the client accepts levels 1–22,
+while the server may clamp the request or apply an operator-configured level.
+session.negotiatedCompression and session.negotiatedZstdLevel report what
+the active server actually selected and refresh after reconnection or failover.
+Both "zstd" and "auto" advertise Zstd followed by raw fallback, and the
+server still sends an individual batch raw when compression would make it
+larger.
+Matching the Java client, egress queries default initialCredit to zero, meaning
+unbounded server send-ahead. Set a positive session or per-query value to bound wire
+buffering—particularly in browsers. With positive credit, the client automatically
+replenishes the exact wire size of each result batch after consumption. Set
+autoCredit: false to manage credit explicitly through query.grantCredit().
+For allocation-sensitive consumers, session.queryViews(sql, onBatch) supplies
+bounded, reusable column views instead of materializing every value into JavaScript
+arrays. Typed accessors read fixed-width values directly from QWP bytes, and raw
+byte views are available for vectorized processing. The callback is awaited before
+credit is replenished, while the receive loop decodes ahead through the bounded
+reusable buffer pool. Views are invalid when their callback returns; copy a byte
+view with .slice() or call batch.materialize() inside the callback to retain
+data. Tune the default four-slot pool with the session's bufferPoolSize.
+queryTimeoutMs sets the session's default query deadline; a per-query
+timeoutMs overrides it, and zero disables the deadline. When a deadline
+expires, the client rejects iteration and query.completion with
+QwpEgressQueryTimeoutError, sends QWP CANCEL, and waits for the terminal
+server response before accepting another query on that connection. Breaking out
+of for await early cancels the query too. cancelDrainTimeoutMs bounds that
+wait (5 seconds by default); an unresponsive cancellation closes the connection
+with QwpEgressQueryCancelTimeoutError instead of wedging the session.
+To bound only the caller's wait without cancelling, use
+await query.awaitCompletion(timeoutMs). It returns false on timeout and leaves
+the query active, matching Java Completion.await(timeout, unit). The SERVER_INFO
+handshake timeout defaults to five seconds on both clients.
+Authentication and secure connection
Username and password authentication with HTTP transport
import { Sender } from "@questdb/nodejs-client";
async function run() {
// authentication details
const USER = "admin";
const PWD = "quest";
// pass the authentication details to the sender
// for secure connection use 'https' protocol instead of 'http'
const sender = await Sender.fromConfig(
`http::addr=127.0.0.1:9000;username=${USER};password=${PWD}`,
);
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.symbol("side", "sell")
.floatColumn("price", 2615.54)
.floatColumn("amount", 0.00044)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
await sender.flush();
// close the connection after all rows ingested
await sender.close();
}
run().catch(console.error);
-REST token authentication with HTTP transport
import { Sender } from "@questdb/nodejs-client";
async function run() {
// authentication details
const TOKEN = "Xyvd3er6GF87ysaHk";
// pass the authentication details to the sender
// for secure connection use 'https' protocol instead of 'http'
const sender = await Sender.fromConfig(
`http::addr=127.0.0.1:9000;token=${TOKEN}`
);
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.symbol("side", "sell")
.floatColumn("price", 2615.54)
.floatColumn("amount", 0.00044)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
await sender.flush();
// close the connection after all rows ingested
await sender.close();
}
run().catch(console.error);
+REST token authentication with HTTP transport
import { Sender } from "@questdb/nodejs-client";
async function run() {
// authentication details
const TOKEN = "Xyvd3er6GF87ysaHk";
// pass the authentication details to the sender
// for secure connection use 'https' protocol instead of 'http'
const sender = await Sender.fromConfig(
`http::addr=127.0.0.1:9000;token=${TOKEN}`,
);
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.symbol("side", "sell")
.floatColumn("price", 2615.54)
.floatColumn("amount", 0.00044)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
await sender.flush();
// close the connection after all rows ingested
await sender.close();
}
run().catch(console.error);
-JWK token authentication with TCP transport
import { Sender } from "@questdb/nodejs-client";
async function run() {
// authentication details
const CLIENT_ID = "admin";
const PRIVATE_KEY = "ZRxmCOQBpZoj2fZ-lEtqzVDkCre_ouF3ePpaQNDwoQk";
// pass the authentication details to the sender
const sender = await Sender.fromConfig(
`tcp::addr=127.0.0.1:9009;username=${CLIENT_ID};token=${PRIVATE_KEY}`
);
await sender.connect();
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "BTC-USD")
.symbol("side", "sell")
.floatColumn("price", 39269.98)
.floatColumn("amount", 0.001)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
await sender.flush();
// close the connection after all rows ingested
await sender.close();
}
run().catch(console.error);
+JWK token authentication with TCP transport
import { Sender } from "@questdb/nodejs-client";
async function run() {
// authentication details
const CLIENT_ID = "admin";
const PRIVATE_KEY = "ZRxmCOQBpZoj2fZ-lEtqzVDkCre_ouF3ePpaQNDwoQk";
// pass the authentication details to the sender
const sender = await Sender.fromConfig(
`tcp::addr=127.0.0.1:9009;username=${CLIENT_ID};token=${PRIVATE_KEY}`,
);
await sender.connect();
// add rows to the buffer of the sender
await sender
.table("trades")
.symbol("symbol", "BTC-USD")
.symbol("side", "sell")
.floatColumn("price", 39269.98)
.floatColumn("amount", 0.001)
.at(Date.now(), "ms");
// flush the buffer of the sender, sending the data to QuestDB
await sender.flush();
// close the connection after all rows ingested
await sender.close();
}
run().catch(console.error);
-Array usage example
import { Sender } from "@questdb/nodejs-client";
async function run() {
// create a sender
const sender = await Sender.fromConfig('http::addr=localhost:9000');
// order book snapshots to ingest
const orderBooks = [
{
symbol: 'BTC-USD',
exchange: 'Coinbase',
timestamp: Date.now(),
bidPrices: [50100.25, 50100.20, 50100.15, 50100.10, 50100.05],
bidSizes: [0.5, 1.2, 2.1, 0.8, 3.5],
askPrices: [50100.30, 50100.35, 50100.40, 50100.45, 50100.50],
askSizes: [0.6, 1.5, 1.8, 2.2, 4.0]
},
{
symbol: 'ETH-USD',
exchange: 'Coinbase',
timestamp: Date.now(),
bidPrices: [2850.50, 2850.45, 2850.40, 2850.35, 2850.30],
bidSizes: [5.0, 8.2, 12.5, 6.8, 15.0],
askPrices: [2850.55, 2850.60, 2850.65, 2850.70, 2850.75],
askSizes: [4.5, 7.8, 10.2, 8.5, 20.0]
}
];
try {
// add rows to the buffer of the sender
for (const orderBook of orderBooks) {
await sender
.table('order_book_l2')
.symbol('symbol', orderBook.symbol)
.symbol('exchange', orderBook.exchange)
.arrayColumn('bid_prices', orderBook.bidPrices)
.arrayColumn('bid_sizes', orderBook.bidSizes)
.arrayColumn('ask_prices', orderBook.askPrices)
.arrayColumn('ask_sizes', orderBook.askSizes)
.at(orderBook.timestamp, 'ms');
}
// flush the buffer of the sender, sending the data to QuestDB
// the buffer is cleared after the data is sent, and the sender is ready to accept new data
await sender.flush();
} finally {
// close the connection after all rows ingested
await sender.close();
}
}
run().then(console.log).catch(console.error);
+Array usage example
import { Sender } from "@questdb/nodejs-client";
async function run() {
// create a sender
const sender = await Sender.fromConfig("http::addr=localhost:9000");
// order book snapshots to ingest
const orderBooks = [
{
symbol: "BTC-USD",
exchange: "Coinbase",
timestamp: Date.now(),
bidPrices: [50100.25, 50100.2, 50100.15, 50100.1, 50100.05],
bidSizes: [0.5, 1.2, 2.1, 0.8, 3.5],
askPrices: [50100.3, 50100.35, 50100.4, 50100.45, 50100.5],
askSizes: [0.6, 1.5, 1.8, 2.2, 4.0],
},
{
symbol: "ETH-USD",
exchange: "Coinbase",
timestamp: Date.now(),
bidPrices: [2850.5, 2850.45, 2850.4, 2850.35, 2850.3],
bidSizes: [5.0, 8.2, 12.5, 6.8, 15.0],
askPrices: [2850.55, 2850.6, 2850.65, 2850.7, 2850.75],
askSizes: [4.5, 7.8, 10.2, 8.5, 20.0],
},
];
try {
// add rows to the buffer of the sender
for (const orderBook of orderBooks) {
await sender
.table("order_book_l2")
.symbol("symbol", orderBook.symbol)
.symbol("exchange", orderBook.exchange)
.arrayColumn("bid_prices", orderBook.bidPrices)
.arrayColumn("bid_sizes", orderBook.bidSizes)
.arrayColumn("ask_prices", orderBook.askPrices)
.arrayColumn("ask_sizes", orderBook.askSizes)
.at(orderBook.timestamp, "ms");
}
// flush the buffer of the sender, sending the data to QuestDB
// the buffer is cleared after the data is sent, and the sender is ready to accept new data
await sender.flush();
} finally {
// close the connection after all rows ingested
await sender.close();
}
}
run().then(console.log).catch(console.error);
-Worker threads example
import { Sender } from "@questdb/nodejs-client";
import { Worker, isMainThread, parentPort, workerData } from "worker_threads";
// fake venue
// generates random prices and amounts for a ticker for max 5 seconds, then the feed closes
function* venue(ticker) {
let end = false;
setTimeout(() => {
end = true;
}, rndInt(5000));
while (!end) {
yield { ticker, price: Math.random(), amount: Math.random() };
}
}
// market data feed simulator
// uses the fake venue to deliver price and amount updates to the feed handler (onTick() callback)
async function subscribe(ticker, onTick) {
const feed = venue(workerData.ticker);
let tick;
while ((tick = feed.next().value)) {
await onTick(tick);
await sleep(rndInt(30));
}
}
async function run() {
if (isMainThread) {
const tickers = ["ETH-USD", "BTC-USD", "SOL-USD", "DOGE-USD"];
// main thread to start a worker thread for each ticker
for (let ticker of tickers) {
new Worker(__filename, { workerData: { ticker: ticker } })
.on("error", (err) => {
throw err;
})
.on("exit", () => {
console.log(`${ticker} thread exiting...`);
})
.on("message", (msg) => {
console.log(`Ingested ${msg.count} prices for ticker ${msg.ticker}`);
});
}
} else {
// it is important that each worker has a dedicated sender object
// threads cannot share the sender because they would write into the same buffer
const sender = await Sender.fromConfig("http::addr=127.0.0.1:9000");
// subscribe for the market data of the ticker assigned to the worker
// ingest each price update into the database using the sender
let count = 0;
await subscribe(workerData.ticker, async (tick) => {
await sender
.table("trades")
.symbol("symbol", tick.ticker)
.symbol("side", "sell")
.floatColumn("price", tick.price)
.floatColumn("amount", tick.amount)
.at(Date.now(), "ms");
await sender.flush();
count++;
});
// let the main thread know how many prices were ingested
parentPort.postMessage({ ticker: workerData.ticker, count });
// close the connection to the database
await sender.close();
}
}
function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
function rndInt(limit: number) {
return Math.floor(Math.random() * limit + 1);
}
run().then(console.log).catch(console.error);
+Worker threads example
import { Sender } from "@questdb/nodejs-client";
import { Worker, isMainThread, parentPort, workerData } from "worker_threads";
// fake venue
// generates random prices and amounts for a ticker for max 5 seconds, then the feed closes
function* venue(ticker) {
let end = false;
setTimeout(() => {
end = true;
}, rndInt(5000));
while (!end) {
yield { ticker, price: Math.random(), amount: Math.random() };
}
}
// market data feed simulator
// uses the fake venue to deliver price and amount updates to the feed handler (onTick() callback)
async function subscribe(ticker, onTick) {
const feed = venue(workerData.ticker);
let tick;
while ((tick = feed.next().value)) {
await onTick(tick);
await sleep(rndInt(30));
}
}
async function run() {
if (isMainThread) {
const tickers = ["ETH-USD", "BTC-USD", "SOL-USD", "DOGE-USD"];
// main thread to start a worker thread for each ticker
for (let ticker of tickers) {
new Worker(__filename, { workerData: { ticker: ticker } })
.on("error", (err) => {
throw err;
})
.on("exit", () => {
console.log(`${ticker} thread exiting...`);
})
.on("message", (msg) => {
console.log(`Ingested ${msg.count} prices for ticker ${msg.ticker}`);
});
}
} else {
// it is important that each worker has a dedicated sender object
// threads cannot share the sender because they would write into the same buffer
const sender = await Sender.fromConfig("http::addr=127.0.0.1:9000");
// subscribe for the market data of the ticker assigned to the worker
// ingest each price update into the database using the sender
let count = 0;
await subscribe(workerData.ticker, async (tick) => {
await sender
.table("trades")
.symbol("symbol", tick.ticker)
.symbol("side", "sell")
.floatColumn("price", tick.price)
.floatColumn("amount", tick.amount)
.at(Date.now(), "ms");
await sender.flush();
count++;
});
// let the main thread know how many prices were ingested
parentPort.postMessage({ ticker: workerData.ticker, count });
// close the connection to the database
await sender.close();
}
}
function sleep(ms: number) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
function rndInt(limit: number) {
return Math.floor(Math.random() * limit + 1);
}
run().then(console.log).catch(console.error);
Decimal usage example
Since v9.2.0, QuestDB supports the DECIMAL data type.
@@ -62,4 +306,4 @@
CommunityCommunity Forum.
You can also sign up to our mailing list
to get notified of new releases.
-
+Buffer used by the Sender for data serialization.
-Provides methods for writing different data types into the buffer.
Resets the buffer, data sitting in the buffer will be lost. -In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
-Returns with a reference to this buffer.
-Returns a cropped buffer, or null if there is nothing to send. -The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated. -Used only in tests to assert the buffer's content.
-Optionalpos: numberOptional position parameter
-A view of the buffer
-Returns a cropped buffer ready to send to the server, or null if there is nothing to send. -The returned buffer is a copy of this buffer. -It also compacts the buffer.
-Optionalpos: numberOptional position parameter
-A copy of the buffer ready to send, or null
-Writes the table name into the buffer.
-Table name.
-Returns with a reference to this buffer.
-Writes a symbol name and value into the buffer. -Use it to insert into SYMBOL columns.
-Symbol name.
-Symbol value, toString() is called to extract the actual symbol value from the parameter.
-Returns with a reference to this buffer.
-Writes a string column with its value into the buffer. -Use it to insert into VARCHAR and STRING columns.
-Column name.
-Column value, accepts only string values.
-Returns with a reference to this buffer.
-Writes a boolean column with its value into the buffer. -Use it to insert into BOOLEAN columns.
-Column name.
-Column value, accepts only boolean values.
-Returns with a reference to this buffer.
-Writes a 64-bit floating point value into the buffer. -Use it to insert into DOUBLE or FLOAT database columns.
-Column name.
-Column value, accepts only number values.
-Returns with a reference to this buffer.
-Writes an array column with its values into the buffer.
-Column name
-Array values to write (currently supports double arrays)
-Returns with a reference to this buffer.
-Writes a 64-bit signed integer into the buffer. -Use it to insert into LONG, INT, SHORT and BYTE columns.
-Column name.
-Column value, accepts only number values.
-Returns with a reference to this buffer.
-Writes a timestamp column and its value into the buffer.
-Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.The column name.
-The epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnitThe time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Writes a decimal value into the buffer using its text format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The decimal value to write.
-number or a string containing a valid decimal representation."123.45" or "-0.001").Returns with a reference to this buffer.
-Writes a decimal value into the buffer using its binary format.
-Use it to insert into DECIMAL database columns.
-Column name.
-The unscaled integer portion of the decimal value.
-bigint is provided, it will be converted automatically.Int8Array is provided, it must contain the two’s complement representation
-of the unscaled value in big-endian byte order.Int8Array represents a NULL value.The number of fractional digits (the scale) of the decimal value.
-Returns with a reference to this buffer.
-Closes the row after writing the designated timestamp into the buffer.
-Precision rules:
-'ns' (nanoseconds) are sent with full nanosecond precision.
-All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnitThe time unit of the timestamp. -Supported values:
-'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
-Closes the row without writing designated timestamp into the buffer. -Designated timestamp will be populated by the server on this record.
-Returns the current position of the buffer. -New data will be written into the buffer starting from this position.
-The current write position in the buffer
-Interface for QuestDB transport implementations.
-Defines the contract for different transport protocols (HTTP/HTTPS/TCP/TCPS).
Establishes a connection to the database server. -Should not be called on HTTP transports.
-Promise resolving to true if connection is successful
-Sends the data to the database server.
-Buffer containing the data to send
-Promise resolving to true if data was sent successfully
-Closes the connection to the database server. -Should not be called on HTTP transports.
-Promise that resolves when the connection is closed
-Gets the default number of rows that trigger auto-flush for this transport.
-Default auto-flush row count
-Normalized binary connection consumed by QWP sessions.
+Adapters buffer messages until the single async iterator consumes them, so +unsolicited frames such as egress SERVER_INFO cannot race session startup.
+ReadonlyclosedOptional ReadonlyendpointEndpoint backing this connection, when supplied by its adapter.
+ReadonlyhandshakeOptional Readonly InternalingressFalse after replay dictionary persistence becomes unavailable.
+Optional Readonly InternalingressRecovered ingress dictionary supplied by replay connections.
+Optional Readonly InternalmanagesTrue when the transport dispatches typed sender errors itself.
+ReadonlymessagesOptionalcode: numberOptionalreason: stringOptionaldeprioritizeInternalMarks this endpoint as temporarily unsuitable and asks a stateful +connection factory to start its next sweep at another configured endpoint.
+OptionalgetInternalResolves a session sequence to its stable replay FSN.
+OptionalgetInternalPhysical delivery metrics exposed by replaying transports.
+OptionalgetInternalPublished watermark alone, for the flush path.
+Transports that expose this must keep it consistent with
+getIngressMetrics's publishedFrameSequence; callers fall back to
+the full snapshot when it is absent.
OptionalpingSends an RFC 6455 PING when the underlying runtime supports it.
+OptionalprepareInternalSerializes a whole logical batch capacity check before its first +frame is sent, preventing a deferred prefix from consuming the only space +needed by its commit-bearing suffix.
+OptionalskipInternalReserves a client sequence for a split-batch suffix suppressed +before send(), keeping replay ACK translation aligned with the session.
+Shared browser transport and authentication for one QWP cluster.
+OptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalprotocolsOptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+OptionalsessionAuthenticates before every connection attempt. When url is omitted from
+this bootstrap, its REST endpoint follows the active cluster endpoint.
OptionalwebShared test or framework hook; either side may override it.
+Browser WebSocket options plus protocol-level egress topology routing.
+OptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalcompressionRequests Zstd-compressed result batches through browser-visible URL +negotiation. Defaults to raw for compatibility.
+OptionalcompressionZstd level hint. Must be between 1 and 22, and only takes effect
+alongside compression; the default raw negotiates no compression for
+a level to travel on.
OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalingressTime allowed for the optional ingress SERVER_INFO message. Defaults to +250ms; zero disables the initial wait while retaining late negotiation.
+OptionalmaxRequests a server-side RESULT_BATCH row cap.
+OptionalprotocolsOptionalrequestRequests durable ingress ACKs through browser-visible WebSocket +subprotocol negotiation.
+OptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+OptionalsessionAuthenticates over REST before every WebSocket connection attempt so the +browser can attach QuestDB's HttpOnly session cookies to the upgrade.
+OptionaltargetSelects any readable node, a primary/standalone node, or a replica.
+OptionalwebTest or framework hook; defaults to the browser's global WebSocket.
+OptionalzoneOpaque, case-insensitive preferred zone; cross-zone fallback stays enabled.
+OptionalfetchTest or framework hook; defaults to the browser's global fetch.
+OptionalserviceOptional Enterprise service account to assume for subsequent QWP use.
+OptionalsignalCancels only the REST bootstrap request.
+Exact QuestDB /exec HTTP(S) URL used to create the session cookie.
Backwards-compatible form with completely independent connection trees.
+Recommended combined-browser form. One endpoint list and authentication +bootstrap are shared while side-specific protocol options remain explicit.
+OptionalegressOptionalegressOptionalingressOptionalingressOptionalpoolOptionalsenderOptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalingressTime allowed for the optional ingress SERVER_INFO message. Defaults to +250ms; zero disables the initial wait while retaining late negotiation.
+OptionalprotocolsOptionalrequestRequests durable ingress ACKs through browser-visible WebSocket +subprotocol negotiation.
+OptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+OptionalsessionAuthenticates over REST before every WebSocket connection attempt so the +browser can attach QuestDB's HttpOnly session cookies to the upgrade.
+OptionalwebTest or framework hook; defaults to the browser's global WebSocket.
+Optional InternalsenderCoordinates stable persistent sender slots with recovery.
+OptionalcloseInternalStops runtime-specific background services during close.
+Optionalsignal: AbortSignalOptionalsignal: AbortSignalOptionalstartInternalStarts runtime-specific background services on first use.
+OptionalacquireMaximum wait for a returned pool slot and for leases during shutdown. +The shutdown wait is capped at 5 seconds. Defaults to 5 seconds.
+OptionalhousekeepingIdle/lifetime sweep interval. Defaults to 5s and must be at least 100ms.
+OptionalidleIdle time before an excess pooled connection is closed. Defaults to 60s; zero disables.
+OptionalmaxMaximum pooled connection age before recycling it while idle. Defaults to 30m; zero disables.
+OptionalqueryMaximum concurrently borrowed query connections. Defaults to 4.
+OptionalqueryWarm egress connections created by connect(). Defaults to 1.
+OptionalsenderMaximum concurrently borrowed ingress senders. Defaults to 4.
+OptionalsenderWarm ingress connections created by connect(). Defaults to 1.
+OptionaldecimalOptionalgeohashOne entry per row; true means NULL.
+Rows accounted for so far, including nulls.
+Non-null values only; QWP compacts values around the null bitmap. +LONG, DATE, and TIMESTAMP values accept safe integer numbers or signed +int64 bigints. LONG_ARRAY applies the same rule to every element.
+OptionalautoReplenishes positive initial credit by each RESULT_BATCH wire size after +the async iterator advances past that batch. Defaults to true.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindsSets typed positional parameters; index 0 maps to SQL placeholder $1.
OptionalinitialOverrides session send-ahead credit. Zero explicitly disables flow control.
+OptionalresetAsk a capable server to reset its connection-scoped symbol dictionary. +Silently omitted when the server lacks QUERY_FLAGS for rolling upgrades.
+OptionaltimeoutPer-query deadline overriding the session default. Zero disables it.
+Optional ReadonlycauseOptional ReadonlyendpointOptional ReadonlypreviousReadonlyrequestClient request being re-executed on the replacement connection.
+ReadonlyserverAuthoritative SERVER_INFO received from the replacement endpoint.
+Endpoint routing preferences. Named for egress, where they landed first, but +ingress ranks and validates its endpoints with the same machinery and honours +the same two keys.
+OptionalbufferMaximum decoded batches waiting for a consumer. Defaults to 4.
+OptionalcancelMaximum wait for a terminal response after CANCEL. Defaults to 5 seconds.
+OptionalconnectionBounded inbox depth for reconnect.onEvent. Defaults to 64, matching
+ingress. Overflow drops the oldest pending notification.
OptionalinitialDefault per-query send-ahead credit. Defaults to zero (unbounded).
+OptionalmaxRejects a RESULT_BATCH declaring more rows than this. The connect helpers
+default it to the maxBatchRows they put on the wire, so the request the
+client makes is also the bound it enforces; decoder scratch is sized from
+the declared row count and retained per pool slot, so an answer above the
+request would set this session's memory floor for its lifetime.
OptionalonOptional notification immediately before an active query is re-executed. +Not-yet-consumed batches are discarded automatically; callers that retain +an already-consumed prefix should discard it here. Omitting this callback +leaves replay enabled and is appropriate for idempotent consumers.
+OptionalqueryDefault per-query deadline. Zero or undefined disables query deadlines.
+OptionalreconnectBounded failover policy. Failover and at-least-once active-query replay +are enabled by default; set false to keep one fixed connection.
+OptionalserverSERVER_INFO handshake deadline. Defaults to 5 seconds.
+Control handle returned by queryViews().
+Metadata negotiated during the QWP WebSocket upgrade.
+Optional ReadonlycontentServer-selected egress content encoding, when advertised.
+Optional ReadonlydurableWhether the server confirmed durable-ACK support.
+Optional ReadonlymaxServer's hard ingress WebSocket-payload cap, when advertised.
+Optional ReadonlynegotiatedParsed effective egress codec and level selected by the server.
+ReadonlyqwpQWP protocol version selected by the server.
+Optional ReadonlyserverServer role advertised on a successful upgrade, when available.
+Optional ReadonlyserverServer zone advertised on a successful upgrade, when available.
+Immutable point-in-time ingress telemetry, safe in browsers and Node.js.
+ReadonlyacknowledgedHighest client-session sequence covered by a successful cumulative ACK.
+ReadonlydeliveredReadonlydeliveredReadonlydeliveredReadonlydroppedReadonlydroppedReadonlydroppedOptional ReadonlylastOptional ReadonlymemoryOptional ReadonlymemoryReadonlypendingReadonlypendingReadonlypendingReadonlypendingReadonlypendingReadonlypublishedHighest client-session sequence allocated, or -1 before the first send.
+Optional ReadonlyreplayTrim watermark; in durable-ACK mode it advances only after durability.
+Optional ReadonlyreplayStable store-and-forward watermark; absent without reconnect/replay.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalPhysical sends; includes replay and dictionary catch-up when available.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlywaitingLightweight durable-frame descriptor used by disk-backed replay stores.
+Browser-safe abstraction; Node supplies a persistent filesystem implementation.
+OptionalappendPersists new dense entries before a delta frame is made replayable.
+OptionaldiscardInternalRemoves a local prefix without representing it as a server ACK. +Persistent stores should provide this when recovery can abandon frames.
+"Without representing it as a server ACK" is about the transport's public
+watermark, which the caller leaves alone. The removal itself must be as
+durable as acknowledgeThrough's: a discarded prefix that a later load()
+can still see is a prefix this client reported abandoned and then sent
+anyway.
OptionalloadOpens and validates the journal without materializing every payload.
+Implementations that provide this must also provide readPayload.
OptionalloadLoads the durable, dense symbol prefix used by persisted delta frames.
+OptionalprepareInternalWaits until every payload in one logical batch can be appended +without an ACK between frames. Implementations must not mutate the journal.
+OptionalreadReads one previously loaded durable payload on demand.
+OptionalreplaceAtomically replaces an unusable dictionary after surviving committed +frames prove that its complete ID space can be reconstructed.
+One ingress operation with independent local-publication and server-ACK +completion. Publication resolves after every physical frame belonging to +the logical batch has been accepted by the connection. For persistent Node +transports that means the frames are durable in the replay journal.
+OptionalackOptional InternalbackgroundStarts memory or persistent replay without waiting for a server.
+Optional InternalcatchMinimum cap-gap dwell before an orphan can be quarantined.
+OptionalconnectionBounded reconnect-listener inbox. Oldest pending events are dropped when +full. Defaults to 64, matching the Java client.
+OptionaldurableEnables durable-ACK tracking. While committed table transactions await +durable upload, Node transports send WebSocket PING frames and browser +transports send table-less QWP poll frames. Zero keeps tracking enabled +but disables automatic polling. Factory-created browser sessions require +requestDurableAck=true when this option is supplied.
+OptionalerrorBounded typed/legacy error inbox. Oldest pending errors are dropped when +full. Defaults to 256, matching the Java client.
+Optional InternalinitialInitial connection policy supplied by the Node adapter.
+OptionalmaxOptional local ingress frame cap. Browsers cannot read WebSocket upgrade +headers, so browser applications should set this to the server's configured +QWP cap. When the server also advertises a cap, the smaller value wins. +Table batches are split at row boundaries automatically; an individual row +that cannot fit is rejected with QwpBatchTooLargeError before it is sent.
+OptionalmemoryMaximum time a memory replay append waits for ACK-driven trimming after +reaching memoryReplayMaxBytes. Defaults to 30 seconds.
+OptionalmemoryTarget cap for the built-in memory-only replay queue, including estimated +per-frame bookkeeping. Defaults to 128 MiB. A transaction-closing logical +batch may temporarily exceed this target by up to one target-sized batch, +because the server cannot ACK its deferred prefix before receiving that +batch. This applies in browsers and non-persistent Node sessions; custom +replay stores enforce their own cap.
+OptionalonOptionalonServer rejections, deadlines, and terminal session failures.
+OptionalonMonotonic send/accept/durability notifications. Callback errors are ignored.
+OptionalonOptionalonJava-parity typed server-rejection and data-loss notifications. When +omitted, the default handler logs retriable errors at warn and terminal +errors or abandoned data at error.
+Optional InternalorphanConsecutive durable-ACK gap budget retained for orphan SF.
+Optional InternalorphanOrphan sessions may quarantine persistent catch-up cap gaps.
+OptionalreconnectBounded reconnection and at-least-once replay policy. Reconnection is +enabled by default for factory-created sessions; set false to keep one +fixed connection. Browser and non-persistent Node replay is memory-only.
+An ACK lost during disconnect can cause a frame to be replayed after the +server accepted it; configure server-side deduplication when duplicates +are not acceptable.
+Optional InternalreplayNode adapter hook for persistent store-and-forward.
+Physical ingress delivery counters maintained by reconnecting transports.
+Optional ReadonlyabandonedStable frame ranges retired without ever receiving a server ACK.
+ReadonlyacknowledgedHighest replay-frame sequence removed after a server acknowledgement.
+Optional ReadonlydeliveredOptional ReadonlydeliveredOptional ReadonlydroppedOptional ReadonlydroppedOptional ReadonlymemoryConfigured cap for the built-in memory replay store.
+Optional ReadonlymemoryEstimated payload and record-bookkeeping bytes charged to that cap.
+ReadonlypendingReadonlypendingReadonlypublishedHighest stable replay-frame sequence handed to the transport.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalPhysical WebSocket sends, including replay and dictionary catch-up.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlywaitingInternalCross-owner reservation for stable pooled sender slot indexes.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindsBrowser-safe typed positional binds.
+OptionalinitialZero means unbounded.
+OptionalqueryAppend only after SERVER_INFO advertises QUERY_FLAGS.
+ReadonlyattemptOne-based reconnect sweep number; zero for lifecycle-only events.
+Optional ReadonlycauseOptional ReadonlyendpointOptional ReadonlyepisodeElapsed time in the current consecutive capability-gap episode.
+ReadonlykindOptional ReadonlypreviousReadonlytimestampReconnect tuning shared by ingress and egress. The two sides ship different +defaults, so every field below documents both; an unset field keeps its own +side's default rather than the other's.
+The ingress defaults favour survival -- a producer holding buffered or +journalled rows must outlast an outage rather than give up on it -- while +egress bounds a query connection so a caller is not left waiting.
+OptionalinitialFull-jitter ceiling before the first failed sweep is retried. +Ingress defaults to 100ms, egress to 50ms.
+OptionalmaxMaximum connection sweeps per outage; zero is unlimited. +Ingress defaults to zero, egress to 8.
+OptionalmaxFull-jitter exponential-backoff ceiling. +Ingress defaults to 5s, egress to 1s.
+OptionalmaxTotal reconnect deadline; zero disables the deadline. +Ingress defaults to 5 minutes, egress to 30s.
+OptionalmaxConsecutive retriable rejections of one ingress frame before it is treated +as poison and retained for inspection. Defaults to 4. Ingress only.
+OptionalonOptionalpoisonMinimum time the same ingress frame must remain suspect before repeated +rejections or non-orderly closes become terminal. Defaults to 5 minutes; +zero escalates as soon as maxFrameRejections is reached. Ingress only.
+Raw or Zstd-compressed delta dictionary and columnar table block; decoded +by the batch decoder according to the frame flags.
+Immutable Java-parity context for an ingress rejection or data loss.
+ReadonlyappliedReadonlycategoryReadonlydetectedOptional ReadonlyfromInclusive stable store-and-forward frame-sequence range.
+Optional ReadonlymessageOptional ReadonlyquarantinedPreserved on-disk bytes for a data-loss/quarantine notification.
+Optional ReadonlyserverOptional ReadonlyserverOptional ReadonlytableOptional ReadonlytoImmutable high-level sender counters plus the active ingress snapshot.
+ReadonlyautoReadonlyclosedReadonlyclosingReadonlyconnectedReadonlydeferredReadonlyeffectiveOptional ReadonlyingressReadonlypendingEstimated raw column-buffer bytes currently staged.
+ReadonlypendingReadonlytotalReadonlytotalReadonlytotalRows whose encoded frames have entered the ingress session.
+ReadonlytotalReadonlytotalOptions for the browser-safe, fluent QWP sender.
+OptionalautoOptionalautoSoft threshold for estimated buffered column bytes. Zero disables the byte +trigger. Defaults to zero and is clamped below a connected server's batch +cap; exact encoded frames remain subject to the protocol batch limit.
+OptionalautoOptionalautoOptionalawaitWait for durable upload after every successful ingress ACK. When true, +this implies awaitServerAck unless awaitServerAck is explicitly false.
+OptionalawaitWait for the server's protocol ACK before flush()/commit() resolves. +Defaults to false, matching the Java QWP sender's local-publication +boundary. Set this to true for an acknowledgement barrier, or use +flushAndGetSequence() followed by waitForAcknowledged().
+OptionalcloseMaximum time close() spends publishing queued rows and waiting for the +server ACK watermark. Zero or a negative value skips the drain. Defaults +to 5 seconds.
+OptionaldurableOptionalencodeQWP frame encoding options supported by the high-level sender.
+OptionallogOptionalmaxMaximum UTF-8 byte length of table and column names. Defaults to 127.
+OptionaltransactionalKeep auto-flushed rows in an open server-side transaction. An explicit +flush()/commit() closes the transaction. QWP transactions are atomic per +table, rather than across every table in a multi-table flush.
+The subset of QwpIngressSession used by QwpSender.
+Optional ReadonlyacknowledgedOptional ReadonlymaxOptional ReadonlymetricsOptional ReadonlypublishedOptionalcode: numberOptionalreason: stringOptionalpublishOptionaloptions: QwpIngressEncodeOptionsOptionalpublishOptionaloptions: Pick<QwpIngressEncodeOptions, "gorilla" | "deferCommit">Optionaloptions: QwpIngressEncodeOptionsOptionalsendOptionaloptions: Pick<QwpIngressEncodeOptions, "gorilla" | "deferCommit">OptionalsendOptionaloptions: Pick<QwpIngressEncodeOptions, "gorilla" | "deferCommit">OptionalsendOptionaloptions: QwpIngressEncodeOptionsOptionalwaitOptionaltimeoutMs: numberOptionaltimeoutMs: numberImmutable endpoint metadata from the most recent successful egress bind.
+OptionalcauseOptionalcloseOptionalretryableWhether a later retry against the configured endpoint set may recover.
+OptionalserverOptionalserverOptionalstatusOptionalstatusOptionaltimeoutOptionaltryWhether failover code should try another endpoint before surfacing this.
+OptionalurlOptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalprotocolsOptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+Optional ReadonlybufferedNumber of application bytes queued by WHATWG-compatible WebSockets.
+Optional ReadonlyprotocolWebSocket subprotocol selected by the server, or an empty string.
+ReadonlyreadyOptionaloptions: { once?: boolean }Optionaloptions: { once?: boolean }Optionaloptions: { once?: boolean }Optionalcode: numberOptionalreason: stringOptionalpingNode WebSocket implementations may expose control-frame PING.
+OptionalremoveOptional cleanup hook implemented by browser WebSocket and Node ws.
OptionalsendNode adapter hook for the ws.send(data, callback) completion signal.
OptionalterminateNode WebSocket implementations may support immediate termination.
+A reusable, immutable column definition for a compiled QWP table writer.
+Optional Readonly Internal__Carries the input type without adding a runtime value. Never
+assigned, and deliberately a plain property rather than a unique symbol:
+each emitted bundle would declare its own symbol, making the key nominally
+distinct per entry point. A column built by './qwp' would then satisfy
+another bundle's QwpWriterColumn without ever matching its phantom key, so
+QwpWriterColumnInput would infer unknown and every row field would
+silently accept anything. A shared property name resolves structurally
+across bundles, which is what keeps row typing alive for consumers of the
+published package.
ReadonlydesignatedReadonlykindOptional ReadonlyprecisionGEOHASH precision in bits, fixed for the whole column.
+Optional ReadonlyscaleDECIMAL scale, fixed for the whole column.
+Optional ReadonlyunitNormalized binary connection consumed by QWP sessions.
+Adapters buffer messages until the single async iterator consumes them, so +unsolicited frames such as egress SERVER_INFO cannot race session startup.
+ReadonlyclosedOptional ReadonlyendpointEndpoint backing this connection, when supplied by its adapter.
+ReadonlyhandshakeOptional Readonly InternalingressFalse after replay dictionary persistence becomes unavailable.
+Optional Readonly InternalingressRecovered ingress dictionary supplied by replay connections.
+Optional Readonly InternalmanagesTrue when the transport dispatches typed sender errors itself.
+ReadonlymessagesOptionalcode: numberOptionalreason: stringOptionaldeprioritizeInternalMarks this endpoint as temporarily unsuitable and asks a stateful +connection factory to start its next sweep at another configured endpoint.
+OptionalgetInternalResolves a session sequence to its stable replay FSN.
+OptionalgetInternalPhysical delivery metrics exposed by replaying transports.
+OptionalgetInternalPublished watermark alone, for the flush path.
+Transports that expose this must keep it consistent with
+getIngressMetrics's publishedFrameSequence; callers fall back to
+the full snapshot when it is absent.
OptionalpingSends an RFC 6455 PING when the underlying runtime supports it.
+OptionalprepareInternalSerializes a whole logical batch capacity check before its first +frame is sent, preventing a deferred prefix from consuming the only space +needed by its commit-bearing suffix.
+OptionalskipInternalReserves a client sequence for a split-batch suffix suppressed +before send(), keeping replay ACK translation aligned with the session.
+Optional InternalsenderCoordinates stable persistent sender slots with recovery.
+OptionalcloseInternalStops runtime-specific background services during close.
+Optionalsignal: AbortSignalOptionalsignal: AbortSignalOptionalstartInternalStarts runtime-specific background services on first use.
+OptionalacquireMaximum wait for a returned pool slot and for leases during shutdown. +The shutdown wait is capped at 5 seconds. Defaults to 5 seconds.
+OptionalhousekeepingIdle/lifetime sweep interval. Defaults to 5s and must be at least 100ms.
+OptionalidleIdle time before an excess pooled connection is closed. Defaults to 60s; zero disables.
+OptionalmaxMaximum pooled connection age before recycling it while idle. Defaults to 30m; zero disables.
+OptionalqueryMaximum concurrently borrowed query connections. Defaults to 4.
+OptionalqueryWarm egress connections created by connect(). Defaults to 1.
+OptionalsenderMaximum concurrently borrowed ingress senders. Defaults to 4.
+OptionalsenderWarm ingress connections created by connect(). Defaults to 1.
+OptionaldecimalOptionalgeohashOne entry per row; true means NULL.
+Rows accounted for so far, including nulls.
+Non-null values only; QWP compacts values around the null bitmap. +LONG, DATE, and TIMESTAMP values accept safe integer numbers or signed +int64 bigints. LONG_ARRAY applies the same rule to every element.
+OptionalautoReplenishes positive initial credit by each RESULT_BATCH wire size after +the async iterator advances past that batch. Defaults to true.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindsSets typed positional parameters; index 0 maps to SQL placeholder $1.
OptionalinitialOverrides session send-ahead credit. Zero explicitly disables flow control.
+OptionalresetAsk a capable server to reset its connection-scoped symbol dictionary. +Silently omitted when the server lacks QUERY_FLAGS for rolling upgrades.
+OptionaltimeoutPer-query deadline overriding the session default. Zero disables it.
+Optional ReadonlycauseOptional ReadonlyendpointOptional ReadonlypreviousReadonlyrequestClient request being re-executed on the replacement connection.
+ReadonlyserverAuthoritative SERVER_INFO received from the replacement endpoint.
+Endpoint routing preferences. Named for egress, where they landed first, but +ingress ranks and validates its endpoints with the same machinery and honours +the same two keys.
+OptionalbufferMaximum decoded batches waiting for a consumer. Defaults to 4.
+OptionalcancelMaximum wait for a terminal response after CANCEL. Defaults to 5 seconds.
+OptionalconnectionBounded inbox depth for reconnect.onEvent. Defaults to 64, matching
+ingress. Overflow drops the oldest pending notification.
OptionalinitialDefault per-query send-ahead credit. Defaults to zero (unbounded).
+OptionalmaxRejects a RESULT_BATCH declaring more rows than this. The connect helpers
+default it to the maxBatchRows they put on the wire, so the request the
+client makes is also the bound it enforces; decoder scratch is sized from
+the declared row count and retained per pool slot, so an answer above the
+request would set this session's memory floor for its lifetime.
OptionalonOptional notification immediately before an active query is re-executed. +Not-yet-consumed batches are discarded automatically; callers that retain +an already-consumed prefix should discard it here. Omitting this callback +leaves replay enabled and is appropriate for idempotent consumers.
+OptionalqueryDefault per-query deadline. Zero or undefined disables query deadlines.
+OptionalreconnectBounded failover policy. Failover and at-least-once active-query replay +are enabled by default; set false to keep one fixed connection.
+OptionalserverSERVER_INFO handshake deadline. Defaults to 5 seconds.
+Control handle returned by queryViews().
+Metadata negotiated during the QWP WebSocket upgrade.
+Optional ReadonlycontentServer-selected egress content encoding, when advertised.
+Optional ReadonlydurableWhether the server confirmed durable-ACK support.
+Optional ReadonlymaxServer's hard ingress WebSocket-payload cap, when advertised.
+Optional ReadonlynegotiatedParsed effective egress codec and level selected by the server.
+ReadonlyqwpQWP protocol version selected by the server.
+Optional ReadonlyserverServer role advertised on a successful upgrade, when available.
+Optional ReadonlyserverServer zone advertised on a successful upgrade, when available.
+Immutable point-in-time ingress telemetry, safe in browsers and Node.js.
+ReadonlyacknowledgedHighest client-session sequence covered by a successful cumulative ACK.
+ReadonlydeliveredReadonlydeliveredReadonlydeliveredReadonlydroppedReadonlydroppedReadonlydroppedOptional ReadonlylastOptional ReadonlymemoryOptional ReadonlymemoryReadonlypendingReadonlypendingReadonlypendingReadonlypendingReadonlypendingReadonlypublishedHighest client-session sequence allocated, or -1 before the first send.
+Optional ReadonlyreplayTrim watermark; in durable-ACK mode it advances only after durability.
+Optional ReadonlyreplayStable store-and-forward watermark; absent without reconnect/replay.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalPhysical sends; includes replay and dictionary catch-up when available.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlywaitingLightweight durable-frame descriptor used by disk-backed replay stores.
+Browser-safe abstraction; Node supplies a persistent filesystem implementation.
+OptionalappendPersists new dense entries before a delta frame is made replayable.
+OptionaldiscardInternalRemoves a local prefix without representing it as a server ACK. +Persistent stores should provide this when recovery can abandon frames.
+"Without representing it as a server ACK" is about the transport's public
+watermark, which the caller leaves alone. The removal itself must be as
+durable as acknowledgeThrough's: a discarded prefix that a later load()
+can still see is a prefix this client reported abandoned and then sent
+anyway.
OptionalloadOpens and validates the journal without materializing every payload.
+Implementations that provide this must also provide readPayload.
OptionalloadLoads the durable, dense symbol prefix used by persisted delta frames.
+OptionalprepareInternalWaits until every payload in one logical batch can be appended +without an ACK between frames. Implementations must not mutate the journal.
+OptionalreadReads one previously loaded durable payload on demand.
+OptionalreplaceAtomically replaces an unusable dictionary after surviving committed +frames prove that its complete ID space can be reconstructed.
+One ingress operation with independent local-publication and server-ACK +completion. Publication resolves after every physical frame belonging to +the logical batch has been accepted by the connection. For persistent Node +transports that means the frames are durable in the replay journal.
+OptionalackOptional InternalbackgroundStarts memory or persistent replay without waiting for a server.
+Optional InternalcatchMinimum cap-gap dwell before an orphan can be quarantined.
+OptionalconnectionBounded reconnect-listener inbox. Oldest pending events are dropped when +full. Defaults to 64, matching the Java client.
+OptionaldurableEnables durable-ACK tracking. While committed table transactions await +durable upload, Node transports send WebSocket PING frames and browser +transports send table-less QWP poll frames. Zero keeps tracking enabled +but disables automatic polling. Factory-created browser sessions require +requestDurableAck=true when this option is supplied.
+OptionalerrorBounded typed/legacy error inbox. Oldest pending errors are dropped when +full. Defaults to 256, matching the Java client.
+Optional InternalinitialInitial connection policy supplied by the Node adapter.
+OptionalmaxOptional local ingress frame cap. Browsers cannot read WebSocket upgrade +headers, so browser applications should set this to the server's configured +QWP cap. When the server also advertises a cap, the smaller value wins. +Table batches are split at row boundaries automatically; an individual row +that cannot fit is rejected with QwpBatchTooLargeError before it is sent.
+OptionalmemoryMaximum time a memory replay append waits for ACK-driven trimming after +reaching memoryReplayMaxBytes. Defaults to 30 seconds.
+OptionalmemoryTarget cap for the built-in memory-only replay queue, including estimated +per-frame bookkeeping. Defaults to 128 MiB. A transaction-closing logical +batch may temporarily exceed this target by up to one target-sized batch, +because the server cannot ACK its deferred prefix before receiving that +batch. This applies in browsers and non-persistent Node sessions; custom +replay stores enforce their own cap.
+OptionalonOptionalonServer rejections, deadlines, and terminal session failures.
+OptionalonMonotonic send/accept/durability notifications. Callback errors are ignored.
+OptionalonOptionalonJava-parity typed server-rejection and data-loss notifications. When +omitted, the default handler logs retriable errors at warn and terminal +errors or abandoned data at error.
+Optional InternalorphanConsecutive durable-ACK gap budget retained for orphan SF.
+Optional InternalorphanOrphan sessions may quarantine persistent catch-up cap gaps.
+OptionalreconnectBounded reconnection and at-least-once replay policy. Reconnection is +enabled by default for factory-created sessions; set false to keep one +fixed connection. Browser and non-persistent Node replay is memory-only.
+An ACK lost during disconnect can cause a frame to be replayed after the +server accepted it; configure server-side deduplication when duplicates +are not acceptable.
+Optional InternalreplayNode adapter hook for persistent store-and-forward.
+Physical ingress delivery counters maintained by reconnecting transports.
+Optional ReadonlyabandonedStable frame ranges retired without ever receiving a server ACK.
+ReadonlyacknowledgedHighest replay-frame sequence removed after a server acknowledgement.
+Optional ReadonlydeliveredOptional ReadonlydeliveredOptional ReadonlydroppedOptional ReadonlydroppedOptional ReadonlymemoryConfigured cap for the built-in memory replay store.
+Optional ReadonlymemoryEstimated payload and record-bookkeeping bytes charged to that cap.
+ReadonlypendingReadonlypendingReadonlypublishedHighest stable replay-frame sequence handed to the transport.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalPhysical WebSocket sends, including replay and dictionary catch-up.
+ReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlywaitingProgrammatic hooks layered over a unified ws/wss cluster string. Values in +this object take precedence after the complete string has been validated.
+OptionalegressEgress-only routing and compression overrides.
+OptionalegressOptionalingressOptionalpoolOptionalsenderOptionalstoreOptional persistent ingress configuration; may supply/override sf_dir.
+OptionalwebShared transport overrides applied to both ingress and egress.
+Node configuration for a combined pooled QWP ingress/egress client.
+OptionalegressOptionalingressOptionallazyCoordinates a non-blocking startup: ingress connects in the background, +using memory replay when store-and-forward is absent, and the egress pool +remains cold until the first query. Conflicts with a positive queryPoolMin +or a non-async initialConnectMode.
+OptionalpoolOptionalsenderEndpoint routing preferences. Named for egress, where they landed first, but +ingress ranks and validates its endpoints with the same machinery and honours +the same two keys.
+OptionalagentOptional HTTP(S) agent used for the WebSocket upgrade.
+OptionalauthorizationOptionalauthTime allowed after TCP/TLS connection for HTTP authentication and the +WebSocket upgrade.
+Defaults to QwpWebSocketConnectOptions.connectTimeoutMs when that +is set, and to 15s otherwise, so narrowing only the connect deadline +bounds the whole opening rather than being exceeded by a default nobody +chose. Set this to give the slower phase its own budget.
+OptionalclientOptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalcompressionRequests Zstd-compressed result batches. The default is raw, which
+preserves compatibility with servers that predate QWP compression.
+auto currently advertises the same ordered preference as zstd.
OptionalcompressionZstd level hint sent to the server. Must be between 1 and 22, and only
+takes effect alongside compression; the default raw sends no
+accept-encoding header for a level to travel on.
OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalheadersOptionalmaxRequests a server-side RESULT_BATCH row cap.
+OptionalmaxOptionalprotocolsOptionalrequestIngress-only. Durable ACK is negotiated on /write/v4; egress ignores it
+and egressTransportOptions() strips it, because sending the header on
+/read/v1 makes every query session fail the capability check.
OptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+OptionaltargetSelects any readable node, a primary/standalone node, or a replica.
+OptionalwebTest hook; defaults to the Node-only ws implementation.
OptionalzoneOpaque, case-insensitive preferred zone; cross-zone fallback stays enabled.
+ReadonlybackpressureReadonlycheckpointReadonlydirtyReadonlydurabilityOptional ReadonlylastReadonlypendingReadonlypendingReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlytotalReadonlywaitingOptionalappendPer-append capacity or retryable store-fault deadline. Defaults to 30 seconds.
+OptionalbackpressureBehavior when maxBytes is exhausted. error fails immediately; wait
+pauses the append until ACK trimming frees space or its deadline expires.
+Defaults to error for backwards compatibility.
This decides journal exhaustion only. A transient retryable fault parks +until appendDeadlineMs under either policy, so the only errors an +append surfaces are exhaustion and that deadline.
+OptionalcheckpointPeriodic durability checkpoint cadence. Defaults to 5 seconds.
+Exclusive directory used by one ingress session.
+OptionaldurabilityLocal persistence barrier. append preserves the existing fsync-per-frame
+behavior, periodic checkpoints dirty files in the background, and
+memory relies on OS page-cache writeback. Defaults to append.
OptionalmaxTarget maximum journal size including fixed segment reservations and +symbol metadata. Defaults to 1 GiB. The current symbol dictionary may +exceed this target so it cannot consume the journal's live frame budget +before a drained close retires that dictionary generation.
+OptionalmaxMaximum QWP frame payload and target segment data size. Each fixed segment +reserves this value plus one record header and its 24-byte SFA header, +so a maximum-sized frame still fits. Defaults to 4 MiB.
+OptionalonReports journal bytes abandoned during recovery. Defaults to logging at +error level; recovery still succeeds, so this must never be silent.
+Endpoint routing preferences. Named for egress, where they landed first, but +ingress ranks and validates its endpoints with the same machinery and honours +the same two keys.
+OptionalagentOptional HTTP(S) agent used for the WebSocket upgrade.
+OptionalauthorizationOptionalauthTime allowed after TCP/TLS connection for HTTP authentication and the +WebSocket upgrade.
+Defaults to QwpWebSocketConnectOptions.connectTimeoutMs when that +is set, and to 15s otherwise, so narrowing only the connect deadline +bounds the whole opening rather than being exceeded by a default nobody +chose. Set this to give the slower phase its own budget.
+OptionalclientOptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalheadersOptionalmaxOptionalprotocolsOptionalrequestIngress-only. Durable ACK is negotiated on /write/v4; egress ignores it
+and egressTransportOptions() strips it, because sending the header on
+/read/v1 makes every query session fail the capability check.
OptionalsenderSlot name below storeAndForward.directory.
+A connect string defaults it to default. Through the typed API it has no
+default: a standalone sender writes straight into directory, and a
+pooled client derives sender-<slot> names, or <senderId>-<slot> when
+this is set.
OptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+OptionalstoreUpgrades the default in-memory ingress replay to persistent Node +store-and-forward. Use a directory owned exclusively by this session.
+OptionaltargetSelects any readable node, a primary/standalone node, or a replica.
+OptionalwebTest hook; defaults to the Node-only ws implementation.
OptionalzoneOpaque, case-insensitive preferred zone; cross-zone fallback stays enabled.
+Optional ReadonlyattemptOne-based attempt in the current capability/topology episode.
+Optional ReadonlydirectoryOptional ReadonlyepisodeElapsed time in the current consecutive capability-gap episode.
+Optional ReadonlyerrorReadonlykindReadonlymetricsOptional ReadonlysenderPresent when a failed slot has been abandoned behind its sentinel.
+ReadonlytimestampMinimal session surface used by the Node orphan drainer.
+ReadonlyclosedReadonlymetricsReadonlyactiveReadonlyclosedReadonlyclosingReadonlydeliveredReadonlydeliveredReadonlydiscoveredReadonlydrainedReadonlydroppedReadonlydroppedReadonlyfailedReadonlylockedReadonlyqueuedReadonlyretryingTransient drain or terminal-marker writes awaiting retry.
+ReadonlyscanReadonlyscansOptionaldurableDurable-ACK prompt cadence for adopted sessions. Zero disables it.
+OptionalerrorBounded data-loss inbox. Defaults to 256.
+OptionaleventBounded lifecycle-event inbox. Defaults to 64.
+OptionalexcludeSlot names owned by the foreground producer/pool and never adoptable.
+OptionalmaxMaximum slots drained concurrently. Defaults to 4.
+OptionalonOptionalonJava-parity data-loss notification for an abandoned orphan slot.
+OptionalreleaseReleases a reservation previously granted by tryReserveSlot.
+Directory whose child directories are independent replay slots.
+OptionalscanPeriodic rescan cadence; zero disables the timer. Explicit scanNow() +requests remain available. Defaults to 30s.
+OptionaltryAtomically reserves a candidate against a foreground pool owner.
+Creates one independent replay session for an adopted slot.
+OptionalonReconnectEvent: (event: QwpReconnectEvent) => voidFrames discarded while recovering a damaged journal. Emitted instead of +failing recovery when the damage sits in the active segment, matching the +Java client, which zeroes an active torn tail by policy and reports the +residue through a WARN plus MmapSegment.tornTailBytes().
+ReadonlydirectoryReadonlydiscardedBytes at and after the damaged record that recovery could not retain.
+Zero means a loss was detected whose extent the journal cannot measure -- +a segment whose records are gone leaves nothing to count. Treat it as +"unknown", not as "nothing lost", and read reason.
+ReadonlyreasonReadonlysegmentNotification that an unreplayable foreground slot was preserved aside.
+Node store-and-forward controls layered on the crash-safe replay journal.
+OptionalappendPer-append capacity or retryable store-fault deadline. Defaults to 30 seconds.
+OptionalbackpressureBehavior when maxBytes is exhausted. error fails immediately; wait
+pauses the append until ACK trimming frees space or its deadline expires.
+Defaults to error for backwards compatibility.
This decides journal exhaustion only. A transient retryable fault parks +until appendDeadlineMs under either policy, so the only errors an +append surfaces are exhaustion and that deadline.
+OptionalcatchMinimum time an orphan slot's symbol catch-up cap gap must persist before +it is quarantined. The gap must also be observed 16 times. Defaults to +five minutes; zero uses the observation threshold alone.
+OptionalcheckpointPeriodic durability checkpoint cadence. Defaults to 5 seconds.
+Exclusive directory used by one ingress session.
+OptionaldrainAdopts sibling replay slots left by terminated producers. Standalone
+senders default this to false; pooled clients always recover their own
+idle in-range and out-of-range sender-N slots.
OptionaldurabilityLocal persistence barrier. append preserves the existing fsync-per-frame
+behavior, periodic checkpoints dirty files in the background, and
+memory relies on OS page-cache writeback. Defaults to append.
OptionalinitialInitial server connection policy. Defaults to off; an explicitly tuned
+reconnect policy promotes it to sync, matching the Java client.
OptionalmaxMaximum sibling slots drained concurrently. Defaults to 4.
+OptionalmaxTarget maximum journal size including fixed segment reservations and +symbol metadata. Defaults to 1 GiB. The current symbol dictionary may +exceed this target so it cannot consume the journal's live frame budget +before a drained close retires that dictionary generation.
+OptionalmaxMaximum QWP frame payload and target segment data size. Each fixed segment +reserves this value plus one record header and its 24-byte SFA header, +so a maximum-sized frame still fits. Defaults to 4 MiB.
+OptionalonReceives isolated scanner, drainer, durable-ACK capability-gap, and +primary-unavailable lifecycle notifications.
+OptionalonReports journal bytes abandoned during recovery. Defaults to logging at +error level; recovery still succeeds, so this must never be silent.
+OptionalonReceives a data-loss notification when corrupt foreground replay bytes are
+preserved under an .unreplayable-N pathname and a fresh slot is opened.
OptionalorphanPeriodic rescan cadence; zero disables the timer. Pooled ownership +changes can still trigger a scan. Defaults to 30 seconds.
+Destination hostname or IPv4 address.
+OptionalmaxMaximum encoded datagram size. Defaults to 1400 bytes.
+OptionalmulticastOptional local IPv4 interface used for multicast traffic.
+OptionalmulticastIPv4 multicast TTL from 0 through 255. Defaults to 0.
+OptionalonReceives isolated local socket errors; UDP has no server acknowledgement.
+OptionalportDestination port. Defaults to the Java QWP UDP port, 9007.
+Optional InternalsocketTest hook.
+Minimal injectable UDP socket surface used by the Node QWP sender.
+OptionalagentOptional HTTP(S) agent used for the WebSocket upgrade.
+OptionalauthorizationOptionalauthTime allowed after TCP/TLS connection for HTTP authentication and the +WebSocket upgrade.
+Defaults to QwpWebSocketConnectOptions.connectTimeoutMs when that +is set, and to 15s otherwise, so narrowing only the connect deadline +bounds the whole opening rather than being exceeded by a default nobody +chose. Set this to give the slower phase its own budget.
+OptionalclientOptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalheadersOptionalmaxOptionalprotocolsOptionalrequestIngress-only. Durable ACK is negotiated on /write/v4; egress ignores it
+and egressTransportOptions() strips it, because sending the header on
+/read/v1 makes every query session fail the capability check.
OptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+OptionalwebTest hook; defaults to the Node-only ws implementation.
InternalCross-owner reservation for stable pooled sender slot indexes.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindAdvanced escape hatch for an already encoded bind section.
+OptionalbindsBrowser-safe typed positional binds.
+OptionalinitialZero means unbounded.
+OptionalqueryAppend only after SERVER_INFO advertises QUERY_FLAGS.
+ReadonlyattemptOne-based reconnect sweep number; zero for lifecycle-only events.
+Optional ReadonlycauseOptional ReadonlyendpointOptional ReadonlyepisodeElapsed time in the current consecutive capability-gap episode.
+ReadonlykindOptional ReadonlypreviousReadonlytimestampReconnect tuning shared by ingress and egress. The two sides ship different +defaults, so every field below documents both; an unset field keeps its own +side's default rather than the other's.
+The ingress defaults favour survival -- a producer holding buffered or +journalled rows must outlast an outage rather than give up on it -- while +egress bounds a query connection so a caller is not left waiting.
+OptionalinitialFull-jitter ceiling before the first failed sweep is retried. +Ingress defaults to 100ms, egress to 50ms.
+OptionalmaxMaximum connection sweeps per outage; zero is unlimited. +Ingress defaults to zero, egress to 8.
+OptionalmaxFull-jitter exponential-backoff ceiling. +Ingress defaults to 5s, egress to 1s.
+OptionalmaxTotal reconnect deadline; zero disables the deadline. +Ingress defaults to 5 minutes, egress to 30s.
+OptionalmaxConsecutive retriable rejections of one ingress frame before it is treated +as poison and retained for inspection. Defaults to 4. Ingress only.
+OptionalonOptionalpoisonMinimum time the same ingress frame must remain suspect before repeated +rejections or non-orderly closes become terminal. Defaults to 5 minutes; +zero escalates as soon as maxFrameRejections is reached. Ingress only.
+Raw or Zstd-compressed delta dictionary and columnar table block; decoded +by the batch decoder according to the frame flags.
+Immutable Java-parity context for an ingress rejection or data loss.
+ReadonlyappliedReadonlycategoryReadonlydetectedOptional ReadonlyfromInclusive stable store-and-forward frame-sequence range.
+Optional ReadonlymessageOptional ReadonlyquarantinedPreserved on-disk bytes for a data-loss/quarantine notification.
+Optional ReadonlyserverOptional ReadonlyserverOptional ReadonlytableOptional ReadonlytoImmutable high-level sender counters plus the active ingress snapshot.
+ReadonlyautoReadonlyclosedReadonlyclosingReadonlyconnectedReadonlydeferredReadonlyeffectiveOptional ReadonlyingressReadonlypendingEstimated raw column-buffer bytes currently staged.
+ReadonlypendingReadonlytotalReadonlytotalReadonlytotalRows whose encoded frames have entered the ingress session.
+ReadonlytotalReadonlytotalOptions for the browser-safe, fluent QWP sender.
+OptionalautoOptionalautoSoft threshold for estimated buffered column bytes. Zero disables the byte +trigger. Defaults to zero and is clamped below a connected server's batch +cap; exact encoded frames remain subject to the protocol batch limit.
+OptionalautoOptionalautoOptionalawaitWait for durable upload after every successful ingress ACK. When true, +this implies awaitServerAck unless awaitServerAck is explicitly false.
+OptionalawaitWait for the server's protocol ACK before flush()/commit() resolves. +Defaults to false, matching the Java QWP sender's local-publication +boundary. Set this to true for an acknowledgement barrier, or use +flushAndGetSequence() followed by waitForAcknowledged().
+OptionalcloseMaximum time close() spends publishing queued rows and waiting for the +server ACK watermark. Zero or a negative value skips the drain. Defaults +to 5 seconds.
+OptionaldurableOptionalencodeQWP frame encoding options supported by the high-level sender.
+OptionallogOptionalmaxMaximum UTF-8 byte length of table and column names. Defaults to 127.
+OptionaltransactionalKeep auto-flushed rows in an open server-side transaction. An explicit +flush()/commit() closes the transaction. QWP transactions are atomic per +table, rather than across every table in a multi-table flush.
+The subset of QwpIngressSession used by QwpSender.
+Optional ReadonlyacknowledgedOptional ReadonlymaxOptional ReadonlymetricsOptional ReadonlypublishedOptionalcode: numberOptionalreason: stringOptionalpublishOptionaloptions: QwpIngressEncodeOptionsOptionalpublishOptionaloptions: Pick<QwpIngressEncodeOptions, "gorilla" | "deferCommit">Optionaloptions: QwpIngressEncodeOptionsOptionalsendOptionaloptions: Pick<QwpIngressEncodeOptions, "gorilla" | "deferCommit">OptionalsendOptionaloptions: Pick<QwpIngressEncodeOptions, "gorilla" | "deferCommit">OptionalsendOptionaloptions: QwpIngressEncodeOptionsOptionalwaitOptionaltimeoutMs: numberOptionaltimeoutMs: numberImmutable endpoint metadata from the most recent successful egress bind.
+OptionalcauseOptionalcloseOptionalretryableWhether a later retry against the configured endpoint set may recover.
+OptionalserverOptionalserverOptionalstatusOptionalstatusOptionaltimeoutOptionaltryWhether failover code should try another endpoint before surfacing this.
+OptionalurlOptionalcloseMaximum time allowed for a graceful WebSocket close. Defaults to 15s.
+OptionalconnectNode TCP/TLS connection deadline, or the complete opening deadline in a +browser. Defaults to 15s.
+OptionalfailoverAdditional endpoints attempted in order when the preferred endpoint fails.
+OptionalprotocolsOptionalsendMaximum time a send may remain queued by the WebSocket. Defaults to 15s.
+Optional ReadonlybufferedNumber of application bytes queued by WHATWG-compatible WebSockets.
+Optional ReadonlyprotocolWebSocket subprotocol selected by the server, or an empty string.
+ReadonlyreadyOptionaloptions: { once?: boolean }Optionaloptions: { once?: boolean }Optionaloptions: { once?: boolean }Optionalcode: numberOptionalreason: stringOptionalpingNode WebSocket implementations may expose control-frame PING.
+OptionalremoveOptional cleanup hook implemented by browser WebSocket and Node ws.
OptionalsendNode adapter hook for the ws.send(data, callback) completion signal.
OptionalterminateNode WebSocket implementations may support immediate termination.
+A reusable, immutable column definition for a compiled QWP table writer.
+Optional Readonly Internal__Carries the input type without adding a runtime value. Never
+assigned, and deliberately a plain property rather than a unique symbol:
+each emitted bundle would declare its own symbol, making the key nominally
+distinct per entry point. A column built by './qwp' would then satisfy
+another bundle's QwpWriterColumn without ever matching its phantom key, so
+QwpWriterColumnInput would infer unknown and every row field would
+silently accept anything. A shared property name resolves structurally
+across bundles, which is what keeps row typing alive for consumers of the
+published package.
ReadonlydesignatedReadonlykindOptional ReadonlyprecisionGEOHASH precision in bits, fixed for the whole column.
+Optional ReadonlyscaleDECIMAL scale, fixed for the whole column.
+Optional ReadonlyunitBuffer used by the Sender for data serialization.
+Provides methods for writing different data types into the buffer.
Writes an array column with its values into the buffer.
+Column name
+Array values to write (currently supports double arrays). A null or undefined value omits the column entirely when arrays are supported; protocol v1 rejects the call for every value.
+Returns with a reference to this buffer.
+Closes the row after writing the designated timestamp into the buffer.
+Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.Designated epoch timestamp. Must be an integer or a BigInt.
Optionalunit: TimestampUnitThe time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+If unit is not one of 'ns', 'us', or 'ms'.
+Argument validation -- the unit and the timestamp alike -- runs before the
+close touches the row, so it leaves the open row unchanged and the call
+can be retried with a corrected argument.
Closes the row without writing designated timestamp into the buffer. +Designated timestamp will be populated by the server on this record.
+Writes a boolean column with its value into the buffer. +Use it to insert into BOOLEAN columns.
+Column name.
+Column value, accepts only boolean values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Returns the current position of the buffer. +New data will be written into the buffer starting from this position.
+The current write position in the buffer
+Writes a decimal value into the buffer using its binary format.
+Use it to insert into DECIMAL database columns.
+Column name.
+The unscaled integer portion of the decimal value.
+bigint is provided, it will be converted automatically.Int8Array is provided, it must contain the two’s complement representation
+of the unscaled value in big-endian byte order.Int8Array represents a NULL value.The number of fractional digits (the scale) of the decimal value.
+Returns with a reference to this buffer.
+Writes a decimal value into the buffer using its text format.
+Use it to insert into DECIMAL database columns.
+Column name.
+The decimal value to write.
+number or a string containing a valid decimal representation."123.45" or "-0.001").Returns with a reference to this buffer.
+Writes a 64-bit floating point value into the buffer. +Use it to insert into DOUBLE or FLOAT database columns.
+Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a 64-bit signed integer into the buffer. +Use it to insert into LONG, INT, SHORT and BYTE columns.
+Column name.
+Column value, accepts only number values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Resets the buffer, data sitting in the buffer will be lost. +In other words it clears the buffer, and sets the writing position to the beginning of the buffer.
+Returns with a reference to this buffer.
+Writes a string column with its value into the buffer. +Use it to insert into VARCHAR and STRING columns.
+Column name.
+Column value, accepts only string values. A null or undefined value omits the column entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes a symbol name and value into the buffer. +Use it to insert into SYMBOL columns.
+Symbol name.
+Symbol value, toString() is called to extract the actual symbol value from the parameter. A null or undefined value omits the symbol entirely (stored as NULL).
+Returns with a reference to this buffer.
+Writes the table name into the buffer.
+Table name.
+Returns with a reference to this buffer.
+Writes a timestamp column and its value into the buffer.
+Use this method to insert data into TIMESTAMP or TIMESTAMP_NS columns.
Precision rules:
+'ns' (nanoseconds) are sent with full nanosecond precision.
+All other timestamps are sent with microsecond precision.The column name.
+The epoch timestamp. Must be an integer or a BigInt. A null or undefined value omits the column entirely (stored as NULL).
Optionalunit: TimestampUnitThe time unit of the timestamp. +Supported values:
+'ns' — nanoseconds (requires BigInt)'us' — microseconds (default)'ms' — millisecondsReturns with a reference to this buffer.
+Returns a cropped buffer ready to send to the server, or null if there is nothing to send. +The returned buffer is a copy of this buffer. +It also compacts the buffer.
+Optionalpos: numberOptional position parameter
+A copy of the buffer ready to send, or null
+Returns a cropped buffer, or null if there is nothing to send. +The returned buffer is backed by this buffer instance, meaning the view can change as the buffer is mutated. +Used only in tests to assert the buffer's content.
+Optionalpos: numberOptional position parameter
+A view of the buffer
+Interface for QuestDB transport implementations.
+Defines the contract for different transport protocols (HTTP/HTTPS/TCP/TCPS).
Closes the connection to the database server. +Should not be called on HTTP transports.
+Promise that resolves when the connection is closed
+Establishes a connection to the database server. +Should not be called on HTTP transports.
+Promise resolving to true if connection is successful
+Gets the default number of rows that trigger auto-flush for this transport.
+Default auto-flush row count
+Sends the data to the database server.
+Buffer containing the data to send
+Promise resolving to true if data was sent successfully
+A Node.js client for QuestDB.
-Browser WebSocket adapter and browser-safe QWP protocol/session APIs.
+The official browser-only QuestDB client. It provides QWP ingestion, streaming +queries, failover, typed row writers, and browser session authentication without +Node.js modules or polyfills.
+The complete browser API is exported from @questdb/browser-client. There are
+no additional public import paths.
ws, or undiciWebSocket, fetch, URL, TextEncoder, and
+TextDecoder/write/v4 and /read/v1/exec REST route when authentication bootstrap is neededThis package does not contain the Node.js ILP transports; use
+@questdb/nodejs-client for server-side Node.js programs.
npm install @questdb/browser-client
+yarn add @questdb/browser-client
+pnpm add @questdb/browser-client
+The package works with browser bundlers such as Vite, Rollup, webpack, and +esbuild. Import only from the package root:
+import { connectQwpBrowserSender } from "@questdb/browser-client";
+Serve QuestDB's QWP route from the application's origin, either directly or +through a reverse proxy. The browser will then apply the page's normal cookie, +origin, and TLS rules to the WebSocket connection.
+import { connectQwpBrowserSender } from "@questdb/browser-client";
const writeUrl = new URL("/write/v4", window.location.href);
writeUrl.protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
const sender = await connectQwpBrowserSender(
{ url: writeUrl },
{ autoFlush: false },
);
try {
await sender
.table("page_events")
.symbol("kind", "view")
.stringColumn("path", window.location.pathname)
.timestampColumn("recorded_at", Date.now(), "ms")
.atNow();
await sender.flush();
} finally {
await sender.close();
}
+Use wss: whenever the page is served over HTTPS. Browsers block insecure
+WebSockets from secure pages.
Transactional mode keeps automatically emitted frames in one open server-side
+transaction. commit() publishes the final frame. Transactions are atomic per
+table, not across every table in one flush.
import { connectQwpBrowserSender } from "@questdb/browser-client";
const sender = await connectQwpBrowserSender(
{ url: writeUrl, requestDurableAck: true },
{
transactional: true,
autoFlushRows: 10_000,
awaitDurableAck: true,
durableAckTimeoutMs: 30_000,
},
);
try {
for (const event of [
{ source: "checkout", value: 1n, timestamp: Date.now() },
{ source: "search", value: 3n, timestamp: Date.now() },
]) {
await sender
.table("events")
.symbol("source", event.source)
.longColumn("value", event.value)
.at(event.timestamp, "ms");
}
await sender.commit();
} finally {
await sender.close();
}
+Browser replay is held in memory and survives reconnects only while the page is +alive. Persistent store-and-forward is intentionally available only from the +Node.js package.
+Compile a table schema once when application data already has an object shape. +TypeScript checks every row against the schema.
+import {
connectQwpBrowserSender,
designatedTimestamp,
double,
symbol,
} from "@questdb/browser-client";
const sender = await connectQwpBrowserSender({ url: writeUrl });
try {
const measurements = sender.writer("measurements", {
device: symbol(),
temperature: double(),
timestamp: designatedTimestamp("ms"),
});
await measurements.rows([
{ device: "sensor-1", temperature: 21.4, timestamp: Date.now() },
{ device: "sensor-2", temperature: 22.1, timestamp: Date.now() },
]);
await sender.flush();
} finally {
await sender.close();
}
+The schema vocabulary also covers QuestDB integers, decimals, UUIDs, IPv4 +addresses, geohashes, binary values, and arrays.
+Browser JavaScript cannot add an Authorization header to a WebSocket upgrade.
+Authenticate over REST first so QuestDB can set an HttpOnly session cookie. The
+browser then sends that cookie during the QWP WebSocket upgrade.
import {
bootstrapQwpBrowserSession,
connectQwpBrowserSender,
} from "@questdb/browser-client";
await bootstrapQwpBrowserSession({
url: new URL("/exec", window.location.href),
authentication: {
type: "bearer",
token: oidcOrRestAccessToken,
},
// QuestDB Enterprise only; omit to use the authenticated principal.
serviceAccount: "market_data_writer",
});
const sender = await connectQwpBrowserSender({ url: writeUrl });
+Basic authentication is also supported:
+const sender = await connectQwpBrowserSender({
url: writeUrl,
sessionBootstrap: {
authentication: {
type: "basic",
username: "admin",
password: "quest",
},
},
});
+Putting sessionBootstrap on the connection options repeats authentication
+before initial connection, reconnect, and failover attempts. The package does
+not run an interactive OIDC flow; the application obtains access tokens from
+its identity provider.
The bootstrap request uses credentials. Prefer serving /exec, /write/v4,
+and /read/v1 from the application's origin. Cross-origin deployments require
+credentialed CORS and cookie attributes that permit the browser to store and
+send the session cookie. JavaScript never reads the HttpOnly cookie.
QWP egress streams typed result batches. A session runs one active query at a +time and automatically reconnects and walks configured failover URLs.
+import { connectQwpBrowserEgress } from "@questdb/browser-client";
const readUrl = new URL("/read/v1", window.location.href);
readUrl.protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
const session = await connectQwpBrowserEgress(
{
url: readUrl,
compression: "zstd",
sessionBootstrap: {
authentication: { type: "bearer", token: oidcOrRestAccessToken },
},
},
{ queryTimeoutMs: 30_000 },
);
try {
const query = await session.query(
"select timestamp, device, temperature " +
"from measurements where device = $1",
{
// Bind index 0 corresponds to SQL placeholder $1.
binds: (binds) => binds.setVarchar(0, "sensor-1"),
// A positive credit window bounds server read-ahead.
initialCredit: 1024 * 1024,
},
);
for await (const batch of query) {
for (const row of batch.rows()) {
console.log(row);
}
}
await query.completion;
} finally {
await session.close();
}
+Use queryViews() for reusable zero-copy result views in allocation-sensitive
+applications. Copy any view that must outlive its batch callback.
connectQwpBrowserClient() creates bounded sender and query pools for an
+application component that needs concurrent ingestion and queries:
import { connectQwpBrowserClient } from "@questdb/browser-client";
const clusterUrl = new URL("/", window.location.href);
clusterUrl.protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
const db = await connectQwpBrowserClient({
cluster: {
url: clusterUrl,
sessionBootstrap: {
authentication: { type: "bearer", token: oidcOrRestAccessToken },
},
},
ingress: { requestDurableAck: true },
egress: { target: "replica", compression: "zstd" },
pool: { senderPoolMax: 2, queryPoolMax: 4 },
});
try {
const sender = await db.borrowSender();
try {
await sender.table("events").symbol("kind", "view").atNow();
} finally {
// Flushes completed rows and returns the sender to the pool.
await sender.close();
}
const query = await db.borrowQuery();
try {
const result = await query.query("select count() from events");
for await (const batch of result) console.log([...batch.rows()]);
await result.completion;
} finally {
await query.close();
}
} finally {
await db.close();
}
+finally blocks.at(), atNow(), and
+writer row()/rows() calls.flush() or close().onReplayReset callback when duplicate prefixes matter.The QuestDB JavaScript client.
+This entry point targets Node.js. Use @questdb/browser-client for the browser build.
The official QuestDB client for Node.js and TypeScript. Use it to ingest rows +with the InfluxDB Line Protocol (ILP), ingest and query with the QuestDB Wire +Protocol (QWP), and keep publishing through outages with Node-only persistent +store-and-forward.
+The complete Node.js API is exported from @questdb/nodejs-client. There are no
+additional public import paths.
undici declares; an earlier v20
+warns with EBADENGINE and fails outright under engine-strict)/write/v4 and /read/v1 for QWP ingestion and queriesnpm install @questdb/nodejs-client
+yarn add @questdb/nodejs-client
+pnpm add @questdb/nodejs-client
+Sender buffers rows locally. Add as many complete rows as needed, then call
+flush() to send the batch.
import { Sender } from "@questdb/nodejs-client";
const sender = await Sender.fromConfig("http::addr=localhost:9000");
try {
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.symbol("side", "buy")
.floatColumn("price", 2_615.54)
.floatColumn("amount", 0.25)
.at(Date.now(), "ms");
await sender.flush();
} finally {
await sender.close();
}
+HTTP and HTTPS connect for each request. TCP, TCPS, WS, WSS, and UDP transports
+have an explicit connection, so call await sender.connect() before writing.
| Configuration prefix | +Protocol | +Typical use | +
|---|---|---|
http::, https:: |
+ILP | +Recommended general-purpose ingestion | +
tcp::, tcps:: |
+ILP | +Long-lived ILP connection | +
ws::, wss:: |
+QWP | +Acknowledged ingestion, failover, and store-and-forward | +
udp:: |
+QWP | +Fire-and-forget datagrams on trusted networks | +
Use encrypted transports and certificate verification outside trusted local +development environments.
+Avoid flushing after every row when the application can send a larger batch. +The sender also supports automatic flushing through its configuration options.
+import { Sender } from "@questdb/nodejs-client";
const sender = await Sender.fromConfig("http::addr=localhost:9000");
try {
for (const trade of [
{ symbol: "ETH-USD", price: 2_615.54, amount: 0.25 },
{ symbol: "BTC-USD", price: 59_750.1, amount: 0.01 },
]) {
await sender
.table("trades")
.symbol("symbol", trade.symbol)
.floatColumn("price", trade.price)
.floatColumn("amount", trade.amount)
.atNow();
}
await sender.flush();
} finally {
await sender.close();
}
+Passing null or undefined to a supported symbol or column method omits that
+column from the row, which records a SQL NULL in QuestDB.
Configuration strings use the form
+protocol::key=value;key=value. HTTP Basic authentication uses username and
+password; REST and OIDC access tokens use token.
import { Sender } from "@questdb/nodejs-client";
const sender = await Sender.fromConfig(
`https::addr=questdb.example:9000;token=${process.env.QUESTDB_TOKEN};tls_verify=on`,
);
try {
await sender.table("service_health").booleanColumn("healthy", true).atNow();
await sender.flush();
} finally {
await sender.close();
}
+The same configuration can be provided through QDB_CLIENT_CONF:
import { Sender } from "@questdb/nodejs-client";
// QDB_CLIENT_CONF=http::addr=localhost:9000
const sender = await Sender.fromEnv();
+Changing the configuration prefix to ws:: or wss:: selects QWP while
+keeping the familiar Sender row API.
import { Sender } from "@questdb/nodejs-client";
const sender = await Sender.fromConfig(
`wss::addr=questdb.example:9000;token=${process.env.QUESTDB_TOKEN};auto_flush=off`,
);
await sender.connect();
try {
await sender
.table("trades")
.symbol("symbol", "ETH-USD")
.floatColumn("price", 2_615.54)
.timestampColumn("received_at", Date.now(), "ms")
.atNow();
await sender.flush();
} finally {
await sender.close();
}
+QWP senders support server acknowledgements, durable acknowledgements, +transactions, reconnect, failover, compiled row writers, and metrics. See the +QWP guide +for the delivery semantics of each option.
+For repeated object-shaped rows, compile a table schema once. TypeScript then +checks each row against that schema.
+import {
Sender,
designatedTimestamp,
double,
long,
symbol,
} from "@questdb/nodejs-client";
const sender = await Sender.fromConfig("ws::addr=localhost:9000");
await sender.connect();
try {
const trades = sender.writer("trades", {
symbol: symbol(),
side: symbol(),
price: double(),
quantity: long(),
timestamp: designatedTimestamp("ns"),
});
await trades.rows([
{
symbol: "ETH-USD",
side: "buy",
price: 2_615.54,
quantity: 42n,
timestamp: 1_723_000_000_000_000_000n,
},
{
symbol: "BTC-USD",
side: "sell",
price: 59_750.1,
quantity: 1n,
timestamp: 1_723_000_001_000_000_000n,
},
]);
await sender.flush();
} finally {
await sender.close();
}
+Compiled writers are available with QWP transports only.
+QWP egress streams typed result batches. One egress session executes one active +query at a time.
+import { connectQwpNodeEgress } from "@questdb/nodejs-client";
const session = await connectQwpNodeEgress(
{
url: "wss://questdb.example:9000/read/v1",
authorization: `Bearer ${process.env.QUESTDB_TOKEN}`,
compression: "zstd",
},
{ queryTimeoutMs: 30_000 },
);
try {
const query = await session.query(
"select timestamp, symbol, price from trades where symbol = $1",
{
// Bind index 0 corresponds to SQL placeholder $1.
binds: (binds) => binds.setVarchar(0, "ETH-USD"),
initialCredit: 1024 * 1024,
},
);
for await (const batch of query) {
for (const row of batch.rows()) {
console.log(row);
}
}
await query.completion;
} finally {
await session.close();
}
+Use queryViews() instead of query() for reusable, allocation-conscious
+column and row views.
Node.js can journal QWP frames to disk before sending them. The producer can +continue accepting rows during a QuestDB outage and replay them in order after +reconnection.
+import { Sender } from "@questdb/nodejs-client";
const sender = await Sender.fromConfig(
"wss::" +
"addr=questdb-a.example:9000,questdb-b.example:9000;" +
"sf_dir=/var/lib/my-service/questdb-replay;" +
"initial_connect_retry=async;",
);
await sender.connect();
+Give every active producer its own journal directory. Durability, +backpressure, capacity, orphan recovery, and shutdown behavior are covered in +the store-and-forward section of the QWP guide.
+close() in a finally block.flush() before closing an ILP sender; otherwise buffered rows are lost.Sender. Give each worker or producer
+its own sender.Logger function type definition.
-The log level for the message
-The message to log, either a string or Error object
-Supported timestamp units for QuestDB operations.
-Phase-1 scalar bind types exposed by the Java reference client.
+Egress-only overrides for a unified browser cluster.
+Ingress-only overrides for a unified browser cluster.
+Browser configuration for a combined pooled QWP ingress/egress client.
+Optionalinit: RequestInitHTTP Basic authentication.
+QuestDB REST token or OIDC access token.
+Optionalurl?: string | URLDefaults to /exec on the current QWP endpoint's HTTP origin.
Opens one connection. The optional signal is aborted when the owning session +closes, so a factory that is still negotiating can tear its socket down +instead of leaving it alive until its own deadline expires. Factories that +ignore the parameter remain assignable.
+Optionalsignal: AbortSignalDECIMAL input: the unscaled bigint at the column's scale, decimal text (or
+a number) that is exactly representable at that scale, or the egress record.
DOUBLE array input: nested arrays or a flat shape-and-values record.
+Query operations that are safe while a reusable batch callback is active.
+GEOHASH input: the raw bits, base-32 geohash text whose length matches the +column precision, or the egress bit record.
+IPV4 input: dotted-quad text or a signed/unsigned packed 32-bit address.
+LONG256 input: an unsigned 256-bit bigint, a 0x-prefixed hex string of
+up to 64 digits, four little-endian words, or the egress word record.
LONG256 little-endian words; word 0 is least significant.
+LONG array input: nested arrays or a flat shape-and-values record.
+Nested LONG array of uniform shape.
+Nested DOUBLE array of uniform shape.
+Runs while one reusable batch view is valid. Do not retain the batch, +columns, or raw byte slices after the callback settles.
+Callback invoked by QwpResultBatchView.forEachRow().
+Opens the sender's session. The signal is aborted by close(), so a connect +still negotiating can be torn down instead of outliving the sender by up to +its connect/auth deadline. Factories that ignore the parameter remain +assignable, matching QwpConnectionFactory.
+Optionalsignal: AbortSignalServer role accepted by an egress connection. Defaults to any.
Opening phase whose Node QWP deadline expired.
+UUID input: canonical text, 16 canonical (RFC 4122) big-endian bytes, or the
+egress limb pair. All three forms describe the same UUID; the byte form is
+what uuid.parse() and java.util.UUID produce, not pre-encoded wire bytes.
The object accepted by a table writer compiled from Schema.
Logger function type definition.
+The log level for the message
+The message to log, either a string or Error object
+Phase-1 scalar bind types exposed by the Java reference client.
+Opens one connection. The optional signal is aborted when the owning session +closes, so a factory that is still negotiating can tear its socket down +instead of leaving it alive until its own deadline expires. Factories that +ignore the parameter remain assignable.
+Optionalsignal: AbortSignalDECIMAL input: the unscaled bigint at the column's scale, decimal text (or
+a number) that is exactly representable at that scale, or the egress record.
DOUBLE array input: nested arrays or a flat shape-and-values record.
+Query operations that are safe while a reusable batch callback is active.
+OptionalsenderHigh-level buffering and auto-flush options.
+OptionalsessionIngress ACK, durable-ACK, and reconnect options.
+OptionaludpNode-only QWP-over-UDP socket overrides.
+OptionalwebNode ingress overrides. Values are applied after the connect string has +been fully parsed and validated; typed values win when both forms set the +same option.
+GEOHASH input: the raw bits, base-32 geohash text whose length matches the +column precision, or the egress bit record.
+IPV4 input: dotted-quad text or a signed/unsigned packed 32-bit address.
+LONG256 input: an unsigned 256-bit bigint, a 0x-prefixed hex string of
+up to 64 digits, four little-endian words, or the egress word record.
LONG256 little-endian words; word 0 is least significant.
+LONG array input: nested arrays or a flat shape-and-values record.
+Nested LONG array of uniform shape.
+Nested DOUBLE array of uniform shape.
+Runs while one reusable batch view is valid. Do not retain the batch, +columns, or raw byte slices after the callback settles.
+Callback invoked by QwpResultBatchView.forEachRow().
+Opens the sender's session. The signal is aborted by close(), so a connect +still negotiating can be torn down instead of outliving the sender by up to +its connect/auth deadline. Factories that ignore the parameter remain +assignable, matching QwpConnectionFactory.
+Optionalsignal: AbortSignalServer role accepted by an egress connection. Defaults to any.
Opening phase whose Node QWP deadline expired.
+UUID input: canonical text, 16 canonical (RFC 4122) big-endian bytes, or the
+egress limb pair. All three forms describe the same UUID; the byte form is
+what uuid.parse() and java.util.UUID produce, not pre-encoded wire bytes.
The object accepted by a table writer compiled from Schema.
Supported timestamp units for QuestDB operations.
+ConstReadonlyBINARY: 23ReadonlyBOOLEAN: 1ReadonlyBYTE: 2ReadonlyCHAR: 22ReadonlyDATE: 11ReadonlyDECIMAL128: 20ReadonlyDECIMAL256: 21ReadonlyDECIMAL64: 19ReadonlyDOUBLE: 7ReadonlyDOUBLE_ARRAY: 17ReadonlyFLOAT: 6ReadonlyGEOHASH: 14ReadonlyINT: 4ReadonlyIPV4: 24ReadonlyLONG: 5ReadonlyLONG_ARRAY: 18ReadonlyLONG256: 13ReadonlySHORT: 3ReadonlySYMBOL: 9ReadonlyTIMESTAMP: 10ReadonlyTIMESTAMP_NANOS: 16ReadonlyUUID: 12ReadonlyVARCHAR: 15ConstReadonlyRAW: 0ReadonlyZSTD: 1ConstMaximum DECIMAL scale of each fixed-width decimal column type.
+Readonlydecimal128: 38Readonlydecimal256: 76Readonlydecimal64: 18ConstDefault decoded result-buffer pool depth, matching the Java client.
+ConstDefault send-ahead credit used by Java and TypeScript: zero is unbounded.
+ConstDefault wait for the initial or reconnected SERVER_INFO frame.
+ConstBrowser-visible WebSocket subprotocol used to request and confirm durable +ingress acknowledgements. Browsers cannot set or inspect X-QWP-* headers.
+ConstReadonlyCOMPRESSION: 4ReadonlyQUERY_FLAGS: 2ReadonlyZONE: 1ConstReadonlyCACHE_RESET: 23ReadonlyCANCEL: 20ReadonlyCREDIT: 21ReadonlyEXEC_DONE: 22ReadonlyQUERY_ERROR: 19ReadonlyQUERY_REQUEST: 16ReadonlyRESULT_BATCH: 17ReadonlyRESULT_END: 18ReadonlySERVER_INFO: 24ConstConstConstConstConstConstTable-less ingress control frame that polls negotiated durable-ACK progress.
+ConstConstConstConstConstReadonlyACKNOWLEDGED: "acknowledged"ReadonlyDURABLE_ACKNOWLEDGED: "durable-acknowledged"ReadonlyPUBLISHED: "published"ConstInitial connection policy for an ingress reconnect session. Public browser +and memory-only helpers resolve their default internally; Node persistent +store-and-forward exposes all three modes.
+ReadonlyASYNC: "async"Return immediately and connect on the background replay loop.
+ReadonlyOFF: "off"Try once on the caller and fail immediately.
+ReadonlySYNC: "sync"Retry on the caller within the configured reconnect budget.
+ConstASCII QWP1, represented as its little-endian uint32 value.
ConstMaximum array rank accepted by QuestDB's QWP ingress decoder.
+ConstMaximum signed int32 array-axis length accepted by QWP ingress.
+ConstLargest client-requested egress RESULT_BATCH row cap.
+ConstLargest rowCount * columnCount a single RESULT_BATCH may declare.
The row and column caps above bound each dimension on its own, and their
+product does not have to be reachable: 1,048,576 rows of 2,048 columns is
+2.1 billion cells. Decoding materializes two rowCount-length arrays per
+column, measured at 16 bytes per cell, so the product is what decides how
+much memory a response can cost. It is also the dimension a compressed body
+detaches from the wire: an all-NULL column is one bit per cell before zstd,
+so without this bound a few kilobytes of RLE-compressed bitmap declares a
+grid no heap can hold.
32Mi cells is roughly 512 MB decoded. That is far above any plausible +result -- the widest supported table at 16k rows, or a full 1,048,576-row +batch at 32 columns -- and far below what the caps alone would permit.
+ConstConstDefault QWP ingress identifier limits, in UTF-8 wire bytes.
+ConstDefensive byte bound for identifiers decoded from query results.
+Existing tables may have names created through APIs that apply Java's +127-UTF-16-code-unit metadata limit. One code unit takes at most three UTF-8 +bytes, so query decoding accepts that larger representation even though QWP +ingress enforces its 127-byte protocol limit.
+ConstConstConstMaximum table count representable by the ingress frame's uint16 header.
+ConstConstMatches the Java client's per-connection decompression safety cap.
+ConstConstReadonlyATTEMPT_FAILED: "attempt-failed"ReadonlyCONNECTED: "connected"ReadonlyDURABLE_ACK_PERSISTENT_FAILURE: "durable-ack-persistent-failure"An orphan exhausted its consecutive durable-ACK mismatch budget.
+ReadonlyDURABLE_ACK_UNAVAILABLE: "durable-ack-unavailable"An unbounded SF loop is waiting for durable-ACK-capable endpoints.
+ReadonlyFAILED_OVER: "failed-over"ReadonlyPRIMARY_UNAVAILABLE: "primary-unavailable"Every reachable ingress endpoint is temporarily unable to be primary.
+ReadonlyRECONNECTED: "reconnected"ReadonlyRECONNECTING: "reconnecting"ConstConstReadonlyCANCELLED: "cancelled"ReadonlyDATA_LOSS: "data-loss"ReadonlyDICTIONARY_GAP: "dictionary-gap"ReadonlyINTERNAL_ERROR: "internal-error"ReadonlyLIMIT_EXCEEDED: "limit-exceeded"ReadonlyNOT_WRITABLE: "not-writable"ReadonlyPARSE_ERROR: "parse-error"ReadonlyPROTOCOL_VIOLATION: "protocol-violation"ReadonlySCHEMA_MISMATCH: "schema-mismatch"ReadonlySECURITY_ERROR: "security-error"ReadonlyUNKNOWN: "unknown"ReadonlyWRITE_ERROR: "write-error"ConstReadonlyABANDONED: "abandoned"ReadonlyRETRIABLE: "retriable"ReadonlyRETRIABLE_OTHER: "retriable-other"ReadonlyTERMINAL: "terminal"ConstReadonlyPRIMARY: 1ReadonlyPRIMARY_CATCHUP: 3ReadonlyREPLICA: 2ReadonlySTANDALONE: 0ConstReadonlyCANCELLED: 10ReadonlyDICTIONARY_GAP: 13ReadonlyDURABLE_ACK: 2ReadonlyINTERNAL_ERROR: 6ReadonlyLIMIT_EXCEEDED: 11ReadonlyNOT_WRITABLE: 12ReadonlyOK: 0ReadonlyPARSE_ERROR: 5ReadonlySCHEMA_MISMATCH: 3ReadonlySECURITY_ERROR: 8ReadonlySERVER_INFO: 1ReadonlyWRITE_ERROR: 9ConstReadonlyANY: "any"ReadonlyPRIMARY: "primary"ReadonlyREPLICA: "replica"ConstReadonlyAUTHENTICATION: "authentication"ReadonlyCAPABILITY_MISMATCH: "capability-mismatch"ReadonlyHTTP_REJECTED: "http-rejected"ReadonlyOPAQUE: "opaque"Browser WebSocket APIs do not expose the rejected HTTP upgrade.
+ReadonlyROLE_REJECTED: "role-rejected"ReadonlyTIMEOUT: "timeout"ReadonlyTRANSPORT: "transport"ReadonlyVERSION_MISMATCH: "version-mismatch"ConstReadonlyAUTHENTICATION: "authentication"ReadonlyCONNECT: "connect"ConstConstConstConstReadonlyBINARY: 23ReadonlyBOOLEAN: 1ReadonlyBYTE: 2ReadonlyCHAR: 22ReadonlyDATE: 11ReadonlyDECIMAL128: 20ReadonlyDECIMAL256: 21ReadonlyDECIMAL64: 19ReadonlyDOUBLE: 7ReadonlyDOUBLE_ARRAY: 17ReadonlyFLOAT: 6ReadonlyGEOHASH: 14ReadonlyINT: 4ReadonlyIPV4: 24ReadonlyLONG: 5ReadonlyLONG_ARRAY: 18ReadonlyLONG256: 13ReadonlySHORT: 3ReadonlySYMBOL: 9ReadonlyTIMESTAMP: 10ReadonlyTIMESTAMP_NANOS: 16ReadonlyUUID: 12ReadonlyVARCHAR: 15ConstReadonlyRAW: 0ReadonlyZSTD: 1ConstMaximum DECIMAL scale of each fixed-width decimal column type.
+Readonlydecimal128: 38Readonlydecimal256: 76Readonlydecimal64: 18ConstDefault decoded result-buffer pool depth, matching the Java client.
+ConstDefault send-ahead credit used by Java and TypeScript: zero is unbounded.
+ConstDefault wait for the initial or reconnected SERVER_INFO frame.
+ConstBrowser-visible WebSocket subprotocol used to request and confirm durable +ingress acknowledgements. Browsers cannot set or inspect X-QWP-* headers.
+ConstReadonlyCOMPRESSION: 4ReadonlyQUERY_FLAGS: 2ReadonlyZONE: 1ConstReadonlyCACHE_RESET: 23ReadonlyCANCEL: 20ReadonlyCREDIT: 21ReadonlyEXEC_DONE: 22ReadonlyQUERY_ERROR: 19ReadonlyQUERY_REQUEST: 16ReadonlyRESULT_BATCH: 17ReadonlyRESULT_END: 18ReadonlySERVER_INFO: 24ConstConstConstConstConstConstTable-less ingress control frame that polls negotiated durable-ACK progress.
+ConstConstConstConstConstReadonlyACKNOWLEDGED: "acknowledged"ReadonlyDURABLE_ACKNOWLEDGED: "durable-acknowledged"ReadonlyPUBLISHED: "published"ConstInitial connection policy for an ingress reconnect session. Public browser +and memory-only helpers resolve their default internally; Node persistent +store-and-forward exposes all three modes.
+ReadonlyASYNC: "async"Return immediately and connect on the background replay loop.
+ReadonlyOFF: "off"Try once on the caller and fail immediately.
+ReadonlySYNC: "sync"Retry on the caller within the configured reconnect budget.
+ConstASCII QWP1, represented as its little-endian uint32 value.
ConstMaximum array rank accepted by QuestDB's QWP ingress decoder.
+ConstMaximum signed int32 array-axis length accepted by QWP ingress.
+ConstLargest client-requested egress RESULT_BATCH row cap.
+ConstLargest rowCount * columnCount a single RESULT_BATCH may declare.
The row and column caps above bound each dimension on its own, and their
+product does not have to be reachable: 1,048,576 rows of 2,048 columns is
+2.1 billion cells. Decoding materializes two rowCount-length arrays per
+column, measured at 16 bytes per cell, so the product is what decides how
+much memory a response can cost. It is also the dimension a compressed body
+detaches from the wire: an all-NULL column is one bit per cell before zstd,
+so without this bound a few kilobytes of RLE-compressed bitmap declares a
+grid no heap can hold.
32Mi cells is roughly 512 MB decoded. That is far above any plausible +result -- the widest supported table at 16k rows, or a full 1,048,576-row +batch at 32 columns -- and far below what the caps alone would permit.
+ConstConstDefault QWP ingress identifier limits, in UTF-8 wire bytes.
+ConstDefensive byte bound for identifiers decoded from query results.
+Existing tables may have names created through APIs that apply Java's +127-UTF-16-code-unit metadata limit. One code unit takes at most three UTF-8 +bytes, so query decoding accepts that larger representation even though QWP +ingress enforces its 127-byte protocol limit.
+ConstConstConstMaximum table count representable by the ingress frame's uint16 header.
+ConstConstMatches the Java client's per-connection decompression safety cap.
+ConstReadonlyDISCOVERED: "discovered"ReadonlyDRAINED: "drained"ReadonlyDURABLE_ACK_PERSISTENT_FAILURE: "durable-ack-persistent-failure"ReadonlyDURABLE_ACK_UNAVAILABLE: "durable-ack-unavailable"ReadonlyFAILED: "failed"ReadonlyLOCKED: "locked"ReadonlyPRIMARY_UNAVAILABLE: "primary-unavailable"ReadonlyRETRYING: "retrying"The attempt or terminal-marker write failed and will be retried.
+ReadonlySCAN_FAILED: "scan-failed"ReadonlySTARTED: "started"ConstJava-compatible marker that excludes a failed slot from automatic drain.
+ConstConstReadonlyATTEMPT_FAILED: "attempt-failed"ReadonlyCONNECTED: "connected"ReadonlyDURABLE_ACK_PERSISTENT_FAILURE: "durable-ack-persistent-failure"An orphan exhausted its consecutive durable-ACK mismatch budget.
+ReadonlyDURABLE_ACK_UNAVAILABLE: "durable-ack-unavailable"An unbounded SF loop is waiting for durable-ACK-capable endpoints.
+ReadonlyFAILED_OVER: "failed-over"ReadonlyPRIMARY_UNAVAILABLE: "primary-unavailable"Every reachable ingress endpoint is temporarily unable to be primary.
+ReadonlyRECONNECTED: "reconnected"ReadonlyRECONNECTING: "reconnecting"ConstConstReadonlyCANCELLED: "cancelled"ReadonlyDATA_LOSS: "data-loss"ReadonlyDICTIONARY_GAP: "dictionary-gap"ReadonlyINTERNAL_ERROR: "internal-error"ReadonlyLIMIT_EXCEEDED: "limit-exceeded"ReadonlyNOT_WRITABLE: "not-writable"ReadonlyPARSE_ERROR: "parse-error"ReadonlyPROTOCOL_VIOLATION: "protocol-violation"ReadonlySCHEMA_MISMATCH: "schema-mismatch"ReadonlySECURITY_ERROR: "security-error"ReadonlyUNKNOWN: "unknown"ReadonlyWRITE_ERROR: "write-error"ConstReadonlyABANDONED: "abandoned"ReadonlyRETRIABLE: "retriable"ReadonlyRETRIABLE_OTHER: "retriable-other"ReadonlyTERMINAL: "terminal"ConstReadonlyPRIMARY: 1ReadonlyPRIMARY_CATCHUP: 3ReadonlyREPLICA: 2ReadonlySTANDALONE: 0ConstReadonlyERROR: "error"ReadonlyWAIT: "wait"ConstReadonlyAPPEND: "append"ReadonlyMEMORY: "memory"ReadonlyPERIODIC: "periodic"ConstReadonlyCANCELLED: 10ReadonlyDICTIONARY_GAP: 13ReadonlyDURABLE_ACK: 2ReadonlyINTERNAL_ERROR: 6ReadonlyLIMIT_EXCEEDED: 11ReadonlyNOT_WRITABLE: 12ReadonlyOK: 0ReadonlyPARSE_ERROR: 5ReadonlySCHEMA_MISMATCH: 3ReadonlySECURITY_ERROR: 8ReadonlySERVER_INFO: 1ReadonlyWRITE_ERROR: 9ConstReadonlyANY: "any"ReadonlyPRIMARY: "primary"ReadonlyREPLICA: "replica"ConstReadonlyAUTHENTICATION: "authentication"ReadonlyCAPABILITY_MISMATCH: "capability-mismatch"ReadonlyHTTP_REJECTED: "http-rejected"ReadonlyOPAQUE: "opaque"Browser WebSocket APIs do not expose the rejected HTTP upgrade.
+ReadonlyROLE_REJECTED: "role-rejected"ReadonlyTIMEOUT: "timeout"ReadonlyTRANSPORT: "transport"ReadonlyVERSION_MISMATCH: "version-mismatch"ConstReadonlyAUTHENTICATION: "authentication"ReadonlyCONNECT: "connect"ConstConstConst
HTTP transport implementation using Node.js built-in http/https modules.
--Supports both HTTP and HTTPS protocols with configurable authentication.