quill_sql/utils/
scalar.rs

1use crate::catalog::DataType;
2use crate::error::{QuillSQLError, QuillSQLResult};
3use std::cmp::Ordering;
4
5#[derive(Debug, Clone)]
6pub enum ScalarValue {
7    Boolean(Option<bool>),
8    Int8(Option<i8>),
9    Int16(Option<i16>),
10    Int32(Option<i32>),
11    Int64(Option<i64>),
12    UInt8(Option<u8>),
13    UInt16(Option<u16>),
14    UInt32(Option<u32>),
15    UInt64(Option<u64>),
16    Float32(Option<f32>),
17    Float64(Option<f64>),
18    Varchar(Option<String>),
19}
20
21impl ScalarValue {
22    pub fn new_empty(data_type: DataType) -> Self {
23        match data_type {
24            DataType::Boolean => Self::Boolean(None),
25            DataType::Int8 => Self::Int8(None),
26            DataType::Int16 => Self::Int16(None),
27            DataType::Int32 => Self::Int32(None),
28            DataType::Int64 => Self::Int64(None),
29            DataType::UInt8 => Self::UInt8(None),
30            DataType::UInt16 => Self::UInt16(None),
31            DataType::UInt32 => Self::UInt32(None),
32            DataType::UInt64 => Self::UInt64(None),
33            DataType::Float32 => Self::Float32(None),
34            DataType::Float64 => Self::Float64(None),
35            DataType::Varchar(_) => Self::Varchar(None),
36        }
37    }
38
39    pub fn data_type(&self) -> DataType {
40        match self {
41            ScalarValue::Boolean(_) => DataType::Boolean,
42            ScalarValue::Int8(_) => DataType::Int8,
43            ScalarValue::Int16(_) => DataType::Int16,
44            ScalarValue::Int32(_) => DataType::Int32,
45            ScalarValue::Int64(_) => DataType::Int64,
46            ScalarValue::UInt8(_) => DataType::UInt8,
47            ScalarValue::UInt16(_) => DataType::UInt16,
48            ScalarValue::UInt32(_) => DataType::UInt32,
49            ScalarValue::UInt64(_) => DataType::UInt64,
50            ScalarValue::Float32(_) => DataType::Float32,
51            ScalarValue::Float64(_) => DataType::Float64,
52            ScalarValue::Varchar(_) => DataType::Varchar(None),
53        }
54    }
55
56    pub fn is_null(&self) -> bool {
57        match self {
58            ScalarValue::Boolean(v) => v.is_none(),
59            ScalarValue::Int8(v) => v.is_none(),
60            ScalarValue::Int16(v) => v.is_none(),
61            ScalarValue::Int32(v) => v.is_none(),
62            ScalarValue::Int64(v) => v.is_none(),
63            ScalarValue::UInt8(v) => v.is_none(),
64            ScalarValue::UInt16(v) => v.is_none(),
65            ScalarValue::UInt32(v) => v.is_none(),
66            ScalarValue::UInt64(v) => v.is_none(),
67            ScalarValue::Float32(v) => v.is_none(),
68            ScalarValue::Float64(v) => v.is_none(),
69            ScalarValue::Varchar(v) => v.is_none(),
70        }
71    }
72
73    /// Try to cast this value to a ScalarValue of type `data_type`
74    pub fn cast_to(&self, data_type: &DataType) -> QuillSQLResult<Self> {
75        let error =
76            QuillSQLError::NotSupport(format!("Failed to cast {:?} to {} type", self, data_type));
77
78        if &self.data_type() == data_type {
79            return Ok(self.clone());
80        }
81
82        match data_type {
83            DataType::Int8 => {
84                let data = match self {
85                    ScalarValue::Int64(v) => Ok(v.map(|v| v as i8)),
86                    _ => Err(error),
87                };
88                data.map(ScalarValue::Int8)
89            }
90            DataType::Int16 => {
91                let data = match self {
92                    ScalarValue::Int8(v) => Ok(v.map(|v| v as i16)),
93                    ScalarValue::Int64(v) => Ok(v.map(|v| v as i16)),
94                    _ => Err(error),
95                };
96                data.map(ScalarValue::Int16)
97            }
98            DataType::Int32 => {
99                let data = match self {
100                    ScalarValue::Int8(v) => Ok(v.map(|v| v as i32)),
101                    ScalarValue::Int64(v) => Ok(v.map(|v| v as i32)),
102                    _ => Err(error),
103                };
104                data.map(ScalarValue::Int32)
105            }
106            DataType::Int64 => {
107                let data = match self {
108                    ScalarValue::Int8(v) => Ok(v.map(|v| v as i64)),
109                    ScalarValue::Int32(v) => Ok(v.map(|v| v as i64)),
110                    _ => Err(error),
111                };
112                data.map(ScalarValue::Int64)
113            }
114            DataType::UInt8 => {
115                let data = match self {
116                    ScalarValue::Int8(v) => Ok(v.map(|v| v as u8)),
117                    ScalarValue::Int64(v) => Ok(v.map(|v| v as u8)),
118                    _ => Err(error),
119                };
120                data.map(ScalarValue::UInt8)
121            }
122            DataType::UInt16 => {
123                let data = match self {
124                    ScalarValue::Int8(v) => Ok(v.map(|v| v as u16)),
125                    ScalarValue::Int64(v) => Ok(v.map(|v| v as u16)),
126                    _ => Err(error),
127                };
128                data.map(ScalarValue::UInt16)
129            }
130            DataType::UInt32 => {
131                let data = match self {
132                    ScalarValue::Int8(v) => Ok(v.map(|v| v as u32)),
133                    ScalarValue::Int64(v) => Ok(v.map(|v| v as u32)),
134                    _ => Err(error),
135                };
136                data.map(ScalarValue::UInt32)
137            }
138            DataType::UInt64 => {
139                let data = match self {
140                    ScalarValue::Int8(v) => Ok(v.map(|v| v as u64)),
141                    ScalarValue::Int64(v) => Ok(v.map(|v| v as u64)),
142                    _ => Err(error),
143                };
144                data.map(ScalarValue::UInt64)
145            }
146            DataType::Float32 => {
147                let data = match self {
148                    ScalarValue::Int8(v) => Ok(v.map(|v| v as f32)),
149                    ScalarValue::Int64(v) => Ok(v.map(|v| v as f32)),
150                    ScalarValue::Float64(v) => Ok(v.map(|v| v as f32)),
151                    _ => Err(error),
152                };
153                data.map(ScalarValue::Float32)
154            }
155            DataType::Float64 => {
156                let data = match self {
157                    ScalarValue::Int8(v) => Ok(v.map(|v| v as f64)),
158                    ScalarValue::Int32(v) => Ok(v.map(|v| v as f64)),
159                    ScalarValue::Int64(v) => Ok(v.map(|v| v as f64)),
160                    _ => Err(error),
161                };
162                data.map(ScalarValue::Float64)
163            }
164            DataType::Varchar(_) => match self {
165                ScalarValue::Varchar(v) => Ok(ScalarValue::Varchar(v.clone())),
166                ScalarValue::Int8(v) => Ok(ScalarValue::Varchar(v.map(|v| v.to_string()))),
167                _ => Err(error),
168            },
169            _ => Err(error),
170        }
171    }
172
173    pub fn as_boolean(&self) -> QuillSQLResult<Option<bool>> {
174        match self {
175            ScalarValue::Boolean(v) => Ok(*v),
176            _ => Err(QuillSQLError::Internal(format!(
177                "Cannot treat {:?} as boolean",
178                self
179            ))),
180        }
181    }
182
183    pub fn wrapping_add(&self, other: Self) -> QuillSQLResult<Self> {
184        use ScalarValue::*;
185        match (self, other.clone()) {
186            (Int8(Some(a)), Int8(Some(b))) => Ok(Int8(Some(a.wrapping_add(b)))),
187            (Int16(Some(a)), Int16(Some(b))) => Ok(Int16(Some(a.wrapping_add(b)))),
188            (Int32(Some(a)), Int32(Some(b))) => Ok(Int32(Some(a.wrapping_add(b)))),
189            (Int64(Some(a)), Int64(Some(b))) => Ok(Int64(Some(a.wrapping_add(b)))),
190            (UInt8(Some(a)), UInt8(Some(b))) => Ok(UInt8(Some(a.wrapping_add(b)))),
191            (UInt16(Some(a)), UInt16(Some(b))) => Ok(UInt16(Some(a.wrapping_add(b)))),
192            (UInt32(Some(a)), UInt32(Some(b))) => Ok(UInt32(Some(a.wrapping_add(b)))),
193            (UInt64(Some(a)), UInt64(Some(b))) => Ok(UInt64(Some(a.wrapping_add(b)))),
194            (Float32(Some(a)), Float32(Some(b))) => Ok(Float32(Some(a + b))),
195            (Float64(Some(a)), Float64(Some(b))) => Ok(Float64(Some(a + b))),
196            (Int8(None), _)
197            | (Int16(None), _)
198            | (Int32(None), _)
199            | (Int64(None), _)
200            | (UInt8(None), _)
201            | (UInt16(None), _)
202            | (UInt32(None), _)
203            | (UInt64(None), _)
204            | (Float32(None), _)
205            | (Float64(None), _) => Ok(self.clone()),
206            _ => Err(QuillSQLError::Execution(format!(
207                "Unsupported addition between {:?} and {:?}",
208                self, other
209            ))),
210        }
211    }
212
213    pub fn wrapping_sub(&self, other: Self) -> QuillSQLResult<Self> {
214        use ScalarValue::*;
215        match (self, other.clone()) {
216            (Int8(Some(a)), Int8(Some(b))) => Ok(Int8(Some(a.wrapping_sub(b)))),
217            (Int16(Some(a)), Int16(Some(b))) => Ok(Int16(Some(a.wrapping_sub(b)))),
218            (Int32(Some(a)), Int32(Some(b))) => Ok(Int32(Some(a.wrapping_sub(b)))),
219            (Int64(Some(a)), Int64(Some(b))) => Ok(Int64(Some(a.wrapping_sub(b)))),
220            (UInt8(Some(a)), UInt8(Some(b))) => Ok(UInt8(Some(a.wrapping_sub(b)))),
221            (UInt16(Some(a)), UInt16(Some(b))) => Ok(UInt16(Some(a.wrapping_sub(b)))),
222            (UInt32(Some(a)), UInt32(Some(b))) => Ok(UInt32(Some(a.wrapping_sub(b)))),
223            (UInt64(Some(a)), UInt64(Some(b))) => Ok(UInt64(Some(a.wrapping_sub(b)))),
224            (Float32(Some(a)), Float32(Some(b))) => Ok(Float32(Some(a - b))),
225            (Float64(Some(a)), Float64(Some(b))) => Ok(Float64(Some(a - b))),
226            (Int8(None), _)
227            | (Int16(None), _)
228            | (Int32(None), _)
229            | (Int64(None), _)
230            | (UInt8(None), _)
231            | (UInt16(None), _)
232            | (UInt32(None), _)
233            | (UInt64(None), _)
234            | (Float32(None), _)
235            | (Float64(None), _) => Ok(self.clone()),
236            _ => Err(QuillSQLError::Execution(format!(
237                "Unsupported subtraction between {:?} and {:?}",
238                self, other
239            ))),
240        }
241    }
242
243    pub fn wrapping_mul(&self, other: Self) -> QuillSQLResult<Self> {
244        use ScalarValue::*;
245        match (self, other.clone()) {
246            (Int32(Some(a)), Int32(Some(b))) => Ok(Int32(Some(a.wrapping_mul(b)))),
247            (Int64(Some(a)), Int64(Some(b))) => Ok(Int64(Some(a.wrapping_mul(b)))),
248            (UInt32(Some(a)), UInt32(Some(b))) => Ok(UInt32(Some(a.wrapping_mul(b)))),
249            (UInt64(Some(a)), UInt64(Some(b))) => Ok(UInt64(Some(a.wrapping_mul(b)))),
250            (Float32(Some(a)), Float32(Some(b))) => Ok(Float32(Some(a * b))),
251            (Float64(Some(a)), Float64(Some(b))) => Ok(Float64(Some(a * b))),
252            (Int8(Some(a)), Int8(Some(b))) => Ok(Int8(Some(a.wrapping_mul(b)))),
253            (Int16(Some(a)), Int16(Some(b))) => Ok(Int16(Some(a.wrapping_mul(b)))),
254            (UInt8(Some(a)), UInt8(Some(b))) => Ok(UInt8(Some(a.wrapping_mul(b)))),
255            (UInt16(Some(a)), UInt16(Some(b))) => Ok(UInt16(Some(a.wrapping_mul(b)))),
256            (Int8(None), _)
257            | (Int16(None), _)
258            | (Int32(None), _)
259            | (Int64(None), _)
260            | (UInt8(None), _)
261            | (UInt16(None), _)
262            | (UInt32(None), _)
263            | (UInt64(None), _)
264            | (Float32(None), _)
265            | (Float64(None), _) => Ok(self.clone()),
266            _ => Err(QuillSQLError::Execution(format!(
267                "Unsupported multiplication between {:?} and {:?}",
268                self, other
269            ))),
270        }
271    }
272
273    pub fn wrapping_div(&self, other: Self) -> QuillSQLResult<Self> {
274        use ScalarValue::*;
275        match (self, other.clone()) {
276            (Int8(Some(a)), Int8(Some(b))) => Ok(Int8(Some(a.wrapping_div(b)))),
277            (Int16(Some(a)), Int16(Some(b))) => Ok(Int16(Some(a.wrapping_div(b)))),
278            (Int32(Some(a)), Int32(Some(b))) => Ok(Int32(Some(a.wrapping_div(b)))),
279            (Int64(Some(a)), Int64(Some(b))) => Ok(Int64(Some(a.wrapping_div(b)))),
280            (UInt8(Some(a)), UInt8(Some(b))) => Ok(UInt8(Some(a.wrapping_div(b)))),
281            (UInt16(Some(a)), UInt16(Some(b))) => Ok(UInt16(Some(a.wrapping_div(b)))),
282            (UInt32(Some(a)), UInt32(Some(b))) => Ok(UInt32(Some(a.wrapping_div(b)))),
283            (UInt64(Some(a)), UInt64(Some(b))) => Ok(UInt64(Some(a.wrapping_div(b)))),
284            (Float32(Some(a)), Float32(Some(b))) => Ok(Float32(Some(a / b))),
285            (Float64(Some(a)), Float64(Some(b))) => Ok(Float64(Some(a / b))),
286            (Int8(None), _)
287            | (Int16(None), _)
288            | (Int32(None), _)
289            | (Int64(None), _)
290            | (UInt8(None), _)
291            | (UInt16(None), _)
292            | (UInt32(None), _)
293            | (UInt64(None), _)
294            | (Float32(None), _)
295            | (Float64(None), _) => Ok(self.clone()),
296            _ => Err(QuillSQLError::Execution(format!(
297                "Unsupported division between {:?} and {:?}",
298                self, other
299            ))),
300        }
301    }
302
303    pub fn from_string(string: &str, data_type: DataType) -> QuillSQLResult<Self> {
304        let is_null = string.eq_ignore_ascii_case("null");
305        match data_type {
306            DataType::Boolean => {
307                let v = if is_null {
308                    None
309                } else {
310                    let v = string
311                        .parse::<bool>()
312                        .map_err(|_| QuillSQLError::Internal("Parse bool failed".to_string()))?;
313                    Some(v)
314                };
315                Ok(ScalarValue::Boolean(v))
316            }
317            DataType::Int8 => {
318                let v = if is_null {
319                    None
320                } else {
321                    let v = string
322                        .parse::<i8>()
323                        .map_err(|_| QuillSQLError::Internal("Parse i8 failed".to_string()))?;
324                    Some(v)
325                };
326                Ok(ScalarValue::Int8(v))
327            }
328            DataType::Int16 => {
329                let v = if is_null {
330                    None
331                } else {
332                    let v = string
333                        .parse::<i16>()
334                        .map_err(|_| QuillSQLError::Internal("Parse i16 failed".to_string()))?;
335                    Some(v)
336                };
337                Ok(ScalarValue::Int16(v))
338            }
339            DataType::Int32 => {
340                let v = if is_null {
341                    None
342                } else {
343                    let v = string
344                        .parse::<i32>()
345                        .map_err(|_| QuillSQLError::Internal("Parse i32 failed".to_string()))?;
346                    Some(v)
347                };
348                Ok(ScalarValue::Int32(v))
349            }
350            DataType::Int64 => {
351                let v = if is_null {
352                    None
353                } else {
354                    let v = string
355                        .parse::<i64>()
356                        .map_err(|_| QuillSQLError::Internal("Parse i64 failed".to_string()))?;
357                    Some(v)
358                };
359                Ok(ScalarValue::Int64(v))
360            }
361            DataType::UInt8 => {
362                let v = if is_null {
363                    None
364                } else {
365                    let v = string
366                        .parse::<u8>()
367                        .map_err(|_| QuillSQLError::Internal("Parse u8 failed".to_string()))?;
368                    Some(v)
369                };
370                Ok(ScalarValue::UInt8(v))
371            }
372            DataType::UInt16 => {
373                let v = if is_null {
374                    None
375                } else {
376                    let v = string
377                        .parse::<u16>()
378                        .map_err(|_| QuillSQLError::Internal("Parse u16 failed".to_string()))?;
379                    Some(v)
380                };
381                Ok(ScalarValue::UInt16(v))
382            }
383            DataType::UInt32 => {
384                let v = if is_null {
385                    None
386                } else {
387                    let v = string
388                        .parse::<u32>()
389                        .map_err(|_| QuillSQLError::Internal("Parse u32 failed".to_string()))?;
390                    Some(v)
391                };
392                Ok(ScalarValue::UInt32(v))
393            }
394            DataType::UInt64 => {
395                let v = if is_null {
396                    None
397                } else {
398                    let v = string
399                        .parse::<u64>()
400                        .map_err(|_| QuillSQLError::Internal("Parse u64 failed".to_string()))?;
401                    Some(v)
402                };
403                Ok(ScalarValue::UInt64(v))
404            }
405            DataType::Float32 => {
406                let v = if is_null {
407                    None
408                } else {
409                    let v = string
410                        .parse::<f32>()
411                        .map_err(|_| QuillSQLError::Internal("Parse f32 failed".to_string()))?;
412                    Some(v)
413                };
414                Ok(ScalarValue::Float32(v))
415            }
416            DataType::Float64 => {
417                let v = if is_null {
418                    None
419                } else {
420                    let v = string
421                        .parse::<f64>()
422                        .map_err(|_| QuillSQLError::Internal("Parse f64 failed".to_string()))?;
423                    Some(v)
424                };
425                Ok(ScalarValue::Float64(v))
426            }
427            DataType::Varchar(_) => {
428                let v = if is_null {
429                    None
430                } else {
431                    Some(string.to_owned())
432                };
433                Ok(ScalarValue::Varchar(v))
434            }
435        }
436    }
437}
438
439impl PartialEq for ScalarValue {
440    fn eq(&self, other: &Self) -> bool {
441        use ScalarValue::*;
442        match (self, other) {
443            (Boolean(v1), Boolean(v2)) => v1.eq(v2),
444            (Boolean(_), _) => false,
445            (Int8(v1), Int8(v2)) => v1.eq(v2),
446            (Int8(_), _) => false,
447            (Int16(v1), Int16(v2)) => v1.eq(v2),
448            (Int16(_), _) => false,
449            (Int32(v1), Int32(v2)) => v1.eq(v2),
450            (Int32(_), _) => false,
451            (Int64(v1), Int64(v2)) => v1.eq(v2),
452            (Int64(_), _) => false,
453            (UInt8(v1), UInt8(v2)) => v1.eq(v2),
454            (UInt8(_), _) => false,
455            (UInt16(v1), UInt16(v2)) => v1.eq(v2),
456            (UInt16(_), _) => false,
457            (UInt32(v1), UInt32(v2)) => v1.eq(v2),
458            (UInt32(_), _) => false,
459            (UInt64(v1), UInt64(v2)) => v1.eq(v2),
460            (UInt64(_), _) => false,
461            (Float32(v1), Float32(v2)) => match (v1, v2) {
462                (Some(f1), Some(f2)) => f1.to_bits() == f2.to_bits(),
463                _ => v1.eq(v2),
464            },
465            (Float32(_), _) => false,
466            (Float64(v1), Float64(v2)) => match (v1, v2) {
467                (Some(f1), Some(f2)) => f1.to_bits() == f2.to_bits(),
468                _ => v1.eq(v2),
469            },
470            (Float64(_), _) => false,
471            (Varchar(v1), Varchar(v2)) => v1.eq(v2),
472            (Varchar(_), _) => false,
473        }
474    }
475}
476
477impl Eq for ScalarValue {}
478
479impl PartialOrd for ScalarValue {
480    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
481        use ScalarValue::*;
482        match (self, other) {
483            (Boolean(v1), Boolean(v2)) => v1.partial_cmp(v2),
484            (Boolean(_), _) => None,
485            (Int8(v1), Int8(v2)) => v1.partial_cmp(v2),
486            (Int8(_), _) => None,
487            (Int16(v1), Int16(v2)) => v1.partial_cmp(v2),
488            (Int16(_), _) => None,
489            (Int32(v1), Int32(v2)) => v1.partial_cmp(v2),
490            (Int32(_), _) => None,
491            (Int64(v1), Int64(v2)) => v1.partial_cmp(v2),
492            (Int64(_), _) => None,
493            (UInt8(v1), UInt8(v2)) => v1.partial_cmp(v2),
494            (UInt8(_), _) => None,
495            (UInt16(v1), UInt16(v2)) => v1.partial_cmp(v2),
496            (UInt16(_), _) => None,
497            (UInt32(v1), UInt32(v2)) => v1.partial_cmp(v2),
498            (UInt32(_), _) => None,
499            (UInt64(v1), UInt64(v2)) => v1.partial_cmp(v2),
500            (UInt64(_), _) => None,
501            (Float32(v1), Float32(v2)) => match (v1, v2) {
502                (Some(f1), Some(f2)) => Some(f1.total_cmp(f2)),
503                _ => v1.partial_cmp(v2),
504            },
505            (Float32(_), _) => None,
506            (Float64(v1), Float64(v2)) => match (v1, v2) {
507                (Some(f1), Some(f2)) => Some(f1.total_cmp(f2)),
508                _ => v1.partial_cmp(v2),
509            },
510            (Float64(_), _) => None,
511            (Varchar(v1), Varchar(v2)) => v1.partial_cmp(v2),
512            (Varchar(_), _) => None,
513        }
514    }
515}
516
517impl std::hash::Hash for ScalarValue {
518    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
519        use ScalarValue::*;
520        match self {
521            Boolean(v) => v.hash(state),
522            Float32(v) => v.map(Fl).hash(state),
523            Float64(v) => v.map(Fl).hash(state),
524            Int8(v) => v.hash(state),
525            Int16(v) => v.hash(state),
526            Int32(v) => v.hash(state),
527            Int64(v) => v.hash(state),
528            UInt8(v) => v.hash(state),
529            UInt16(v) => v.hash(state),
530            UInt32(v) => v.hash(state),
531            UInt64(v) => v.hash(state),
532            Varchar(v) => v.hash(state),
533        }
534    }
535}
536
537//Float wrapper over f32/f64. Just because we cannot build std::hash::Hash for floats directly we have to do it through type wrapper
538struct Fl<T>(T);
539
540macro_rules! hash_float_value {
541    ($(($t:ty, $i:ty)),+) => {
542        $(impl std::hash::Hash for Fl<$t> {
543            #[inline]
544            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
545                state.write(&<$i>::from_ne_bytes(self.0.to_ne_bytes()).to_ne_bytes())
546            }
547        })+
548    };
549}
550
551hash_float_value!((f64, u64), (f32, u32));
552
553impl std::fmt::Display for ScalarValue {
554    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
555        match self {
556            ScalarValue::Boolean(None) => write!(f, "NULL"),
557            ScalarValue::Boolean(Some(v)) => write!(f, "{v}"),
558            ScalarValue::Int8(None) => write!(f, "NULL"),
559            ScalarValue::Int8(Some(v)) => write!(f, "{v}"),
560            ScalarValue::Int16(None) => write!(f, "NULL"),
561            ScalarValue::Int16(Some(v)) => write!(f, "{v}"),
562            ScalarValue::Int32(None) => write!(f, "NULL"),
563            ScalarValue::Int32(Some(v)) => write!(f, "{v}"),
564            ScalarValue::Int64(None) => write!(f, "NULL"),
565            ScalarValue::Int64(Some(v)) => write!(f, "{v}"),
566            ScalarValue::UInt8(None) => write!(f, "NULL"),
567            ScalarValue::UInt8(Some(v)) => write!(f, "{v}"),
568            ScalarValue::UInt16(None) => write!(f, "NULL"),
569            ScalarValue::UInt16(Some(v)) => write!(f, "{v}"),
570            ScalarValue::UInt32(None) => write!(f, "NULL"),
571            ScalarValue::UInt32(Some(v)) => write!(f, "{v}"),
572            ScalarValue::UInt64(None) => write!(f, "NULL"),
573            ScalarValue::UInt64(Some(v)) => write!(f, "{v}"),
574            ScalarValue::Float32(None) => write!(f, "NULL"),
575            ScalarValue::Float32(Some(v)) => write!(f, "{v}"),
576            ScalarValue::Float64(None) => write!(f, "NULL"),
577            ScalarValue::Float64(Some(v)) => write!(f, "{v}"),
578            ScalarValue::Varchar(None) => write!(f, "NULL"),
579            ScalarValue::Varchar(Some(v)) => write!(f, "{v}"),
580        }
581    }
582}
583
584macro_rules! impl_from_for_scalar {
585    ($ty:ty, $scalar:tt) => {
586        impl From<$ty> for ScalarValue {
587            fn from(value: $ty) -> Self {
588                ScalarValue::$scalar(Some(value))
589            }
590        }
591
592        impl From<Option<$ty>> for ScalarValue {
593            fn from(value: Option<$ty>) -> Self {
594                ScalarValue::$scalar(value)
595            }
596        }
597    };
598}
599
600impl_from_for_scalar!(bool, Boolean);
601impl_from_for_scalar!(i8, Int8);
602impl_from_for_scalar!(i16, Int16);
603impl_from_for_scalar!(i32, Int32);
604impl_from_for_scalar!(i64, Int64);
605impl_from_for_scalar!(u8, UInt8);
606impl_from_for_scalar!(u16, UInt16);
607impl_from_for_scalar!(u32, UInt32);
608impl_from_for_scalar!(u64, UInt64);
609impl_from_for_scalar!(f32, Float32);
610impl_from_for_scalar!(f64, Float64);
611impl_from_for_scalar!(String, Varchar);
quill_sql/utils/scalar.rs

quill_sql/utils/
scalar.rs
