Crate skytable

Skytable driver

This is Skytable’s official client driver for Rust that you can use to build applications. The client-driver is distributed under the liberal Apache-2.0 License and hence you can use it in your applications without any licensing issues.

Definitive example

use skytable::{Query, Response, Config, query};

#[derive(Query, Response)]
#[derive(Clone, PartialEq, Debug)] // we just do these for the assert (they are not needed)
struct User {
    userid: String,
    pass: String,
    followers: u64,
    email: Option<String>
}

let our_user = User { userid: "user".into(), pass: "pass".into(), followers: 120, email: None };

let mut db = Config::new_default("username", "password").connect().unwrap();

// insert data
let q = query!("insert into myspace.mymodel(?, ?, ?, ?)", our_user.clone());
db.query_parse::<()>(&q).unwrap();

// select data
let user: User = db.query_parse(&query!("select * from myspace.mymodel where username = ?", &our_user.userid)).unwrap();
assert_eq!(user, our_user);

Getting started

Make sure you have Skytable set up. If not, follow the official installation guide here and then come back here.

Let’s run our first query. Connections are set up using the Config object and then we establish a connection by calling Config::connect or use other functions for different connection configurations (for TLS or async).

use skytable::{Config, query};
let mut db = Config::new_default("username", "password").connect().unwrap();
// the query `sysctl report status` returns a `Response::Empty` indicating that everything is okay. This is equivalent to
// rust's unit type `()` so that's what the driver uses
db.query_parse::<()>(&query!("sysctl report status")).unwrap();

We used the query! macro above which allows us to conveniently create queries when we don’t need to handle complex cases and we have a fixed number of arguments.

Diving in

Now let’s say that we have a model create model myspace.mymodel(username: string, password: string, followers: uint64) and we want to do some DML operations. Here’s how we do it.

use skytable::{Config, query};
let mut db = Config::new_default("username", "password").connect().unwrap();

let insert_query = query!("insert into myspace.mymodel(?, ?, ?)", "sayan", "pass123", 1_500_000_u64);
db.query_parse::<()>(&insert_query).unwrap(); // insert will return empty on success

let select_query = query!("select password, followers FROM myspace.mymodel WHERE username = ?", "sayan");
let (pass, followers): (String, u64) = db.query_parse(&select_query).unwrap();
assert_eq!(pass, "pass123");
assert_eq!(followers, 1_500_000_u64);

let update_query = query!("update myspace.mymodel set followers += ? where username = ?", 1u64, "sayan");
db.query_parse::<()>(&update_query).unwrap(); // update will return empty on success

Now you’re ready to run your own queries!

Going advanced

You can use the Query and Response derive macros to directly pass complex types as parameters and read as responses. This should cover most of the general use-cases (otherwise you can manually implement them).

• Custom query generation
• Custom response parsing
• Connection pooling

Need help? Get help!

Jump into Skytable’s official Discord server where maintainers, developers and fellow users help each other out.

Re-exports

• pub use aio::ConnectionAsync;
• pub use aio::ConnectionTlsAsync;
• pub use config::Config;
• pub use error::ClientResult;
• pub use query::Query;
• pub use syncio::Connection;
• pub use syncio::ConnectionTls;

Modules

• aio
  Asynchronous database I/O
• config
  Configuration
• error
  Client errors
• pool
  Connection pooling
• query
  Queries
• response
  Responses
• syncio
  Synchronous database I/O

Macros

• query
  This macro can be used to create a Query, almost like a variadic function

Derive Macros

• Query
  The Query derive macro enables you to directly pass complex types as parameters into queries
• Response
  The Response derive macro enables you to directly pass complex types as parameters into queries