feat: add sqlx setup

src/sql.rs

@@ -0,0 +1,112 @@
+use chrono::Utc;
+use sqlx::postgres::PgRow;
+use sqlx::Column;
+use sqlx::Row;
+use sqlx::TypeInfo;
+
+use crate::error;
+
+#[derive(Debug)]
+pub struct Col<T> {
+    name: String,
+    sql_type: String,
+    value: Option<T>,
+}
+
+#[derive(Debug)]
+pub enum ColType {
+    I8(Col<i8>),
+    String(Col<String>),
+    Bool(Col<bool>),
+    I16(Col<i16>),
+    I32(Col<i32>),
+    I64(Col<i64>),
+    F32(Col<f32>),
+    F64(Col<f64>),
+    DateTime(Col<chrono::DateTime<Utc>>),
+}
+
+impl ColType {
+    pub fn new(row: &PgRow, idx: usize) -> error::Result<Self> {
+        let column = row.columns().get(idx).unwrap();
+        let sql_type = column.type_info().name();
+        let name = String::from(column.name());
+
+        match sql_type {
+            "BOOL" => {
+                let value: Option<bool> = row.try_get(idx)?;
+                Ok(ColType::Bool(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "VARCHAR" | "char(n)" | "TEXT" | "NAME" => {
+                let value: Option<String> = row.try_get(idx)?;
+                Ok(ColType::String(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "CHAR" => {
+                let value: Option<i8> = row.try_get(idx)?;
+                Ok(ColType::I8(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "SMALLSERIAL" | "SMALLINT" => {
+                let value: Option<i16> = row.try_get(idx)?;
+                Ok(ColType::I16(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "INT" | "INT4" | "SERIAL" => {
+                let value: Option<i32> = row.try_get(idx)?;
+                Ok(ColType::I32(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "INT8" | "BIGSERIAL" | "BIGINT" => {
+                let value: Option<i64> = row.try_get(idx)?;
+                Ok(ColType::I64(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "FLOAT4" | "REAL" => {
+                let value: Option<f32> = row.try_get(idx)?;
+                Ok(ColType::F32(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "FLOAT8" | "double precision" => {
+                let value: Option<f64> = row.try_get(idx)?;
+                Ok(ColType::F64(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "TIMESTAMP" | "TIMESTAMPTZ" => {
+                // with-chrono feature is needed for this
+                let value: Option<chrono::DateTime<Utc>> = row.try_get(idx)?;
+                Ok(ColType::DateTime(Col {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            &_ => panic!("{} Type not found!", sql_type),
+        }
+    }
+}