cartel-sqlite 0.31.0

SQLite driver for the dope runtime
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::api::stmt;
use std::{result, string, vec};

pub(super) trait Value {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error>;
}

trait Integer: Copy {
    fn widen(self) -> i64;
}

impl Integer for i32 {
    fn widen(self) -> i64 {
        i64::from(self)
    }
}

impl Integer for i64 {
    fn widen(self) -> i64 {
        self
    }
}

impl<T: Value> Value for Option<T> {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        match self {
            Some(value) => value.bind(binder, index),
            None => binder.bind_null(index),
        }
    }
}

impl<T: Integer> Value for T {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_integer(index, (*self).widen())
    }
}

impl Value for u64 {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        if *self > i64::MAX as u64 {
            return Err(crate::Error::ParameterU64 { value: *self });
        }
        binder.bind_integer(index, *self as i64)
    }
}

impl Value for usize {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        if *self > i64::MAX as usize {
            return Err(crate::Error::ParameterUsize { value: *self });
        }
        binder.bind_integer(index, *self as i64)
    }
}

impl Value for f64 {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_real(index, *self)
    }
}

impl Value for bool {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_integer(index, i64::from(*self))
    }
}

impl Value for &str {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_text(index, self)
    }
}

impl Value for &string::String {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_text(index, self.as_str())
    }
}

impl Value for &[u8] {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_blob(index, self)
    }
}

impl Value for &vec::Vec<u8> {
    fn bind<'value>(
        &'value self,
        binder: &mut stmt::Binder<'_, 'value>,
        index: i32,
    ) -> result::Result<(), crate::Error> {
        binder.bind_blob(index, self.as_slice())
    }
}