voltdb_client_rust/
encode_option.rs

1use bigdecimal::BigDecimal;
2use bytebuffer::ByteBuffer;
3use chrono::{DateTime, Utc};
4
5use crate::{*};
6
7impl Value for Option<bool> {
8    fn get_write_length(&self) -> i32 {
9        return 2;
10    }
11
12    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
13        bytebuffer.write_i8(TINYINT_COLUMN);
14        self.marshal_in_table(bytebuffer, TINYINT_COLUMN)
15    }
16
17    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
18        match self {
19            None => {
20                bytebuffer.write_bytes(&NULL_BIT_VALUE)
21            }
22            Some(v) => {
23                v.marshal_in_table(bytebuffer, TINYINT_COLUMN)
24            }
25        }
26    }
27
28    fn to_value_string(&self) -> String {
29        return format!("{:?}", self);
30    }
31
32    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
33        if bs == NULL_BIT_VALUE {
34            return Ok(Option::None);
35        }
36        return Ok(Some(bool::from_bytes(bs, _column)?));
37    }
38}
39
40
41impl Value for Option<BigDecimal> {
42    fn get_write_length(&self) -> i32 {
43        return 17;
44    }
45
46    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
47        bytebuffer.write_i8(DECIMAL_COLUMN);
48        self.marshal_in_table(bytebuffer, DECIMAL_COLUMN);
49    }
50
51    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
52        match self {
53            None => {
54                bytebuffer.write_bytes(&NULL_DECIMAL)
55            }
56            Some(v) => {
57                v.marshal_in_table(bytebuffer, DECIMAL_COLUMN)
58            }
59        }
60    }
61
62    fn to_value_string(&self) -> String {
63        return format!("{:?}", self);
64    }
65
66    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> where Self: Sized {
67        if bs == NULL_DECIMAL {
68            return Ok(Option::None);
69        }
70        Ok(Some(BigDecimal::from_bytes(bs, _column)?))
71    }
72}
73
74impl Value for Option<i8> {
75    fn get_write_length(&self) -> i32 {
76        return 2;
77    }
78
79    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
80        bytebuffer.write_i8(TINYINT_COLUMN);
81        self.marshal_in_table(bytebuffer, TINYINT_COLUMN)
82    }
83
84    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
85        match self {
86            None => {
87                bytebuffer.write_bytes(&NULL_BIT_VALUE)
88            }
89            Some(v) => {
90                v.marshal_in_table(bytebuffer, TINYINT_COLUMN)
91            }
92        }
93    }
94
95    fn to_value_string(&self) -> String {
96        return format!("{:?}", self);
97    }
98
99    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
100        if bs == NULL_BIT_VALUE {
101            return Ok(Option::None);
102        }
103        return Ok(Some(i8::from_bytes(bs, _column)?));
104    }
105}
106
107impl Value for Option<u8> {
108    fn get_write_length(&self) -> i32 {
109        return 2;
110    }
111
112    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
113        bytebuffer.write_i8(TINYINT_COLUMN);
114        self.marshal_in_table(bytebuffer, TINYINT_COLUMN)
115    }
116
117    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
118        match self {
119            None => {
120                bytebuffer.write_bytes(&NULL_BIT_VALUE)
121            }
122            Some(v) => {
123                v.marshal_in_table(bytebuffer, TINYINT_COLUMN)
124            }
125        }
126    }
127
128    fn to_value_string(&self) -> String {
129        return format!("{:?}", self);
130    }
131
132    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
133        if bs == NULL_BIT_VALUE {
134            return Ok(Option::None);
135        }
136        return Ok(Some(u8::from_bytes(bs, _column)?));
137    }
138}
139
140impl Value for Option<i16> {
141    fn get_write_length(&self) -> i32 {
142        return 3;
143    }
144
145    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
146        bytebuffer.write_i8(SHORT_COLUMN);
147        self.marshal_in_table(bytebuffer, SHORT_COLUMN);
148    }
149
150    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
151        match self {
152            None => {
153                bytebuffer.write_bytes(&NULL_SHORT_VALUE)
154            }
155            Some(v) => {
156                v.marshal_in_table(bytebuffer, SHORT_COLUMN)
157            }
158        }
159    }
160
161    fn to_value_string(&self) -> String {
162        return format!("{:?}", self);
163    }
164
165    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
166        if bs == NULL_SHORT_VALUE {
167            return Ok(Option::None);
168        }
169        return Ok(Some(i16::from_bytes(bs, _column)?));
170    }
171}
172
173impl Value for Option<u16> {
174    fn get_write_length(&self) -> i32 {
175        return 3;
176    }
177
178    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
179        bytebuffer.write_i8(SHORT_COLUMN);
180        self.marshal_in_table(bytebuffer, SHORT_COLUMN);
181    }
182
183    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
184        match self {
185            None => {
186                bytebuffer.write_bytes(&NULL_SHORT_VALUE)
187            }
188            Some(v) => {
189                v.marshal_in_table(bytebuffer, SHORT_COLUMN)
190            }
191        }
192    }
193
194    fn to_value_string(&self) -> String {
195        return format!("{:?}", self);
196    }
197
198    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
199        if bs == NULL_SHORT_VALUE {
200            return Ok(Option::None);
201        }
202        return Ok(Some(u16::from_bytes(bs, _column)?));
203    }
204}
205
206impl Value for Option<i32> {
207    fn get_write_length(&self) -> i32 {
208        return 5;
209    }
210
211    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
212        bytebuffer.write_i8(INT_COLUMN);
213        self.marshal_in_table(bytebuffer, INT_COLUMN);
214    }
215
216    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
217        match self {
218            None => {
219                bytebuffer.write_bytes(&NULL_INT_VALUE)
220            }
221            Some(v) => {
222                v.marshal_in_table(bytebuffer, INT_COLUMN)
223            }
224        }
225    }
226
227    fn to_value_string(&self) -> String {
228        return format!("{:?}", self);
229    }
230
231    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
232        if bs == NULL_INT_VALUE {
233            return Ok(Option::None);
234        }
235        return Ok(Some(i32::from_bytes(bs, _column)?));
236    }
237}
238
239impl Value for Option<u32> {
240    fn get_write_length(&self) -> i32 {
241        return 5;
242    }
243
244    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
245        bytebuffer.write_i8(INT_COLUMN);
246        self.marshal_in_table(bytebuffer, INT_COLUMN);
247    }
248
249    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
250        match self {
251            None => {
252                bytebuffer.write_bytes(&NULL_INT_VALUE)
253            }
254            Some(v) => {
255                v.marshal_in_table(bytebuffer, INT_COLUMN)
256            }
257        }
258    }
259
260    fn to_value_string(&self) -> String {
261        return format!("{:?}", self);
262    }
263
264    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
265        if bs == NULL_INT_VALUE {
266            return Ok(Option::None);
267        }
268        return Ok(Some(u32::from_bytes(bs, _column)?));
269    }
270}
271
272impl Value for Option<i64> {
273    fn get_write_length(&self) -> i32 {
274        return 9;
275    }
276    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
277        bytebuffer.write_i8(LONG_COLUMN);
278        self.marshal_in_table(bytebuffer, LONG_COLUMN);
279    }
280
281    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
282        match self {
283            None => {
284                bytebuffer.write_bytes(&NULL_LONG_VALUE)
285            }
286            Some(v) => {
287                v.marshal_in_table(bytebuffer, LONG_COLUMN)
288            }
289        }
290    }
291
292    fn to_value_string(&self) -> String {
293        return format!("{:?}", self);
294    }
295
296    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
297        if bs == NULL_LONG_VALUE {
298            return Ok(Option::None);
299        }
300        return Ok(Some(i64::from_bytes(bs, _column)?));
301    }
302}
303
304impl Value for Option<u64> {
305    fn get_write_length(&self) -> i32 {
306        return 9;
307    }
308
309    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
310        bytebuffer.write_i8(LONG_COLUMN);
311        self.marshal_in_table(bytebuffer, LONG_COLUMN);
312    }
313
314    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
315        match self {
316            None => {
317                bytebuffer.write_bytes(&NULL_LONG_VALUE)
318            }
319            Some(v) => {
320                v.marshal_in_table(bytebuffer, LONG_COLUMN)
321            }
322        }
323    }
324
325    fn to_value_string(&self) -> String {
326        return format!("{:?}", self);
327    }
328
329    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
330        if bs == NULL_LONG_VALUE {
331            return Ok(Option::None);
332        }
333        return Ok(Some(u64::from_bytes(bs, _column)?));
334    }
335}
336
337impl Value for Option<f64> {
338    fn get_write_length(&self) -> i32 {
339        return 9;
340    }
341
342    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
343        bytebuffer.write_i8(FLOAT_COLUMN);
344        self.marshal_in_table(bytebuffer, FLOAT_COLUMN);
345    }
346
347    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
348        match self {
349            None => {
350                bytebuffer.write_bytes(&NULL_FLOAT_VALUE)
351            }
352            Some(v) => {
353                v.marshal_in_table(bytebuffer, FLOAT_COLUMN)
354            }
355        }
356    }
357
358    fn to_value_string(&self) -> String {
359        return format!("{:?}", self);
360    }
361
362    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
363        if bs == NULL_FLOAT_VALUE {
364            return Ok(Option::None);
365        }
366        return Ok(Some(f64::from_bytes(bs, _column)?));
367    }
368}
369
370
371impl Value for Option<String> {
372    fn get_write_length(&self) -> i32 {
373        match self {
374            None => {
375                return 5;
376            }
377            Some(v) => {
378                return (5 + v.len()) as i32;
379            }
380        }
381    }
382
383    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
384        bytebuffer.write_i8(STRING_COLUMN);
385        match self {
386            None => {
387                bytebuffer.write_bytes(&NULL_VARCHAR)
388            }
389            Some(v) => {
390                v.marshal_in_table(bytebuffer, STRING_COLUMN)
391            }
392        }
393    }
394
395    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
396        match self {
397            None => {
398                bytebuffer.write_bytes(&NULL_VARCHAR)
399            }
400            Some(v) => {
401                v.marshal_in_table(bytebuffer, STRING_COLUMN)
402            }
403        }
404    }
405
406    fn to_value_string(&self) -> String {
407        return format!("{:?}", self);
408    }
409
410    fn from_bytes(bs: Vec<u8>, table_column: &Column) -> Result<Self, VoltError> {
411        return match table_column.header_type {
412            STRING_COLUMN => {
413                if bs == NULL_VARCHAR {
414                    return Ok(Option::None);
415                }
416                let mut buffer = ByteBuffer::from_bytes(&bs);
417                Ok(Option::Some(buffer.read_string()?))
418            }
419            _ => {
420                let res = crate::table::VoltTable::get_value_by_idx_column(table_column, bs)?;
421                match res {
422                    Some(v) => {
423                        Ok(Option::Some(v.to_value_string()))
424                    }
425                    None => {
426                        Ok(Option::None)
427                    }
428                }
429            }
430        };
431    }
432}
433
434impl Value for Option<&str> {
435    fn get_write_length(&self) -> i32 {
436        match self {
437            None => {
438                return 5;
439            }
440            Some(v) => {
441                return (5 + v.len()) as i32;
442            }
443        }
444    }
445
446
447    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
448        bytebuffer.write_i8(STRING_COLUMN);
449        match self {
450            None => {
451                bytebuffer.write_bytes(&NULL_VARCHAR)
452            }
453            Some(v) => {
454                v.marshal_in_table(bytebuffer, STRING_COLUMN)
455            }
456        }
457    }
458
459    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
460        match self {
461            None => {
462                bytebuffer.write_bytes(&NULL_VARCHAR)
463            }
464            Some(v) => {
465                v.marshal_in_table(bytebuffer, STRING_COLUMN)
466            }
467        }
468    }
469
470    fn to_value_string(&self) -> String {
471        return format!("{:?}", self);
472    }
473
474    fn from_bytes(_bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
475        todo!()
476    }
477}
478
479impl Value for Option<Vec<u8>> {
480    fn get_write_length(&self) -> i32 {
481        match self {
482            None => {
483                return 5;
484            }
485            Some(v) => {
486                return (5 + v.len()) as i32;
487            }
488        }
489    }
490
491    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
492        bytebuffer.write_i8(VAR_BIN_COLUMN);
493        match self {
494            None => {
495                bytebuffer.write_bytes(&NULL_VARCHAR)
496            }
497            Some(v) => {
498                bytebuffer.write_bytes(&v);
499            }
500        }
501    }
502
503    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
504        match self {
505            None => {
506                bytebuffer.write_bytes(&NULL_VARCHAR)
507            }
508            Some(v) => {
509                bytebuffer.write_bytes(&v);
510            }
511        }
512    }
513
514    fn to_value_string(&self) -> String {
515        return format!("{:?}", self);
516    }
517
518    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
519        if bs == NULL_VARCHAR {
520            let res: Option<Vec<u8>> = Option::None;
521            return Ok(res);
522        }
523        let mut cp = bs.clone();
524        cp.drain(0..4);
525        return Ok(Option::Some(cp));
526    }
527}
528
529
530impl Value for Option<DateTime<Utc>> {
531    fn get_write_length(&self) -> i32 {
532        return 9;
533    }
534    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
535        bytebuffer.write_i8(TIMESTAMP_COLUMN);
536        match self {
537            None => {
538                bytebuffer.write_bytes(&NULL_TIMESTAMP)
539            }
540            Some(v) => {
541                v.marshal_in_table(bytebuffer, TIMESTAMP_COLUMN)
542            }
543        }
544    }
545
546
547    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
548        match self {
549            None => {
550                bytebuffer.write_bytes(&NULL_TIMESTAMP)
551            }
552            Some(v) => {
553                v.marshal_in_table(bytebuffer, TIMESTAMP_COLUMN)
554            }
555        }
556    }
557
558    fn to_value_string(&self) -> String {
559        return format!("{:?}", self);
560    }
561
562    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> where Self: Sized {
563        if bs == NULL_TIMESTAMP {
564            return Ok(Option::None);
565        }
566        return Ok(Option::Some(DateTime::from_bytes(bs, _column)?));
567    }
568}
voltdb_client_rust/encode_option.rs

voltdb_client_rust/
encode_option.rs
