cdrs 2.2.0

Cassandra DB driver written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#[macro_use]
extern crate cdrs;
#[macro_use]
extern crate cdrs_helpers_derive;

use std::sync::Arc;
use std::thread;

use cdrs::authenticators::NoneAuthenticator;
use cdrs::cluster::session::{new as new_session, Session};
use cdrs::cluster::{ClusterTcpConfig, NodeTcpConfigBuilder, TcpConnectionPool};
use cdrs::load_balancing::RoundRobinSync;
use cdrs::query::*;

use cdrs::frame::IntoBytes;
use cdrs::types::from_cdrs::FromCDRSByName;
use cdrs::types::prelude::*;

type CurrentSession = Session<RoundRobinSync<TcpConnectionPool<NoneAuthenticator>>>;

fn main() {
  let node = NodeTcpConfigBuilder::new("127.0.0.1:9042", NoneAuthenticator {}).build();
  let cluster_config = ClusterTcpConfig(vec![node]);
  let lb = RoundRobinSync::new();
  let no_compression: Arc<CurrentSession> =
    Arc::new(new_session(&cluster_config, lb).expect("session should be created"));

  create_keyspace(&no_compression.clone());
  create_table(&no_compression.clone());

  for i in 0..20 {
    let thread_session = no_compression.clone();
    thread::spawn(move || {
      insert_struct(&thread_session, i);
    }).join()
      .expect("thread error");
  }

  select_struct(&no_compression);
}

#[derive(Clone, Debug, IntoCDRSValue, TryFromRow, PartialEq)]
struct RowStruct {
  key: i32,
}

impl RowStruct {
  fn into_query_values(self) -> QueryValues {
    query_values!("key" => self.key)
  }
}

#[derive(Debug, Clone, PartialEq, IntoCDRSValue, TryFromUDT)]
struct User {
  username: String,
}

fn create_keyspace(session: &CurrentSession) {
  let create_ks: &'static str = "CREATE KEYSPACE IF NOT EXISTS test_ks WITH REPLICATION = { \
                                 'class' : 'SimpleStrategy', 'replication_factor' : 1 };";
  session.query(create_ks).expect("Keyspace creation error");
}

fn create_table(session: &CurrentSession) {
  let create_table_cql =
    "CREATE TABLE IF NOT EXISTS test_ks.multi_thread_table (key int PRIMARY KEY);";
  session
    .query(create_table_cql)
    .expect("Table creation error");
}

fn insert_struct(session: &CurrentSession, key: i32) {
  let row = RowStruct { key };

  let insert_struct_cql = "INSERT INTO test_ks.multi_thread_table (key) VALUES (?)";
  session
    .query_with_values(insert_struct_cql, row.into_query_values())
    .expect("insert");
}

fn select_struct(session: &CurrentSession) {
  let select_struct_cql = "SELECT * FROM test_ks.multi_thread_table";
  let rows = session
    .query(select_struct_cql)
    .expect("query")
    .get_body()
    .expect("get body")
    .into_rows()
    .expect("into rows");

  for row in rows {
    let my_row: RowStruct = RowStruct::try_from_row(row).expect("into RowStruct");
    println!("struct got: {:?}", my_row);
  }
}