tank_core/
value.rs

1use crate::{AsValue, Error, Result, TableRef, interval::Interval};
2use proc_macro2::TokenStream;
3use quote::{ToTokens, quote};
4use rust_decimal::Decimal;
5use serde_json::Value as JsonValue;
6use std::{borrow::Cow, collections::HashMap, hash::Hash, mem::discriminant};
7use time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
8use uuid::Uuid;
9
10/// SQL value representation.
11///
12/// Variants correspond to database column types.
13#[derive(Default, Debug, Clone)]
14pub enum Value {
15    /// SQL NULL.
16    #[default]
17    Null,
18    Boolean(Option<bool>),
19    Int8(Option<i8>),
20    Int16(Option<i16>),
21    Int32(Option<i32>),
22    Int64(Option<i64>),
23    Int128(Option<i128>),
24    UInt8(Option<u8>),
25    UInt16(Option<u16>),
26    UInt32(Option<u32>),
27    UInt64(Option<u64>),
28    UInt128(Option<u128>),
29    Float32(Option<f32>),
30    Float64(Option<f64>),
31    /// Decimal (value, precision, scale).
32    Decimal(Option<Decimal>, u8, u8),
33    Char(Option<char>),
34    Varchar(Option<Cow<'static, str>>),
35    Blob(Option<Box<[u8]>>),
36    Date(Option<Date>),
37    Time(Option<Time>),
38    Timestamp(Option<PrimitiveDateTime>),
39    TimestampWithTimezone(Option<OffsetDateTime>),
40    Interval(Option<Interval>),
41    Uuid(Option<Uuid>),
42    /// Homogeneous array (values, inner type, length).
43    Array(Option<Box<[Value]>>, Box<Value>, u32),
44    /// Variable-length list (values, inner type).
45    List(Option<Vec<Value>>, Box<Value>),
46    /// Map (entries, key type, value type).
47    Map(Option<HashMap<Value, Value>>, Box<Value>, Box<Value>),
48    Json(Option<JsonValue>),
49    /// Named struct (fields, field types, type name).
50    Struct(Option<Vec<(String, Value)>>, Vec<(String, Value)>, TableRef),
51    /// Unknown type (usually used when no further information is available).
52    Unknown(Option<String>),
53}
54
55impl Value {
56    pub fn same_type(&self, other: &Self) -> bool {
57        match (self, other) {
58            (Self::Decimal(.., l_width, l_scale), Self::Decimal(.., r_width, r_scale)) => {
59                (*l_width == 0 || *r_width == 0 || l_width == r_width)
60                    && (*l_scale == 0 || *r_scale == 0 || l_scale == r_scale)
61            }
62            (Self::Array(.., l_type, l_len), Self::Array(.., r_type, r_len)) => {
63                l_len == r_len && l_type.same_type(&r_type)
64            }
65            (Self::List(.., l), Self::List(.., r)) => l.same_type(r),
66            (Self::Map(.., l_key, l_value), Self::Map(.., r_key, r_value)) => {
67                l_key.same_type(r_key) && l_value.same_type(&r_value)
68            }
69            _ => discriminant(self) == discriminant(other),
70        }
71    }
72
73    pub fn is_null(&self) -> bool {
74        match self {
75            Value::Null
76            | Value::Boolean(None, ..)
77            | Value::Int8(None, ..)
78            | Value::Int16(None, ..)
79            | Value::Int32(None, ..)
80            | Value::Int64(None, ..)
81            | Value::Int128(None, ..)
82            | Value::UInt8(None, ..)
83            | Value::UInt16(None, ..)
84            | Value::UInt32(None, ..)
85            | Value::UInt64(None, ..)
86            | Value::UInt128(None, ..)
87            | Value::Float32(None, ..)
88            | Value::Float64(None, ..)
89            | Value::Decimal(None, ..)
90            | Value::Char(None, ..)
91            | Value::Varchar(None, ..)
92            | Value::Blob(None, ..)
93            | Value::Date(None, ..)
94            | Value::Time(None, ..)
95            | Value::Timestamp(None, ..)
96            | Value::TimestampWithTimezone(None, ..)
97            | Value::Interval(None, ..)
98            | Value::Uuid(None, ..)
99            | Value::Array(None, ..)
100            | Value::List(None, ..)
101            | Value::Map(None, ..)
102            | Value::Json(None, ..)
103            | Value::Json(Some(serde_json::Value::Null), ..)
104            | Value::Struct(None, ..)
105            | Value::Unknown(None, ..) => true,
106            _ => false,
107        }
108    }
109
110    pub fn as_null(&self) -> Value {
111        match self {
112            Value::Null => Value::Null,
113            Value::Boolean(..) => Value::Boolean(None),
114            Value::Int8(..) => Value::Int8(None),
115            Value::Int16(..) => Value::Int16(None),
116            Value::Int32(..) => Value::Int32(None),
117            Value::Int64(..) => Value::Int64(None),
118            Value::Int128(..) => Value::Int128(None),
119            Value::UInt8(..) => Value::UInt8(None),
120            Value::UInt16(..) => Value::UInt16(None),
121            Value::UInt32(..) => Value::UInt32(None),
122            Value::UInt64(..) => Value::UInt64(None),
123            Value::UInt128(..) => Value::UInt128(None),
124            Value::Float32(..) => Value::Float32(None),
125            Value::Float64(..) => Value::Float64(None),
126            Value::Decimal(.., w, s) => Value::Decimal(None, *w, *s),
127            Value::Char(..) => Value::Char(None),
128            Value::Varchar(..) => Value::Varchar(None),
129            Value::Blob(..) => Value::Blob(None),
130            Value::Date(..) => Value::Date(None),
131            Value::Time(..) => Value::Time(None),
132            Value::Timestamp(..) => Value::Timestamp(None),
133            Value::TimestampWithTimezone(..) => Value::TimestampWithTimezone(None),
134            Value::Interval(..) => Value::Interval(None),
135            Value::Uuid(..) => Value::Uuid(None),
136            Value::Array(.., t, len) => Value::Array(None, t.clone(), *len),
137            Value::List(.., t) => Value::List(None, t.clone()),
138            Value::Map(.., k, v) => Value::Map(None, k.clone(), v.clone()),
139            Value::Json(..) => Value::Json(None),
140            Value::Struct(.., ty, name) => Value::Struct(None, ty.clone(), name.clone()),
141            Value::Unknown(..) => Value::Unknown(None),
142        }
143    }
144
145    pub fn try_as(self, value: &Value) -> Result<Value> {
146        if self.same_type(value) {
147            return Ok(self);
148        }
149        match value {
150            Value::Boolean(..) => bool::try_from_value(self).map(AsValue::as_value),
151            Value::Int8(..) => i8::try_from_value(self).map(AsValue::as_value),
152            Value::Int16(..) => i16::try_from_value(self).map(AsValue::as_value),
153            Value::Int32(..) => i32::try_from_value(self).map(AsValue::as_value),
154            Value::Int64(..) => i64::try_from_value(self).map(AsValue::as_value),
155            Value::Int128(..) => i128::try_from_value(self).map(AsValue::as_value),
156            Value::UInt8(..) => u8::try_from_value(self).map(AsValue::as_value),
157            Value::UInt16(..) => u16::try_from_value(self).map(AsValue::as_value),
158            Value::UInt32(..) => u32::try_from_value(self).map(AsValue::as_value),
159            Value::UInt64(..) => u64::try_from_value(self).map(AsValue::as_value),
160            Value::UInt128(..) => u128::try_from_value(self).map(AsValue::as_value),
161            Value::Float32(..) => f32::try_from_value(self).map(AsValue::as_value),
162            Value::Float64(..) => f64::try_from_value(self).map(AsValue::as_value),
163            Value::Decimal(..) => Decimal::try_from_value(self).map(AsValue::as_value),
164            Value::Char(..) => char::try_from_value(self).map(AsValue::as_value),
165            Value::Varchar(..) => String::try_from_value(self).map(AsValue::as_value),
166            Value::Blob(..) => Box::<[u8]>::try_from_value(self).map(AsValue::as_value),
167            Value::Date(..) => Date::try_from_value(self).map(AsValue::as_value),
168            Value::Time(..) => Time::try_from_value(self).map(AsValue::as_value),
169            Value::Timestamp(..) => PrimitiveDateTime::try_from_value(self).map(AsValue::as_value),
170            Value::TimestampWithTimezone(..) => {
171                OffsetDateTime::try_from_value(self).map(AsValue::as_value)
172            }
173            Value::Interval(..) => Interval::try_from_value(self).map(AsValue::as_value),
174            Value::Uuid(..) => Uuid::try_from_value(self).map(AsValue::as_value),
175            // Value::Array(.., ty, len) => {
176            //     Box::<[Value]>::try_from_value(self).map(AsValue::as_value)
177            // }
178            // Value::List(..) => Box::<[Value]>::try_from_value(self).map(AsValue::as_value),
179            // Value::Map(..) => Date::try_from_value(self).map(AsValue::as_value),
180            _ => {
181                return Err(Error::msg(format!(
182                    "Cannot convert value {:?} into value {:?}",
183                    self, value
184                )));
185            }
186        }
187    }
188
189    pub fn is_scalar(&self) -> bool {
190        match self {
191            Value::Boolean(..)
192            | Value::Int8(..)
193            | Value::Int16(..)
194            | Value::Int32(..)
195            | Value::Int64(..)
196            | Value::Int128(..)
197            | Value::UInt8(..)
198            | Value::UInt16(..)
199            | Value::UInt32(..)
200            | Value::UInt64(..)
201            | Value::UInt128(..)
202            | Value::Float32(..)
203            | Value::Float64(..)
204            | Value::Decimal(..)
205            | Value::Char(..)
206            | Value::Varchar(..)
207            | Value::Blob(..)
208            | Value::Date(..)
209            | Value::Time(..)
210            | Value::Timestamp(..)
211            | Value::TimestampWithTimezone(..)
212            | Value::Interval(..)
213            | Value::Uuid(..)
214            | Value::Unknown(..) => true,
215            _ => false,
216        }
217    }
218}
219
220impl PartialEq for Value {
221    fn eq(&self, other: &Self) -> bool {
222        match (self, other) {
223            (Self::Boolean(l), Self::Boolean(r)) => l == r,
224            (Self::Int8(l), Self::Int8(r)) => l == r,
225            (Self::Int16(l), Self::Int16(r)) => l == r,
226            (Self::Int32(l), Self::Int32(r)) => l == r,
227            (Self::Int64(l), Self::Int64(r)) => l == r,
228            (Self::Int128(l), Self::Int128(r)) => l == r,
229            (Self::UInt8(l), Self::UInt8(r)) => l == r,
230            (Self::UInt16(l), Self::UInt16(r)) => l == r,
231            (Self::UInt32(l), Self::UInt32(r)) => l == r,
232            (Self::UInt64(l), Self::UInt64(r)) => l == r,
233            (Self::UInt128(l), Self::UInt128(r)) => l == r,
234            (Self::Float32(l), Self::Float32(r)) => {
235                l == r
236                    || l.and_then(|l| r.and_then(|r| Some(l.is_nan() && r.is_nan())))
237                        .unwrap_or_default()
238            }
239            (Self::Float64(l), Self::Float64(r)) => {
240                l == r
241                    || l.and_then(|l| r.and_then(|r| Some(l.is_nan() && r.is_nan())))
242                        .unwrap_or_default()
243            }
244            (Self::Decimal(l, l_width, l_scale), Self::Decimal(r, r_width, r_scale)) => {
245                l == r && l_width == r_width && l_scale == r_scale
246            }
247            (Self::Char(l), Self::Char(r)) => l == r,
248            (Self::Varchar(l), Self::Varchar(r)) => l == r,
249            (Self::Blob(l), Self::Blob(r)) => l == r,
250            (Self::Date(l), Self::Date(r)) => l == r,
251            (Self::Time(l), Self::Time(r)) => l == r,
252            (Self::Timestamp(l), Self::Timestamp(r)) => l == r,
253            (Self::TimestampWithTimezone(l), Self::TimestampWithTimezone(r)) => l == r,
254            (Self::Interval(l), Self::Interval(r)) => l == r,
255            (Self::Uuid(l), Self::Uuid(r)) => l == r,
256            (Self::Array(l, ..), Self::Array(r, ..)) => l == r && self.same_type(other),
257            (Self::List(l, ..), Self::List(r, ..)) => l == r && self.same_type(other),
258            (Self::Map(None, ..), Self::Map(None, ..)) => self.same_type(other),
259            (Self::Map(Some(l), ..), Self::Map(Some(r), ..)) => {
260                l.is_empty() == r.is_empty() && self.same_type(other)
261            }
262            (Self::Map(..), Self::Map(..)) => self.same_type(other),
263            (Self::Json(l), Self::Json(r)) => l == r,
264            (Self::Struct(l, l_ty, l_name), Self::Struct(r, r_ty, r_name)) => {
265                l_name == r_name && l == r && l_ty == r_ty
266            }
267            (Self::Unknown(..), Self::Unknown(..)) => false,
268            _ => false,
269        }
270    }
271}
272
273impl Eq for Value {}
274
275impl Hash for Value {
276    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
277        use Value::*;
278        discriminant(self).hash(state);
279        match self {
280            Null => {}
281            Boolean(v) => v.hash(state),
282            Int8(v) => v.hash(state),
283            Int16(v) => v.hash(state),
284            Int32(v) => v.hash(state),
285            Int64(v) => v.hash(state),
286            Int128(v) => v.hash(state),
287
288            UInt8(v) => v.hash(state),
289            UInt16(v) => v.hash(state),
290            UInt32(v) => v.hash(state),
291            UInt64(v) => v.hash(state),
292            UInt128(v) => v.hash(state),
293            Float32(Some(v)) => {
294                v.to_bits().hash(state);
295            }
296            Float32(None) => None::<u32>.hash(state),
297            Float64(Some(v)) => {
298                v.to_bits().hash(state);
299            }
300            Float64(None) => None::<u64>.hash(state),
301            Decimal(v, width, scale) => {
302                v.hash(state);
303                width.hash(state);
304                scale.hash(state);
305            }
306            Char(v) => v.hash(state),
307            Varchar(v) => v.hash(state),
308            Blob(v) => v.hash(state),
309            Date(v) => v.hash(state),
310            Time(v) => v.hash(state),
311            Timestamp(v) => v.hash(state),
312            TimestampWithTimezone(v) => v.hash(state),
313            Interval(v) => v.hash(state),
314            Uuid(v) => v.hash(state),
315            Array(v, typ, len) => {
316                v.hash(state);
317                typ.hash(state);
318                len.hash(state);
319            }
320            List(v, typ) => {
321                v.hash(state);
322                typ.hash(state);
323            }
324            Map(v, key, val) => {
325                match v {
326                    Some(map) => {
327                        for (key, val) in map {
328                            key.hash(state);
329                            val.hash(state);
330                        }
331                    }
332                    None => {}
333                }
334                key.hash(state);
335                val.hash(state);
336            }
337            Json(v) => v.hash(state),
338            Struct(v, t, name) => {
339                match v {
340                    Some(v) => v.hash(state),
341                    None => {}
342                }
343                t.hash(state);
344                name.hash(state);
345            }
346            Unknown(v) => v.hash(state),
347        }
348    }
349}
350
351/// Internally decoded type info for macros.
352#[derive(Default)]
353pub struct TypeDecoded {
354    /// Representative value establishing variant & metadata.
355    pub value: Value,
356    /// Nullability indicator.
357    pub nullable: bool,
358    /// Passive flag (exclude from INSERT column/value list).
359    pub passive: bool,
360}
361
362pub type CheckPassive = Box<dyn Fn(TokenStream) -> TokenStream>;
363
364impl ToTokens for Value {
365    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
366        let ts = match self {
367            Value::Null => quote!(::tank::Value::Null),
368            Value::Boolean(..) => quote!(::tank::Value::Boolean(None)),
369            Value::Int8(..) => quote!(::tank::Value::Int8(None)),
370            Value::Int16(..) => quote!(::tank::Value::Int16(None)),
371            Value::Int32(..) => quote!(::tank::Value::Int32(None)),
372            Value::Int64(..) => quote!(::tank::Value::Int64(None)),
373            Value::Int128(..) => quote!(::tank::Value::Int128(None)),
374            Value::UInt8(..) => quote!(::tank::Value::UInt8(None)),
375            Value::UInt16(..) => quote!(::tank::Value::UInt16(None)),
376            Value::UInt32(..) => quote!(::tank::Value::UInt32(None)),
377            Value::UInt64(..) => quote!(::tank::Value::UInt64(None)),
378            Value::UInt128(..) => quote!(::tank::Value::UInt128(None)),
379            Value::Float32(..) => quote!(::tank::Value::Float32(None)),
380            Value::Float64(..) => quote!(::tank::Value::Float64(None)),
381            Value::Decimal(.., width, scale) => {
382                quote!(::tank::Value::Decimal(None, #width, #scale))
383            }
384            Value::Char(..) => quote!(tank::Value::Char(None)),
385            Value::Varchar(..) => quote!(::tank::Value::Varchar(None)),
386            Value::Blob(..) => quote!(::tank::Value::Blob(None)),
387            Value::Date(..) => quote!(::tank::Value::Date(None)),
388            Value::Time(..) => quote!(::tank::Value::Time(None)),
389            Value::Timestamp(..) => quote!(::tank::Value::Timestamp(None)),
390            Value::TimestampWithTimezone(..) => quote!(::tank::Value::TimestampWithTimezone(None)),
391            Value::Interval(..) => quote!(::tank::Value::Interval(None)),
392            Value::Uuid(..) => quote!(::tank::Value::Uuid(None)),
393            Value::Array(.., inner, size) => {
394                quote!(::tank::Value::Array(None, Box::new(#inner), #size))
395            }
396            Value::List(.., inner) => {
397                let inner = inner.as_ref().to_token_stream();
398                quote!(::tank::Value::List(None, Box::new(#inner)))
399            }
400            Value::Map(.., key, value) => {
401                let key = key.as_ref().to_token_stream();
402                let value = value.as_ref().to_token_stream();
403                quote!(::tank::Value::Map(None, Box::new(#key), Box::new(#value)))
404            }
405            Value::Json(..) => quote!(::tank::Value::Json(None)),
406            Value::Struct(.., ty, name) => {
407                let values = ty.into_iter().map(|(k, v)| quote!((#k.into(), #v)));
408                quote!(::tank::Value::Struct(None, vec!(#(#values),*), #name))
409            }
410            Value::Unknown(..) => quote!(::tank::Value::Unknown(None)),
411        };
412        tokens.extend(ts);
413    }
414}
tank_core/value.rs

tank_core/
value.rs
