voltdb_client_rust/
generate.rs

1use bytebuffer::ByteBuffer;
2
3use crate::encode::*;
4use crate::table::VoltTable;
5
6impl VoltTable {
7    pub fn get_i8_by_column(&mut self, column: &str) -> Result<Option<i8>, VoltError> {
8        let idx = self.get_column_index(column)?;
9        self.get_i8_by_idx(idx)
10    }
11
12    pub fn get_i8_by_idx(&mut self, column: i16) -> Result<Option<i8>, VoltError> {
13        let bs = self.get_bytes_by_idx(column)?;
14        if bs == NULL_BIT_VALUE {
15            return Ok(Option::None);
16        }
17        let mut buffer = ByteBuffer::from_bytes(&bs);
18        let value = buffer.read_i8()?;
19        Ok(Some(value))
20    }
21
22    pub fn get_u8_by_column(&mut self, column: &str) -> Result<Option<u8>, VoltError> {
23        let idx = self.get_column_index(column)?;
24        self.get_u8_by_idx(idx)
25    }
26
27    pub fn get_u8_by_idx(&mut self, column: i16) -> Result<Option<u8>, VoltError> {
28        let bs = self.get_bytes_by_idx(column)?;
29        if bs == NULL_BIT_VALUE {
30            return Ok(Option::None);
31        }
32        let mut buffer = ByteBuffer::from_bytes(&bs);
33        let value = buffer.read_u8()?;
34        Ok(Some(value))
35    }
36
37    pub fn get_i16_by_column(&mut self, column: &str) -> Result<Option<i16>, VoltError> {
38        let idx = self.get_column_index(column)?;
39        self.get_i16_by_idx(idx)
40    }
41
42    pub fn get_i16_by_idx(&mut self, column: i16) -> Result<Option<i16>, VoltError> {
43        let bs = self.get_bytes_by_idx(column)?;
44        if bs == NULL_SHORT_VALUE {
45            return Ok(Option::None);
46        }
47        let mut buffer = ByteBuffer::from_bytes(&bs);
48        let value = buffer.read_i16()?;
49        Ok(Some(value))
50    }
51
52    pub fn get_u16_by_column(&mut self, column: &str) -> Result<Option<u16>, VoltError> {
53        let idx = self.get_column_index(column)?;
54        self.get_u16_by_idx(idx)
55    }
56
57    pub fn get_u16_by_idx(&mut self, column: i16) -> Result<Option<u16>, VoltError> {
58        let bs = self.get_bytes_by_idx(column)?;
59        if bs == NULL_SHORT_VALUE {
60            return Ok(Option::None);
61        }
62        let mut buffer = ByteBuffer::from_bytes(&bs);
63        let value = buffer.read_u16()?;
64        Ok(Some(value))
65    }
66
67    pub fn get_i32_by_column(&mut self, column: &str) -> Result<Option<i32>, VoltError> {
68        let idx = self.get_column_index(column)?;
69        self.get_i32_by_idx(idx)
70    }
71
72    pub fn get_i32_by_idx(&mut self, column: i16) -> Result<Option<i32>, VoltError> {
73        let bs = self.get_bytes_by_idx(column)?;
74        if bs == NULL_INT_VALUE {
75            return Ok(Option::None);
76        }
77        let mut buffer = ByteBuffer::from_bytes(&bs);
78        let value = buffer.read_i32()?;
79        Ok(Some(value))
80    }
81
82    pub fn get_u32_by_column(&mut self, column: &str) -> Result<Option<u32>, VoltError> {
83        let idx = self.get_column_index(column)?;
84        self.get_u32_by_idx(idx)
85    }
86
87    pub fn get_u32_by_idx(&mut self, column: i16) -> Result<Option<u32>, VoltError> {
88        let bs = self.get_bytes_by_idx(column)?;
89        if bs == NULL_INT_VALUE {
90            return Ok(Option::None);
91        }
92        let mut buffer = ByteBuffer::from_bytes(&bs);
93        let value = buffer.read_u32()?;
94        Ok(Some(value))
95    }
96
97    pub fn get_i64_by_column(&mut self, column: &str) -> Result<Option<i64>, VoltError> {
98        let idx = self.get_column_index(column)?;
99        self.get_i64_by_idx(idx)
100    }
101
102    pub fn get_i64_by_idx(&mut self, column: i16) -> Result<Option<i64>, VoltError> {
103        let bs = self.get_bytes_by_idx(column)?;
104        if bs == NULL_LONG_VALUE {
105            return Ok(Option::None);
106        }
107        let mut buffer = ByteBuffer::from_bytes(&bs);
108        let value = buffer.read_i64()?;
109        Ok(Some(value))
110    }
111
112    pub fn get_u64_by_column(&mut self, column: &str) -> Result<Option<u64>, VoltError> {
113        let idx = self.get_column_index(column)?;
114        self.get_u64_by_idx(idx)
115    }
116
117    pub fn get_u64_by_idx(&mut self, column: i16) -> Result<Option<u64>, VoltError> {
118        let bs = self.get_bytes_by_idx(column)?;
119        if bs == NULL_LONG_VALUE {
120            return Ok(Option::None);
121        }
122        let mut buffer = ByteBuffer::from_bytes(&bs);
123        let value = buffer.read_u64()?;
124        Ok(Some(value))
125    }
126
127    pub fn get_f32_by_column(&mut self, column: &str) -> Result<Option<f32>, VoltError> {
128        let idx = self.get_column_index(column)?;
129        self.get_f32_by_idx(idx)
130    }
131
132    pub fn get_f32_by_idx(&mut self, column: i16) -> Result<Option<f32>, VoltError> {
133        let bs = self.get_bytes_by_idx(column)?;
134        if bs == NULL_FLOAT_VALUE {
135            return Ok(Option::None);
136        }
137        let mut buffer = ByteBuffer::from_bytes(&bs);
138        let value = buffer.read_f32()?;
139        Ok(Some(value))
140    }
141
142    pub fn get_f64_by_column(&mut self, column: &str) -> Result<Option<f64>, VoltError> {
143        let idx = self.get_column_index(column)?;
144        self.get_f64_by_idx(idx)
145    }
146
147    pub fn get_f64_by_idx(&mut self, column: i16) -> Result<Option<f64>, VoltError> {
148        let bs = self.get_bytes_by_idx(column)?;
149        if bs == NULL_FLOAT_VALUE {
150            return Ok(Option::None);
151        }
152        let mut buffer = ByteBuffer::from_bytes(&bs);
153        let value = buffer.read_f64()?;
154        Ok(Some(value))
155    }
156}
157
158#[cfg(test)]
159mod tests {
160    use crate::response::VoltResponseInfo;
161    use crate::table::new_volt_table;
162    use bytebuffer::ByteBuffer;
163
164    // Test bytes for a table with various numeric columns:
165    // Columns: T1(tinyint), T2(short), T3(int), T4(long), T5(float)
166    // Values: -128 (NULL), -32768 (NULL), -2147483648 (NULL), -9223372036854775808 (NULL), NULL float
167    fn get_null_table_bytes() -> Vec<u8> {
168        vec![
169            0, 1, 128, 0, 0, 0, 3, 0, 1, 0, 0, 0, 133, 0, 0, 0, 66, 128, 0, 9, 3, 4, 5, 6, 8, 22,
170            9, 25, 11, 0, 0, 0, 2, 84, 49, 0, 0, 0, 2, 84, 50, 0, 0, 0, 2, 84, 51, 0, 0, 0, 2, 84,
171            52, 0, 0, 0, 2, 84, 53, 0, 0, 0, 2, 84, 54, 0, 0, 0, 2, 84, 55, 0, 0, 0, 2, 84, 56, 0,
172            0, 0, 2, 84, 57, 0, 0, 0, 1, 0, 0, 0, 55, 128, // T1: NULL tinyint
173            128, 0, // T2: NULL short
174            128, 0, 0, 0, // T3: NULL int
175            128, 0, 0, 0, 0, 0, 0, 0, // T4: NULL long
176            255, 239, 255, 255, 255, 255, 255, 255, // T5: NULL float
177            128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // T6: NULL decimal
178            255, 255, 255, 255, // T7: NULL string
179            255, 255, 255, 255, // T8: NULL varbinary
180            128, 0, 0, 0, 0, 0, 0, 0, // T9: NULL timestamp
181        ]
182    }
183
184    // Test bytes with actual values (non-NULL)
185    fn get_value_table_bytes() -> Vec<u8> {
186        vec![
187            0, 1, 128, 0, 0, 0, 3, 0, 1, 0, 0, 0, 133, 0, 0, 0, 66, 128, 0, 9, 3, 4, 5, 6, 8, 22,
188            9, 25, 11, 0, 0, 0, 2, 84, 49, 0, 0, 0, 2, 84, 50, 0, 0, 0, 2, 84, 51, 0, 0, 0, 2, 84,
189            52, 0, 0, 0, 2, 84, 53, 0, 0, 0, 2, 84, 54, 0, 0, 0, 2, 84, 55, 0, 0, 0, 2, 84, 56, 0,
190            0, 0, 2, 84, 57, 0, 0, 0, 1, 0, 0, 0, 55, 42, // T1: tinyint = 42
191            0, 100, // T2: short = 100
192            0, 0, 1, 0, // T3: int = 256
193            0, 0, 0, 0, 0, 0, 0, 42, // T4: long = 42
194            64, 9, 33, 251, 84, 68, 45, 24, // T5: f64 ~ 3.14159
195            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 212, 165, 16, 0, // T6: decimal
196            255, 255, 255, 255, // T7: NULL string
197            255, 255, 255, 255, // T8: NULL varbinary
198            0, 0, 0, 0, 0, 15, 66, 64, // T9: timestamp
199        ]
200    }
201
202    #[test]
203    fn test_get_i8_by_idx_null() {
204        let bs = get_null_table_bytes();
205        let mut b = ByteBuffer::from_bytes(&bs);
206        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
207        let mut table = new_volt_table(&mut b, info).unwrap();
208        table.advance_row();
209
210        let result = table.get_i8_by_idx(0).unwrap();
211        assert_eq!(result, None);
212    }
213
214    #[test]
215    fn test_get_i8_by_idx_value() {
216        let bs = get_value_table_bytes();
217        let mut b = ByteBuffer::from_bytes(&bs);
218        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
219        let mut table = new_volt_table(&mut b, info).unwrap();
220        table.advance_row();
221
222        let result = table.get_i8_by_idx(0).unwrap();
223        assert_eq!(result, Some(42));
224    }
225
226    #[test]
227    fn test_get_u8_by_idx_null() {
228        let bs = get_null_table_bytes();
229        let mut b = ByteBuffer::from_bytes(&bs);
230        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
231        let mut table = new_volt_table(&mut b, info).unwrap();
232        table.advance_row();
233
234        let result = table.get_u8_by_idx(0).unwrap();
235        assert_eq!(result, None);
236    }
237
238    #[test]
239    fn test_get_u8_by_idx_value() {
240        let bs = get_value_table_bytes();
241        let mut b = ByteBuffer::from_bytes(&bs);
242        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
243        let mut table = new_volt_table(&mut b, info).unwrap();
244        table.advance_row();
245
246        let result = table.get_u8_by_idx(0).unwrap();
247        assert_eq!(result, Some(42));
248    }
249
250    #[test]
251    fn test_get_i16_by_idx_null() {
252        let bs = get_null_table_bytes();
253        let mut b = ByteBuffer::from_bytes(&bs);
254        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
255        let mut table = new_volt_table(&mut b, info).unwrap();
256        table.advance_row();
257
258        let result = table.get_i16_by_idx(1).unwrap();
259        assert_eq!(result, None);
260    }
261
262    #[test]
263    fn test_get_i16_by_idx_value() {
264        let bs = get_value_table_bytes();
265        let mut b = ByteBuffer::from_bytes(&bs);
266        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
267        let mut table = new_volt_table(&mut b, info).unwrap();
268        table.advance_row();
269
270        let result = table.get_i16_by_idx(1).unwrap();
271        assert_eq!(result, Some(100));
272    }
273
274    #[test]
275    fn test_get_u16_by_idx_null() {
276        let bs = get_null_table_bytes();
277        let mut b = ByteBuffer::from_bytes(&bs);
278        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
279        let mut table = new_volt_table(&mut b, info).unwrap();
280        table.advance_row();
281
282        let result = table.get_u16_by_idx(1).unwrap();
283        assert_eq!(result, None);
284    }
285
286    #[test]
287    fn test_get_u16_by_idx_value() {
288        let bs = get_value_table_bytes();
289        let mut b = ByteBuffer::from_bytes(&bs);
290        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
291        let mut table = new_volt_table(&mut b, info).unwrap();
292        table.advance_row();
293
294        let result = table.get_u16_by_idx(1).unwrap();
295        assert_eq!(result, Some(100));
296    }
297
298    #[test]
299    fn test_get_i32_by_idx_null() {
300        let bs = get_null_table_bytes();
301        let mut b = ByteBuffer::from_bytes(&bs);
302        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
303        let mut table = new_volt_table(&mut b, info).unwrap();
304        table.advance_row();
305
306        let result = table.get_i32_by_idx(2).unwrap();
307        assert_eq!(result, None);
308    }
309
310    #[test]
311    fn test_get_i32_by_idx_value() {
312        let bs = get_value_table_bytes();
313        let mut b = ByteBuffer::from_bytes(&bs);
314        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
315        let mut table = new_volt_table(&mut b, info).unwrap();
316        table.advance_row();
317
318        let result = table.get_i32_by_idx(2).unwrap();
319        assert_eq!(result, Some(256));
320    }
321
322    #[test]
323    fn test_get_u32_by_idx_null() {
324        let bs = get_null_table_bytes();
325        let mut b = ByteBuffer::from_bytes(&bs);
326        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
327        let mut table = new_volt_table(&mut b, info).unwrap();
328        table.advance_row();
329
330        let result = table.get_u32_by_idx(2).unwrap();
331        assert_eq!(result, None);
332    }
333
334    #[test]
335    fn test_get_u32_by_idx_value() {
336        let bs = get_value_table_bytes();
337        let mut b = ByteBuffer::from_bytes(&bs);
338        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
339        let mut table = new_volt_table(&mut b, info).unwrap();
340        table.advance_row();
341
342        let result = table.get_u32_by_idx(2).unwrap();
343        assert_eq!(result, Some(256));
344    }
345
346    #[test]
347    fn test_get_i64_by_idx_null() {
348        let bs = get_null_table_bytes();
349        let mut b = ByteBuffer::from_bytes(&bs);
350        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
351        let mut table = new_volt_table(&mut b, info).unwrap();
352        table.advance_row();
353
354        let result = table.get_i64_by_idx(3).unwrap();
355        assert_eq!(result, None);
356    }
357
358    #[test]
359    fn test_get_i64_by_idx_value() {
360        let bs = get_value_table_bytes();
361        let mut b = ByteBuffer::from_bytes(&bs);
362        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
363        let mut table = new_volt_table(&mut b, info).unwrap();
364        table.advance_row();
365
366        let result = table.get_i64_by_idx(3).unwrap();
367        assert_eq!(result, Some(42));
368    }
369
370    #[test]
371    fn test_get_u64_by_idx_null() {
372        let bs = get_null_table_bytes();
373        let mut b = ByteBuffer::from_bytes(&bs);
374        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
375        let mut table = new_volt_table(&mut b, info).unwrap();
376        table.advance_row();
377
378        let result = table.get_u64_by_idx(3).unwrap();
379        assert_eq!(result, None);
380    }
381
382    #[test]
383    fn test_get_u64_by_idx_value() {
384        let bs = get_value_table_bytes();
385        let mut b = ByteBuffer::from_bytes(&bs);
386        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
387        let mut table = new_volt_table(&mut b, info).unwrap();
388        table.advance_row();
389
390        let result = table.get_u64_by_idx(3).unwrap();
391        assert_eq!(result, Some(42));
392    }
393
394    #[test]
395    fn test_get_f32_by_idx_null() {
396        let bs = get_null_table_bytes();
397        let mut b = ByteBuffer::from_bytes(&bs);
398        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
399        let mut table = new_volt_table(&mut b, info).unwrap();
400        table.advance_row();
401
402        let result = table.get_f32_by_idx(4).unwrap();
403        assert_eq!(result, None);
404    }
405
406    #[test]
407    fn test_get_f64_by_idx_null() {
408        let bs = get_null_table_bytes();
409        let mut b = ByteBuffer::from_bytes(&bs);
410        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
411        let mut table = new_volt_table(&mut b, info).unwrap();
412        table.advance_row();
413
414        let result = table.get_f64_by_idx(4).unwrap();
415        assert_eq!(result, None);
416    }
417
418    #[test]
419    fn test_get_f64_by_idx_value() {
420        let bs = get_value_table_bytes();
421        let mut b = ByteBuffer::from_bytes(&bs);
422        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
423        let mut table = new_volt_table(&mut b, info).unwrap();
424        table.advance_row();
425
426        let result = table.get_f64_by_idx(4).unwrap();
427        assert!(result.is_some());
428        let val = result.unwrap();
429        assert!((val - 3.14159).abs() < 0.0001);
430    }
431
432    #[test]
433    fn test_get_i8_by_column() {
434        let bs = get_value_table_bytes();
435        let mut b = ByteBuffer::from_bytes(&bs);
436        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
437        let mut table = new_volt_table(&mut b, info).unwrap();
438        table.advance_row();
439
440        let result = table.get_i8_by_column("T1").unwrap();
441        assert_eq!(result, Some(42));
442    }
443
444    #[test]
445    fn test_get_u8_by_column() {
446        let bs = get_value_table_bytes();
447        let mut b = ByteBuffer::from_bytes(&bs);
448        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
449        let mut table = new_volt_table(&mut b, info).unwrap();
450        table.advance_row();
451
452        let result = table.get_u8_by_column("T1").unwrap();
453        assert_eq!(result, Some(42));
454    }
455
456    #[test]
457    fn test_get_i16_by_column() {
458        let bs = get_value_table_bytes();
459        let mut b = ByteBuffer::from_bytes(&bs);
460        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
461        let mut table = new_volt_table(&mut b, info).unwrap();
462        table.advance_row();
463
464        let result = table.get_i16_by_column("T2").unwrap();
465        assert_eq!(result, Some(100));
466    }
467
468    #[test]
469    fn test_get_u16_by_column() {
470        let bs = get_value_table_bytes();
471        let mut b = ByteBuffer::from_bytes(&bs);
472        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
473        let mut table = new_volt_table(&mut b, info).unwrap();
474        table.advance_row();
475
476        let result = table.get_u16_by_column("T2").unwrap();
477        assert_eq!(result, Some(100));
478    }
479
480    #[test]
481    fn test_get_i32_by_column() {
482        let bs = get_value_table_bytes();
483        let mut b = ByteBuffer::from_bytes(&bs);
484        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
485        let mut table = new_volt_table(&mut b, info).unwrap();
486        table.advance_row();
487
488        let result = table.get_i32_by_column("T3").unwrap();
489        assert_eq!(result, Some(256));
490    }
491
492    #[test]
493    fn test_get_u32_by_column() {
494        let bs = get_value_table_bytes();
495        let mut b = ByteBuffer::from_bytes(&bs);
496        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
497        let mut table = new_volt_table(&mut b, info).unwrap();
498        table.advance_row();
499
500        let result = table.get_u32_by_column("T3").unwrap();
501        assert_eq!(result, Some(256));
502    }
503
504    #[test]
505    fn test_get_i64_by_column() {
506        let bs = get_value_table_bytes();
507        let mut b = ByteBuffer::from_bytes(&bs);
508        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
509        let mut table = new_volt_table(&mut b, info).unwrap();
510        table.advance_row();
511
512        let result = table.get_i64_by_column("T4").unwrap();
513        assert_eq!(result, Some(42));
514    }
515
516    #[test]
517    fn test_get_u64_by_column() {
518        let bs = get_value_table_bytes();
519        let mut b = ByteBuffer::from_bytes(&bs);
520        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
521        let mut table = new_volt_table(&mut b, info).unwrap();
522        table.advance_row();
523
524        let result = table.get_u64_by_column("T4").unwrap();
525        assert_eq!(result, Some(42));
526    }
527
528    #[test]
529    fn test_get_f32_by_column_null() {
530        let bs = get_null_table_bytes();
531        let mut b = ByteBuffer::from_bytes(&bs);
532        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
533        let mut table = new_volt_table(&mut b, info).unwrap();
534        table.advance_row();
535
536        let result = table.get_f32_by_column("T5").unwrap();
537        assert_eq!(result, None);
538    }
539
540    #[test]
541    fn test_get_f64_by_column() {
542        let bs = get_value_table_bytes();
543        let mut b = ByteBuffer::from_bytes(&bs);
544        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
545        let mut table = new_volt_table(&mut b, info).unwrap();
546        table.advance_row();
547
548        let result = table.get_f64_by_column("T5").unwrap();
549        assert!(result.is_some());
550        let val = result.unwrap();
551        assert!((val - 3.14159).abs() < 0.0001);
552    }
553}
voltdb_client_rust/generate.rs

voltdb_client_rust/
generate.rs
