cassandra-cpp-sys 0.10.0

A bindgen-generated Rust wrapper around the DataStax Cassandra C++ driver plus working examples. You probably want to use the "cassandra-cpp" crate which provides a safe wrapper.
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

// #![feature(plugin)]
// #![plugin(clippy)]

extern crate cassandra_cpp_sys;

use std::mem;
use std::ffi::CString;

use cassandra_cpp_sys::*;

fn main() {
    unsafe {
        // Setup and connect to cluster
        let cluster = cass_cluster_new();
        let session = cass_session_new();

        // Add contact points
        cass_cluster_set_contact_points(cluster, CString::new("127.0.0.1").unwrap().as_ptr());

        // Provide the cluster object as configuration to connect the session
        let connect_future = cass_session_connect(session, cluster);

        let result = match cass_future_error_code(connect_future) {
            CASS_OK => {
                // Build statement and execute query
                let query = "SELECT keyspace_name FROM system_schema.keyspaces;";
                let statement = cass_statement_new(CString::new(query).unwrap().as_ptr(), 0);

                let result_future = cass_session_execute(session, statement);

                match cass_future_error_code(result_future) {
                    CASS_OK => {
                        // Retrieve result set and iterate over the rows
                        let result = cass_future_get_result(result_future);
                        let rows = cass_iterator_from_result(result);

                        while cass_iterator_next(rows) == cass_true {
                            let row = cass_iterator_get_row(rows);
                            let value = cass_row_get_column_by_name(row,
                                                                    CString::new("keyspace_name").unwrap().as_ptr());

                            let mut keyspace_name = mem::zeroed();
                            let mut keyspace_name_length = mem::zeroed();
                            cass_value_get_string(value, &mut keyspace_name, &mut keyspace_name_length);
                            println!("keyspace_name: {:?}",
                                     raw2utf8(keyspace_name, keyspace_name_length).unwrap());
                        }

                        cass_result_free(result);
                        cass_iterator_free(rows);
                    }
                    rc => {
                        // Handle error
                        let mut message = mem::zeroed();
                        let mut message_length = mem::zeroed();
                        cass_future_error_message(result_future, &mut message, &mut message_length);
                        println!("Unable to run query: {:?}",
                                 raw2utf8(message, message_length));
                    }
                }

                cass_statement_free(statement);
                cass_future_free(result_future);

                // Close the session
                let close_future = cass_session_close(session);
                cass_future_wait(close_future);
                cass_future_free(close_future);
            }
            rc => {
                // Handle error
                let mut message = mem::zeroed();
                let mut message_length = mem::zeroed();
                cass_future_error_message(connect_future, &mut message, &mut message_length);
                println!("Unable to connect: {:?}", raw2utf8(message, message_length));
            }
        };



    };



}