Merge branch 'master' of https://github.com/Johnhong9527/tauri-app

.yarnrc

@@ -0,0 +1,15 @@
+registry "https://registry.npmmirror.com"
+disturl "https://registry.npmmirror.com/dist"
+nvm_nodejs_org_mirror "https://registry.npmmirror.com/mirrors/node"
+NODEJS_ORG_MIRROR "https://registry.npmmirror.com/mirrors/node"
+sass_binary_site "https://registry.npmmirror.com/mirrors/node-sass"
+electron_mirror "https://registry.npmmirror.com/mirrors/electron/"
+SQLITE3_BINARY_SITE "https://registry.npmmirror.com/mirrors/sqlite3"
+profiler_binary_host_mirror "https://registry.npmmirror.com/mirrors/node-inspector/"
+node_inspector_cdnurl "https://registry.npmmirror.com/mirrors/node-inspector"
+selenium_cdnurl "https://registry.npmmirror.com/mirrors/selenium"
+puppeteer_download_host "https://registry.npmmirror.com/mirrors"
+chromedriver_cdnurl "https://registry.npmmirror.com/mirrors/chromedriver"
+operadriver_cdnurl "https://registry.npmmirror.com/mirrors/operadriver"
+phantomjs_cdnurl "https://registry.npmmirror.com/mirrors/phantomjs"
+fse_binary_host_mirror "https://registry.npmmirror.com/mirrors/fsevents"

src-tauri/src/common/sqlite/migration/database_version.rs

@@ -2,31 +2,39 @@ use crate::self_plugin::tauri_plugin_sqlite::sqlite::{execute, execute_batch, qu
 use anyhow::{anyhow, Result};
 use serde_json::{json, Value};
 
+// 定义一个异步的数据库版本操作接口
 #[async_trait::async_trait]
 pub trait DatabaseVersionSql {
+    // 获取版本号
     async fn version(&self) -> u32;
+    // 执行DDL脚本之前的操作
     async fn before(&self);
+    // 获取DDL脚本
     async fn ddl(&self) -> Vec<String>;
+    // 执行DDL脚本之后的操作
     async fn after(&self);
 }
 
+// 获取数据库版本
 pub async fn get_database_version(path: &String) -> Result<u32> {
+    // 检查版本表是否存在
     if !check_version_table(path).await? {
         Err(anyhow!("系统错误，没有数据库版本表!"))
     } else {
-        //查询
+        // 查询数据库版本
         let versions = query_with_args(
-        path.to_string(),
+            path.to_string(),
             "SELECT version FROM databases_version WHERE name = :name".to_string(),
             json!({
-                ":name":path.clone()
+                ":name": path.clone()
             }),
-        )
-        .await?;
+        ).await?;
+
+        // 如果没有版本记录，返回0
         if versions.len() == 0 {
             Ok(0)
         } else {
-            //
+            // 获取版本号
             let version = versions.get(0).map_or(0, |row| {
                 if let Some(Value::Number(v)) = row.get("version") {
                     let v: u32 = v.as_u64().unwrap().try_into().unwrap();
@@ -40,60 +48,71 @@ pub async fn get_database_version(path: &String) -> Result<u32> {
     }
 }
 
+// 设置数据库版本
 pub async fn set_database_version(path: &String, version: u32) -> Result<bool> {
+    // 检查版本表是否存在
     if !check_version_table(path).await? {
         Err(anyhow!("系统错误，没有数据库版本表!"))
     } else {
-        //查询
-        execute(path.to_string(), "INSERT INTO databases_version (name, version)VALUES (:name, :version) ON CONFLICT(name) DO UPDATE SET version = :version".to_string(), json!({
-            ":name":path.clone(),
-            ":version":version
-        })).await?;
+        // 更新数据库版本
+        execute(
+            path.to_string(),
+            "INSERT INTO databases_version (name, version) VALUES (:name, :version) 
+             ON CONFLICT(name) DO UPDATE SET version = :version".to_string(),
+            json!({
+                ":name": path.clone(),
+                ":version": version
+            }),
+        ).await?;
         Ok(true)
     }
 }
 
+// 合并数据库版本
 pub async fn merge_database_version<T>(path: &String, list: Vec<T>) -> Result<bool>
-where
-    T: DatabaseVersionSql,
+    where
+        T: DatabaseVersionSql,
 {
-    //当前的版本
+    // 获取当前版本
     let version = get_database_version(path).await?;
-
     tracing::debug!("当前数据库版本:{}", version);
-    //循环脚本
+
+    // 循环执行升级脚本
     for item in list {
         let item_version = item.version().await;
 
+        // 如果新版本大于当前版本，执行升级
         if item_version > version {
-            //before
             item.before().await;
-            //ddl
             let ddls = item.ddl().await;
 
+            // 执行DDL脚本
             for ddl_sql in ddls {
                 execute_batch(path.to_string(), ddl_sql).await?;
             }
-            //after
-            item.after().await;
 
+            item.after().await;
             set_database_version(path, item_version).await?;
         }
     }
     Ok(true)
 }
 
+// 普通DDL数据库版本结构体
 #[derive(Debug)]
 pub struct NormalDdlDatabaseVersionSql {
     version: u32,
     ddl: Vec<String>,
 }
+
 impl NormalDdlDatabaseVersionSql {
+    // 创建一个新实例
     pub fn new(version: u32, ddl: Vec<String>) -> Self {
         Self { version, ddl }
     }
 }
 
+// 实现 DatabaseVersionSql 接口
 #[async_trait::async_trait]
 impl DatabaseVersionSql for NormalDdlDatabaseVersionSql {
     async fn version(&self) -> u32 {
@@ -110,32 +129,29 @@ impl DatabaseVersionSql for NormalDdlDatabaseVersionSql {
     }
 }
 
+// 检查版本表是否存在
 async fn check_version_table(path: &String) -> Result<bool> {
     let sql = String::from(
         "SELECT count(1) count FROM sqlite_master WHERE type='table' and name = :name ",
     );
-    //
+
     let rows = query_with_args(
         path.to_string(),
         sql,
         json!({
-            ":name":"databases_version"
+            ":name": "databases_version"
         }),
-    )
-    .await?;
+    ).await?;
 
+    // 如果表不存在，创建版本表
     if rows.len() == 0 {
-        //没有版本表
         execute_batch(
             path.to_string(),
             "CREATE TABLE databases_version (name TEXT, version INTEGER, unique(name));"
                 .to_string(),
-        )
-        .await?;
-        //
+        ).await?;
         Ok(true)
     } else {
-        //
         let count = rows.get(0).map_or(0, |row| {
             if let Some(Value::Number(v)) = row.get("count") {
                 let v: u32 = v.as_u64().unwrap().try_into().unwrap();
@@ -144,14 +160,15 @@ async fn check_version_table(path: &String) -> Result<bool> {
                 0
             }
         });
+
+        // 如果表不存在，创建版本表
         if count == 0 {
             execute_batch(
                 path.to_string(),
                 "CREATE TABLE databases_version (name TEXT, version INTEGER, unique(name));"
                     .to_string(),
-            )
-            .await?;
+            ).await?;
         }
         Ok(true)
     }
-}
+}

src-tauri/src/common/sqlite/mod.rs

@@ -1,23 +1,26 @@
-pub mod migration;
-mod rusqlite_utils;
+pub mod migration; // 定义数据库迁移模块
+mod rusqlite_utils; // 定义一些辅助工具模块
 
-use anyhow::{anyhow, Result};
-use rusqlite::{types::Value as SqliteValue, Connection, OpenFlags, ToSql};
-use serde_json::Value as JsonValue;
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex, RwLock};
+use anyhow::{anyhow, Result}; // 引入错误处理库
+use rusqlite::{types::Value as SqliteValue, Connection, OpenFlags, ToSql}; // 引入rusqlite库
+use serde_json::Value as JsonValue; // 引入JSON库
+use std::collections::HashMap; // 引入HashMap数据结构
+use std::sync::{Arc, Mutex, RwLock}; // 引入并发处理库
 
+// 定义一个全局的数据库连接缓存，使用RwLock进行读写锁定
 lazy_static::lazy_static! {
     pub(crate) static ref CONNECTIONS: RwLock<HashMap<String, Arc<Mutex<Connection>>>> =
         RwLock::new(HashMap::new());
 }
 
+// 打开数据库连接
 pub async fn open(path: &String) -> Result<Arc<Mutex<Connection>>> {
     open_with_flags(path, OpenFlags::default()).await
 }
 
+// 打开带有标志的数据库连接
 pub async fn open_with_flags(path: &String, flags: OpenFlags) -> Result<Arc<Mutex<Connection>>> {
-    //判断是否已经打开
+    // 判断是否已经打开
     let exist = CONNECTIONS.read().unwrap().contains_key(path);
 
     if exist {
@@ -27,18 +30,20 @@ pub async fn open_with_flags(path: &String, flags: OpenFlags) -> Result<Arc<Mute
             Err(anyhow!("获取失败"))
         }
     } else {
-        //
+        // 构造数据库路径
         let mut storage_path = crate::utils::system_tools_home_path()?.join("sqlite");
         storage_path.push(path.clone());
 
         let prefix = storage_path.parent().unwrap_or(storage_path.as_path());
         std::fs::create_dir_all(prefix).map_err(|err| anyhow::anyhow!(err))?;
 
+        // 打开数据库连接
         let arc_conn = Arc::new(Mutex::new(Connection::open_with_flags(
             &storage_path,
             flags,
         )?));
 
+        // 将连接缓存
         let mut cache = CONNECTIONS.write().unwrap();
         cache.insert(path.clone(), arc_conn.clone());
 
@@ -46,6 +51,7 @@ pub async fn open_with_flags(path: &String, flags: OpenFlags) -> Result<Arc<Mute
     }
 }
 
+// 执行SQL语句
 pub async fn execute_sql(path: &String, sql: &String) -> Result<usize> {
     let arc_conn = open(path).await?;
 
@@ -57,6 +63,7 @@ pub async fn execute_sql(path: &String, sql: &String) -> Result<usize> {
     Ok(res)
 }
 
+// 关闭数据库连接
 pub async fn close(path: &String) -> Result<bool> {
     let arc_conn = open(path).await?;
 
@@ -65,7 +72,7 @@ pub async fn close(path: &String) -> Result<bool> {
         .map_err(|err| anyhow!("lock数据库连接失败:{}", err))?;
 
     drop(conn);
-    //移除
+    // 移除缓存
     let mut cache = CONNECTIONS
         .write()
         .map_err(|err| anyhow!("获取锁失败:{}", err))?;
@@ -74,6 +81,7 @@ pub async fn close(path: &String) -> Result<bool> {
     Ok(true)
 }
 
+// 批量执行SQL语句
 pub async fn execute_batch(path: &String, sql: &String) -> Result<bool> {
     let arc_conn = open(path).await?;
 
@@ -85,6 +93,7 @@ pub async fn execute_batch(path: &String, sql: &String) -> Result<bool> {
     Ok(true)
 }
 
+// 执行带参数的SQL语句
 pub async fn execute(path: &String, sql: &String, args: &JsonValue) -> Result<usize> {
     let arc_conn = open(path).await?;
 
@@ -92,13 +101,13 @@ pub async fn execute(path: &String, sql: &String, args: &JsonValue) -> Result<us
         .lock()
         .map_err(|err| anyhow!("lock数据库连接失败:{}", err))?;
 
+    // 将参数转换为SQLite的值
     let mut args_sqlite_values = HashMap::<String, SqliteValue>::new();
     let mut named_args: Vec<(&str, &dyn ToSql)> = vec![];
 
     if let JsonValue::Object(json_value) = args {
         for (k, v) in json_value {
             args_sqlite_values.insert(k.clone(), rusqlite_utils::value_to_rusqlite_value(v)?);
-            //
         }
     }
 
@@ -110,6 +119,7 @@ pub async fn execute(path: &String, sql: &String, args: &JsonValue) -> Result<us
     return Ok(res);
 }
 
+// 执行带参数的查询语句
 pub async fn query_with_args(
     path: &String,
     sql: &String,
@@ -150,9 +160,8 @@ pub async fn query_with_args(
 
     for table_result in schema_iter {
         if let Ok(row_value) = table_result {
-            //
             result.push(row_value);
         }
     }
     Ok(result)
-}
+}

src-tauri/src/common/sqlite/rusqlite_utils.rs

@@ -1,79 +1,90 @@
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Result}; // 引入错误处理库
 use rusqlite::{
-    types::FromSql,
-    types::Value as SqliteValue,
-    types::ValueRef::{Blob, Integer, Null, Real, Text},
-    Connection, Params, Row, ToSql,
+    types::FromSql, // 用于将 SQLite 数据类型转换为 Rust 类型
+    types::Value as SqliteValue, // SQLite 的值类型
+    types::ValueRef::{Blob, Integer, Null, Real, Text}, // SQLite 值引用类型
+    Connection, Params, Row, ToSql, // 引入 SQLite 连接、参数、行和 ToSql 类型
 };
-use serde_json::{Number, Value};
-use std::{collections::HashMap, sync::Mutex};
+use serde_json::{Number, Value}; // 引入 JSON 处理库
+use std::{collections::HashMap, sync::Mutex}; // 引入 HashMap 和 Mutex
 
+// 查询单个值
 pub fn query_one_value<P, V>(connection: &Connection, sql: &str, p: P) -> Result<V>
-where
-    P: Params,
-    V: FromSql,
+    where
+        P: Params, // 参数类型
+        V: FromSql, // 从 SQLite 值转换的类型
 {
+    // 准备 SQL 语句
     let mut stmt = connection.prepare(sql)?;
 
+    // 执行查询并映射结果
     let result_iter = stmt.query_map(p, |row| Ok(row.get(0)?))?;
 
+    // 遍历查询结果
     for result in result_iter {
         if let Ok(i32_temp) = result {
-            //table
+            // 返回查询到的值
             return Ok(i32_temp);
         }
     }
-    Err(anyhow!(""))
+    Err(anyhow!("")) // 如果没有结果，返回错误
 }
 
+// 将 rusqlite 的行转换为 JSON 值
 pub fn rusqlite_row_to_value(row: &Row<'_>, cnt: usize) -> Result<Vec<Value>> {
-    let mut cols = Vec::<Value>::new();
+    let mut cols = Vec::<Value>::new(); // 存储列值
     for i in 0..cnt {
+        // 获取每一列的值
         let rusqlite_value = row.get_ref_unwrap(i);
+        // 将 rusqlite 的值转换为 JSON 值
         let idns_value = match rusqlite_value {
-            Null => Value::Null,
-            Integer(i64_v) => Value::Number(Number::from(i64_v)),
-            Real(f64_v) => Value::Number(Number::from_f64(f64_v).map_or(Number::from(0i64), |r| r)),
-            Text(str_v) => Value::String(String::from_utf8(str_v.to_vec()).unwrap()),
-            Blob(v) => Value::Null,
+            Null => Value::Null, // 空值
+            Integer(i64_v) => Value::Number(Number::from(i64_v)), // 整数
+            Real(f64_v) => Value::Number(Number::from_f64(f64_v).map_or(Number::from(0i64), |r| r)), // 浮点数
+            Text(str_v) => Value::String(String::from_utf8(str_v.to_vec()).unwrap()), // 文本
+            Blob(v) => Value::Null, // 二进制数据（这里处理为 Null）
         };
-        cols.push(idns_value);
+        cols.push(idns_value); // 将转换后的值添加到列集合中
     }
 
-    return Ok(cols);
+    return Ok(cols); // 返回列值集合
 }
 
+// 将 rusqlite 的行转换为 HashMap
 pub fn rusqlite_row_to_map(_row: &Row<'_>, names: &Vec<String>) -> Result<HashMap<String, Value>> {
-    let mut row = HashMap::default();
+    let mut row = HashMap::default(); // 创建一个 HashMap 来存储行数据
     for (i, name) in names.iter().enumerate() {
+        // 获取每一列的值
         let rusqlite_value = _row.get_ref_unwrap(i);
+        // 将 rusqlite 的值转换为 JSON 值
         let v = match rusqlite_value {
-            Real(f64_v) => Value::Number(Number::from_f64(f64_v).map_or(Number::from(0i64), |r| r)),
-            Integer(i64_v) => Value::Number(Number::from(i64_v)),
-            Text(str_v) => Value::String(String::from_utf8(str_v.to_vec()).unwrap()),
-            Blob(v) => Value::Null,
-            _ => Value::Null,
+            Real(f64_v) => Value::Number(Number::from_f64(f64_v).map_or(Number::from(0i64), |r| r)), // 浮点数
+            Integer(i64_v) => Value::Number(Number::from(i64_v)), // 整数
+            Text(str_v) => Value::String(String::from_utf8(str_v.to_vec()).unwrap()), // 文本
+            Blob(v) => Value::Null, // 二进制数据（这里处理为 Null）
+            _ => Value::Null, // 其他类型处理为 Null
         };
-        row.insert(name.to_owned(), v);
+        row.insert(name.to_owned(), v); // 将列名和值添加到 HashMap 中
     }
-    Ok(row)
+    Ok(row) // 返回 HashMap
 }
 
+// 将 JSON 值转换为 rusqlite 的值
 pub fn value_to_rusqlite_value(json_value: &Value) -> Result<SqliteValue> {
     return Ok(match json_value {
-        Value::Null => SqliteValue::Null,
+        Value::Null => SqliteValue::Null, // 空值
         Value::Number(v) => {
             if v.is_f64() {
-                SqliteValue::Real(v.as_f64().unwrap() as f64)
+                SqliteValue::Real(v.as_f64().unwrap() as f64) // 浮点数
             } else if v.is_i64() {
-                SqliteValue::Integer(v.as_i64().unwrap())
+                SqliteValue::Integer(v.as_i64().unwrap()) // 有符号整数
             } else if v.is_u64() {
-                SqliteValue::Integer(v.as_u64().unwrap().try_into().unwrap())
+                SqliteValue::Integer(v.as_u64().unwrap().try_into().unwrap()) // 无符号整数
             } else {
-                SqliteValue::Integer(0)
+                SqliteValue::Integer(0) // 其他情况默认整数0
             }
         }
-        Value::String(string_v) => SqliteValue::Text(string_v.clone()),
-        _ => SqliteValue::Null,
+        Value::String(string_v) => SqliteValue::Text(string_v.clone()), // 字符串
+        _ => SqliteValue::Null, // 其他类型处理为 Null
     });
 }