rusqlite 0.9.3

Ergonomic wrapper for SQLite
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

use std::ffi::CStr;
use std::ptr;
use libc::c_int;
use super::ffi;

// Private newtype for raw sqlite3_stmts that finalize themselves when dropped.
#[derive(Debug)]
pub struct RawStatement(*mut ffi::sqlite3_stmt);

impl RawStatement {
    pub fn new(stmt: *mut ffi::sqlite3_stmt) -> RawStatement {
        RawStatement(stmt)
    }

    pub unsafe fn ptr(&self) -> *mut ffi::sqlite3_stmt {
        self.0
    }

    pub fn column_count(&self) -> c_int {
        unsafe { ffi::sqlite3_column_count(self.0) }
    }

    pub fn column_type(&self, idx: c_int) -> c_int {
        unsafe { ffi::sqlite3_column_type(self.0, idx) }
    }

    pub fn column_name(&self, idx: c_int) -> &CStr {
        unsafe { CStr::from_ptr(ffi::sqlite3_column_name(self.0, idx)) }
    }

    pub fn step(&self) -> c_int {
        unsafe { ffi::sqlite3_step(self.0) }
    }

    pub fn reset(&self) -> c_int {
        unsafe { ffi::sqlite3_reset(self.0) }
    }

    pub fn bind_parameter_count(&self) -> c_int {
        unsafe { ffi::sqlite3_bind_parameter_count(self.0) }
    }

    pub fn bind_parameter_index(&self, name: &CStr) -> Option<c_int> {
        let r = unsafe { ffi::sqlite3_bind_parameter_index(self.0, name.as_ptr()) };
        match r {
            0 => None,
            i => Some(i),
        }
    }

    pub fn clear_bindings(&self) -> c_int {
        unsafe { ffi::sqlite3_clear_bindings(self.0) }
    }

    pub fn sql(&self) -> &CStr {
        unsafe { CStr::from_ptr(ffi::sqlite3_sql(self.0)) }
    }

    pub fn finalize(mut self) -> c_int {
        self.finalize_()
    }

    fn finalize_(&mut self) -> c_int {
        let r = unsafe { ffi::sqlite3_finalize(self.0) };
        self.0 = ptr::null_mut();
        r
    }
}

impl Drop for RawStatement {
    fn drop(&mut self) {
        self.finalize_();
    }
}