voltdb_client_rust/
encode.rs

1use std::fmt::Debug;
2use std::str::Utf8Error;
3use std::sync::PoisonError;
4
5use bigdecimal::BigDecimal;
6use bigdecimal::num_bigint::BigInt;
7use bytebuffer::ByteBuffer;
8use chrono::{DateTime, Utc};
9use quick_error::quick_error;
10
11use crate::chrono::TimeZone;
12use crate::Column;
13use crate::response::VoltResponseInfo;
14
15#[allow(dead_code)]
16pub const ARRAY_COLUMN: i8 = -99;
17pub const NULL_COLUMN: i8 = 1;
18pub const TINYINT_COLUMN: i8 = 3;
19pub const SHORT_COLUMN: i8 = 4;
20pub const INT_COLUMN: i8 = 5;
21pub const LONG_COLUMN: i8 = 6;
22pub const FLOAT_COLUMN: i8 = 8;
23pub const STRING_COLUMN: i8 = 9;
24pub const TIMESTAMP_COLUMN: i8 = 11;
25pub const TABLE: i8 = 21;
26pub const DECIMAL_COLUMN: i8 = 22;
27pub const VAR_BIN_COLUMN: i8 = 25; // varbinary (int)(bytes)
28
29
30pub const NULL_DECIMAL: [u8; 16] = [128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
31
32pub const NULL_BIT_VALUE: [u8; 1] = [128];
33pub const NULL_SHORT_VALUE: [u8; 2] = [128, 0];
34pub const NULL_INT_VALUE: [u8; 4] = [128, 0, 0, 0];
35pub const NULL_LONG_VALUE: [u8; 8] = [128, 0, 0, 0, 0, 0, 0, 0];
36pub const NULL_TIMESTAMP: [u8; 8] = [128, 0, 0, 0, 0, 0, 0, 0];
37
38
39pub const NULL_FLOAT_VALUE: [u8; 8] = [255, 239, 255, 255, 255, 255, 255, 255];
40pub const NULL_VARCHAR: [u8; 4] = [255, 255, 255, 255];
41
42
43quick_error! {
44#[derive(Debug)]
45pub enum VoltError {
46        Io(err: std::io::Error) {
47            from()
48            display("I/O error: {}", err)
49            source(err)
50        }
51
52        RecvError(err: std::sync::mpsc::RecvError){
53            from()
54            display("Recv error: {}", err)
55            source(err)
56        }
57
58        ExecuteFail ( info: VoltResponseInfo ){
59            display("volt execute failed: {:?}", info)
60        }
61        InvalidColumnType(tp: i8) {
62            display("InvalidColumnType {}", tp)
63        }
64
65        NoValue (descr : String) {
66            display("Error {}", descr)
67        }
68        Other(descr: String) {
69            display("Error {}", descr)
70        }
71        NegativeNumTables (num: i16) {
72             display("Error {}", num)
73        }
74
75         Utf8Error(err : Utf8Error){
76            from()
77            display("Utf8 error: {}", err)
78            source(err)
79        }
80
81        PoisonError (descr: String){
82              display("Error {}", descr)
83        }
84        BadReturnStatusOnTable (status: i8) {
85             display("Error {}", status)
86        }
87        AuthFailed {
88             display("Auth failed")
89        }
90        ConnectionNotAvailable {
91             display("Connection lost")
92        }
93       InvalidConfig {
94             display("Invalid Config")
95        }
96        Timeout
97
98
99}}
100
101impl<T> From<PoisonError<T>> for VoltError {
102    fn from(p: PoisonError<T>) -> VoltError {
103        VoltError::PoisonError(p.to_string().to_owned())
104    }
105}
106
107pub trait ValuePrimary {}
108
109//pub trait
110pub trait Value: Debug {
111    fn get_write_length(&self) -> i32;
112    fn marshal(&self, bytebuffer: &mut ByteBuffer);
113    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8);
114    fn to_value_string(&self) -> String;
115    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> where Self: Sized;
116}
117
118
119trait WriteBool {
120    fn write_bool(&mut self, val: bool);
121}
122
123impl WriteBool for ByteBuffer {
124    fn write_bool(&mut self, val: bool) {
125        if val {
126            self.write_i8(1)
127        } else {
128            self.write_i8(0);
129        }
130    }
131}
132
133
134impl Value for bool {
135    fn get_write_length(&self) -> i32 {
136        return 2;
137    }
138
139    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
140        bytebuffer.write_i8(TINYINT_COLUMN);
141        bytebuffer.write_bool(*self);
142    }
143
144    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
145        bytebuffer.write_bool(*self);
146    }
147
148    fn to_value_string(&self) -> String {
149        return self.to_string();
150    }
151
152    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
153        if bs[0] == 0 {
154            return Ok(false);
155        }
156        return Ok(true);
157    }
158}
159
160
161impl Value for BigDecimal {
162    fn get_write_length(&self) -> i32 {
163        return 17;
164    }
165
166    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
167        bytebuffer.write_i8(DECIMAL_COLUMN);
168        self.marshal_in_table(bytebuffer, DECIMAL_COLUMN);
169    }
170
171    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
172        let (b, _) = self.clone().with_scale(12).into_bigint_and_exponent();
173        let bs = b.to_signed_bytes_be();
174        let pad = 16 - bs.len();
175        if pad > 0 {
176            let arr = vec![0; pad];
177            bytebuffer.write_bytes(&arr)
178        }
179        bytebuffer.write_bytes(&bs);
180    }
181
182    fn to_value_string(&self) -> String {
183        return self.to_string();
184    }
185
186    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> where Self: Sized {
187        let int = BigInt::from_signed_bytes_be(&*bs);
188        let decimal = BigDecimal::new(int, 12);
189        return Ok(decimal);
190    }
191}
192
193impl Value for i8 {
194    fn get_write_length(&self) -> i32 {
195        return 2;
196    }
197
198    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
199        bytebuffer.write_i8(TINYINT_COLUMN);
200        bytebuffer.write_i8(*self);
201    }
202
203    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
204        //   bytebuffer.write_i8(0);
205        bytebuffer.write_i8(*self);
206    }
207
208    fn to_value_string(&self) -> String {
209        return self.to_string();
210    }
211
212    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
213        let mut buffer = ByteBuffer::from_bytes(&bs);
214        let value = buffer.read_i8()?;
215        return Ok(value);
216    }
217}
218
219impl Value for u8 {
220    fn get_write_length(&self) -> i32 {
221        return 2;
222    }
223
224    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
225        bytebuffer.write_i8(TINYINT_COLUMN);
226        bytebuffer.write_u8(*self);
227    }
228
229    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
230        //  bytebuffer.write_u8(0);
231        bytebuffer.write_u8(*self);
232    }
233
234    fn to_value_string(&self) -> String {
235        return self.to_string();
236    }
237
238    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
239        let mut buffer = ByteBuffer::from_bytes(&bs);
240        let value = buffer.read_u8()?;
241        return Ok(value);
242    }
243}
244
245impl Value for i16 {
246    fn get_write_length(&self) -> i32 {
247        return 3;
248    }
249
250    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
251        bytebuffer.write_i8(SHORT_COLUMN);
252        bytebuffer.write_i16(*self);
253    }
254
255    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
256        //    bytebuffer.write_i16(0);
257        bytebuffer.write_i16(*self);
258    }
259
260    fn to_value_string(&self) -> String {
261        return self.to_string();
262    }
263
264    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
265        let mut buffer = ByteBuffer::from_bytes(&bs);
266        let value = buffer.read_i16()?;
267        return Ok(value);
268    }
269}
270
271impl Value for u16 {
272    fn get_write_length(&self) -> i32 {
273        return 3;
274    }
275
276    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
277        bytebuffer.write_i8(SHORT_COLUMN);
278        bytebuffer.write_u16(*self);
279    }
280
281    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
282        //  bytebuffer.write_i16(0);
283        bytebuffer.write_u16(*self);
284    }
285
286    fn to_value_string(&self) -> String {
287        return self.to_string();
288    }
289
290    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
291        let mut buffer = ByteBuffer::from_bytes(&bs);
292        let value = buffer.read_u16()?;
293        return Ok(value);
294    }
295}
296
297impl Value for i32 {
298    fn get_write_length(&self) -> i32 {
299        return 5;
300    }
301
302    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
303        bytebuffer.write_i8(INT_COLUMN);
304        bytebuffer.write_i32(*self);
305    }
306
307    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
308        //   bytebuffer.write_i32(0);
309        bytebuffer.write_i32(*self);
310    }
311
312    fn to_value_string(&self) -> String {
313        return self.to_string();
314    }
315
316    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
317        let mut buffer = ByteBuffer::from_bytes(&bs);
318        let value = buffer.read_i32()?;
319        return Ok(value);
320    }
321}
322
323impl Value for u32 {
324    fn get_write_length(&self) -> i32 {
325        return 5;
326    }
327
328    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
329        bytebuffer.write_i8(INT_COLUMN);
330        bytebuffer.write_u32(*self);
331    }
332
333    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
334        //   bytebuffer.write_u32(0);
335        bytebuffer.write_u32(*self);
336    }
337
338    fn to_value_string(&self) -> String {
339        return self.to_string();
340    }
341
342    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
343        let mut buffer = ByteBuffer::from_bytes(&bs);
344        let value = buffer.read_u32()?;
345        return Ok(value);
346    }
347}
348
349impl Value for i64 {
350    fn get_write_length(&self) -> i32 {
351        return 9;
352    }
353
354    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
355        bytebuffer.write_i8(LONG_COLUMN);
356        bytebuffer.write_i64(*self);
357    }
358
359    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
360        //   bytebuffer.write_i64(0);
361        bytebuffer.write_i64(*self);
362    }
363
364    fn to_value_string(&self) -> String {
365        return self.to_string();
366    }
367
368    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
369        let mut buffer = ByteBuffer::from_bytes(&bs);
370        let value = buffer.read_i64()?;
371        return Ok(value);
372    }
373}
374
375impl Value for u64 {
376    fn get_write_length(&self) -> i32 {
377        return 9;
378    }
379
380    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
381        bytebuffer.write_i8(LONG_COLUMN);
382        bytebuffer.write_u64(*self);
383    }
384
385    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
386        // bytebuffer.write_u64(0);
387        bytebuffer.write_u64(*self);
388    }
389
390    fn to_value_string(&self) -> String {
391        return self.to_string();
392    }
393
394    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
395        let mut buffer = ByteBuffer::from_bytes(&bs);
396        let value = buffer.read_u64()?;
397        return Ok(value);
398    }
399}
400
401impl Value for f64 {
402    fn get_write_length(&self) -> i32 {
403        return 9;
404    }
405
406    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
407        bytebuffer.write_i8(FLOAT_COLUMN);
408        bytebuffer.write_f64(*self);
409    }
410
411    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
412        bytebuffer.write_f64(*self);
413    }
414
415    fn to_value_string(&self) -> String {
416        return self.to_string();
417    }
418
419    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
420        let mut buffer = ByteBuffer::from_bytes(&bs);
421        let value = buffer.read_f64()?;
422        return Ok(value);
423    }
424}
425
426
427impl Value for String {
428    fn get_write_length(&self) -> i32 {
429        return (5 + self.len()) as i32;
430    }
431
432    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
433        bytebuffer.write_i8(STRING_COLUMN);
434        bytebuffer.write_string(self);
435    }
436
437    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
438        bytebuffer.write_string(self);
439    }
440
441    fn to_value_string(&self) -> String {
442        return self.to_string();
443    }
444
445    fn from_bytes(bs: Vec<u8>, table_column: &Column) -> Result<Self, VoltError> {
446        return match table_column.header_type {
447            STRING_COLUMN => {
448                // if bs == NULL_VARCHAR {
449                //     return Ok(Option::None);
450                // }
451                let mut buffer = ByteBuffer::from_bytes(&bs);
452                Ok(buffer.read_string()?)
453            }
454            _ => {
455                let res = crate::table::VoltTable::get_value_by_idx_column(table_column, bs)?;
456                match res {
457                    Some(v) => {
458                        Ok(v.to_value_string())
459                    }
460                    None => {
461                        Ok("".to_string())
462                    }
463                }
464            }
465        };
466    }
467}
468
469impl Value for &str {
470    fn get_write_length(&self) -> i32 {
471        return (5 + self.len()) as i32;
472    }
473
474    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
475        bytebuffer.write_i8(STRING_COLUMN);
476        // write length , then data
477        bytebuffer.write_string(self);
478    }
479
480    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
481        bytebuffer.write_string(self);
482    }
483
484    fn to_value_string(&self) -> String {
485        return self.to_string();
486    }
487
488    fn from_bytes(_bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
489        todo!()
490    }
491}
492
493impl Value for Vec<u8> {
494    fn get_write_length(&self) -> i32 {
495        return (5 + self.len()) as i32;
496    }
497
498    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
499        bytebuffer.write_i8(VAR_BIN_COLUMN);
500        bytebuffer.write_u32(self.len() as u32);
501        bytebuffer.write_bytes(&self);
502    }
503
504    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
505        bytebuffer.write_u32(self.len() as u32);
506        bytebuffer.write_bytes(&self);
507    }
508
509    fn to_value_string(&self) -> String {
510        return format!("{:?}", self);
511    }
512
513    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> {
514        let mut cp = bs.clone();
515        cp.drain(0..4);
516        return Ok(cp);
517    }
518}
519
520
521impl Value for DateTime<Utc> {
522    fn get_write_length(&self) -> i32 {
523        return 9;
524    }
525    fn marshal(&self, bytebuffer: &mut ByteBuffer) {
526        bytebuffer.write_i8(TIMESTAMP_COLUMN);
527        bytebuffer.write_i64(self.timestamp_millis() * 1000);
528    }
529
530    fn marshal_in_table(&self, bytebuffer: &mut ByteBuffer, _column_type: i8) {
531        bytebuffer.write_i64(self.timestamp_millis() * 1000);
532    }
533
534    fn to_value_string(&self) -> String {
535        return self.to_string();
536    }
537
538    fn from_bytes(bs: Vec<u8>, _column: &Column) -> Result<Self, VoltError> where Self: Sized {
539        let mut buffer = ByteBuffer::from_bytes(&bs);
540        let time = buffer.read_i64()?;
541        return Ok(Utc.timestamp_millis(time / 1000));
542    }
543}
544
545#[cfg(test)]
546mod tests {
547    use std::str::FromStr;
548
549    use bigdecimal::num_bigint::BigInt;
550    use chrono::TimeZone;
551
552    use crate::procedure_invocation::new_procedure_invocation;
553
554    use super::*;
555
556    #[test]
557    fn test_encoding_proc() {
558        let mut zero_vec: Vec<&dyn Value> = Vec::new();
559        zero_vec.push(&"select * from account limit 1;");
560
561        let mut proc = new_procedure_invocation(1, false, &zero_vec, "@AdHoc");
562        let bs = proc.bytes();
563        assert_eq!(bs, vec!(0, 0, 0, 56, 0, 0, 0, 0, 6, 64, 65, 100, 72, 111, 99, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 9, 0, 0, 0, 30, 115, 101, 108, 101, 99, 116, 32, 42, 32, 102, 114, 111, 109, 32, 97, 99, 99, 111, 117, 110, 116, 32, 108, 105, 109, 105, 116, 32, 49, 59));
564    }
565
566    #[test]
567    fn test_time_stamp() {
568        let time = Utc.timestamp_millis(1637323002445000 / 1000);
569        println!("{}", time.timestamp_millis() * 1000);
570    }
571
572    #[test]
573    fn test_big_decimal() {
574        let bs: Vec<u8> = vec!(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 90, 243, 16, 122, 64, 0);
575        let int = BigInt::from_signed_bytes_be(&*bs);
576        let decimal = BigDecimal::new(int, 12);
577        let (b, _) = decimal.into_bigint_and_exponent();
578        let b = b.to_signed_bytes_be();
579        println!("{:?}", b);
580
581        let decimal = BigDecimal::from_str("1.11").unwrap().with_scale(12);
582        println!("{:?}", decimal.into_bigint_and_exponent());
583    }
584
585    #[test]
586    fn test_big_test_bytes() {
587        let i = ByteBuffer::from_bytes(&NULL_BIT_VALUE).read_i8().unwrap();
588        assert_eq!(i, -128);
589        let i = ByteBuffer::from_bytes(&NULL_SHORT_VALUE).read_i16().unwrap();
590        assert_eq!(i, -32768);
591        let i = ByteBuffer::from_bytes(&NULL_INT_VALUE).read_i32().unwrap();
592        assert_eq!(i, -2147483648);
593        let i = ByteBuffer::from_bytes(&NULL_LONG_VALUE).read_i64().unwrap();
594        assert_eq!(i, -9223372036854775808);
595
596        let column = Column {
597            header_name: "".to_string(),
598            header_type: STRING_COLUMN,
599        };
600
601        let vec = NULL_BIT_VALUE.to_vec();
602        let op: Option<i8> = Option::from_bytes(vec, &column).unwrap();
603        assert_eq!(None, op);
604        let vec = NULL_BIT_VALUE.to_vec();
605        let op: Option<u8> = Option::from_bytes(vec, &column).unwrap();
606        assert_eq!(None, op);
607        let vec = NULL_SHORT_VALUE.to_vec();
608        let op: Option<i16> = Option::from_bytes(vec, &column).unwrap();
609        assert_eq!(None, op);
610        let vec = NULL_SHORT_VALUE.to_vec();
611        let op: Option<u16> = Option::from_bytes(vec, &column).unwrap();
612        assert_eq!(None, op);
613        let vec = NULL_INT_VALUE.to_vec();
614        let op: Option<i32> = Option::from_bytes(vec, &column).unwrap();
615        assert_eq!(None, op);
616        let vec = NULL_INT_VALUE.to_vec();
617        let op: Option<u32> = Option::from_bytes(vec, &column).unwrap();
618        assert_eq!(None, op);
619
620        let vec = NULL_LONG_VALUE.to_vec();
621        let op: Option<i64> = Option::from_bytes(vec, &column).unwrap();
622        assert_eq!(None, op);
623        let vec = NULL_LONG_VALUE.to_vec();
624        let op: Option<u64> = Option::from_bytes(vec, &column).unwrap();
625        assert_eq!(None, op);
626
627
628        let vec = NULL_VARCHAR.to_vec();
629        let op: Option<String> = Option::from_bytes(vec, &column).unwrap();
630        assert_eq!(None, op);
631
632        let vec = NULL_VARCHAR.to_vec();
633        let op: Option<Vec<u8>> = Option::from_bytes(vec, &column).unwrap();
634        assert_eq!(None, op);
635
636
637        let vec = NULL_FLOAT_VALUE.to_vec();
638        let op: Option<f64> = Option::from_bytes(vec, &column).unwrap();
639        assert_eq!(None, op);
640
641
642        let vec = NULL_DECIMAL.to_vec();
643        let op: Option<BigDecimal> = Option::from_bytes(vec, &column).unwrap();
644        assert_eq!(None, op);
645
646
647        let vec = NULL_TIMESTAMP.to_vec();
648        let op: Option<DateTime<Utc>> = Option::from_bytes(vec, &column).unwrap();
649        assert_eq!(None, op);
650    }
651
652    #[test]
653    fn test_error() {
654        let err = VoltError::NoValue("key is af".to_owned());
655        println!("{:?} {} ", err, err);
656    }
657}
658
voltdb_client_rust/encode.rs

voltdb_client_rust/
encode.rs
