From bae487867be3bac0f946c4e61e1c93b51a7a7c45 Mon Sep 17 00:00:00 2001
From: t8y2 <1156263951@qq.com>
Date: Tue, 19 May 2026 11:32:54 +0800
Subject: [PATCH] feat(connection): support in-memory sqlite and duckdb
---
.../connection/ConnectionDialog.vue | 30 +++++++++------
apps/desktop/src/i18n/locales/en.ts | 1 +
apps/desktop/src/i18n/locales/zh-CN.ts | 1 +
.../src/lib/databaseTableDataCapabilities.ts | 18 +++++++++
crates/dbx-core/src/db/duckdb_driver.rs | 29 +++++++++++++--
crates/dbx-core/src/db/sqlite.rs | 37 +++++++++++++++++--
packages/app-tests/tableEditing.test.ts | 6 +++
src-tauri/src/commands/connection.rs | 16 ++++----
8 files changed, 112 insertions(+), 26 deletions(-)
diff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vue
index 855b95a53f..a827d9e9d1 100644
--- a/apps/desktop/src/components/connection/ConnectionDialog.vue
+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue
@@ -517,10 +517,11 @@ const isJdbcConnection = computed(() => form.value.db_type === "jdbc");
const connectionUrlPlaceholder = computed(() => getUrlPlaceholder(form.value.db_type));
const filePathPlaceholder = computed(() => {
- if (form.value.db_type === "duckdb") return "/path/to/database.duckdb";
+ if (form.value.db_type === "duckdb") return "/path/to/database.duckdb or :memory:";
if (form.value.db_type === "access") return "/path/to/database.accdb";
- return "/path/to/database.db";
+ return "/path/to/database.db or :memory:";
});
+const supportsMemoryDatabasePath = computed(() => form.value.db_type === "sqlite" || form.value.db_type === "duckdb");
const canUseSsh = computed(() => form.value.db_type !== "sqlite" && form.value.db_type !== "access");
const canUseProxy = computed(
() => form.value.db_type !== "sqlite" && form.value.db_type !== "duckdb" && form.value.db_type !== "access",
@@ -1109,16 +1110,21 @@ function openExternalUrl(url: string) {
>
-
-
-
-
-
-
- {{ t("connection.sshKeyPathBrowse") }}
-
+
+
+
+
+
+
+
+ {{ t("connection.sshKeyPathBrowse") }}
+
+
+
+ {{ t("connection.memoryDatabasePathHint") }}
+
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index f5647040f7..bcfd4063f7 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -97,6 +97,7 @@ export default {
type: "Type",
host: "Host",
filePath: "File Path",
+ memoryDatabasePathHint: "Use :memory: to create an in-memory SQLite or DuckDB database.",
user: "User",
password: "Password",
database: "Database",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 4705eaea1c..6e378ec891 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -96,6 +96,7 @@ export default {
type: "类型",
host: "主机",
filePath: "文件路径",
+ memoryDatabasePathHint: "输入 :memory: 可创建 SQLite 或 DuckDB 内存数据库。",
user: "用户名",
password: "密码",
database: "数据库",
diff --git a/apps/desktop/src/lib/databaseTableDataCapabilities.ts b/apps/desktop/src/lib/databaseTableDataCapabilities.ts
index 059e99472c..5b8daf1e99 100644
--- a/apps/desktop/src/lib/databaseTableDataCapabilities.ts
+++ b/apps/desktop/src/lib/databaseTableDataCapabilities.ts
@@ -35,6 +35,24 @@ const DEFAULT_CAPABILITY: DatabaseCapability = {
};
const DATABASE_CAPABILITY_OVERRIDES: Partial
>> = {
+ sqlite: {
+ tableData: {
+ insert: true,
+ updateRequiresPrimaryKey: true,
+ deleteRequiresPrimaryKey: true,
+ requiresTransactionalTableForExistingRows: false,
+ transaction: true,
+ },
+ },
+ duckdb: {
+ tableData: {
+ insert: true,
+ updateRequiresPrimaryKey: true,
+ deleteRequiresPrimaryKey: true,
+ requiresTransactionalTableForExistingRows: false,
+ transaction: true,
+ },
+ },
access: {
tableData: {
insert: true,
diff --git a/crates/dbx-core/src/db/duckdb_driver.rs b/crates/dbx-core/src/db/duckdb_driver.rs
index 3b36bd82f8..456a746849 100644
--- a/crates/dbx-core/src/db/duckdb_driver.rs
+++ b/crates/dbx-core/src/db/duckdb_driver.rs
@@ -11,10 +11,13 @@ use std::sync::Mutex;
/// * `Ok(Arc>)` on successful connection
/// * `Err(String)` with descriptive error message if connection fails
pub fn connect_path(path: &str) -> Result>, String> {
- // Validate file path using universal validator
- validate_file_path(path, is_network_path)?;
+ let is_memory = is_memory_database_path(path);
+ if !is_memory {
+ validate_file_path(path, is_network_path)?;
+ }
- let connection = duckdb::Connection::open(path).map_err(|e| format!("DuckDb connection failed: {e}"))?;
+ let connection = if is_memory { duckdb::Connection::open_in_memory() } else { duckdb::Connection::open(path) }
+ .map_err(|e| format!("DuckDb connection failed: {e}"))?;
Ok(Arc::new(Mutex::new(connection)))
}
@@ -22,3 +25,23 @@ pub fn connect_path(path: &str) -> Result>, String
fn is_network_path(path: &str) -> bool {
path.starts_with("\\\\") || path.starts_with("//") || path.contains("wsl.localhost") || path.contains("wsl$")
}
+
+pub fn is_memory_database_path(path: &str) -> bool {
+ path.trim().eq_ignore_ascii_case(":memory:")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn connect_path_supports_memory_database() {
+ let con = connect_path(":memory:").expect("connect in-memory DuckDB");
+ let locked = con.lock().expect("lock connection");
+
+ locked.execute_batch("CREATE TABLE memory_probe AS SELECT 42 AS id;").expect("create table");
+ let value: i32 = locked.query_row("SELECT id FROM memory_probe;", [], |row| row.get(0)).expect("select row");
+
+ assert_eq!(value, 42);
+ }
+}
diff --git a/crates/dbx-core/src/db/sqlite.rs b/crates/dbx-core/src/db/sqlite.rs
index e773414588..6e48e25c7a 100644
--- a/crates/dbx-core/src/db/sqlite.rs
+++ b/crates/dbx-core/src/db/sqlite.rs
@@ -1,6 +1,7 @@
use futures::StreamExt;
use sqlx::sqlite::{SqliteConnectOptions, SqlitePool, SqlitePoolOptions, SqliteRow};
use sqlx::{Column, Executor, Row};
+use std::str::FromStr;
use std::time::{Duration, Instant};
use super::file_validator::validate_file_path;
@@ -8,17 +9,23 @@ use crate::sql::starts_with_executable_sql_keyword;
use crate::types::{ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, QueryResult, TableInfo, TriggerInfo};
pub async fn connect_path(path: &str) -> Result {
- // Validate file path using universal validator
- validate_file_path(path, is_network_path)?;
+ let is_memory = is_memory_database_path(path);
+ if !is_memory {
+ validate_file_path(path, is_network_path)?;
+ }
- let mut options = SqliteConnectOptions::new().filename(path).create_if_missing(false);
+ let mut options = if is_memory {
+ SqliteConnectOptions::from_str("sqlite::memory:").map_err(|e| format!("SQLite connection failed: {e}"))?
+ } else {
+ SqliteConnectOptions::new().filename(path).create_if_missing(false)
+ };
if is_network_path(path) {
options = options.vfs("unix-nolock");
}
SqlitePoolOptions::new()
- .max_connections(5)
+ .max_connections(if is_memory { 1 } else { 5 })
.acquire_timeout(Duration::from_secs(10))
.idle_timeout(Duration::from_secs(300))
.connect_with(options)
@@ -30,6 +37,28 @@ fn is_network_path(path: &str) -> bool {
path.starts_with("\\\\") || path.starts_with("//") || path.contains("wsl.localhost") || path.contains("wsl$")
}
+pub fn is_memory_database_path(path: &str) -> bool {
+ path.trim().eq_ignore_ascii_case(":memory:")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[tokio::test]
+ async fn connect_path_supports_memory_database_across_statements() {
+ let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+ execute_query(&pool, "CREATE TABLE memory_probe (id INTEGER PRIMARY KEY, name TEXT);")
+ .await
+ .expect("create table");
+ execute_query(&pool, "INSERT INTO memory_probe (name) VALUES ('Ada');").await.expect("insert row");
+ let result = execute_query(&pool, "SELECT name FROM memory_probe WHERE id = 1;").await.expect("select row");
+
+ assert_eq!(result.rows[0][0], serde_json::json!("Ada"));
+ }
+}
+
pub async fn list_databases(_pool: &SqlitePool) -> Result, String> {
Ok(vec![DatabaseInfo { name: "main".to_string() }])
}
diff --git a/packages/app-tests/tableEditing.test.ts b/packages/app-tests/tableEditing.test.ts
index 23d6dd0f58..a725bba18e 100644
--- a/packages/app-tests/tableEditing.test.ts
+++ b/packages/app-tests/tableEditing.test.ts
@@ -47,6 +47,8 @@ test("uses tbname and timestamp as TDengine editable keys", () => {
test("allows Hive table data editing even without declared primary keys", () => {
assert.equal(isTableDataEditable("access", []), true);
+ assert.equal(isTableDataEditable("sqlite", []), true);
+ assert.equal(isTableDataEditable("duckdb", []), true);
assert.equal(isTableDataEditable("hive", []), true);
assert.equal(isTableDataEditable("trino", []), true);
assert.equal(isTableDataEditable("informix", []), true);
@@ -71,6 +73,10 @@ test("allows existing row edits according to database-specific key requirements"
assert.equal(canEditExistingTableRows("hive", undefined), false);
assert.equal(canEditExistingTableRows("trino", undefined, []), false);
assert.equal(canEditExistingTableRows("trino", undefined, ["id"]), true);
+ assert.equal(canEditExistingTableRows("sqlite", undefined, []), false);
+ assert.equal(canEditExistingTableRows("sqlite", undefined, ["id"]), true);
+ assert.equal(canEditExistingTableRows("duckdb", undefined, []), false);
+ assert.equal(canEditExistingTableRows("duckdb", undefined, ["id"]), true);
assert.equal(canEditExistingTableRows("informix", undefined, []), false);
assert.equal(canEditExistingTableRows("informix", undefined, ["id"]), true);
assert.equal(canEditExistingTableRows("tdengine", undefined, ["ts"]), false);
diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rs
index d4089d32ae..28303e7f7a 100644
--- a/src-tauri/src/commands/connection.rs
+++ b/src-tauri/src/commands/connection.rs
@@ -152,9 +152,8 @@ pub async fn test_connection(state: State<'_, Arc>, config: Connection
Err(e) => Err(e),
},
DatabaseType::Redis => db::redis_driver::connect(&url).await.map(|_| "Connection successful".to_string()),
- DatabaseType::DuckDb => duckdb::Connection::open(&expand_tilde(&config.host))
- .map(|_| "Connection successful".to_string())
- .map_err(|e| e.to_string()),
+ DatabaseType::DuckDb => db::duckdb_driver::connect_path(&expand_tilde(&config.host))
+ .map(|_| "Connection successful".to_string()),
DatabaseType::MongoDb => {
let native_err = match db::mongo_driver::connect(&url).await {
Ok(client) => match db::mongo_driver::test_connection(&client).await {
@@ -258,11 +257,14 @@ pub async fn connect_db(state: State<'_, Arc>, config: ConnectionConfi
PoolKind::Redis(tokio::sync::Mutex::new(con))
}
DatabaseType::DuckDb => {
- let con = duckdb::Connection::open(&expand_tilde(&db_config.host)).map_err(|e| e.to_string())?;
- for attached in &db_config.attached_databases {
- dbx_core::schema::duckdb_attach_database(&con, &attached.name, &expand_tilde(&attached.path))?;
+ let con = db::duckdb_driver::connect_path(&expand_tilde(&db_config.host))?;
+ {
+ let locked = con.lock().map_err(|e| e.to_string())?;
+ for attached in &db_config.attached_databases {
+ dbx_core::schema::duckdb_attach_database(&locked, &attached.name, &expand_tilde(&attached.path))?;
+ }
}
- PoolKind::DuckDb(std::sync::Arc::new(std::sync::Mutex::new(con)))
+ PoolKind::DuckDb(con)
}
DatabaseType::MongoDb => {
let native_err = match db::mongo_driver::connect(&url).await {