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        #[allow(clippy::approx_constant)]
430        let expected = 3.14159;
431        assert!((val - expected).abs() < 0.0001);
432    }
433
434    #[test]
435    fn test_get_i8_by_column() {
436        let bs = get_value_table_bytes();
437        let mut b = ByteBuffer::from_bytes(&bs);
438        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
439        let mut table = new_volt_table(&mut b, info).unwrap();
440        table.advance_row();
441
442        let result = table.get_i8_by_column("T1").unwrap();
443        assert_eq!(result, Some(42));
444    }
445
446    #[test]
447    fn test_get_u8_by_column() {
448        let bs = get_value_table_bytes();
449        let mut b = ByteBuffer::from_bytes(&bs);
450        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
451        let mut table = new_volt_table(&mut b, info).unwrap();
452        table.advance_row();
453
454        let result = table.get_u8_by_column("T1").unwrap();
455        assert_eq!(result, Some(42));
456    }
457
458    #[test]
459    fn test_get_i16_by_column() {
460        let bs = get_value_table_bytes();
461        let mut b = ByteBuffer::from_bytes(&bs);
462        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
463        let mut table = new_volt_table(&mut b, info).unwrap();
464        table.advance_row();
465
466        let result = table.get_i16_by_column("T2").unwrap();
467        assert_eq!(result, Some(100));
468    }
469
470    #[test]
471    fn test_get_u16_by_column() {
472        let bs = get_value_table_bytes();
473        let mut b = ByteBuffer::from_bytes(&bs);
474        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
475        let mut table = new_volt_table(&mut b, info).unwrap();
476        table.advance_row();
477
478        let result = table.get_u16_by_column("T2").unwrap();
479        assert_eq!(result, Some(100));
480    }
481
482    #[test]
483    fn test_get_i32_by_column() {
484        let bs = get_value_table_bytes();
485        let mut b = ByteBuffer::from_bytes(&bs);
486        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
487        let mut table = new_volt_table(&mut b, info).unwrap();
488        table.advance_row();
489
490        let result = table.get_i32_by_column("T3").unwrap();
491        assert_eq!(result, Some(256));
492    }
493
494    #[test]
495    fn test_get_u32_by_column() {
496        let bs = get_value_table_bytes();
497        let mut b = ByteBuffer::from_bytes(&bs);
498        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
499        let mut table = new_volt_table(&mut b, info).unwrap();
500        table.advance_row();
501
502        let result = table.get_u32_by_column("T3").unwrap();
503        assert_eq!(result, Some(256));
504    }
505
506    #[test]
507    fn test_get_i64_by_column() {
508        let bs = get_value_table_bytes();
509        let mut b = ByteBuffer::from_bytes(&bs);
510        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
511        let mut table = new_volt_table(&mut b, info).unwrap();
512        table.advance_row();
513
514        let result = table.get_i64_by_column("T4").unwrap();
515        assert_eq!(result, Some(42));
516    }
517
518    #[test]
519    fn test_get_u64_by_column() {
520        let bs = get_value_table_bytes();
521        let mut b = ByteBuffer::from_bytes(&bs);
522        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
523        let mut table = new_volt_table(&mut b, info).unwrap();
524        table.advance_row();
525
526        let result = table.get_u64_by_column("T4").unwrap();
527        assert_eq!(result, Some(42));
528    }
529
530    #[test]
531    fn test_get_f32_by_column_null() {
532        let bs = get_null_table_bytes();
533        let mut b = ByteBuffer::from_bytes(&bs);
534        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
535        let mut table = new_volt_table(&mut b, info).unwrap();
536        table.advance_row();
537
538        let result = table.get_f32_by_column("T5").unwrap();
539        assert_eq!(result, None);
540    }
541
542    #[test]
543    fn test_get_f64_by_column() {
544        let bs = get_value_table_bytes();
545        let mut b = ByteBuffer::from_bytes(&bs);
546        let info = VoltResponseInfo::new(&mut b, 1).unwrap();
547        let mut table = new_volt_table(&mut b, info).unwrap();
548        table.advance_row();
549
550        let result = table.get_f64_by_column("T5").unwrap();
551        assert!(result.is_some());
552        let val = result.unwrap();
553        #[allow(clippy::approx_constant)]
554        let expected = 3.14159;
555        assert!((val - expected).abs() < 0.0001);
556    }
557}
voltdb_client_rust/generate.rs

voltdb_client_rust/
generate.rs
