wasm-dbms-api 0.8.1

Runtime-agnostic API types and traits for the wasm-dbms DBMS engine.
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::prelude::{DbmsResult, Sanitize, Value};

/// Sanitizer that clamps integer values within a specified range.
///
/// # Example
///
/// ```rust
/// use wasm_dbms_api::prelude::{ClampSanitizer, Value, Sanitize as _};
///
/// let value = Value::Int32(150.into());
/// let sanitizer = ClampSanitizer { min: 0, max: 100 };
/// let sanitized_value = sanitizer.sanitize(value).unwrap();
/// assert_eq!(sanitized_value, Value::Int32(100.into()));
/// ```
pub struct ClampSanitizer {
    pub min: i64,
    pub max: i64,
}

impl Sanitize for ClampSanitizer {
    fn sanitize(&self, value: Value) -> DbmsResult<Value> {
        match value {
            Value::Int32(num) => {
                let clamped = (num.0 as i64).clamp(self.min, self.max);
                let clamped: Result<i32, _> = clamped.try_into();
                match clamped {
                    Ok(clamped_i32) => Ok(Value::Int32(clamped_i32.into())),
                    Err(_) => Err(crate::prelude::DbmsError::Sanitize(
                        "Clamped value out of Int32 range".into(),
                    )),
                }
            }
            Value::Int64(num) => {
                let clamped = num.0.clamp(self.min, self.max);
                Ok(Value::Int64(clamped.into()))
            }
            other => Ok(other),
        }
    }
}

/// Sanitizer that clamps unsigned integer values within a specified range.
///
/// # Example
///
/// ```rust
/// use wasm_dbms_api::prelude::{ClampUnsignedSanitizer, Value, Sanitize as _};
///
/// let value = Value::Uint32(150.into());
/// let sanitizer = ClampUnsignedSanitizer { min: 0, max: 100 };
/// let sanitized_value = sanitizer.sanitize(value).unwrap();
/// assert_eq!(sanitized_value, Value::Uint32(100.into()));
/// ```
pub struct ClampUnsignedSanitizer {
    pub min: u64,
    pub max: u64,
}

impl Sanitize for ClampUnsignedSanitizer {
    fn sanitize(&self, value: Value) -> DbmsResult<Value> {
        match value {
            Value::Uint32(num) => {
                let clamped = (num.0 as u64).clamp(self.min, self.max);
                let clamped: Result<u32, _> = clamped.try_into();
                match clamped {
                    Ok(clamped_u32) => Ok(Value::Uint32(clamped_u32.into())),
                    Err(_) => Err(crate::prelude::DbmsError::Sanitize(
                        "Clamped value out of Uint32 range".into(),
                    )),
                }
            }
            Value::Uint64(num) => {
                let clamped = num.0.clamp(self.min, self.max);
                Ok(Value::Uint64(clamped.into()))
            }
            other => Ok(other),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_clamp_sanitizer_i32() {
        let sanitizer = ClampSanitizer { min: 0, max: 100 };
        let value_in_range = Value::Int32(50.into());
        let value_below_range = Value::Int32((-10i32).into());
        let value_above_range = Value::Int32(150.into());
        let non_integer_value = Value::Text("Not an integer".into());

        let sanitized_in_range = sanitizer.sanitize(value_in_range).unwrap();
        let sanitized_below_range = sanitizer.sanitize(value_below_range).unwrap();
        let sanitized_above_range = sanitizer.sanitize(value_above_range).unwrap();
        let sanitized_non_integer = sanitizer.sanitize(non_integer_value).unwrap();

        assert_eq!(sanitized_in_range, Value::Int32(50.into()));
        assert_eq!(sanitized_below_range, Value::Int32(0.into()));
        assert_eq!(sanitized_above_range, Value::Int32(100.into()));
        assert_eq!(sanitized_non_integer, Value::Text("Not an integer".into()));
    }

    #[test]
    fn test_clamp_sanitizer_i64() {
        let sanitizer = ClampSanitizer { min: 0, max: 100 };
        let value_in_range = Value::Int64(50.into());
        let value_below_range = Value::Int64((-10i64).into());
        let value_above_range = Value::Int64(150.into());
        let non_integer_value = Value::Text("Not an integer".into());

        let sanitized_in_range = sanitizer.sanitize(value_in_range).unwrap();
        let sanitized_below_range = sanitizer.sanitize(value_below_range).unwrap();
        let sanitized_above_range = sanitizer.sanitize(value_above_range).unwrap();
        let sanitized_non_integer = sanitizer.sanitize(non_integer_value).unwrap();

        assert_eq!(sanitized_in_range, Value::Int64(50.into()));
        assert_eq!(sanitized_below_range, Value::Int64(0.into()));
        assert_eq!(sanitized_above_range, Value::Int64(100.into()));
        assert_eq!(sanitized_non_integer, Value::Text("Not an integer".into()));
    }

    #[test]
    fn test_clamp_unsigned_sanitizer_u32() {
        let sanitizer = ClampUnsignedSanitizer { min: 0, max: 100 };
        let value_in_range = Value::Uint32(50.into());
        let value_below_range = Value::Uint32(0.into()); // Unsigned can't be negative
        let value_above_range = Value::Uint32(150.into());
        let non_integer_value = Value::Text("Not an integer".into());

        let sanitized_in_range = sanitizer.sanitize(value_in_range).unwrap();
        let sanitized_below_range = sanitizer.sanitize(value_below_range).unwrap();
        let sanitized_above_range = sanitizer.sanitize(value_above_range).unwrap();
        let sanitized_non_integer = sanitizer.sanitize(non_integer_value).unwrap();

        assert_eq!(sanitized_in_range, Value::Uint32(50.into()));
        assert_eq!(sanitized_below_range, Value::Uint32(0.into()));
        assert_eq!(sanitized_above_range, Value::Uint32(100.into()));
        assert_eq!(sanitized_non_integer, Value::Text("Not an integer".into()));
    }

    #[test]
    fn test_clamp_unsigned_sanitizer_u64() {
        let sanitizer = ClampUnsignedSanitizer { min: 0, max: 100 };
        let value_in_range = Value::Uint64(50.into());
        let value_below_range = Value::Uint64(0.into()); // Unsigned can't be negative
        let value_above_range = Value::Uint64(150.into());
        let non_integer_value = Value::Text("Not an integer".into());

        let sanitized_in_range = sanitizer.sanitize(value_in_range).unwrap();
        let sanitized_below_range = sanitizer.sanitize(value_below_range).unwrap();
        let sanitized_above_range = sanitizer.sanitize(value_above_range).unwrap();
        let sanitized_non_integer = sanitizer.sanitize(non_integer_value).unwrap();

        assert_eq!(sanitized_in_range, Value::Uint64(50.into()));
        assert_eq!(sanitized_below_range, Value::Uint64(0.into()));
        assert_eq!(sanitized_above_range, Value::Uint64(100.into()));
        assert_eq!(sanitized_non_integer, Value::Text("Not an integer".into()));
    }
}