CDRS
CDRS is a native Cassandra driver written in Rust. The motivation to write it in Rust is a lack of native one. Existing ones are bindings to C clients.
CDRS is under active development at the moment, so API may not be stable.
As well CDRS provides tools for mapping results into Rust structures It supports 4-th version of Cassandra protocol.
Supported features
- lz4 decompression
- snappy decompression
- password authorization
Frames
Request
- STARTUP
- AUTH_RESPONSE
- OPTIONS
- QUERY
- PREPARE
- EXECUTE
- BATCH
- REGISTER
Response
- ERROR
- READY
- AUTHENTICATE
- SUPPORTED
- RESULT (Void)
- RESULT (Rows)
- RESULT (Set_keyspace)
- RESULT (Prepared)
- RESULT (Schema_change)
- EVENT
- AUTH_CHALLENGE
- AUTH_SUCCESS
Examples
Creating new connection and authorization
To use password authenticator, just include the one implemented in
cdrs::authenticators
.
use CDRS;
use PasswordAuthenticator;
After that you can create a new instace of CDRS
and establish new connection:
let authenticator = new;
let addr = "127.0.0.1:9042";
// pass authenticator into CDRS' constructor
let client = CDRS new.unwrap;
use compression;
// start session without compression
let mut session = try!;
If Server does not require authorization authenticator
won't be used, but is still
required for the constructor (most probably it will be refactored in future).
Using compression
Two types of compression are supported - snappy and lz4. To use compression just start connection with desired type:
// session without compression
let mut session_res = client.start;
// session lz4 compression
let mut session_res = client.start;
// v with snappy compression
let mut session_res = client.start;
Query execution
Query execution is provided in scope of Session. So to start executing queries you need to start Session first.
Use Query:
let use_query = String from;
match session.query
Select Query:
As a response to select query CDRS returns a result frame of type Rows with data items (columns) encoded in Cassandra's way. Currently there are decode helpers only, but no helper methods which could easily map results into Rust structures. To have them is a goal of first stable version of CDRS.
use Consistency;
use CBytes;
let select_query = String from;
// Query parameters:
let consistency = One;
let values: = None;
let with_names: = None;
let page_size: = None;
let paging_state = None;
let serial_consistency: = None;
let timestamp: = None;
match session.query
Select Query (mapping results):
Once CDRS got response to SELECT
query you can map rows encapsulated within
Result
frame into Rust values or into List
, Map
or UDT
helper structures
which provide a way to convert wrapped values into plain ones.
As an example let's consider a case when application gets a collection of messages of following format:
To get a collection of messages Vec<Message>
let's convert a result of query
into collection of rows Vec<cdrs::types::row::Row>
and then convert each column
into appropriate Rust type:
let res_body = parsed.get_body;
let rows = res_body.into_rows.unwrap;
let messages: = rows
.iter
.map
.collect;
There is no difference between Cassandra's List and Sets in terms of Rust.
They could be represented as Vec<T>
. To convert a frame into a structure
that contains a collection of elements do as follows:
//...
let res_body = parsed.get_body;
let rows = res_body.into_rows.unwrap;
let messages: = rows
.iter
.map
.collect;
License
The MIT License (MIT)
Copyright (c) 2016 Alex Pikalov
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.