1use bytes::BytesMut;
2use postgres_types::{FromSql, IsNull, ToSql, Type, to_sql_checked};
3use rust_decimal::{Decimal, prelude::FromPrimitive};
4use std::{error::Error, io::Read};
5use tank_core::Value;
6use time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
7use uuid::Uuid;
8
9#[derive(Debug)]
10pub(crate) struct ValueHolder(pub(crate) Value);
11
12impl From<Value> for ValueHolder {
13 fn from(value: Value) -> Self {
14 ValueHolder(value)
15 }
16}
17
18impl<'a> FromSql<'a> for ValueHolder {
19 fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {
20 Self::from_sql_nullable(ty, Some(raw))
21 }
22 fn from_sql_null(ty: &Type) -> Result<Self, Box<dyn Error + Sync + Send>> {
23 Self::from_sql_nullable(ty, None)
24 }
25 fn from_sql_nullable(
26 ty: &Type,
27 raw: Option<&'a [u8]>,
28 ) -> Result<Self, Box<dyn Error + Sync + Send>> {
29 macro_rules! to_value {
30 ($ty_var:ident, $raw:ident, $($($ty:path)|+ => ( $value:path, $source:ty $(, $additional:expr)* ) ,)+) => {
31 match *$ty_var {
32 $($($ty)|+ => $value(if let Some($raw) = $raw { Some(<$source>::from_sql($ty_var, $raw)?.into()) } else { None } $(, $additional)*),)+
33 _ => {
34 if let Some(mut raw) = $raw {
35 let mut buf = String::new();
36 let _ = raw.read_to_string(&mut buf);
37 return Err(tank_core::Error::msg(format!("Unknown value type {}: `{}`", $ty_var, buf)).into());
38 }
39 Value::Null
40 }
41 }
42 };
43 }
44 let value = to_value!(ty, raw,
45 Type::BOOL => (Value::Boolean, bool),
46 Type::CHAR => (Value::Int8, i8),
47 Type::INT2 => (Value::Int16, i16),
48 Type::INT4 => (Value::Int32, i32),
49 Type::INT8 => (Value::Int64, i64),
50 Type::FLOAT4 => (Value::Float32, f32),
51 Type::FLOAT8 => (Value::Float64, f64),
52 Type::NUMERIC => (Value::Decimal, Decimal, 0, 0),
53 Type::OID => (Value::UInt32, u32),
54 Type::VARCHAR
55 | Type::TEXT
56 | Type::NAME
57 | Type::BPCHAR
58 | Type::JSON
59 | Type::XML => (Value::Varchar, String),
60 Type::BYTEA => (Value::Blob, Vec<u8>),
61 Type::DATE => (Value::Date, Date),
62 Type::TIME => (Value::Time, Time),
63 Type::TIMESTAMP => (Value::Timestamp, PrimitiveDateTime),
64 Type::TIMESTAMPTZ => (Value::TimestampWithTimezone, OffsetDateTime),
65 Type::UUID => (Value::Uuid, Uuid),
66 Type::INT2_ARRAY => (Value::List, VecWrap<ValueHolder>, Box::new(Value::Int16(None))),
67 Type::INT4_ARRAY => (Value::List, VecWrap<ValueHolder>, Box::new(Value::Int32(None))),
68 Type::INT8_ARRAY => (Value::List, VecWrap<ValueHolder>, Box::new(Value::Int64(None))),
69 Type::FLOAT4_ARRAY => (Value::List, VecWrap<ValueHolder>, Box::new(Value::Float32(None))),
70 Type::FLOAT8_ARRAY => (Value::List, VecWrap<ValueHolder>, Box::new(Value::Float64(None))),
71 Type::BPCHAR_ARRAY => (Value::List, VecWrap<ValueHolder>, Box::new(Value::Varchar(None))),
72 );
73 Ok(value.into())
74 }
75
76 fn accepts(_ty: &Type) -> bool {
77 true
78 }
79}
80
81impl ToSql for ValueHolder {
82 fn to_sql(&self, ty: &Type, out: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>>
83 where
84 Self: Sized,
85 {
86 match &self.0 {
87 Value::Null => None::<String>.to_sql(ty, out),
88 Value::Boolean(v) => v.to_sql(ty, out),
89 Value::Int8(v) => v.to_sql(ty, out),
90 Value::Int16(v) => v.to_sql(ty, out),
91 Value::Int32(v) => v.to_sql(ty, out),
92 Value::Int64(v) => v.to_sql(ty, out),
93 Value::Int128(v) => v.map(|v| Decimal::from_i128(v)).to_sql(ty, out),
94 Value::UInt8(v) => v.map(|v| v as i16).to_sql(ty, out),
95 Value::UInt16(v) => v.map(|v| v as i32).to_sql(ty, out),
96 Value::UInt32(v) => v.to_sql(ty, out),
97 Value::UInt64(v) => v.map(|v| Decimal::from_u64(v)).to_sql(ty, out),
98 Value::UInt128(v) => v.map(|v| Decimal::from_u128(v)).to_sql(ty, out),
99 Value::Float32(v) => v.to_sql(ty, out),
100 Value::Float64(v) => v.to_sql(ty, out),
101 Value::Decimal(v, _, _) => v.to_sql(ty, out),
102 Value::Char(v) => v.map(|v| v.to_string()).to_sql(ty, out),
103 Value::Varchar(v) => v.to_sql(ty, out),
104 Value::Blob(v) => v.as_deref().to_sql(ty, out),
105 Value::Date(v) => v.to_sql(ty, out),
106 Value::Time(v) => v.to_sql(ty, out),
107 Value::Timestamp(v) => v.to_sql(ty, out),
108 Value::TimestampWithTimezone(v) => v.to_sql(ty, out),
109 Value::Uuid(v) => v.to_sql(ty, out),
110 Value::Array(v, ..) => v
111 .as_ref()
112 .map(|v| v.clone().into_iter().map(ValueHolder).collect::<Vec<_>>())
113 .to_sql(ty, out),
114 Value::List(v, ..) => v
115 .as_ref()
116 .map(|v| v.clone().into_iter().map(ValueHolder).collect::<Vec<_>>())
117 .to_sql(ty, out),
118 _ => {
119 return Err(tank_core::Error::msg(format!(
120 "tank::Value variant `{:?}` is not supported by Postgres",
121 &self.0
122 ))
123 .into());
124 }
125 }
126 }
127
128 fn accepts(_ty: &Type) -> bool
129 where
130 Self: Sized,
131 {
132 true
133 }
134
135 to_sql_checked!();
136}
137pub fn postgres_type_to_value(ty: &Type) -> Value {
138 match *ty {
139 Type::BOOL => Value::Boolean(None),
140 Type::CHAR => Value::Int8(None),
141 Type::INT2 => Value::Int16(None),
142 Type::INT4 => Value::Int32(None),
143 Type::INT8 => Value::Int64(None),
144 Type::FLOAT4 => Value::Float32(None),
145 Type::FLOAT8 => Value::Float64(None),
146 Type::NUMERIC => Value::Decimal(None, 0, 0),
147 Type::VARCHAR | Type::TEXT | Type::BPCHAR | Type::JSON | Type::XML => Value::Varchar(None),
148 Type::BYTEA => Value::Blob(None),
149 Type::DATE => Value::Date(None),
150 Type::TIME => Value::Time(None),
151 Type::TIMESTAMP => Value::Timestamp(None),
152 Type::TIMESTAMPTZ => Value::TimestampWithTimezone(None),
153 Type::INTERVAL => Value::Interval(None),
154 Type::UUID => Value::Uuid(None),
155 Type::BOOL_ARRAY => Value::List(None, Box::new(Value::Boolean(None))),
156 Type::INT2_ARRAY => Value::List(None, Box::new(Value::Int16(None))),
157 Type::INT4_ARRAY => Value::List(None, Box::new(Value::Int32(None))),
158 Type::INT8_ARRAY => Value::List(None, Box::new(Value::Int64(None))),
159 Type::FLOAT4_ARRAY => Value::List(None, Box::new(Value::Float32(None))),
160 Type::FLOAT8_ARRAY => Value::List(None, Box::new(Value::Float64(None))),
161 Type::NUMERIC_ARRAY => Value::List(None, Box::new(Value::Decimal(None, 0, 0))),
162 Type::TEXT_ARRAY | Type::VARCHAR_ARRAY => Value::List(None, Box::new(Value::Varchar(None))),
163 Type::BYTEA_ARRAY => Value::List(None, Box::new(Value::Blob(None))),
164 Type::DATE_ARRAY => Value::List(None, Box::new(Value::Date(None))),
165 Type::TIME_ARRAY => Value::List(None, Box::new(Value::Time(None))),
166 Type::TIMESTAMP_ARRAY => Value::List(None, Box::new(Value::Timestamp(None))),
167 Type::TIMESTAMPTZ_ARRAY => Value::List(None, Box::new(Value::TimestampWithTimezone(None))),
168 Type::INTERVAL_ARRAY => Value::List(None, Box::new(Value::Interval(None))),
169 Type::UUID_ARRAY => Value::List(None, Box::new(Value::Uuid(None))),
170 _ => Value::Null,
171 }
172}
173
174struct VecWrap<T>(pub Vec<T>);
175
176impl<'a, T: FromSql<'a>> FromSql<'a> for VecWrap<T> {
177 fn from_sql_null(ty: &Type) -> Result<Self, Box<dyn Error + Sync + Send>> {
178 Vec::<T>::from_sql_null(ty).map(VecWrap)
179 }
180 fn from_sql_nullable(
181 ty: &Type,
182 raw: Option<&'a [u8]>,
183 ) -> Result<Self, Box<dyn Error + Sync + Send>> {
184 Vec::<T>::from_sql_nullable(ty, raw).map(VecWrap)
185 }
186 fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn Error + Sync + Send>> {
187 Vec::<T>::from_sql(ty, raw).map(VecWrap)
188 }
189 fn accepts(ty: &Type) -> bool {
190 Vec::<T>::accepts(ty)
191 }
192}
193
194impl From<VecWrap<ValueHolder>> for Vec<Value> {
195 fn from(value: VecWrap<ValueHolder>) -> Self {
196 value.0.into_iter().map(|v| v.0).collect()
197 }
198}