1use std::error::Error as StdError;
28
29use prax_query::row::{RowError, RowRef, into_row_error};
30use tokio_postgres::Row;
31use tokio_postgres::types::{FromSql, Kind, Type};
32
33struct AnyText(String);
42
43impl<'a> FromSql<'a> for AnyText {
44 fn from_sql(_ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn StdError + Sync + Send>> {
45 Ok(AnyText(std::str::from_utf8(raw)?.to_owned()))
46 }
47 fn accepts(_ty: &Type) -> bool {
48 true
49 }
50}
51
52struct UtcDateTime(chrono::DateTime<chrono::Utc>);
61
62impl<'a> FromSql<'a> for UtcDateTime {
63 fn from_sql(ty: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn StdError + Sync + Send>> {
64 if *ty == Type::TIMESTAMP {
65 let naive = chrono::NaiveDateTime::from_sql(ty, raw)?;
66 return Ok(UtcDateTime(naive.and_utc()));
67 }
68 Ok(UtcDateTime(chrono::DateTime::<chrono::Utc>::from_sql(
69 ty, raw,
70 )?))
71 }
72 fn accepts(ty: &Type) -> bool {
73 *ty == Type::TIMESTAMP || <chrono::DateTime<chrono::Utc> as FromSql>::accepts(ty)
74 }
75}
76
77struct NullProbe;
90
91impl<'a> FromSql<'a> for NullProbe {
92 fn from_sql(_ty: &Type, _raw: &'a [u8]) -> Result<Self, Box<dyn StdError + Sync + Send>> {
93 Ok(NullProbe)
94 }
95 fn accepts(_ty: &Type) -> bool {
96 true
97 }
98}
99
100#[repr(transparent)]
108pub struct PgRow(Row);
109
110impl PgRow {
111 pub fn into_inner(self) -> Row {
113 self.0
114 }
115}
116
117impl std::ops::Deref for PgRow {
118 type Target = Row;
119 fn deref(&self) -> &Self::Target {
120 &self.0
121 }
122}
123
124impl From<Row> for PgRow {
125 fn from(row: Row) -> Self {
126 PgRow(row)
127 }
128}
129
130impl RowRef for PgRow {
131 fn get_i32(&self, c: &str) -> Result<i32, RowError> {
132 into_row_error(c, self.try_get::<_, i32>(c))
133 }
134 fn get_i32_opt(&self, c: &str) -> Result<Option<i32>, RowError> {
135 into_row_error(c, self.try_get::<_, Option<i32>>(c))
136 }
137 fn get_i64(&self, c: &str) -> Result<i64, RowError> {
138 into_row_error(c, self.try_get::<_, i64>(c))
139 }
140 fn get_i64_opt(&self, c: &str) -> Result<Option<i64>, RowError> {
141 into_row_error(c, self.try_get::<_, Option<i64>>(c))
142 }
143 fn get_f64(&self, c: &str) -> Result<f64, RowError> {
144 into_row_error(c, self.try_get::<_, f64>(c))
145 }
146 fn get_f64_opt(&self, c: &str) -> Result<Option<f64>, RowError> {
147 into_row_error(c, self.try_get::<_, Option<f64>>(c))
148 }
149 fn get_bool(&self, c: &str) -> Result<bool, RowError> {
150 into_row_error(c, self.try_get::<_, bool>(c))
151 }
152 fn get_bool_opt(&self, c: &str) -> Result<Option<bool>, RowError> {
153 into_row_error(c, self.try_get::<_, Option<bool>>(c))
154 }
155 fn get_str(&self, c: &str) -> Result<&str, RowError> {
156 into_row_error(c, self.try_get::<_, &str>(c))
157 }
158 fn get_str_opt(&self, c: &str) -> Result<Option<&str>, RowError> {
159 into_row_error(c, self.try_get::<_, Option<&str>>(c))
160 }
161 fn get_string(&self, c: &str) -> Result<String, RowError> {
178 let columns = self.0.columns();
179 if let Some(col) = columns.iter().find(|col| col.name() == c) {
180 let ty = col.type_();
181 if *ty == Type::UUID {
182 return into_row_error(c, self.try_get::<_, ::uuid::Uuid>(c))
183 .map(|u| u.to_string());
184 }
185 if matches!(ty.kind(), Kind::Enum(_)) {
186 return into_row_error(c, self.try_get::<_, AnyText>(c)).map(|t| t.0);
187 }
188 }
189 into_row_error(c, self.try_get::<_, &str>(c)).map(|s| s.to_string())
190 }
191 fn get_string_opt(&self, c: &str) -> Result<Option<String>, RowError> {
192 let columns = self.0.columns();
193 if let Some(col) = columns.iter().find(|col| col.name() == c) {
194 let ty = col.type_();
195 if *ty == Type::UUID {
196 return into_row_error(c, self.try_get::<_, Option<::uuid::Uuid>>(c))
197 .map(|opt| opt.map(|u| u.to_string()));
198 }
199 if matches!(ty.kind(), Kind::Enum(_)) {
200 return into_row_error(c, self.try_get::<_, Option<AnyText>>(c))
201 .map(|opt| opt.map(|t| t.0));
202 }
203 }
204 into_row_error(c, self.try_get::<_, Option<&str>>(c)).map(|opt| opt.map(|s| s.to_string()))
205 }
206 fn is_null(&self, c: &str) -> Result<bool, RowError> {
217 into_row_error(c, self.try_get::<_, Option<NullProbe>>(c)).map(|opt| opt.is_none())
218 }
219
220 fn get_bytes(&self, c: &str) -> Result<&[u8], RowError> {
221 into_row_error(c, self.try_get::<_, &[u8]>(c))
222 }
223 fn get_bytes_opt(&self, c: &str) -> Result<Option<&[u8]>, RowError> {
224 into_row_error(c, self.try_get::<_, Option<&[u8]>>(c))
225 }
226 fn get_datetime_utc(&self, c: &str) -> Result<chrono::DateTime<chrono::Utc>, RowError> {
227 into_row_error(c, self.try_get::<_, UtcDateTime>(c).map(|v| v.0))
228 }
229 fn get_datetime_utc_opt(
230 &self,
231 c: &str,
232 ) -> Result<Option<chrono::DateTime<chrono::Utc>>, RowError> {
233 into_row_error(
234 c,
235 self.try_get::<_, Option<UtcDateTime>>(c)
236 .map(|v| v.map(|v| v.0)),
237 )
238 }
239 fn get_naive_datetime(&self, c: &str) -> Result<chrono::NaiveDateTime, RowError> {
240 into_row_error(c, self.try_get::<_, chrono::NaiveDateTime>(c))
241 }
242 fn get_naive_datetime_opt(&self, c: &str) -> Result<Option<chrono::NaiveDateTime>, RowError> {
243 into_row_error(c, self.try_get::<_, Option<chrono::NaiveDateTime>>(c))
244 }
245 fn get_naive_date(&self, c: &str) -> Result<chrono::NaiveDate, RowError> {
246 into_row_error(c, self.try_get::<_, chrono::NaiveDate>(c))
247 }
248 fn get_naive_date_opt(&self, c: &str) -> Result<Option<chrono::NaiveDate>, RowError> {
249 into_row_error(c, self.try_get::<_, Option<chrono::NaiveDate>>(c))
250 }
251 fn get_naive_time(&self, c: &str) -> Result<chrono::NaiveTime, RowError> {
252 into_row_error(c, self.try_get::<_, chrono::NaiveTime>(c))
253 }
254 fn get_naive_time_opt(&self, c: &str) -> Result<Option<chrono::NaiveTime>, RowError> {
255 into_row_error(c, self.try_get::<_, Option<chrono::NaiveTime>>(c))
256 }
257 fn get_uuid(&self, c: &str) -> Result<uuid::Uuid, RowError> {
258 into_row_error(c, self.try_get::<_, uuid::Uuid>(c))
259 }
260 fn get_uuid_opt(&self, c: &str) -> Result<Option<uuid::Uuid>, RowError> {
261 into_row_error(c, self.try_get::<_, Option<uuid::Uuid>>(c))
262 }
263 fn get_json(&self, c: &str) -> Result<serde_json::Value, RowError> {
264 into_row_error(c, self.try_get::<_, serde_json::Value>(c))
265 }
266 fn get_json_opt(&self, c: &str) -> Result<Option<serde_json::Value>, RowError> {
267 into_row_error(c, self.try_get::<_, Option<serde_json::Value>>(c))
268 }
269 fn get_decimal(&self, c: &str) -> Result<rust_decimal::Decimal, RowError> {
270 into_row_error(c, self.try_get::<_, rust_decimal::Decimal>(c))
271 }
272 fn get_decimal_opt(&self, c: &str) -> Result<Option<rust_decimal::Decimal>, RowError> {
273 into_row_error(c, self.try_get::<_, Option<rust_decimal::Decimal>>(c))
274 }
275 fn get_string_array(&self, c: &str) -> Result<Vec<String>, RowError> {
278 into_row_error(c, self.try_get::<_, Vec<String>>(c))
279 }
280}
281
282#[cfg(test)]
283mod tests {
284 use super::*;
285 use tokio_postgres::types::ToSql;
286
287 fn encode(value: &(dyn ToSql + Sync), ty: &Type) -> bytes::BytesMut {
288 let mut buf = bytes::BytesMut::new();
289 value.to_sql_checked(ty, &mut buf).unwrap();
290 buf
291 }
292
293 #[test]
294 fn utc_datetime_reads_timestamp_as_utc() {
295 let naive = chrono::NaiveDate::from_ymd_opt(2024, 1, 2)
296 .unwrap()
297 .and_hms_micro_opt(3, 4, 5, 123_456)
298 .unwrap();
299 let buf = encode(&naive, &Type::TIMESTAMP);
300 let decoded = UtcDateTime::from_sql(&Type::TIMESTAMP, &buf).unwrap();
301 assert_eq!(decoded.0, naive.and_utc());
302 }
303
304 #[test]
305 fn utc_datetime_reads_timestamptz_unchanged() {
306 let at = chrono::DateTime::parse_from_rfc3339("2024-01-02T03:04:05+02:00")
307 .unwrap()
308 .with_timezone(&chrono::Utc);
309 let buf = encode(&at, &Type::TIMESTAMPTZ);
310 let decoded = UtcDateTime::from_sql(&Type::TIMESTAMPTZ, &buf).unwrap();
311 assert_eq!(decoded.0, at);
312 }
313
314 #[test]
315 fn utc_datetime_accepts_only_timestamp_types() {
316 assert!(<UtcDateTime as FromSql>::accepts(&Type::TIMESTAMP));
317 assert!(<UtcDateTime as FromSql>::accepts(&Type::TIMESTAMPTZ));
318 assert!(!<UtcDateTime as FromSql>::accepts(&Type::DATE));
319 assert!(!<UtcDateTime as FromSql>::accepts(&Type::TEXT));
320 }
321}