quill_sql/storage/codec/
common.rs

1use crate::error::{QuillSQLError, QuillSQLResult};
2use crate::storage::codec::DecodedData;
3use core::f32;
4use std::f64;
5
6pub struct CommonCodec;
7
8impl CommonCodec {
9    pub fn encode_bool(data: bool) -> Vec<u8> {
10        if data {
11            vec![1]
12        } else {
13            vec![0]
14        }
15    }
16
17    pub fn decode_bool(bytes: &[u8]) -> QuillSQLResult<DecodedData<bool>> {
18        if bytes.is_empty() {
19            return Err(QuillSQLError::Storage(format!(
20                "bytes length {} is less than {}",
21                bytes.len(),
22                1
23            )));
24        }
25        Ok((bytes[0] != 0, 1))
26    }
27
28    pub fn encode_u8(data: u8) -> Vec<u8> {
29        data.to_be_bytes().to_vec()
30    }
31
32    pub fn decode_u8(bytes: &[u8]) -> QuillSQLResult<DecodedData<u8>> {
33        if bytes.is_empty() {
34            return Err(QuillSQLError::Storage(format!(
35                "bytes length {} is less than {}",
36                bytes.len(),
37                1
38            )));
39        }
40        Ok((u8::from_be_bytes([bytes[0]]), 1))
41    }
42
43    pub fn encode_u16(data: u16) -> Vec<u8> {
44        data.to_be_bytes().to_vec()
45    }
46
47    pub fn decode_u16(bytes: &[u8]) -> QuillSQLResult<DecodedData<u16>> {
48        if bytes.len() < 2 {
49            return Err(QuillSQLError::Storage(format!(
50                "bytes length {} is less than {}",
51                bytes.len(),
52                2
53            )));
54        }
55        let data = [bytes[0], bytes[1]];
56        Ok((u16::from_be_bytes(data), 2))
57    }
58
59    pub fn encode_u32(data: u32) -> Vec<u8> {
60        data.to_be_bytes().to_vec()
61    }
62
63    pub fn decode_u32(bytes: &[u8]) -> QuillSQLResult<DecodedData<u32>> {
64        if bytes.len() < 4 {
65            return Err(QuillSQLError::Storage(format!(
66                "bytes length {} is less than {}",
67                bytes.len(),
68                4
69            )));
70        }
71        let data = [bytes[0], bytes[1], bytes[2], bytes[3]];
72        Ok((u32::from_be_bytes(data), 4))
73    }
74
75    pub fn encode_u64(data: u64) -> Vec<u8> {
76        data.to_be_bytes().to_vec()
77    }
78
79    pub fn decode_u64(bytes: &[u8]) -> QuillSQLResult<DecodedData<u64>> {
80        if bytes.len() < 8 {
81            return Err(QuillSQLError::Storage(format!(
82                "bytes length {} is less than {}",
83                bytes.len(),
84                8
85            )));
86        }
87        let data = [
88            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
89        ];
90        Ok((u64::from_be_bytes(data), 8))
91    }
92
93    pub fn encode_i8(data: i8) -> Vec<u8> {
94        data.to_be_bytes().to_vec()
95    }
96
97    pub fn decode_i8(bytes: &[u8]) -> QuillSQLResult<DecodedData<i8>> {
98        if bytes.is_empty() {
99            return Err(QuillSQLError::Storage(format!(
100                "bytes length {} is less than {}",
101                bytes.len(),
102                1
103            )));
104        }
105        Ok((i8::from_be_bytes([bytes[0]]), 1))
106    }
107
108    pub fn encode_i16(data: i16) -> Vec<u8> {
109        data.to_be_bytes().to_vec()
110    }
111
112    pub fn decode_i16(bytes: &[u8]) -> QuillSQLResult<DecodedData<i16>> {
113        if bytes.len() < 2 {
114            return Err(QuillSQLError::Storage(format!(
115                "bytes length {} is less than {}",
116                bytes.len(),
117                2
118            )));
119        }
120        let data = [bytes[0], bytes[1]];
121        Ok((i16::from_be_bytes(data), 2))
122    }
123
124    pub fn encode_i32(data: i32) -> Vec<u8> {
125        data.to_be_bytes().to_vec()
126    }
127
128    pub fn decode_i32(bytes: &[u8]) -> QuillSQLResult<DecodedData<i32>> {
129        if bytes.len() < 4 {
130            return Err(QuillSQLError::Storage(format!(
131                "bytes length {} is less than {}",
132                bytes.len(),
133                4
134            )));
135        }
136        let data = [bytes[0], bytes[1], bytes[2], bytes[3]];
137        Ok((i32::from_be_bytes(data), 4))
138    }
139
140    pub fn encode_i64(data: i64) -> Vec<u8> {
141        data.to_be_bytes().to_vec()
142    }
143
144    pub fn decode_i64(bytes: &[u8]) -> QuillSQLResult<DecodedData<i64>> {
145        if bytes.len() < 8 {
146            return Err(QuillSQLError::Storage(format!(
147                "bytes length {} is less than {}",
148                bytes.len(),
149                8
150            )));
151        }
152        let data = [
153            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
154        ];
155        Ok((i64::from_be_bytes(data), 8))
156    }
157
158    pub fn encode_f32(data: f32) -> Vec<u8> {
159        data.to_be_bytes().to_vec()
160    }
161
162    pub fn decode_f32(bytes: &[u8]) -> QuillSQLResult<DecodedData<f32>> {
163        if bytes.len() < 4 {
164            return Err(QuillSQLError::Storage(format!(
165                "bytes length {} is less than {}",
166                bytes.len(),
167                4
168            )));
169        }
170        let data = [bytes[0], bytes[1], bytes[2], bytes[3]];
171        Ok((f32::from_be_bytes(data), 4))
172    }
173
174    pub fn encode_f64(data: f64) -> Vec<u8> {
175        data.to_be_bytes().to_vec()
176    }
177
178    pub fn decode_f64(bytes: &[u8]) -> QuillSQLResult<DecodedData<f64>> {
179        if bytes.len() < 8 {
180            return Err(QuillSQLError::Storage(format!(
181                "bytes length {} is less than {}",
182                bytes.len(),
183                8
184            )));
185        }
186        let data = [
187            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
188        ];
189        Ok((f64::from_be_bytes(data), 8))
190    }
191
192    pub fn encode_string(data: &String) -> Vec<u8> {
193        data.as_bytes().to_vec()
194    }
195
196    pub fn decode_string(bytes: &[u8]) -> QuillSQLResult<DecodedData<String>> {
197        let data = String::from_utf8(bytes.to_vec())
198            .map_err(|e| QuillSQLError::Storage(format!("Failed to decode string {}", e)))?;
199        Ok((data, bytes.len()))
200    }
201}
202
203#[cfg(test)]
204mod tests {
205    use crate::storage::codec::CommonCodec;
206
207    #[test]
208    fn common_codec() {
209        assert!(
210            CommonCodec::decode_bool(&CommonCodec::encode_bool(true))
211                .unwrap()
212                .0
213        );
214        assert!(
215            !CommonCodec::decode_bool(&CommonCodec::encode_bool(false))
216                .unwrap()
217                .0
218        );
219        assert_eq!(
220            5u8,
221            CommonCodec::decode_u8(&CommonCodec::encode_u8(5u8))
222                .unwrap()
223                .0
224        );
225        assert_eq!(
226            5u16,
227            CommonCodec::decode_u16(&CommonCodec::encode_u16(5u16))
228                .unwrap()
229                .0
230        );
231        assert_eq!(
232            5u32,
233            CommonCodec::decode_u32(&CommonCodec::encode_u32(5u32))
234                .unwrap()
235                .0
236        );
237        assert_eq!(
238            5u64,
239            CommonCodec::decode_u64(&CommonCodec::encode_u64(5u64))
240                .unwrap()
241                .0
242        );
243
244        assert_eq!(
245            5i8,
246            CommonCodec::decode_i8(&CommonCodec::encode_i8(5i8))
247                .unwrap()
248                .0
249        );
250        assert_eq!(
251            5i16,
252            CommonCodec::decode_i16(&CommonCodec::encode_i16(5i16))
253                .unwrap()
254                .0
255        );
256        assert_eq!(
257            5i32,
258            CommonCodec::decode_i32(&CommonCodec::encode_i32(5i32))
259                .unwrap()
260                .0
261        );
262        assert_eq!(
263            5i64,
264            CommonCodec::decode_i64(&CommonCodec::encode_i64(5i64))
265                .unwrap()
266                .0
267        );
268        assert_eq!(
269            5.0f32,
270            CommonCodec::decode_f32(&CommonCodec::encode_f32(5.0f32))
271                .unwrap()
272                .0
273        );
274        assert_eq!(
275            5.0f64,
276            CommonCodec::decode_f64(&CommonCodec::encode_f64(5.0f64))
277                .unwrap()
278                .0
279        );
280        assert_eq!(
281            "abc".to_string(),
282            CommonCodec::decode_string(&CommonCodec::encode_string(&"abc".to_string()))
283                .unwrap()
284                .0
285        );
286    }
287}
quill_sql/storage/codec/common.rs

quill_sql/storage/codec/
common.rs
