mool 0.2.0

A source-first Rust database toolkit for typed SQL queries, migrations, and model metadata
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
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
136
137
138
139
140
141
142
143
144

use std::any::Any;
use std::sync::Arc;

use super::commons::{Arguments, Database};

type ArgBinder =
    dyn Fn(&mut Arguments<'static>) -> Result<(), sqlx::error::BoxDynError> + Send + Sync;

#[derive(Clone)]
pub struct ArgValue {
    storage: ArgStorage,
}

#[derive(Clone)]
enum ArgStorage {
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    F32(f32),
    F64(f64),
    String(String),
    Dyn(Arc<ArgBinder>),
}

impl ArgValue {
    pub fn new<T>(val: T) -> Self
    where
        T: Clone
            + for<'q> sqlx::Encode<'q, Database>
            + sqlx::Type<Database>
            + Send
            + Sync
            + 'static,
    {
        if let Some(storage) = inline_storage(&val) {
            return Self { storage };
        }
        Self {
            storage: ArgStorage::Dyn(Arc::new(move |args| {
                use sqlx::Arguments as _;
                args.add(val.clone())
            })),
        }
    }

    pub fn bind_value(
        &self,
        args: &mut Arguments<'static>,
    ) -> Result<(), sqlx::error::BoxDynError> {
        use sqlx::Arguments as _;

        match &self.storage {
            ArgStorage::Bool(value) => args.add(*value),
            ArgStorage::I8(value) => args.add(*value),
            ArgStorage::I16(value) => args.add(*value),
            ArgStorage::I32(value) => args.add(*value),
            ArgStorage::I64(value) => args.add(*value),
            ArgStorage::F32(value) => args.add(*value),
            ArgStorage::F64(value) => args.add(*value),
            ArgStorage::String(value) => args.add(value.clone()),
            ArgStorage::Dyn(binder) => binder(args),
        }
    }
}

fn inline_storage<T>(val: &T) -> Option<ArgStorage>
where
    T: Any + Clone,
{
    let any = val as &dyn Any;
    if let Some(value) = any.downcast_ref::<bool>() {
        return Some(ArgStorage::Bool(*value));
    }
    if let Some(value) = any.downcast_ref::<i8>() {
        return Some(ArgStorage::I8(*value));
    }
    if let Some(value) = any.downcast_ref::<i16>() {
        return Some(ArgStorage::I16(*value));
    }
    if let Some(value) = any.downcast_ref::<i32>() {
        return Some(ArgStorage::I32(*value));
    }
    if let Some(value) = any.downcast_ref::<i64>() {
        return Some(ArgStorage::I64(*value));
    }
    if let Some(value) = any.downcast_ref::<f32>() {
        return Some(ArgStorage::F32(*value));
    }
    if let Some(value) = any.downcast_ref::<f64>() {
        return Some(ArgStorage::F64(*value));
    }
    any.downcast_ref::<String>()
        .map(|value| ArgStorage::String(value.clone()))
}

impl<T> From<T> for ArgValue
where
    T: Clone + for<'q> sqlx::Encode<'q, Database> + sqlx::Type<Database> + Send + Sync + 'static,
{
    fn from(val: T) -> Self {
        ArgValue::new(val)
    }
}

#[cfg(test)]
mod tests {
    use super::ArgValue;
    use crate::Arguments;

    /// Verifies inline primitive and string bind values increment SQLx arguments.
    #[test]
    fn inline_values_bind_to_arguments() {
        use sqlx::Arguments as _;

        let values = [
            ArgValue::new(true),
            ArgValue::new(1_i8),
            ArgValue::new(2_i16),
            ArgValue::new(3_i32),
            ArgValue::new(4_i64),
            ArgValue::new(5.0_f32),
            ArgValue::new(6.0_f64),
            ArgValue::new("seven".to_string()),
        ];
        let mut args = Arguments::default();
        for value in values {
            value.bind_value(&mut args).unwrap();
        }
        assert_eq!(args.len(), 8);
    }

    /// Verifies fallback dynamic bind values keep the same bind behavior.
    #[test]
    fn fallback_values_bind_to_arguments() {
        use sqlx::Arguments as _;

        let value = ArgValue::new(vec![1_u8, 2, 3]);
        let mut args = Arguments::default();
        value.bind_value(&mut args).unwrap();
        assert_eq!(args.len(), 1);
    }
}