add support for displaying date time and datetime objects natively

Before, one used to have to cast them to text on the database,
which wasn't practical for use with the table component, for instance.

Fixes #41

Author: lovasoa

Cargo.lock

@@ -17,7 +17,7 @@ panic = "abort"
 codegen-units = 2
 
 [dependencies]
-sqlx = { package = "sqlx-oldapi", version = "0.6.8", features = ["any", "runtime-actix-rustls", "sqlite", "postgres", "mysql", "mssql", "chrono"] }
+sqlx = { package = "sqlx-oldapi", version = "0.6.9", features = ["any", "runtime-actix-rustls", "sqlite", "postgres", "mysql", "mssql", "chrono"] }
 chrono = "0.4.23"
 actix-web = { version = "4", features = ["rustls", "cookies"] }
 percent-encoding = "2.2.0"

Cargo.toml

@@ -26,7 +26,7 @@ use sqlx::pool::{PoolConnection, PoolOptions};
 use sqlx::query::Query;
 use sqlx::{
     Any, AnyConnection, AnyPool, Arguments, Column, ConnectOptions, Decode, Either, Executor, Row,
-    Statement,
+    Statement, ValueRef, TypeInfo,
 };
 
 use self::sql::ParsedSQLStatement;
@@ -202,58 +202,108 @@ pub enum DbItem {
     Error(anyhow::Error),
 }
 
+macro_rules! try_decode_with {
+    ($raw_value:expr, [$ty0:ty], $fn:expr) => {
+        <$ty0 as Decode<sqlx::any::Any>>::decode($raw_value).map($fn)
+    };
+    ($raw_value:expr, [$ty0:ty, $($ty:ty),+], $fn:expr) => {
+        match try_decode_with!($raw_value, [$ty0], $fn) {
+            Ok(value) => Ok(value),
+            Err(_) => try_decode_with!($raw_value, [$($ty),+], $fn),
+        }
+    };
+}
+
 fn row_to_json(row: &AnyRow) -> Value {
-    use sqlx::{TypeInfo, ValueRef};
-    use Value::{Null, Object};
+    use Value::Object;
 
     let columns = row.columns();
     let mut map = Map::new();
     for col in columns {
         let key = col.name().to_string();
-        let value: Value = match row.try_get_raw(col.ordinal()) {
-            Ok(raw_value) if !raw_value.is_null() => match raw_value.type_info().name() {
-                "REAL" | "FLOAT" | "NUMERIC" | "FLOAT4" | "FLOAT8" | "DOUBLE" => {
-                    <f64 as Decode<sqlx::any::Any>>::decode(raw_value)
-                        .unwrap_or(f64::NAN)
-                        .into()
-                }
-                "INT8" | "BIGINT" | "INTEGER" => <i64 as Decode<sqlx::any::Any>>::decode(raw_value)
-                    .unwrap_or_default()
-                    .into(),
-                "INT" | "INT4" => <i32 as Decode<sqlx::any::Any>>::decode(raw_value)
-                    .unwrap_or_default()
-                    .into(),
-                "INT2" | "SMALLINT" => <i16 as Decode<sqlx::any::Any>>::decode(raw_value)
-                    .unwrap_or_default()
-                    .into(),
-                "BOOL" | "BOOLEAN" => <bool as Decode<sqlx::any::Any>>::decode(raw_value)
-                    .unwrap_or_default()
-                    .into(),
-                "JSON" | "JSON[]" | "JSONB" | "JSONB[]" => {
-                    <&[u8] as Decode<sqlx::any::Any>>::decode(raw_value)
-                        .and_then(|rv| {
-                            serde_json::from_slice::<Value>(rv).map_err(|e| {
-                                Box::new(e) as Box<dyn std::error::Error + Sync + Send>
-                            })
-                        })
-                        .unwrap_or_default()
-                }
-                // Deserialize as a string by default
-                _ => <String as Decode<sqlx::any::Any>>::decode(raw_value)
-                    .unwrap_or_default()
-                    .into(),
-            },
-            Ok(_null) => Null,
-            Err(e) => {
-                log::warn!("Unable to extract value from row: {:?}", e);
-                Null
-            }
-        };
+        let value: Value = sql_to_json(row, col);
         map = add_value_to_map(map, (key, value));
     }
     Object(map)
 }
 
+fn sql_to_json(row: &AnyRow, col: &sqlx::any::AnyColumn) -> Value {
+    let raw_value_result = row.try_get_raw(col.ordinal());
+    match raw_value_result {
+        Ok(raw_value) if !raw_value.is_null() => {
+            let mut raw_value = Some(raw_value);
+            log::trace!("Decoding a value of type {:?}", col.type_info().name());
+            let decoded = sql_nonnull_to_json(|| {
+                raw_value.take().unwrap_or_else(|| {
+                    row.try_get_raw(col.ordinal()).unwrap()
+                })
+            });
+            log::trace!("Decoded value: {:?}", decoded);
+            decoded
+        },
+        Ok(_null) => Value::Null,
+        Err(e) => {
+            log::warn!("Unable to extract value from row: {:?}", e);
+            Value::Null
+        }
+    }
+}
+
+fn sql_nonnull_to_json<'r>(mut get_ref: impl FnMut() -> sqlx::any::AnyValueRef<'r>) -> Value {
+    let raw_value = get_ref();
+    match raw_value.type_info().name() {
+        "REAL" | "FLOAT" | "NUMERIC" | "DECIMAL" | "FLOAT4" | "FLOAT8" | "DOUBLE" => {
+            <f64 as Decode<sqlx::any::Any>>::decode(raw_value)
+                .unwrap_or(f64::NAN)
+                .into()
+        }
+        "INT8" | "BIGINT" | "INTEGER" => <i64 as Decode<sqlx::any::Any>>::decode(raw_value)
+            .unwrap_or_default()
+            .into(),
+        "INT" | "INT4" => <i32 as Decode<sqlx::any::Any>>::decode(raw_value)
+            .unwrap_or_default()
+            .into(),
+        "INT2" | "SMALLINT" => <i16 as Decode<sqlx::any::Any>>::decode(raw_value)
+            .unwrap_or_default()
+            .into(),
+        "BOOL" | "BOOLEAN" => <bool as Decode<sqlx::any::Any>>::decode(raw_value)
+            .unwrap_or_default()
+            .into(),
+        "DATE" => <chrono::NaiveDate as Decode<sqlx::any::Any>>::decode(raw_value)
+            .as_ref()
+            .map(ToString::to_string)
+            .unwrap_or_else(|e| e.to_string())
+            .into(),
+        "TIME" => <chrono::NaiveTime as Decode<sqlx::any::Any>>::decode(raw_value)
+            .as_ref()
+            .map(ToString::to_string)
+            .unwrap_or_else(|e| e.to_string())
+            .into(),
+        "DATETIME" | "DATETIME2" | "DATETIMEOFFSET" | "TIMESTAMP" | "TIMESTAMPTZ" => {
+                try_decode_with!(
+                    get_ref(),
+                    [chrono::NaiveDateTime, chrono::DateTime<chrono::Utc>],
+                    |v| dbg!(v).to_string()
+                )
+                .unwrap_or_else(|e| format!("Unable to decode date: {:?}", e))
+                .into()
+        }
+        "JSON" | "JSON[]" | "JSONB" | "JSONB[]" => {
+            <&[u8] as Decode<sqlx::any::Any>>::decode(raw_value)
+                .and_then(|rv| {
+                    serde_json::from_slice::<Value>(rv).map_err(|e| {
+                        Box::new(e) as Box<dyn std::error::Error + Sync + Send>
+                    })
+                })
+                .unwrap_or_default()
+        }
+        // Deserialize as a string by default
+        _ => <String as Decode<sqlx::any::Any>>::decode(raw_value)
+            .unwrap_or_default()
+            .into(),
+    }
+}
+
 impl Database {
     pub async fn init(config: &AppConfig) -> anyhow::Result<Self> {
         let database_url = &config.database_url;