scylla-rust-driver

• CDC partitioner support was added
• tower integration example was added
• CQL type parser was rewritten to recursive-descent, to properly handle nested types
• failing to fetch metadata is now non-fatal
• uuid and dashmap dependencies were updated
• the driver now officially declares its minimum supported Rust version: 1.59
• CI is updated accordingly, to ensure that we work properly on the minimum Rust version

• added retrying in case of not being able to allocate a stream id
• added support for deserializing timestamps to i64
• added support for using Time struct as CqlValue, e.g. for serialization structs
• added support for Duration type (from CQL v5)
• added default page size (5000) for query_iter and execute_iter
• switched from deprecated max_value and min_value to ::MAX and ::MIN respectively
• added a new docs theme

• It's now possible to set up a keepalive interval for a session, which is useful for rarely used sessions (e.g. ones querying once an hour for statistical purposes)
• use_keyspace request now has a timeout, equal to the specified connect_timeout, with a default value of 5 seconds
• UDT fields from CqlValue can now be borrowed
• SerializedValuesIterator implementation got substantially simplified

• token aware policy is now capable of falling back to non-replicas, if none are available
• Value is implemented for slice &[T]
• more tracing logs are added

• fixed issue #392 - IoError used to lose context when it was propagated from lower layers and it's no longer the case

The Scylla team is pleased to announce Scylla Rust Driver 0.4.0,
an asynchronous CQL driver for Rust, optimized for Scylla, but also compatible with Apache Cassandra!

We're also excited to shamelessly brag about:

• over 10k downloads on crates;
• over 200 GitHub stars!

=== Notable changes ===

Non-standard partitioners used to cause the driver to fail - it's no longer the case, a fallback token policy will be used.

Maps and sets based on B-Trees can now be used as the source of their corresponding CQL types: map and set.

Getting column specification is now also possible for iterator-based queries.

It's now possible to inspect current schema information directly from the driver. The metadata includes tables, their columns, types, column kinds (regular, static, clustering/partition key), ordering of partition key and clustering columns, UDTs, partitioner, etc. Fetching schemas can be optionally disabled when building a session.

Request ids orphaned by timeouts are now accounted for and managed. When a request times out, its request id cannot be immediately reused in order to avoid matching responses with incorrect requests (e.g. see an interesting bug lately discovered in Python CQL driver: https://github.com/scylladb/python-driver/pull/106). Scylla Rust Driver now properly tracks which requests got orphaned and returns them to the pool only once it's safe to do so.

Batched requests used to fail when one or more statements turned out to be not prepared on the server side. The new heuristics tries to reprepare all missing statements and retry the execution.

Named bind markers are now supported. It's still recommended to use unnamed markers for binding variables in statements (?) since they induce less overhead, but the named syntax (:name) is now also accepted.

A visibility bug in the load balancing layer made it impossible to actually implement custom load balancing policies. It's now fixed, and custom policies can be coded by implementing the LoadBalancingPolicy trait.

A number of convenience functions were added in order to make it more ergonomic to manage query results: rows_num, rows, rows_typed, result_not_rows, rows_or_empty, rows_typed_or_empty, first_row, first_row_typed, maybe_first_row, maybe_first_row_typed, single_row, single_row_typed.

Also, as usual, many fixes, smaller amendments, examples and doc updates were applied.

Congrats to all contributors and thanks everyone for using our driver!

=======================

The source code of the driver can be found here:

• https://github.com/scylladb/scylla-rust-driver
  Contributions are most welcome!

The official crates.io registry entry is here:

• https://crates.io/crates/scylla

Thank you for your attention, please do not hesitate to contact us if you have any questions, issues, feature requests, or are simply interested in our driver!

Contributors since last release:
commits|author
24 Piotr Sarna
16 Jan Ciolek
12 Piotr Dulikowski
8 Marcin Mazurek
6 Michał Sala
3 nemosupremo
3 Maciej Herdon
2 Jan Ciołek
1 Ultrabug
1 guy9
1 Creston Bunch
1 Adam Boguszewski

• performance improvements by applying buffering to reads and writes
• CqlFromValue for HashSet

he Scylla team is pleased to announce Scylla Rust Driver 0.3.0,
an asynchronous CQL driver for Rust, optimized for Scylla, but also compatible with Apache Cassandra!

Notable changes

• Connection management is heavily revamped:
  • a configurable pool of connections is kept per node or per shard (Scylla only)
  • shard awareness is now also supported without a dedicated shard-aware port (Scylla only)
  • several optimizations were applied to make this layer more robust
• A CachingSession class is introduced - it allows creating a session which automatically prepares its statements
  and maintains them in a local cache.
• Colummn values can now be extracted from result rows by the column name, not only by their index.
• Handling user defined types is improved - when a new field is added to the type, the driver is now still capable of reading the values.
• A ValueList derive macro is now available - when it's applied to a struct, an instance of this struct can be used as a list of values in queries.
• Client-side timestamps can now be defined for queries.
• Tuples with null elements are now handled correctly.
• Serial consistency level (for lightweight transactions) is now split into a separate type in order to make it clear that it should not be mixed with regular consistency level.
• Shorter topology names, e.g. "SimpleStrategy" are now recognized and accepted.
• Internal queries now use paging internally in order to avoid overloading the cluster and the driver with large requests.
• Serialization path got optimized.
• lots of other fixes and improvements

Congrats to all contributors and thanks everyone for using our driver!

The (extended) Scylla team is pleased to announce the first release of Scylla Rust Driver 0.1.0 - a brand new, asynchronous CQL driver for Rust, optimized for Scylla, but also compatible with Apache Cassandra!

Our new driver is capable of the following, and much more:

• Asynchronous API based on Tokio (tokio.rs)
• Token-aware routing
• Shard-aware routing (specific to Scylla)
• Prepared statements
• Query paging
• Compression (LZ4 and Snappy algorithms)
• CQL binary protocol version 4
• Batch statements
• Configurable load balancing policies
• Driver-side metrics
• TLS support (based on openssl)
• Configurable retry policies
• Authentication support
• CQL tracing

Crates:

• https://crates.io/crates/scylla
• https://crates.io/crates/scylla-macros