refactor

src-tauri/src/cmd.rs

@@ -149,7 +149,7 @@ pub async fn get_db(
   port: Option<String>,
   cwd: Option<String>,
   database: Option<String>,
-) -> Result<Option<TreeNode>, String> {
+) -> Result<TreeNode, String> {
   let payload = DialectPayload {
     dialect: dialect.to_string(),
     path,
@@ -162,7 +162,7 @@ pub async fn get_db(
   };
 
   if let Some(d) = get_dialect(payload).await {
-    Ok(d.get_db().await)
+    d.get_db().await.map_err(|e| e.to_string())
   } else {
     Err("not support dialect".to_string())
   }

src-tauri/src/dialect/clickhouse.rs

@@ -43,18 +43,15 @@ impl ClickhouseDialect {
 
 #[async_trait]
 impl Dialect for ClickhouseDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
     let url = self.get_url();
-    if let Ok(tables) = get_tables(&url).await {
-      Some(TreeNode {
-        name: self.host.clone(),
-        path: self.host.clone(),
-        node_type: "root".to_string(),
-        children: Some(build_tree(tables)),
-      })
-    } else {
-      None
-    }
+    let tables = get_tables(&url).await?;
+    Ok(TreeNode {
+      name: self.host.clone(),
+      path: self.host.clone(),
+      node_type: "root".to_string(),
+      children: Some(build_tree(tables)),
+    })
   }
 
   async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {
@@ -221,7 +218,7 @@ fn convert_type(col_type: &SqlType) -> DataType {
     SqlType::Date => DataType::Date32,
     SqlType::String => DataType::Utf8,
     SqlType::DateTime(_) => DataType::Date64,
-    SqlType::Nullable(t) => convert_type(t.clone()),
+    SqlType::Nullable(t) => convert_type(*t),
     SqlType::Decimal(d1, d2) => DataType::Utf8,
     SqlType::Array(t) => DataType::List(Arc::new(Field::new("", convert_type(t), false))),
     _ => DataType::Utf8,
@@ -267,7 +264,7 @@ fn convert_col(
 ) -> anyhow::Result<(Field, ArrayRef)> {
   let nullable = matches!(col_type, SqlType::Nullable(_));
   let typ = if let SqlType::Nullable(t) = col_type {
-    t.clone()
+    *t
   } else {
     col_type
   };

src-tauri/src/dialect/duckdb.rs

@@ -1,14 +1,11 @@
-use std::env::{current_dir, set_current_dir};
-use std::fs::File;
+use async_trait::async_trait;
+use duckdb::Connection;
 
 use crate::api;
-use crate::api::{serialize_preview, ArrowData};
+use crate::api::ArrowData;
 use crate::dialect::{Dialect, TreeNode};
 use crate::utils::{build_tree, get_file_name, write_csv, Table};
-use arrow::csv::{Writer, WriterBuilder};
-use arrow::ipc::RecordBatch;
-use async_trait::async_trait;
-use duckdb::Connection;
+
 #[derive(Debug, Default)]
 pub struct DuckDbDialect {
   pub path: String,
@@ -17,17 +14,14 @@ pub struct DuckDbDialect {
 
 #[async_trait]
 impl Dialect for DuckDbDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
-    if let Ok(tables) = get_tables(&self.path) {
-      Some(TreeNode {
-        name: get_file_name(&self.path),
-        path: self.path.clone(),
-        node_type: "root".to_string(),
-        children: Some(build_tree(tables)),
-      })
-    } else {
-      None
-    }
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
+    let tables = get_tables(&self.path)?;
+    Ok(TreeNode {
+      name: get_file_name(&self.path),
+      path: self.path.clone(),
+      node_type: "root".to_string(),
+      children: Some(build_tree(tables)),
+    })
   }
 
   async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {

src-tauri/src/dialect/file.rs

@@ -12,10 +12,10 @@ pub struct FileDialect {
 
 #[async_trait]
 impl Dialect for FileDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
     let path = PathBuf::from(self.path.as_str());
 
-    Some(TreeNode {
+    Ok(TreeNode {
       path: self.path.clone(),
       name: get_file_name(&self.path),
       node_type: path.extension().unwrap().to_string_lossy().to_string(),

src-tauri/src/dialect/folder.rs

@@ -1,17 +1,13 @@
-use anyhow::anyhow;
-use arrow::csv::WriterBuilder;
-use async_trait::async_trait;
-use std::env::current_dir;
-use std::fs::File;
+use std::fs;
 use std::path::Path;
-use std::{env::set_current_dir, fs};
 
+use async_trait::async_trait;
 use duckdb::Connection;
 
 use crate::api;
 use crate::utils::write_csv;
 use crate::{
-  api::{serialize_preview, ArrowData},
+  api::ArrowData,
   dialect::{Dialect, TreeNode},
 };
 
@@ -23,8 +19,8 @@ pub struct FolderDialect {
 
 #[async_trait]
 impl Dialect for FolderDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
-    directory_tree(self.path.as_str())
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
+    directory_tree(self.path.as_str()).ok_or(anyhow::bail!("null"))
   }
 
   async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {

src-tauri/src/dialect/mod.rs

@@ -29,11 +29,11 @@ pub struct Title {
 
 #[async_trait]
 pub trait Dialect: Sync + Send {
-  async fn get_db(&self) -> Option<TreeNode>;
-  async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {
+  async fn get_db(&self) -> anyhow::Result<TreeNode>;
+  async fn query(&self, _sql: &str, _limit: usize, _offset: usize) -> anyhow::Result<ArrowData> {
     unimplemented!()
   }
-  async fn export(&self, sql: &str, file: &str) {
+  async fn export(&self, _sql: &str, _file: &str) {
     unimplemented!()
   }
 }

src-tauri/src/dialect/mysql.rs

@@ -24,23 +24,20 @@ pub struct MySqlDialect {
 
 #[async_trait]
 impl Dialect for MySqlDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
-    if let Ok(tables) = self.get_tables() {
-      Some(TreeNode {
-        name: self.host.clone(),
-        path: self.host.clone(),
-        node_type: "root".to_string(),
-        children: Some(build_tree(tables)),
-      })
-    } else {
-      None
-    }
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
+    let tables = self.get_tables()?;
+    Ok(TreeNode {
+      name: self.host.clone(),
+      path: self.host.clone(),
+      node_type: "root".to_string(),
+      children: Some(build_tree(tables)),
+    })
   }
 
   async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {
     let mut conn = self.get_conn()?;
 
-    let mut stmt = conn.prep(sql)?;
+    let stmt = conn.prep(sql)?;
     let mut fields = vec![];
     let k = stmt.num_columns();
     let mut titles = vec![];

src-tauri/src/dialect/postgres.rs

@@ -29,27 +29,24 @@ pub struct PostgresDialect {
 
 #[async_trait]
 impl Dialect for PostgresDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
-    if let Ok(tables) = self.get_all_tables().await {
-      Some(TreeNode {
-        name: self.host.clone(),
-        path: self.host.clone(),
-        node_type: "root".to_string(),
-        children: Some(build_tree(tables)),
-      })
-    } else {
-      None
-    }
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
+    let tables = self.get_all_tables().await?;
+    Ok(TreeNode {
+      name: self.host.clone(),
+      path: self.host.clone(),
+      node_type: "root".to_string(),
+      children: Some(build_tree(tables)),
+    })
   }
 
   async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {
-    let mut conn = self
+    let conn = self
       .get_conn(&self.database.clone().unwrap_or("postgres".to_string()))
       .await?;
 
-    let mut stmt = conn.prepare(sql).await?;
+    let stmt = conn.prepare(sql).await?;
     let mut fields = vec![];
-    let k = stmt.columns().len();
+    let _k = stmt.columns().len();
     let mut titles = vec![];
     for col in stmt.columns() {
       titles.push(Title {
@@ -110,7 +107,7 @@ impl PostgresDialect {
   }
 
   async fn get_schema(&self) -> Vec<Table> {
-    vec![]
+    unimplemented!()
   }
   pub async fn databases(&self) -> anyhow::Result<Vec<String>> {
     let mut client = self.get_conn("postgres").await?;

src-tauri/src/dialect/sqlite.rs

@@ -20,27 +20,25 @@ pub struct SqliteDialect {
 
 #[async_trait]
 impl Dialect for SqliteDialect {
-  async fn get_db(&self) -> Option<TreeNode> {
+  async fn get_db(&self) -> anyhow::Result<TreeNode> {
     let url = self.get_url();
-    if let Ok(tables) = get_tables(&url).await {
-      let mut tree = build_tree(tables);
-      let children = if tree.len() > 0 {
-        &tree[0].children
-      } else {
-        &None
-      };
-      Some(TreeNode {
-        name: get_file_name(&self.path),
-        path: self.path.clone(),
-        node_type: "root".to_string(),
-        children: children.clone(),
-      })
+    let tables = get_tables(&url).await?;
+    println!("tables={:?}", tables);
+    let tree = build_tree(tables);
+    let children = if tree.len() > 0 {
+      &tree[0].children
     } else {
-      None
-    }
+      &None
+    };
+    Ok(TreeNode {
+      name: get_file_name(&self.path),
+      path: self.path.clone(),
+      node_type: "root".to_string(),
+      children: children.clone(),
+    })
   }
 
-  async fn query(&self, sql: &str, limit: usize, offset: usize) -> anyhow::Result<ArrowData> {
+  async fn query(&self, sql: &str, _limit: usize, _offset: usize) -> anyhow::Result<ArrowData> {
     let conn = Connection::open(&self.path)?;
     let mut stmt = conn.prepare(sql)?;
 
@@ -104,7 +102,7 @@ impl SqliteDialect {
   }
 
   async fn get_schema(&self) -> Vec<Table> {
-    vec![]
+    unimplemented!()
   }
 
   fn fetch_all(&self, sql: &str) -> anyhow::Result<ArrowData> {
@@ -222,6 +220,7 @@ pub fn convert_arrow(value: &Value, typ: &str) -> ArrayRef {
   }
 }
 
+#[allow(dead_code)]
 pub fn convert_to_string(value: &Value) -> Option<String> {
   match value {
     Value::Integer(i) => Some(i.to_string()),
@@ -232,6 +231,7 @@ pub fn convert_to_string(value: &Value) -> Option<String> {
   }
 }
 
+#[allow(dead_code)]
 pub fn convert_to_i64(value: &Value) -> Option<i64> {
   match value {
     Value::Integer(i) => Some(*i),
@@ -250,14 +250,17 @@ pub fn convert_to_f64(value: &Value) -> Option<f64> {
   }
 }
 
+#[allow(dead_code)]
 pub fn convert_to_strings(values: &[Value]) -> Vec<Option<String>> {
   values.iter().map(|v| convert_to_string(v)).collect()
 }
 
+#[allow(dead_code)]
 pub fn convert_to_i64s(values: &[Value]) -> Vec<Option<i64>> {
   values.iter().map(|v| convert_to_i64(v)).collect()
 }
 
+#[allow(dead_code)]
 pub fn convert_to_f64s(values: &[Value]) -> Vec<Option<f64>> {
   values.iter().map(|v| convert_to_f64(v)).collect()
 }