Expand description
Async Rust driver for the Scylla database written in Rust. Although optimized for Scylla, the driver is also compatible with Apache Cassandra®.
§Documentation book
The best source to learn about this driver is the documentation book.
This page contains mainly API documentation
§Other documentation
§Driver overview
§Connecting
All driver activity revolves around the Session
Session
is created by specifying a few known nodes and connecting to them:
use scylla::{Session, SessionBuilder};
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let session: Session = SessionBuilder::new()
.known_node("127.0.0.1:9042")
.known_node("1.2.3.4:9876")
.build()
.await?;
Ok(())
}
Session
is usually created using the SessionBuilder.
All configuration options for a Session
can be specified while building.
§Making queries
After successfully connecting to the cluster we can make queries.
The driver supports multiple query types:
- Simple
- Simple paged
- Prepared (need to be prepared before use)
- Prepared paged
- Batch
To specify options for a single query create the query object and configure it:
- For simple: Query
- For prepared: PreparedStatement
- For batch: Batch
The easiest way to specify bound values in a query is using a tuple:
// Insert an int and text into the table
session
.query_unpaged(
"INSERT INTO ks.tab (a, b) VALUES(?, ?)",
(2_i32, "some text")
)
.await?;
But the driver will accept anything implementing the trait SerializeRow.
§Receiving results
The easiest way to read rows returned by a query is to cast each row to a tuple of values:
// Read rows containing an int and text
// Keep in mind that all results come in one response (no paging is done!),
// so the memory footprint and latency may be huge!
// To prevent that, use `Session::query_iter` or `Session::query_single_page`.
let query_rows = session
.query_unpaged("SELECT a, b FROM ks.tab", &[])
.await?
.into_rows_result()?;
for row in query_rows.rows()? {
// Parse row as int and text \
let (int_val, text_val): (i32, &str) = row?;
}
See the book for more receiving methods
Re-exports§
pub use statement::batch;
pub use statement::prepared_statement;
pub use statement::query;
pub use transport::execution_profile::ExecutionProfile;
pub use transport::legacy_query_result::LegacyQueryResult;
Deprecated pub use transport::query_result::QueryResult;
pub use transport::query_result::QueryRowsResult;
pub use transport::session::IntoTypedRows;
pub use transport::session::LegacySession;
Deprecated pub use transport::session::Session;
pub use transport::session::SessionConfig;
pub use transport::session_builder::SessionBuilder;
pub use transport::session_builder::CloudSessionBuilder;
cloud
pub use transport::execution_profile;
pub use transport::host_filter;
pub use transport::load_balancing;
pub use transport::retry_policy;
pub use transport::speculative_execution;
Modules§
- cloud
cloud
- Deserializing DB response containing CQL query results.
- Collecting history of query executions - retries, speculative, etc.
- Serializing bound values of a query to be sent to the DB.
Macros§
- This macro implements FromCqlVal given a type and method of CqlValue that returns this type.
- Implements the
SerializeRow
trait for a type, provided that the type already implements the legacyValueList
trait. - Implements the
SerializeValue
trait for a type, provided that the type already implements the legacyValue
trait.
Structs§
- A cheaply cloneable and sliceable chunk of contiguous memory.
- A unique reference to a contiguous slice of memory.
- Provides auto caching while executing queries
Traits§
- A trait for values that provide sequential write access to bytes.
- FromRow
Deprecated This trait defines a way to convert CQL Row into some rust type
Type Aliases§
- Legacy
Caching Session Deprecated
Derive Macros§
- Derive macro for the
DeserializeRow
trait that generates an implementation which deserializes a row with a similar layout to the Rust struct. - Derive macro for the
DeserializeValue
trait that generates an implementation which deserializes a User Defined Type with the same layout as the Rust struct. - Derive macro for the
FromRow
trait which deserializes a row to given Rust structure. - #[derive(FromUserType)] allows to parse struct as a User Defined Type
- #[derive(IntoUserType)] allows to pass struct a User Defined Type Value in queries
- Derive macro for the
SerializeRow
trait which serializes given Rust structure into bind markers for a CQL statement. - Derive macro for the
SerializeValue
trait which serializes given Rust structure as a User Defined Type (UDT). - #[derive(ValueList)] allows to pass struct as a list of values for a query