5.1.0 (yanked)

Yanked release

There are no reported bugs, but this release has some behaviour and usability inconsistencies with nanoseconds behaviour and 9.1.0 in what precision is used by the server for messages sent by the client between the designated timestamp and other timestamp columns behaving differently. We will release 6.0.0 shortly which will make using nanosecond timestamps more consistent.

Overview

This is a very small release which adds support for nanosecond-precision columns.

Features

From QuestDB 9.1.0 you can use CREATE TABLE SQL statement with TIMESTAMP_NANO column types,
and/or configure the database to use nanosecond precision designated timestamp columns by setting the line.timestamp.default.column.type=TIMESTAMP_NANO config option in server.conf.

This client release adds support for sending timestamps to the server without loss of precision.

The change is backwards compatible with older QuestDB versions and does not introduce new APIs.

Full Changelog: 5.0.0...5.1.0

5.0.0

Overview

This release adds a new protocol version that brings support for N-dimensional arrays and faster serialization of doubles.

It stabilizes the features first introduced with version 5.0.0-rc1.

Features

• You can now ingest the ARRAY datatype when connected to QuestDB 9.0.0 or newer. It uses a new protocol_version=2.
• This new protocol version is auto-negotiated when using HTTP and needs to be enabled manually for ILP/TCP.
• The new protocol version also serializes doubles (f64) as binary for better performance.
• Updated to the latest snapshot of the https://www.ccadb.org/ root TLS certificates by updating the webpki-roots dependency.
• Internally, we've upgraded to the latest ureq Rust library version 3 to perform HTTP requests.

Bug Fixes

• Fixed a Windows ILP/TCP bug where some rows could be lost when the client shuts down the connection.

Breaking Changes

• Previously, you could peek into the serialized state of a Buffer object and it would expose a UTF-8 string.
  Since protocol version 2 is now binary, the exposed data is now binary for protocol version 2
  while it remains UTF-8 for protocol version 1. The C, C++ and Rust APIs have been changed to return a view into the buffered bytes.

Rust

There are also a few Rust-specific changes.

• Added optional integration with the ndarray crate via ndarray feature flag.
• Added support for the aws-lc cryptographic backend for TLS and TCP auth. You can select it via feature flags. The AWS-LC backend is mutually exclusive with the Ring backend.
• You can now also check if a buffer is ready to be sent via the .check_can_flush() method (Thank you @ischeinkman).
• You can now selectively disable compiling support for ILP/TCP via feature flags.
• Thus, the ilp-over-http feature flag is removed: Use the sync-sender-tcp or sync-sender-http (or both) feature flags as needed.

Full Changelog: 4.0.5...5.0.0

4.0.5

What's Changed

This release ships a performance improvement which avoids memory allocations when setting a marker on a buffer object.
Details are in #108

Full Changelog: 4.0.4...4.0.5

5.0.0-rc1

Overview

This is a pre-release version that adds a new protocol version which adds new features.

Features

• When using protocol 2 (which is automatically enabled if connecting over HTTP and the server supports it):
  • Sending floating point data is now done over binary with reduced overhead
  • New added support for ingesting 64-bit float multi-dimensional arrays targeting the upcoming ARRAY datatype in QuestDB.
• In Rust, we've optionally (see feature flag) added integration for sending arrays from the ndarray crate.
• Internally, we've upgraded to the latest ureq rust library version 3 to perform HTTP requests.
• In Rust we've also optionally added the aws-lc cryptographic backend for TLS and TCP auth. You can select it via feature flags.
• We have internally updated the webpki-roots crate which uses an updated set of root TLS certificates.
• You can now also check if a buffer is ready to be sent via the .check_can_flush() method (Thank you @ischeinkman).

Breaking Changes

• Previously, you could peek into the serialized state of a Buffer object and it would expose a UTF-8 string.
  Since protocol version 2 is now binary, the APIs have been updated and the exposed data is binary for protocol version 2
  while it remains UTF-8 for protocol version 1.

Full Changelog: 4.0.4...5.0.0-rc1

4.0.4

What's Changed

In this release we've fixed a C++ build issue due to an incompatibility in the newest release of the Rust tool rustup.

• CMake "corrosion" library upgraded to 0.5.1, fixing C++ build issues.
• Various minor documentation fixes.

Full Changelog: 4.0.3...4.0.4

4.0.3

What's Changed

In this release, we have addressed a significant issue related to a version conflict with rustls library, which was causing compilation errors in Rust projects using our client. Here are the detailed changes:

• ureq library pinned to 2.9. This is a workaround for algesten/ureq#765
• Enforce request timeout greater than zero. #74

Full Changelog: 4.0.2...4.0.3

4.0.2

What's Changed

• bug: HTTP timeout wasn't applied to the TCP connection phase

Full Changelog: 4.0.1...4.0.2

4.0.1

What's Changed

• Significant improvement in the Rustdoc documentation
• ilp-over-http is now a default feature flag, improving the quick start experience

Full Changelog: 4.0.0...4.0.1

4.0.0

Features

This release introduces a number of changes, including major new features and a few breaking changes in the Rust, C and C++ APIs.

Introduction of ILP over HTTP Support

The library now supports InfluxDB Line Protocol (ILP) over HTTP in addition to the existing TCP protocol.

• ILP/HTTP allows for better error feedback and control over transactions and is the recommended for both existing and new users.
• ILP/HTTP introduces basic (username/password) and token (bearer) authentication.

// C++
auto sender = questdb::ingress::sender::from_conf("http::addr=localhost:9000;token=auth_token;");

Configuration via String or Environment Variable

Users can now configure the client by passing a configuration string or via an environment variable (QDB_CLIENT_CONF). This provides a more flexible and convenient way to configure the client. This new approach is being adopted for all our client libraries.

// Rust
let sender = Sender::from_conf("tcp::addr=localhost:9009;")?

The builder/opts APIs remain available.

Transaction Support

The library introduces transactional flushes for ILP over HTTP, allowing users to ensure that all rows in a flush request refer to the same table, treating the request as a single transaction. This feature is allows for use cases where ingestion atomicity is required.

Reliability Enhancements

The ILP over HTTP implementation includes features like configurable request timeouts, retry mechanisms, and minimum expected throughput settings to improve the performance and reliability of data transmission.

Buffer Row Count

You can ask the buffer how many rows it has recorded by calling its .row_count() method.

Breaking Changes

.connect() renamed to .build()

When using the builder/opts API, the connect method has been renamed to build.

This is because when connecting via HTTP, the connection to the database is made lazily at the first flush.

TCP Auth API Changes

The ILP/TCP .auth(username, token, token_x, token_y) method which took for parameters has been expanded to four different settings.

From conf:

// Rust
let sender = Sender::from_conf("tcps::addr=localhost:9009;username=u;token=t;token_x=x;token_y=y;");

Programmatically:

// Rust
let sender = SenderBuilder::new(Protocol::Tcps, "localhost", 9009)
    .username("u")?
    .token("t")?
    .token_x("x")?
    .token_y("y")?
    .build()?;

TLS configuration parameters

The .tls(...) API has been removed and replaced with:

• tls_ca which takes an enum (webpki, os, webpki+os, pem_file)
• tls_roots replaces the old tls_ca API.
• tls_verify(false) replaces the older insecure_skip_verify API.

net_interface -> bind_interface

The TCP-only setting for binding the outbound network interface has been renamed to bind_interface.
This feature is no longer available when using HTTP. Raise an issue if this is something you require.

Full changelog: 3.1.0...4.0.0

3.1.0

What's Changed

This release adds support for reading TLS CA root certificates from the host operating system.
The default remains to use the root certificates provided by the webpki-roots Rust crate.
The TLS negotiation is still performed by using the rustls Rust crate, and not using OpenSSL or other OS-specific TLS APIs.

This new feature is particularly valuable when using QuestDB Enterprise in corporate environments where the set of trusted root CA certificates is custom to the organisation and deployed to each OS's root CA certificate store.

To enable this feature:

If programming in Rust:

SenderBuilder::new(...)
    .tls(Tls::Enabled(CertificateAuthority::OsRoots))

If programming in C:

line_sender_opts* opts = ...;
line_sender_opts_tls_os_roots(opts);

If programming in C++:

questdb::ingress::opts opts{...};
opts.tls_os_roots(opts);

Full Changelog: 3.0.0...3.1.0