feat: add sqlx setup

src/sql.rs

@@ -0,0 +1,112 @@
+use chrono::Utc;
+use sqlx::postgres::PgRow;
+use sqlx::Column as _;
+use sqlx::Row as _;
+use sqlx::TypeInfo;
+
+use crate::error;
+
+#[derive(Debug)]
+pub struct Column<T> {
+    name: String,
+    sql_type: String,
+    value: Option<T>,
+}
+
+#[derive(Debug)]
+pub enum ColumnType {
+    I8(Column<i8>),
+    String(Column<String>),
+    Bool(Column<bool>),
+    I16(Column<i16>),
+    I32(Column<i32>),
+    I64(Column<i64>),
+    F32(Column<f32>),
+    F64(Column<f64>),
+    DateTime(Column<chrono::DateTime<Utc>>),
+}
+
+impl ColumnType {
+    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(ColumnType::Bool(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "VARCHAR" | "char(n)" | "TEXT" | "NAME" => {
+                let value: Option<String> = row.try_get(idx)?;
+                Ok(ColumnType::String(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "CHAR" => {
+                let value: Option<i8> = row.try_get(idx)?;
+                Ok(ColumnType::I8(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "SMALLSERIAL" | "SMALLINT" => {
+                let value: Option<i16> = row.try_get(idx)?;
+                Ok(ColumnType::I16(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "INT" | "INT4" | "SERIAL" => {
+                let value: Option<i32> = row.try_get(idx)?;
+                Ok(ColumnType::I32(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "INT8" | "BIGSERIAL" | "BIGINT" => {
+                let value: Option<i64> = row.try_get(idx)?;
+                Ok(ColumnType::I64(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "FLOAT4" | "REAL" => {
+                let value: Option<f32> = row.try_get(idx)?;
+                Ok(ColumnType::F32(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            "FLOAT8" | "double precision" => {
+                let value: Option<f64> = row.try_get(idx)?;
+                Ok(ColumnType::F64(Column {
+                    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(ColumnType::DateTime(Column {
+                    sql_type: String::from(sql_type),
+                    value,
+                    name,
+                }))
+            }
+            &_ => panic!("{} Type not found!", sql_type),
+        }
+    }
+}