feat: migrate to postgres

Author: dancixx

src-tauri/Cargo.toml

@@ -16,8 +16,9 @@ tauri-build = { version = "1.5", features = [] }
 tauri = { version = "1.5.2", features = ["shell-open"] }
 serde = { version = "1.0.192", features = ["derive"] }
 serde_json = "1.0.108"
-sqlx = { version = "0.7.2", features = ["runtime-tokio", "tls-rustls", "postgres"] }
 tokio = "1.34.0"
+tokio-postgres = "0.7.10"
+chrono = "0.4.31"
 
 
 

src-tauri/src/main.rs

@@ -2,18 +2,19 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 mod postgres;
+mod utils;
 
 use postgres::{get_schema_tables, get_sql_result, pg_connector};
-use sqlx::PgPool;
 use std::sync::Arc;
 #[cfg(debug_assertions)]
 use tauri::Manager;
 use tokio::sync::Mutex;
+use tokio_postgres::Client;
 
 #[derive(Default)]
 pub struct AppState {
     pub connection_strings: Arc<Mutex<String>>,
-    pub pool: Arc<Mutex<Option<PgPool>>>,
+    pub client: Arc<Mutex<Option<Client>>>,
 }
 
 fn main() {

src-tauri/src/postgres.rs

@@ -1,33 +1,35 @@
-use sqlx::{postgres::PgPoolOptions, Column, Row};
 use tauri::{Result, State};
+use tokio_postgres::{connect, NoTls};
 
-use crate::AppState;
+use crate::{utils::reflective_get, AppState};
 
 #[tauri::command]
 pub async fn pg_connector(key: &str, app_state: State<'_, AppState>) -> Result<Vec<String>> {
     if key.is_empty() {
         return Ok(Vec::new());
     }
+    let (client, connection) = connect(key, NoTls).await.expect("connection error");
 
-    let pool = PgPoolOptions::new()
-        .max_connections(5)
-        .connect(key)
-        .await
-        .unwrap();
+    tokio::spawn(async move {
+        if let Err(e) = connection.await {
+            eprintln!("connection error: {}", e);
+        }
+    });
 
-    let schemas: Vec<(String,)> = sqlx::query_as(
-        r#"
+    let schemas = client
+        .query(
+            r#"
         SELECT schema_name
         FROM information_schema.schemata;
         "#,
-    )
-    .fetch_all(&pool)
-    .await
-    .unwrap();
-    let schemas = schemas.iter().map(|r| r.0.clone()).collect();
+            &[],
+        )
+        .await
+        .unwrap();
+    let schemas = schemas.iter().map(|r| r.get(0)).collect();
 
     *app_state.connection_strings.lock().await = key.to_string();
-    *app_state.pool.lock().await = Some(pool);
+    *app_state.client.lock().await = Some(client);
 
     Ok(schemas)
 }
@@ -37,19 +39,20 @@ pub async fn get_schema_tables(
     schema: &str,
     app_state: State<'_, AppState>,
 ) -> Result<Vec<String>> {
-    let pool = app_state.pool.lock().await;
-    let tables: Vec<(String,)> = sqlx::query_as(
-        r#"
+    let client = app_state.client.lock().await;
+    let client = client.as_ref().unwrap();
+    let tables = client
+        .query(
+            r#"
         SELECT table_name
         FROM information_schema.tables
         WHERE table_schema = $1
         "#,
-    )
-    .bind(schema)
-    .fetch_all(pool.as_ref().unwrap())
-    .await
-    .unwrap();
-    let tables = tables.iter().map(|r| r.0.clone()).collect();
+            &[&schema],
+        )
+        .await
+        .unwrap();
+    let tables = tables.iter().map(|r| r.get(0)).collect();
 
     Ok(tables)
 }
@@ -59,30 +62,26 @@ pub async fn get_sql_result(
     sql: String,
     app_state: State<'_, AppState>,
 ) -> Result<(Vec<String>, Vec<Vec<String>>)> {
-    let pool = app_state.pool.lock().await;
+    let client = app_state.client.lock().await;
+    let client = client.as_ref().unwrap();
 
-    let query = sqlx::query(&sql)
-        .fetch_all(pool.as_ref().unwrap())
-        .await
-        .unwrap();
-    // get columns
-    let columns = query
-        .get(0)
+    let rows = client.query(sql.as_str(), &[]).await.unwrap();
+    let columns = rows
+        .first()
         .unwrap()
         .columns()
         .iter()
         .map(|c| c.name().to_string())
         .collect::<Vec<String>>();
-    // get rows
-    let rows = query
+    let rows = rows
         .iter()
-        .map(|r| {
-            let mut row = Vec::new();
-            for i in 0..r.len() {
-                let value = r.try_get::<String, _>(i).unwrap_or(String::from("null"));
-                row.push(value);
+        .map(|row| {
+            let mut row_values = Vec::new();
+            for i in 0..row.len() {
+                let value = reflective_get(row, i);
+                row_values.push(value);
             }
-            row
+            row_values
         })
         .collect::<Vec<Vec<String>>>();
 

src-tauri/src/utils.rs

@@ -0,0 +1,48 @@
+use tokio_postgres::Row;
+
+/// The postgres-crate does not provide a default mapping to fallback to String for all
+/// types: row.get is generic and without a type assignment the FromSql-Trait cannot be inferred.
+/// This function matches over the current column-type and does a manual conversion
+pub fn reflective_get(row: &Row, index: usize) -> String {
+    let column_type = row.columns().get(index).map(|c| c.type_().name()).unwrap();
+    // see https://docs.rs/sqlx/0.4.0-beta.1/sqlx/postgres/types/index.html
+
+    let value = match column_type {
+        "bool" => {
+            let v = row.get::<_, Option<bool>>(index);
+            v.map(|v| v.to_string())
+        }
+        "varchar" | "char(n)" | "text" | "name" => row.get(index),
+        // "char" => {
+        //     let v: i8 = row.get(index);
+        // }
+        "int2" | "smallserial" | "smallint" => {
+            let v = row.get::<_, Option<i16>>(index);
+            v.map(|v| v.to_string())
+        }
+        "int" | "int4" | "serial" => {
+            let v = row.get::<_, Option<i32>>(index);
+            v.map(|v| v.to_string())
+        }
+        "int8" | "bigserial" | "bigint" => {
+            let v = row.get::<_, Option<i64>>(index);
+            v.map(|v| v.to_string())
+        }
+        "float4" | "real" => {
+            let v = row.get::<_, Option<f32>>(index);
+            v.map(|v| v.to_string())
+        }
+        "float8" | "double precision" => {
+            let v = row.get::<_, Option<f64>>(index);
+            v.map(|v| v.to_string())
+        }
+        // "timestamp" | "timestamptz" => {
+        //     // with-chrono feature is needed for this
+        //     let v: Option<chrono::DateTime<chrono::Utc>> = row.get(index);
+        //     v.map(|v| v.to_string())
+        // }
+        &_ => Some("CANNOT PARSE".to_string()),
+    };
+    value.unwrap_or("null".to_string())
+}
+

src/db_connector.rs

@@ -2,8 +2,7 @@ use leptos::{html::*, *};
 
 use crate::store::{db::DBStore, query::QueryState};
 
-#[component]
-pub fn DBConnector() -> impl IntoView {
+pub fn db_connector() -> impl IntoView {
     let db = use_context::<DBStore>().unwrap();
     let connect = create_action(move |db: &DBStore| {
         let mut db_clone = *db;

src/layout.rs

@@ -1,12 +1,12 @@
-use crate::{db_connector::DBConnector, sidebar::sidebar};
+use crate::{db_connector::db_connector, sidebar::sidebar};
 use leptos::html::{div, main};
 use leptos::*;
 
 pub fn layout(children: Children) -> impl IntoView {
     div().attr("class", "flex h-screen").child(sidebar()).child(
         div()
             .attr("class", "flex flex-col flex-1 overflow-hidden")
-            .child(DBConnector())
+            .child(db_connector())
             .child(
                 main()
                     .attr("class", "flex-1 overflow-y-scroll")

src/main.rs

@@ -13,6 +13,6 @@ use app::*;
 use leptos::*;
 
 fn main() {
-    mount_to_body(|| app())
+    mount_to_body(app)
 }
 

src/sidebar.rs

@@ -15,7 +15,7 @@ pub fn sidebar() -> impl IntoView {
             children: ChildrenFn::to_children(move || {
                 Fragment::new(vec![p().child("Loading...").into_view()])
             }),
-            fallback: ViewFn::from(|| div()),
+            fallback: ViewFn::from(div),
         }))
         .child(move || {
             db.schemas
@@ -48,7 +48,7 @@ pub fn sidebar() -> impl IntoView {
                             children: ChildrenFn::to_children(move || {
                                 Fragment::new(vec![tables(schema.clone()).into_view()])
                             }),
-                            fallback: ViewFn::from(|| div()),
+                            fallback: ViewFn::from(div),
                         }))
                 })
                 .collect_view()

src/store/db.rs

@@ -37,7 +37,7 @@ impl DBStore {
 
     pub fn create_connection_string(&self) -> String {
         format!(
-            "postgresql://{}:{}@{}:{}",
+            "user={} password={} host={} port={}",
             self.db_user.get_untracked(),
             self.db_password.get_untracked(),
             self.db_host.get_untracked(),