Struct skytable::config::Config

pub struct Config { /* private fields */ }

Configuration for a Skytable connection

Implementations

impl Config

pub async fn connect_async(&self) -> ClientResult<ConnectionAsync>

Establish an async connection to the database using the current configuration

pub async fn connect_tls_async( &self, cert: &str ) -> ClientResult<ConnectionTlsAsync>

Establish an async TLS connection to the database using the current configuration. Pass the certificate in PEM format.

impl Config

pub fn new_default(username: &str, password: &str) -> Self

Create a new Config using the default connection settings and using the provided username and password

Examples found in repository

examples/custom_types.rs (line 44)

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

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64, null email: string"
    ))
    .unwrap();

    // insert data
    let our_user = User::new("myuser".into(), "pass123".into(), 0, None);
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?, ?)",
        our_user.clone()
    ))
    .unwrap();

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

    assert_eq!(our_user, ret_user);
}

examples/simple.rs (line 11)

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

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64"
    ))
    .unwrap();

    // manipulate data

    let (form_username, form_pass) = dummy_web_fetch_username_password();
    // insert some data
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?)",
        &form_username,
        form_pass,
        100_000_000u64
    ))
    .unwrap();

    // get it back
    let (password, followers): (String, u64) = db
        .query_parse(&query!(
            "select password, followers FROM myspace.mymodel WHERE username = ?",
            &form_username
        ))
        .unwrap();
    assert_eq!(password, "rick123", "password changed!");
    // send to our client
    dummy_respond_to_request(followers);

    // update followers to account for huge numbers who were angry after being rickrolled
    db.query_parse::<()>(&query!(
        "update myspace.mymodel SET followers -= ? WHERE username = ?",
        50_000_000u64,
        &form_username
    ))
    .unwrap();

    // alright, everyone is tired from being rickrolled so we'll have to ban rick's account
    db.query_parse::<()>(&query!(
        "delete from myspace.mymodel where username = ?",
        &form_username
    ))
    .unwrap();
}

pub fn new(host: &str, port: u16, username: &str, password: &str) -> Self

Create a new Config using the given settings

pub fn host(&self) -> &str

Returns the host setting for this this configuration

pub fn port(&self) -> u16

Returns the port setting for this this configuration

pub fn username(&self) -> &str

Returns the username setting for this this configuration

pub fn password(&self) -> &str

Returns the password set using this configuration

impl Config

pub fn connect(&self) -> ClientResult<Connection>

Establish a connection to the database using the current configuration

Examples found in repository

examples/custom_types.rs (line 45)

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

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64, null email: string"
    ))
    .unwrap();

    // insert data
    let our_user = User::new("myuser".into(), "pass123".into(), 0, None);
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?, ?)",
        our_user.clone()
    ))
    .unwrap();

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

    assert_eq!(our_user, ret_user);
}

examples/simple.rs (line 12)

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

    // set up schema
    // create space
    db.query_parse::<()>(&query!("create space myspace"))
        .unwrap();
    // create model
    db.query_parse::<()>(&query!(
        "create model myspace.mymodel(username: string, password: string, followers: uint64"
    ))
    .unwrap();

    // manipulate data

    let (form_username, form_pass) = dummy_web_fetch_username_password();
    // insert some data
    db.query_parse::<()>(&query!(
        "insert into myspace.mymodel(?, ?, ?)",
        &form_username,
        form_pass,
        100_000_000u64
    ))
    .unwrap();

    // get it back
    let (password, followers): (String, u64) = db
        .query_parse(&query!(
            "select password, followers FROM myspace.mymodel WHERE username = ?",
            &form_username
        ))
        .unwrap();
    assert_eq!(password, "rick123", "password changed!");
    // send to our client
    dummy_respond_to_request(followers);

    // update followers to account for huge numbers who were angry after being rickrolled
    db.query_parse::<()>(&query!(
        "update myspace.mymodel SET followers -= ? WHERE username = ?",
        50_000_000u64,
        &form_username
    ))
    .unwrap();

    // alright, everyone is tired from being rickrolled so we'll have to ban rick's account
    db.query_parse::<()>(&query!(
        "delete from myspace.mymodel where username = ?",
        &form_username
    ))
    .unwrap();
}

pub fn connect_tls(&self, cert: &str) -> ClientResult<ConnectionTls>

Establish a TLS connection to the database using the current configuration. Pass the certificate in PEM format.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Config

fn eq(&self, other: &Config) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Config