From 6eb6ff9a31525fcb01fb36c521460d4fdbbb7307 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Wed, 8 Apr 2026 15:29:02 +0800
Subject: [PATCH 01/15] feat: expand create database charset and collation
 options

---
 src-tauri/src/commands/connection.rs          | 147 ++++++++++++++++-
 src-tauri/src/lib.rs                          |   2 +
 .../tests/mariadb_command_integration.rs      |  81 ++++++++++
 .../mysql_stateful_command_integration.rs     | 140 ++++++++++++++++
 .../business/Sidebar/ConnectionList.tsx       | 150 ++++++++++++++++--
 src/services/api.ts                           |   4 +
 src/services/api.unit.test.ts                 |   9 ++
 src/services/mocks.service.test.ts            | 101 +++++++++++-
 src/services/mocks.ts                         |  44 +++++
 9 files changed, 663 insertions(+), 15 deletions(-)

diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rs
index 452f34e0..12483119 100644
--- a/src-tauri/src/commands/connection.rs
+++ b/src-tauri/src/commands/connection.rs
@@ -419,6 +419,118 @@ pub async fn test_connection_ephemeral(
     })
 }
 
+#[tauri::command]
+pub async fn get_mysql_charsets_by_id(
+    state: State<'_, AppState>,
+    id: i64,
+) -> Result<Vec<String>, String> {
+    super::execute_with_retry(&state, id, None, |driver| async move {
+        let result = driver.execute_query("SHOW CHARACTER SET".to_string()).await?;
+        let mut charsets: Vec<String> = result
+            .data
+            .iter()
+            .filter_map(|row| {
+                row.get("Charset")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string())
+            })
+            .collect();
+        charsets.sort();
+        Ok(charsets)
+    })
+    .await
+}
+
+#[tauri::command]
+pub async fn get_mysql_collations_by_id(
+    state: State<'_, AppState>,
+    id: i64,
+    charset: Option<String>,
+) -> Result<Vec<String>, String> {
+    let sql = match &charset {
+        Some(cs) if is_safe_option_token(cs) => {
+            format!("SHOW COLLATION WHERE Charset = '{}'", cs)
+        }
+        Some(cs) => {
+            return Err(format!("[VALIDATION_ERROR] Invalid charset: {}", cs));
+        }
+        None => "SHOW COLLATION".to_string(),
+    };
+    super::execute_with_retry(&state, id, None, |driver| {
+        let sql = sql.clone();
+        async move {
+            let result = driver.execute_query(sql).await?;
+            let mut collations: Vec<String> = result
+                .data
+                .iter()
+                .filter_map(|row| {
+                    row.get("Collation")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string())
+                })
+                .collect();
+            collations.sort();
+            Ok(collations)
+        }
+    })
+    .await
+}
+
+pub async fn get_mysql_charsets_by_id_direct(
+    state: &AppState,
+    id: i64,
+) -> Result<Vec<String>, String> {
+    super::execute_with_retry_from_app_state(state, id, None, |driver| async move {
+        let result = driver.execute_query("SHOW CHARACTER SET".to_string()).await?;
+        let mut charsets: Vec<String> = result
+            .data
+            .iter()
+            .filter_map(|row| {
+                row.get("Charset")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string())
+            })
+            .collect();
+        charsets.sort();
+        Ok(charsets)
+    })
+    .await
+}
+
+pub async fn get_mysql_collations_by_id_direct(
+    state: &AppState,
+    id: i64,
+    charset: Option<String>,
+) -> Result<Vec<String>, String> {
+    let sql = match &charset {
+        Some(cs) if is_safe_option_token(cs) => {
+            format!("SHOW COLLATION WHERE Charset = '{}'", cs)
+        }
+        Some(cs) => {
+            return Err(format!("[VALIDATION_ERROR] Invalid charset: {}", cs));
+        }
+        None => "SHOW COLLATION".to_string(),
+    };
+    super::execute_with_retry_from_app_state(state, id, None, |driver| {
+        let sql = sql.clone();
+        async move {
+            let result = driver.execute_query(sql).await?;
+            let mut collations: Vec<String> = result
+                .data
+                .iter()
+                .filter_map(|row| {
+                    row.get("Collation")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string())
+                })
+                .collect();
+            collations.sort();
+            Ok(collations)
+        }
+    })
+    .await
+}
+
 #[tauri::command]
 pub async fn get_connections(state: State<'_, AppState>) -> Result<Vec<Connection>, String> {
     let local_db = {
@@ -553,8 +665,8 @@ mod tests {
         validate_database_name, CreateDatabasePayload,
     };
     use super::{
-        normalize_create_database_error, normalize_option_token, quote_clickhouse_ident,
-        quote_mssql_ident, quote_mysql_ident, quote_pg_ident,
+        is_safe_option_token, normalize_create_database_error, normalize_option_token,
+        quote_clickhouse_ident, quote_mssql_ident, quote_mysql_ident, quote_pg_ident,
     };
     use crate::connection_input::normalize_connection_form;
     use crate::models::ConnectionForm;
@@ -734,4 +846,35 @@ mod tests {
         .unwrap_err();
         assert!(err.contains("does not support charset option"));
     }
+
+    #[test]
+    fn get_mysql_collations_charset_validation_rejects_unsafe_tokens() {
+        // Verify the validation logic used by get_mysql_collations_by_id/_direct.
+        // A charset with spaces or semicolons must be rejected.
+        assert!(!is_safe_option_token("utf8 mb4"));
+        assert!(!is_safe_option_token("utf8;drop"));
+        assert!(!is_safe_option_token(""));
+    }
+
+    #[test]
+    fn get_mysql_collations_charset_validation_accepts_valid_charsets() {
+        // All standard MySQL charset names must pass the token check.
+        let valid = [
+            "utf8mb4",
+            "utf8",
+            "latin1",
+            "gbk",
+            "gb18030",
+            "ascii",
+            "binary",
+            "utf8mb4_0900_ai_ci",
+        ];
+        for cs in valid {
+            assert!(
+                is_safe_option_token(cs),
+                "expected '{}' to be accepted",
+                cs
+            );
+        }
+    }
 }
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index d4fb21f2..7f1d7d6b 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -125,6 +125,8 @@ pub fn run() {
             commands::connection::list_databases,
             commands::connection::list_databases_by_id,
             commands::connection::create_database_by_id,
+            commands::connection::get_mysql_charsets_by_id,
+            commands::connection::get_mysql_collations_by_id,
             commands::storage::save_query,
             commands::storage::get_saved_queries,
             commands::storage::update_saved_query,
diff --git a/src-tauri/tests/mariadb_command_integration.rs b/src-tauri/tests/mariadb_command_integration.rs
index bba658a9..7940a60d 100644
--- a/src-tauri/tests/mariadb_command_integration.rs
+++ b/src-tauri/tests/mariadb_command_integration.rs
@@ -335,3 +335,84 @@ async fn test_mariadb_command_get_table_data_by_conn_invalid_pagination_returns_
 
     cleanup_table(&form, &table).await;
 }
+
+#[tokio::test]
+#[ignore]
+async fn test_mariadb_show_character_set_returns_standard_charsets() {
+    let docker = (!mariadb_context::should_reuse_local_db()).then(Cli::default);
+    let (_mariadb_container, form) =
+        mariadb_context::mariadb_form_from_test_context(docker.as_ref());
+    wait_until_mariadb_ready(&form).await;
+
+    let driver = MysqlDriver::connect(&form)
+        .await
+        .expect("failed to connect mariadb driver");
+
+    let result = driver
+        .execute_query("SHOW CHARACTER SET".to_string())
+        .await
+        .expect("SHOW CHARACTER SET should succeed");
+
+    let charsets: Vec<String> = result
+        .data
+        .iter()
+        .filter_map(|row| {
+            row.get("Charset")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+        })
+        .collect();
+
+    assert!(!charsets.is_empty(), "charset list must not be empty");
+    assert!(charsets.iter().any(|c| c == "utf8mb4"), "utf8mb4 must be present");
+    assert!(charsets.iter().any(|c| c == "latin1"), "latin1 must be present");
+    assert!(
+        charsets.iter().all(|c| !c.trim().is_empty()),
+        "all charset names must be non-empty"
+    );
+
+    driver.close().await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_mariadb_show_collation_for_utf8mb4_returns_matching_collations() {
+    let docker = (!mariadb_context::should_reuse_local_db()).then(Cli::default);
+    let (_mariadb_container, form) =
+        mariadb_context::mariadb_form_from_test_context(docker.as_ref());
+    wait_until_mariadb_ready(&form).await;
+
+    let driver = MysqlDriver::connect(&form)
+        .await
+        .expect("failed to connect mariadb driver");
+
+    let result = driver
+        .execute_query("SHOW COLLATION WHERE Charset = 'utf8mb4'".to_string())
+        .await
+        .expect("SHOW COLLATION should succeed");
+
+    let collations: Vec<String> = result
+        .data
+        .iter()
+        .filter_map(|row| {
+            row.get("Collation")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+        })
+        .collect();
+
+    assert!(!collations.is_empty(), "utf8mb4 collation list must not be empty");
+    assert!(
+        collations.iter().any(|c| c == "utf8mb4_general_ci"),
+        "utf8mb4_general_ci must be present"
+    );
+    for col in &collations {
+        assert!(
+            col.starts_with("utf8mb4"),
+            "collation '{}' does not belong to utf8mb4",
+            col
+        );
+    }
+
+    driver.close().await;
+}
diff --git a/src-tauri/tests/mysql_stateful_command_integration.rs b/src-tauri/tests/mysql_stateful_command_integration.rs
index fcbdb796..07e7e767 100644
--- a/src-tauri/tests/mysql_stateful_command_integration.rs
+++ b/src-tauri/tests/mysql_stateful_command_integration.rs
@@ -856,3 +856,143 @@ async fn test_mysql_command_ai_minimal_provider_conversation_and_chat_flow() {
         .await
         .expect("ai_delete_provider should succeed");
 }
+
+#[tokio::test]
+#[ignore]
+async fn test_mysql_command_get_charsets_by_id_returns_standard_charsets() {
+    let docker = (!mysql_context::should_reuse_local_db()).then(Cli::default);
+    let (_mysql_container, form) = mysql_context::mysql_form_from_test_context(docker.as_ref());
+    wait_until_mysql_ready(&form).await;
+    let state = init_state_with_local_db().await;
+    let conn_id = create_mysql_connection_for_state(&state, &form, "get-charsets").await;
+
+    let charsets = connection::get_mysql_charsets_by_id_direct(&state, conn_id)
+        .await
+        .expect("get_mysql_charsets_by_id should succeed");
+
+    assert!(!charsets.is_empty(), "charset list must not be empty");
+    assert!(
+        charsets.iter().any(|c| c == "utf8mb4"),
+        "utf8mb4 must be present"
+    );
+    assert!(
+        charsets.iter().any(|c| c == "utf8"),
+        "utf8 must be present"
+    );
+    assert!(
+        charsets.iter().any(|c| c == "latin1"),
+        "latin1 must be present"
+    );
+    assert!(
+        charsets.windows(2).all(|w| w[0] <= w[1]),
+        "charsets must be sorted"
+    );
+    assert!(
+        charsets.iter().all(|c| !c.trim().is_empty()),
+        "all charset names must be non-empty"
+    );
+
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_mysql_command_get_charsets_by_id_invalid_connection_returns_error() {
+    let state = init_state_with_local_db().await;
+    let result = connection::get_mysql_charsets_by_id_direct(&state, -999_999).await;
+    assert!(result.is_err());
+    assert!(!result.err().unwrap_or_default().trim().is_empty());
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_mysql_command_get_collations_by_id_without_charset_returns_all() {
+    let docker = (!mysql_context::should_reuse_local_db()).then(Cli::default);
+    let (_mysql_container, form) = mysql_context::mysql_form_from_test_context(docker.as_ref());
+    wait_until_mysql_ready(&form).await;
+    let state = init_state_with_local_db().await;
+    let conn_id = create_mysql_connection_for_state(&state, &form, "get-collations-all").await;
+
+    let collations = connection::get_mysql_collations_by_id_direct(&state, conn_id, None)
+        .await
+        .expect("get_mysql_collations_by_id should succeed without charset filter");
+
+    assert!(!collations.is_empty(), "collation list must not be empty");
+    assert!(
+        collations.iter().any(|c| c == "utf8mb4_general_ci"),
+        "utf8mb4_general_ci must be present"
+    );
+    assert!(
+        collations.iter().any(|c| c == "utf8_general_ci"),
+        "utf8_general_ci must be present"
+    );
+    assert!(
+        collations.windows(2).all(|w| w[0] <= w[1]),
+        "collations must be sorted"
+    );
+
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_mysql_command_get_collations_by_id_with_charset_returns_only_matching() {
+    let docker = (!mysql_context::should_reuse_local_db()).then(Cli::default);
+    let (_mysql_container, form) = mysql_context::mysql_form_from_test_context(docker.as_ref());
+    wait_until_mysql_ready(&form).await;
+    let state = init_state_with_local_db().await;
+    let conn_id =
+        create_mysql_connection_for_state(&state, &form, "get-collations-filtered").await;
+
+    let collations = connection::get_mysql_collations_by_id_direct(
+        &state,
+        conn_id,
+        Some("utf8mb4".to_string()),
+    )
+    .await
+    .expect("get_mysql_collations_by_id should succeed with charset filter");
+
+    assert!(!collations.is_empty(), "utf8mb4 collation list must not be empty");
+    assert!(
+        collations.iter().any(|c| c == "utf8mb4_general_ci"),
+        "utf8mb4_general_ci must be present"
+    );
+    // All returned collations must start with the requested charset prefix
+    for col in &collations {
+        assert!(
+            col.starts_with("utf8mb4"),
+            "collation '{}' does not belong to utf8mb4",
+            col
+        );
+    }
+
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_mysql_command_get_collations_by_id_with_invalid_charset_returns_error() {
+    let docker = (!mysql_context::should_reuse_local_db()).then(Cli::default);
+    let (_mysql_container, form) = mysql_context::mysql_form_from_test_context(docker.as_ref());
+    wait_until_mysql_ready(&form).await;
+    let state = init_state_with_local_db().await;
+    let conn_id =
+        create_mysql_connection_for_state(&state, &form, "get-collations-invalid-cs").await;
+
+    let result = connection::get_mysql_collations_by_id_direct(
+        &state,
+        conn_id,
+        Some("utf8 mb4; DROP TABLE users".to_string()),
+    )
+    .await;
+
+    assert!(result.is_err());
+    let err = result.err().unwrap_or_default();
+    assert!(
+        err.contains("[VALIDATION_ERROR]"),
+        "expected VALIDATION_ERROR, got: {}",
+        err
+    );
+
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
diff --git a/src/components/business/Sidebar/ConnectionList.tsx b/src/components/business/Sidebar/ConnectionList.tsx
index c0756bfc..f7f608ed 100644
--- a/src/components/business/Sidebar/ConnectionList.tsx
+++ b/src/components/business/Sidebar/ConnectionList.tsx
@@ -178,14 +178,50 @@ const defaultCreateDatabaseForm: CreateDatabaseForm = {
 };
 
 const createDbNoneOption = "__none__";
-const mysqlCharsetOptions = ["utf8mb4", "utf8", "latin1"];
-const mysqlCollationOptions = [
-  "utf8mb4_general_ci",
-  "utf8mb4_unicode_ci",
-  "utf8_general_ci",
-  "latin1_swedish_ci",
+const postgresEncodingOptions = [
+  "UTF8",
+  "SQL_ASCII",
+  "BIG5",
+  "EUC_CN",
+  "EUC_JP",
+  "EUC_JIS_2004",
+  "EUC_KR",
+  "EUC_TW",
+  "GB18030",
+  "GBK",
+  "ISO_8859_5",
+  "ISO_8859_6",
+  "ISO_8859_7",
+  "ISO_8859_8",
+  "JOHAB",
+  "KOI8R",
+  "KOI8U",
+  "LATIN1",
+  "LATIN2",
+  "LATIN3",
+  "LATIN4",
+  "LATIN5",
+  "LATIN6",
+  "LATIN7",
+  "LATIN8",
+  "LATIN9",
+  "LATIN10",
+  "MULE_INTERNAL",
+  "SHIFT_JIS_2004",
+  "SJIS",
+  "UHC",
+  "WIN866",
+  "WIN874",
+  "WIN1250",
+  "WIN1251",
+  "WIN1252",
+  "WIN1253",
+  "WIN1254",
+  "WIN1255",
+  "WIN1256",
+  "WIN1257",
+  "WIN1258",
 ];
-const postgresEncodingOptions = ["UTF8", "LATIN1", "SQL_ASCII"];
 const postgresLocaleOptions = [
   "en_US.UTF-8",
   "C",
@@ -195,9 +231,60 @@ const postgresLocaleOptions = [
 ];
 const mssqlCollationOptions = [
   "SQL_Latin1_General_CP1_CI_AS",
+  "SQL_Latin1_General_CP1_CS_AS",
+  "SQL_Latin1_General_CP1_CI_AI",
+  "SQL_Latin1_General_CP1_CS_AI",
+  "Latin1_General_CI_AS",
+  "Latin1_General_CS_AS",
+  "Latin1_General_BIN",
+  "Latin1_General_BIN2",
+  "Latin1_General_100_CI_AS",
+  "Latin1_General_100_CS_AS",
+  "Latin1_General_100_CI_AI",
+  "Latin1_General_100_BIN2",
   "Latin1_General_100_CI_AS_SC",
+  "Latin1_General_100_CS_AS_SC",
+  "Latin1_General_100_CI_AI_SC",
+  "Latin1_General_100_BIN2_UTF8",
+  "Latin1_General_100_CI_AS_SC_UTF8",
+  "Latin1_General_100_CI_AI_SC_UTF8",
+  "SQL_Latin1_General_CP850_CI_AS",
+  "Modern_Spanish_CI_AS",
+  "Modern_Spanish_100_CI_AS",
+  "French_CI_AS",
+  "French_100_CI_AS",
+  "German_PhoneBook_CI_AS",
+  "German_PhoneBook_100_CI_AS",
+  "Turkish_CI_AS",
+  "Turkish_100_CI_AS",
+  "Cyrillic_General_CI_AS",
+  "Cyrillic_General_100_CI_AS",
   "Chinese_PRC_CI_AS",
+  "Chinese_PRC_CS_AS",
+  "Chinese_PRC_100_CI_AS",
+  "Chinese_PRC_100_CS_AS",
+  "Chinese_PRC_100_BIN2",
+  "Chinese_PRC_100_CI_AS_SC",
+  "Chinese_PRC_100_CI_AS_SC_UTF8",
+  "Chinese_Simplified_Pinyin_100_CI_AS",
+  "Chinese_Simplified_Pinyin_100_CS_AS",
+  "Chinese_Traditional_Stroke_Order_100_CI_AS",
   "Japanese_CI_AS",
+  "Japanese_CS_AS",
+  "Japanese_BIN2",
+  "Japanese_XJIS_100_CI_AS",
+  "Japanese_XJIS_100_CS_AS",
+  "Japanese_XJIS_100_BIN2",
+  "Japanese_XJIS_140_CI_AS",
+  "Japanese_XJIS_140_CI_AS_KS_WS",
+  "Japanese_Bushu_Kakusu_100_CI_AS",
+  "Japanese_Bushu_Kakusu_140_CI_AS",
+  "Korean_Wansung_CI_AS",
+  "Korean_Wansung_100_CI_AS",
+  "Korean_Wansung_140_CI_AS",
+  "Korean_Unicode_CI_AS",
+  "Korean_Unicode_100_CI_AS",
+  "Korean_Unicode_140_CI_AS",
 ];
 interface ConnectionListProps {
   onTableSelect?: (
@@ -324,6 +411,9 @@ export function ConnectionList({
   const [createDbForm, setCreateDbForm] = useState<CreateDatabaseForm>(
     defaultCreateDatabaseForm,
   );
+  const [mysqlCharsets, setMysqlCharsets] = useState<string[]>([]);
+  const [mysqlCollations, setMysqlCollations] = useState<string[]>([]);
+  const [loadingMysqlOptions, setLoadingMysqlOptions] = useState(false);
   const [testMsg, setTestMsg] = useState<{
     ok: boolean;
     text: string;
@@ -368,6 +458,34 @@ export function ConnectionList({
   const isPostgresCreateDb = createDbTargetDriver === "postgres";
   const isMssqlCreateDb = createDbTargetDriver === "mssql";
 
+  useEffect(() => {
+    if (!isCreateDbDialogOpen || !isMySqlFamilyCreateDb || !createDbConnectionId)
+      return;
+    setLoadingMysqlOptions(true);
+    api.connections
+      .getMysqlCharsets(Number(createDbConnectionId))
+      .then(setMysqlCharsets)
+      .catch(() => setMysqlCharsets(["utf8mb4", "utf8", "latin1"]))
+      .finally(() => setLoadingMysqlOptions(false));
+  }, [isCreateDbDialogOpen, isMySqlFamilyCreateDb, createDbConnectionId]);
+
+  useEffect(() => {
+    if (!isCreateDbDialogOpen || !isMySqlFamilyCreateDb || !createDbConnectionId)
+      return;
+    api.connections
+      .getMysqlCollations(
+        Number(createDbConnectionId),
+        createDbForm.charset || undefined,
+      )
+      .then(setMysqlCollations)
+      .catch(() => setMysqlCollations([]));
+  }, [
+    isCreateDbDialogOpen,
+    isMySqlFamilyCreateDb,
+    createDbConnectionId,
+    createDbForm.charset,
+  ]);
+
   const getConnectionStatusLabel = (connection: Connection) => {
     if (connection.connectState === "success") {
       return t("connection.status.connected");
@@ -3034,6 +3152,8 @@ export function ConnectionList({
             setCreateDbConnectionId(null);
             setShowCreateDbAdvanced(false);
             setCreateDbForm(defaultCreateDatabaseForm);
+            setMysqlCharsets([]);
+            setMysqlCollations([]);
           }
         }}
       >
@@ -3093,25 +3213,31 @@ export function ConnectionList({
                       </Label>
                       <Select
                         value={createDbForm.charset || createDbNoneOption}
+                        disabled={loadingMysqlOptions}
                         onValueChange={(v) =>
                           setCreateDbForm((prev) => ({
                             ...prev,
                             charset: v === createDbNoneOption ? "" : v,
+                            collation: "",
                           }))
                         }
                       >
                         <SelectTrigger id="create-db-charset">
                           <SelectValue
-                            placeholder={t(
-                              "connection.createDbDialog.placeholders.charset",
-                            )}
+                            placeholder={
+                              loadingMysqlOptions
+                                ? t("common.loading")
+                                : t(
+                                    "connection.createDbDialog.placeholders.charset",
+                                  )
+                            }
                           />
                         </SelectTrigger>
                         <SelectContent>
                           <SelectItem value={createDbNoneOption}>
                             {t("connection.createDbDialog.defaultOption")}
                           </SelectItem>
-                          {mysqlCharsetOptions.map((opt) => (
+                          {mysqlCharsets.map((opt) => (
                             <SelectItem key={opt} value={opt}>
                               {opt}
                             </SelectItem>
@@ -3143,7 +3269,7 @@ export function ConnectionList({
                           <SelectItem value={createDbNoneOption}>
                             {t("connection.createDbDialog.defaultOption")}
                           </SelectItem>
-                          {mysqlCollationOptions.map((opt) => (
+                          {mysqlCollations.map((opt) => (
                             <SelectItem key={opt} value={opt}>
                               {opt}
                             </SelectItem>
diff --git a/src/services/api.ts b/src/services/api.ts
index bcdad2d2..21f12d4e 100644
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -467,6 +467,10 @@ export const api = {
     delete: (id: number) => invoke<void>("delete_connection", { id }),
     createDatabase: (id: number, payload: CreateDatabasePayload) =>
       invoke<void>("create_database_by_id", { id, payload }),
+    getMysqlCharsets: (id: number) =>
+      invoke<string[]>("get_mysql_charsets_by_id", { id }),
+    getMysqlCollations: (id: number, charset?: string) =>
+      invoke<string[]>("get_mysql_collations_by_id", { id, charset }),
     testEphemeral: (form: ConnectionForm) =>
       invoke<TestConnectionResult>("test_connection_ephemeral", { form }),
     listSqliteIssues: () =>
diff --git a/src/services/api.unit.test.ts b/src/services/api.unit.test.ts
index 258fd4dd..9bd63923 100644
--- a/src/services/api.unit.test.ts
+++ b/src/services/api.unit.test.ts
@@ -257,6 +257,15 @@ describe("api command mapping", () => {
     ["ai_delete_provider", () => api.ai.providers.delete(1)],
     ["ai_list_conversations", () => api.ai.conversations.list()],
     ["cancel_query", () => api.query.cancel("uuid-abc", "qid-1")],
+    ["get_mysql_charsets_by_id", () => api.connections.getMysqlCharsets(1)],
+    [
+      "get_mysql_collations_by_id",
+      () => api.connections.getMysqlCollations(1),
+    ],
+    [
+      "get_mysql_collations_by_id",
+      () => api.connections.getMysqlCollations(1, "utf8mb4"),
+    ],
   ];
 
   for (const [expectedCmd, callFn] of commands) {
diff --git a/src/services/mocks.service.test.ts b/src/services/mocks.service.test.ts
index e81b6274..9e862cbf 100644
--- a/src/services/mocks.service.test.ts
+++ b/src/services/mocks.service.test.ts
@@ -1,5 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { invokeMock } from "./mocks";
+import {
+  invokeMock,
+  mockGetMysqlCharsets,
+  mockGetMysqlCollations,
+} from "./mocks";
 
 describe("invokeMock service layer", () => {
   test("returns table list for metadata command", async () => {
@@ -28,3 +32,98 @@ describe("invokeMock service layer", () => {
     );
   });
 });
+
+describe("mockGetMysqlCharsets", () => {
+  test("returns a non-empty list", async () => {
+    const charsets = await mockGetMysqlCharsets(1);
+    expect(charsets.length).toBeGreaterThan(0);
+  });
+
+  test("contains the three most common charsets", async () => {
+    const charsets = await mockGetMysqlCharsets(1);
+    expect(charsets).toContain("utf8mb4");
+    expect(charsets).toContain("utf8");
+    expect(charsets).toContain("latin1");
+  });
+
+  test("contains CJK charsets", async () => {
+    const charsets = await mockGetMysqlCharsets(1);
+    expect(charsets).toContain("gbk");
+    expect(charsets).toContain("gb18030");
+    expect(charsets).toContain("euckr");
+  });
+
+  test("all entries are non-empty strings", async () => {
+    const charsets = await mockGetMysqlCharsets(1);
+    for (const cs of charsets) {
+      expect(typeof cs).toBe("string");
+      expect(cs.trim().length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("mockGetMysqlCollations", () => {
+  test("returns all collations when no charset given", async () => {
+    const collations = await mockGetMysqlCollations(1);
+    expect(collations.length).toBeGreaterThan(0);
+  });
+
+  test("returns collations for utf8mb4", async () => {
+    const collations = await mockGetMysqlCollations(1, "utf8mb4");
+    expect(collations.length).toBeGreaterThan(0);
+    expect(collations).toContain("utf8mb4_general_ci");
+    expect(collations).toContain("utf8mb4_unicode_ci");
+    for (const col of collations) {
+      expect(col.startsWith("utf8mb4")).toBe(true);
+    }
+  });
+
+  test("returns collations for utf8", async () => {
+    const collations = await mockGetMysqlCollations(1, "utf8");
+    expect(collations).toContain("utf8_general_ci");
+  });
+
+  test("falls back to all collations for unknown charset", async () => {
+    const all = await mockGetMysqlCollations(1);
+    const unknown = await mockGetMysqlCollations(1, "euckr");
+    expect(unknown.length).toBe(all.length);
+  });
+
+  test("all entries are non-empty strings", async () => {
+    const collations = await mockGetMysqlCollations(1);
+    for (const col of collations) {
+      expect(typeof col).toBe("string");
+      expect(col.trim().length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("invokeMock charset/collation commands", () => {
+  test("get_mysql_charsets_by_id returns charset array", async () => {
+    const charsets = await invokeMock<string[]>("get_mysql_charsets_by_id", {
+      id: 1,
+    });
+    expect(Array.isArray(charsets)).toBe(true);
+    expect(charsets).toContain("utf8mb4");
+  });
+
+  test("get_mysql_collations_by_id without charset returns all collations", async () => {
+    const collations = await invokeMock<string[]>(
+      "get_mysql_collations_by_id",
+      { id: 1 },
+    );
+    expect(Array.isArray(collations)).toBe(true);
+    expect(collations.length).toBeGreaterThan(0);
+  });
+
+  test("get_mysql_collations_by_id with charset filters results", async () => {
+    const collations = await invokeMock<string[]>(
+      "get_mysql_collations_by_id",
+      { id: 1, charset: "utf8mb4" },
+    );
+    expect(collations).toContain("utf8mb4_general_ci");
+    for (const col of collations) {
+      expect(col.startsWith("utf8mb4")).toBe(true);
+    }
+  });
+});
diff --git a/src/services/mocks.ts b/src/services/mocks.ts
index 781bec53..c0f317b5 100644
--- a/src/services/mocks.ts
+++ b/src/services/mocks.ts
@@ -942,6 +942,44 @@ export async function mockListDatabasesById(_id: number): Promise<string[]> {
   return mockDatabases;
 }
 
+/**
+ * Mock get MySQL charsets
+ */
+export async function mockGetMysqlCharsets(_id: number): Promise<string[]> {
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  return [
+    "armscii8", "ascii", "big5", "binary", "cp1250", "cp1251", "cp1256",
+    "cp1257", "cp850", "cp852", "cp866", "cp932", "dec8", "eucjpms", "euckr",
+    "gb18030", "gb2312", "gbk", "geostd8", "greek", "hebrew", "hp8",
+    "keybcs2", "koi8r", "koi8u", "latin1", "latin2", "latin5", "latin7",
+    "macce", "macroman", "sjis", "swe7", "tis620", "ucs2", "ujis", "utf16",
+    "utf16le", "utf32", "utf8", "utf8mb4",
+  ];
+}
+
+/**
+ * Mock get MySQL collations
+ */
+export async function mockGetMysqlCollations(
+  _id: number,
+  charset?: string,
+): Promise<string[]> {
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  const all: Record<string, string[]> = {
+    utf8mb4: [
+      "utf8mb4_0900_ai_ci", "utf8mb4_0900_as_ci", "utf8mb4_0900_as_cs",
+      "utf8mb4_bin", "utf8mb4_general_ci", "utf8mb4_unicode_ci",
+      "utf8mb4_unicode_520_ci",
+    ],
+    utf8: ["utf8_bin", "utf8_general_ci", "utf8_unicode_ci"],
+    latin1: ["latin1_bin", "latin1_general_ci", "latin1_swedish_ci"],
+    ascii: ["ascii_bin", "ascii_general_ci"],
+    binary: ["binary"],
+  };
+  if (charset && all[charset]) return all[charset];
+  return Object.values(all).flat().sort();
+}
+
 /**
  * Mock get schema overview
  */
@@ -1357,6 +1395,12 @@ export async function invokeMock<T>(cmd: string, args?: any): Promise<T> {
     case "create_database_by_id":
       return mockCreateDatabaseById(args.id, args.payload) as Promise<T>;
 
+    case "get_mysql_charsets_by_id":
+      return mockGetMysqlCharsets(args.id) as Promise<T>;
+
+    case "get_mysql_collations_by_id":
+      return mockGetMysqlCollations(args.id, args.charset) as Promise<T>;
+
     case "test_connection_ephemeral":
       return mockTestConnectionEphemeral(args.form) as Promise<T>;
 

From 04b75577f9bb9298c02bcf051fe51551c3f154e9 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Wed, 8 Apr 2026 17:56:41 +0800
Subject: [PATCH 02/15] fix: prevent white screen on table load with error
 boundary and defensive guards

- Add ErrorBoundary component to catch render errors at root and tab level,
  replacing white screen with a visible error message
- Fix useEffect dep loop in TableView: remove columnWidths from calculateAutoColumnWidths
  effect deps and read via ref instead, eliminating extra re-renders on data load
- Add null/non-object row guard in TableView render loop to prevent TypeError
  crashing the render when data contains unexpected values

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/App.tsx                                   |  7 ++-
 src/components/ErrorBoundary.tsx              | 43 +++++++++++++++++++
 .../business/DataGrid/TableView.tsx           | 10 +++--
 src/main.tsx                                  | 11 +++--
 4 files changed, 62 insertions(+), 9 deletions(-)
 create mode 100644 src/components/ErrorBoundary.tsx

diff --git a/src/App.tsx b/src/App.tsx
index f3b30334..726b0e30 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -17,6 +17,7 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { Sidebar } from "@/components/business/Sidebar/Sidebar";
 import { SaveQueryDialog } from "@/components/business/Editor/SaveQueryDialog";
 import { TableView } from "@/components/business/DataGrid/TableView";
+import { ErrorBoundary } from "@/components/ErrorBoundary";
 import { TableMetadataView } from "@/components/business/Metadata/TableMetadataView";
 import { SqlExecutionLogsDropdown } from "@/components/business/SqlLogs/SqlExecutionLogsDialog";
 import { FileCode, Table, X, Settings, Sparkles } from "lucide-react";
@@ -1616,7 +1617,8 @@ export default function App() {
                       value={tab.id}
                       className="h-full m-0"
                     >
-                      {tab.type === "editor" ? (
+                      <ErrorBoundary>
+                        {tab.type === "editor" ? (
                         <Suspense
                           fallback={
                             <LazyPanelFallback label={t("common.loading")} />
@@ -1734,7 +1736,8 @@ export default function App() {
                           schema={tab.schema}
                           table={tab.tableName}
                         />
-                      ) : null}
+                        ) : null}
+                      </ErrorBoundary>
                     </TabsContent>
                   ))
                 )}
diff --git a/src/components/ErrorBoundary.tsx b/src/components/ErrorBoundary.tsx
new file mode 100644
index 00000000..1677b0f0
--- /dev/null
+++ b/src/components/ErrorBoundary.tsx
@@ -0,0 +1,43 @@
+import { Component } from "react";
+import type { ReactNode, ErrorInfo } from "react";
+
+interface Props {
+  children: ReactNode;
+  /** Custom fallback rendered instead of the default error UI. */
+  fallback?: ReactNode;
+}
+
+interface State {
+  error: Error | null;
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+  state: State = { error: null };
+
+  static getDerivedStateFromError(error: Error): State {
+    return { error };
+  }
+
+  componentDidCatch(error: Error, info: ErrorInfo) {
+    console.error("[ErrorBoundary] Uncaught render error:", error, info.componentStack);
+  }
+
+  render() {
+    const { error } = this.state;
+    if (!error) return this.props.children;
+    if (this.props.fallback) return this.props.fallback;
+
+    return (
+      <div className="h-full flex items-center justify-center p-8">
+        <div className="max-w-lg w-full rounded-lg border border-destructive/50 bg-destructive/5 p-6">
+          <p className="text-sm font-semibold text-destructive mb-2">
+            Something went wrong
+          </p>
+          <pre className="text-xs text-muted-foreground whitespace-pre-wrap break-all font-mono">
+            {error.message}
+          </pre>
+        </div>
+      </div>
+    );
+  }
+}
diff --git a/src/components/business/DataGrid/TableView.tsx b/src/components/business/DataGrid/TableView.tsx
index cddbf226..fc606179 100644
--- a/src/components/business/DataGrid/TableView.tsx
+++ b/src/components/business/DataGrid/TableView.tsx
@@ -178,6 +178,8 @@ export function TableView({
   const [pageInput, setPageInput] = useState(String(page));
   const [pageSizeInput, setPageSizeInput] = useState(String(pageSize));
   const [columnWidths, setColumnWidths] = useState<Record<string, number>>({});
+  const columnWidthsRef = useRef<Record<string, number>>({});
+  columnWidthsRef.current = columnWidths;
 
   // Reset column widths when columns definition changes (e.g. switching tables)
   const prevColumnsRef = useRef<string>("");
@@ -189,19 +191,20 @@ export function TableView({
     }
   }, [columns]);
 
-  // Auto-calculate column widths based on content
+  // Auto-calculate column widths based on content.
+  // Read columnWidths via ref to avoid re-triggering the effect on every width update.
   useEffect(() => {
     const newWidths = calculateAutoColumnWidths({
       data,
       columns,
-      columnWidths,
+      columnWidths: columnWidthsRef.current,
     });
     const hasChanges = Object.keys(newWidths).length > 0;
 
     if (hasChanges) {
       setColumnWidths((prev) => ({ ...prev, ...newWidths }));
     }
-  }, [data, columns, columnWidths]);
+  }, [data, columns]);
 
   useEffect(() => {
     setWhereInput(controlledFilter || "");
@@ -1977,6 +1980,7 @@ export function TableView({
           </thead>
           <tbody>
             {currentData.map((row, rowIndex) => {
+              if (!row || typeof row !== "object") return null;
               const isEditing = (col: string) =>
                 editingCell?.row === rowIndex && editingCell?.col === col;
               const isSelected = (col: string) =>
diff --git a/src/main.tsx b/src/main.tsx
index b9556bf3..5c4af3e8 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -5,6 +5,7 @@ import { ThemeProvider } from "./components/theme-provider";
 import { Toaster } from "./components/ui/sonner";
 import "./lib/i18n";
 import { initI18nFromStore } from "./lib/i18n";
+import { ErrorBoundary } from "./components/ErrorBoundary";
 
 const renderApp = async () => {
   await initI18nFromStore();
@@ -20,10 +21,12 @@ const renderApp = async () => {
     });
   }
   createRoot(document.getElementById("root")!).render(
-    <ThemeProvider defaultTheme="default">
-      <App />
-      <Toaster />
-    </ThemeProvider>,
+    <ErrorBoundary>
+      <ThemeProvider defaultTheme="default">
+        <App />
+        <Toaster />
+      </ThemeProvider>
+    </ErrorBoundary>,
   );
 };
 

From 3694be72e3bfd131e01c0bb14e6890e2e8a05fa6 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Wed, 8 Apr 2026 18:23:55 +0800
Subject: [PATCH 03/15] feat: split SQL export into DML, DDL, and DML & DDL
 options
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the single "Export as SQL" right-click menu item with three
separate options — Export DML (INSERT), Export DDL (CREATE), and
Export DML & DDL — so users can choose exactly what to export.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src-tauri/src/commands/transfer.rs            | 368 ++++++++++++------
 src/App.tsx                                   |   2 +-
 .../business/DataGrid/TableView.tsx           |   6 +-
 src/components/business/Editor/SqlEditor.tsx  |   2 +-
 .../business/Sidebar/ConnectionList.tsx       |  64 ++-
 src/components/business/Sidebar/Sidebar.tsx   |   2 +-
 .../Sidebar/connection-list/helpers.tsx       |  10 +-
 .../connection-list/helpers.unit.test.ts      |  47 ++-
 src/lib/i18n/locales/en.ts                    |   4 +-
 src/lib/i18n/locales/ja.ts                    |   4 +-
 src/lib/i18n/locales/zh.ts                    |   4 +-
 src/services/api.ts                           |   2 +-
 12 files changed, 378 insertions(+), 137 deletions(-)

diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
index fbbe0f5f..d595f4aa 100644
--- a/src-tauri/src/commands/transfer.rs
+++ b/src-tauri/src/commands/transfer.rs
@@ -15,7 +15,9 @@ const MAX_IMPORT_STATEMENTS: usize = 50_000;
 pub enum ExportFormat {
     Csv,
     Json,
-    Sql,
+    SqlDml,
+    SqlDdl,
+    SqlFull,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -107,65 +109,30 @@ pub async fn export_table_data(
                 ExportWriter::new(output_path.clone(), format.clone(), columns.clone())?;
             let mut exported = 0i64;
 
-            match scope {
-                ExportScope::CurrentPage => {
-                    let use_page = page.unwrap_or(1).max(1);
-                    let use_limit = limit.unwrap_or(50).max(1);
-                    let resp = db_driver
-                        .get_table_data_chunk(
-                            schema.clone(),
-                            table.clone(),
-                            use_page,
-                            use_limit,
-                            sort_column.clone(),
-                            sort_direction.clone(),
-                            filter.clone(),
-                            order_by.clone(),
-                        )
-                        .await?;
-                    exported +=
-                        writer.write_rows(&resp.data, &columns, Some(&schema), &table, &driver)?;
-                }
-                ExportScope::Filtered | ExportScope::FullTable => {
-                    let filter_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        filter.clone()
-                    } else {
-                        None
-                    };
-                    let order_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        order_by.clone()
-                    } else {
-                        None
-                    };
-                    let sort_col_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        sort_column.clone()
-                    } else {
-                        None
-                    };
-                    let sort_dir_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        sort_direction.clone()
-                    } else {
-                        None
-                    };
-
-                    let mut current_page = 1;
-                    loop {
+            if matches!(format, ExportFormat::SqlDdl | ExportFormat::SqlFull) {
+                let ddl = db_driver
+                    .get_table_ddl(schema.clone(), table.clone())
+                    .await?;
+                writer.write_ddl(&ddl)?;
+            }
+
+            if !matches!(format, ExportFormat::SqlDdl) {
+                match scope {
+                    ExportScope::CurrentPage => {
+                        let use_page = page.unwrap_or(1).max(1);
+                        let use_limit = limit.unwrap_or(50).max(1);
                         let resp = db_driver
                             .get_table_data_chunk(
                                 schema.clone(),
                                 table.clone(),
-                                current_page,
-                                chunk,
-                                sort_col_for_scope.clone(),
-                                sort_dir_for_scope.clone(),
-                                filter_for_scope.clone(),
-                                order_for_scope.clone(),
+                                use_page,
+                                use_limit,
+                                sort_column.clone(),
+                                sort_direction.clone(),
+                                filter.clone(),
+                                order_by.clone(),
                             )
                             .await?;
-                        if resp.data.is_empty() {
-                            break;
-                        }
-
                         exported += writer.write_rows(
                             &resp.data,
                             &columns,
@@ -173,10 +140,59 @@ pub async fn export_table_data(
                             &table,
                             &driver,
                         )?;
-                        if exported >= resp.total {
-                            break;
+                    }
+                    ExportScope::Filtered | ExportScope::FullTable => {
+                        let filter_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            filter.clone()
+                        } else {
+                            None
+                        };
+                        let order_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            order_by.clone()
+                        } else {
+                            None
+                        };
+                        let sort_col_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            sort_column.clone()
+                        } else {
+                            None
+                        };
+                        let sort_dir_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            sort_direction.clone()
+                        } else {
+                            None
+                        };
+
+                        let mut current_page = 1;
+                        loop {
+                            let resp = db_driver
+                                .get_table_data_chunk(
+                                    schema.clone(),
+                                    table.clone(),
+                                    current_page,
+                                    chunk,
+                                    sort_col_for_scope.clone(),
+                                    sort_dir_for_scope.clone(),
+                                    filter_for_scope.clone(),
+                                    order_for_scope.clone(),
+                                )
+                                .await?;
+                            if resp.data.is_empty() {
+                                break;
+                            }
+
+                            exported += writer.write_rows(
+                                &resp.data,
+                                &columns,
+                                Some(&schema),
+                                &table,
+                                &driver,
+                            )?;
+                            if exported >= resp.total {
+                                break;
+                            }
+                            current_page += 1;
                         }
-                        current_page += 1;
                     }
                 }
             }
@@ -236,65 +252,30 @@ pub async fn export_table_data_direct(
                 ExportWriter::new(output_path.clone(), format.clone(), columns.clone())?;
             let mut exported = 0i64;
 
-            match scope {
-                ExportScope::CurrentPage => {
-                    let use_page = page.unwrap_or(1).max(1);
-                    let use_limit = limit.unwrap_or(50).max(1);
-                    let resp = db_driver
-                        .get_table_data_chunk(
-                            schema.clone(),
-                            table.clone(),
-                            use_page,
-                            use_limit,
-                            sort_column.clone(),
-                            sort_direction.clone(),
-                            filter.clone(),
-                            order_by.clone(),
-                        )
-                        .await?;
-                    exported +=
-                        writer.write_rows(&resp.data, &columns, Some(&schema), &table, &driver)?;
-                }
-                ExportScope::Filtered | ExportScope::FullTable => {
-                    let filter_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        filter.clone()
-                    } else {
-                        None
-                    };
-                    let order_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        order_by.clone()
-                    } else {
-                        None
-                    };
-                    let sort_col_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        sort_column.clone()
-                    } else {
-                        None
-                    };
-                    let sort_dir_for_scope = if matches!(scope, ExportScope::Filtered) {
-                        sort_direction.clone()
-                    } else {
-                        None
-                    };
-
-                    let mut current_page = 1;
-                    loop {
+            if matches!(format, ExportFormat::SqlDdl | ExportFormat::SqlFull) {
+                let ddl = db_driver
+                    .get_table_ddl(schema.clone(), table.clone())
+                    .await?;
+                writer.write_ddl(&ddl)?;
+            }
+
+            if !matches!(format, ExportFormat::SqlDdl) {
+                match scope {
+                    ExportScope::CurrentPage => {
+                        let use_page = page.unwrap_or(1).max(1);
+                        let use_limit = limit.unwrap_or(50).max(1);
                         let resp = db_driver
                             .get_table_data_chunk(
                                 schema.clone(),
                                 table.clone(),
-                                current_page,
-                                chunk,
-                                sort_col_for_scope.clone(),
-                                sort_dir_for_scope.clone(),
-                                filter_for_scope.clone(),
-                                order_for_scope.clone(),
+                                use_page,
+                                use_limit,
+                                sort_column.clone(),
+                                sort_direction.clone(),
+                                filter.clone(),
+                                order_by.clone(),
                             )
                             .await?;
-                        if resp.data.is_empty() {
-                            break;
-                        }
-
                         exported += writer.write_rows(
                             &resp.data,
                             &columns,
@@ -302,10 +283,59 @@ pub async fn export_table_data_direct(
                             &table,
                             &driver,
                         )?;
-                        if exported >= resp.total {
-                            break;
+                    }
+                    ExportScope::Filtered | ExportScope::FullTable => {
+                        let filter_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            filter.clone()
+                        } else {
+                            None
+                        };
+                        let order_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            order_by.clone()
+                        } else {
+                            None
+                        };
+                        let sort_col_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            sort_column.clone()
+                        } else {
+                            None
+                        };
+                        let sort_dir_for_scope = if matches!(scope, ExportScope::Filtered) {
+                            sort_direction.clone()
+                        } else {
+                            None
+                        };
+
+                        let mut current_page = 1;
+                        loop {
+                            let resp = db_driver
+                                .get_table_data_chunk(
+                                    schema.clone(),
+                                    table.clone(),
+                                    current_page,
+                                    chunk,
+                                    sort_col_for_scope.clone(),
+                                    sort_dir_for_scope.clone(),
+                                    filter_for_scope.clone(),
+                                    order_for_scope.clone(),
+                                )
+                                .await?;
+                            if resp.data.is_empty() {
+                                break;
+                            }
+
+                            exported += writer.write_rows(
+                                &resp.data,
+                                &columns,
+                                Some(&schema),
+                                &table,
+                                &driver,
+                            )?;
+                            if exported >= resp.total {
+                                break;
+                            }
+                            current_page += 1;
                         }
-                        current_page += 1;
                     }
                 }
             }
@@ -906,7 +936,7 @@ fn extension_for_format(format: &ExportFormat) -> &'static str {
     match format {
         ExportFormat::Csv => "csv",
         ExportFormat::Json => "json",
-        ExportFormat::Sql => "sql",
+        ExportFormat::SqlDml | ExportFormat::SqlDdl | ExportFormat::SqlFull => "sql",
     }
 }
 
@@ -1254,7 +1284,7 @@ impl ExportWriter {
                     .write_all(b"[\n")
                     .map_err(|e| format!("[EXPORT_ERROR] write json header failed: {e}"))?;
             }
-            ExportFormat::Sql => {}
+            ExportFormat::SqlDml | ExportFormat::SqlDdl | ExportFormat::SqlFull => {}
         }
 
         Ok(Self {
@@ -1315,7 +1345,7 @@ impl ExportWriter {
                     .write_all(text.as_bytes())
                     .map_err(|e| format!("[EXPORT_ERROR] write json row failed: {e}"))?;
             }
-            ExportFormat::Sql => {
+            ExportFormat::SqlDml | ExportFormat::SqlFull => {
                 let quoted_cols = columns
                     .iter()
                     .map(|c| quote_ident(c, driver))
@@ -1340,10 +1370,21 @@ impl ExportWriter {
                     .write_all(statement.as_bytes())
                     .map_err(|e| format!("[EXPORT_ERROR] write sql row failed: {e}"))?;
             }
+            ExportFormat::SqlDdl => {
+                // DDL-only mode: rows are not written
+            }
         }
         Ok(())
     }
 
+    fn write_ddl(&mut self, ddl: &str) -> Result<(), String> {
+        let content = format!("{}\n\n", ddl.trim_end());
+        self.writer
+            .write_all(content.as_bytes())
+            .map_err(|e| format!("[EXPORT_ERROR] write ddl failed: {e}"))?;
+        Ok(())
+    }
+
     fn finish(&mut self) -> Result<(), String> {
         if matches!(self.format, ExportFormat::Json) {
             self.writer
@@ -1694,4 +1735,99 @@ mod tests {
         assert!(truncated.len() <= 503);
         assert!(truncated.ends_with("..."));
     }
+
+    fn tmp_path(suffix: &str) -> PathBuf {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        std::env::temp_dir().join(format!("dbpaw-transfer-test-{unique}-{suffix}"))
+    }
+
+    fn make_row(pairs: &[(&str, Value)]) -> Value {
+        let mut map = serde_json::Map::new();
+        for (k, v) in pairs {
+            map.insert(k.to_string(), v.clone());
+        }
+        Value::Object(map)
+    }
+
+    #[test]
+    fn extension_for_format_sql_variants_all_return_sql() {
+        assert_eq!(extension_for_format(&ExportFormat::SqlDml), "sql");
+        assert_eq!(extension_for_format(&ExportFormat::SqlDdl), "sql");
+        assert_eq!(extension_for_format(&ExportFormat::SqlFull), "sql");
+        assert_eq!(extension_for_format(&ExportFormat::Csv), "csv");
+        assert_eq!(extension_for_format(&ExportFormat::Json), "json");
+    }
+
+    #[test]
+    fn export_writer_sql_dml_writes_insert_statements() {
+        let path = tmp_path("sql_dml.sql");
+        let cols = vec!["id".to_string(), "name".to_string()];
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDml, cols.clone()).unwrap();
+        let rows = vec![
+            make_row(&[("id", Value::Number(1.into())), ("name", Value::String("alice".to_string()))]),
+            make_row(&[("id", Value::Number(2.into())), ("name", Value::Null)]),
+        ];
+        let count = writer.write_rows(&rows, &cols, Some("public"), "users", "postgres").unwrap();
+        writer.finish().unwrap();
+        assert_eq!(count, 2);
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.contains("INSERT INTO \"public\".\"users\""));
+        assert!(content.contains("VALUES (1, 'alice')"));
+        assert!(content.contains("VALUES (2, NULL)"));
+        assert!(!content.contains("CREATE TABLE"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn export_writer_sql_ddl_writes_ddl_and_no_rows() {
+        let path = tmp_path("sql_ddl.sql");
+        let cols = vec!["id".to_string()];
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl, cols.clone()).unwrap();
+        writer.write_ddl("CREATE TABLE users (id INTEGER);").unwrap();
+        // In DDL-only mode write_rows is a no-op, but we test write_ddl here
+        let rows = vec![make_row(&[("id", Value::Number(1.into()))])];
+        let count = writer.write_rows(&rows, &cols, Some("public"), "users", "postgres").unwrap();
+        writer.finish().unwrap();
+        assert_eq!(count, 1); // write_rows counts rows even if they produce no output
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.contains("CREATE TABLE users (id INTEGER);"));
+        assert!(!content.contains("INSERT INTO"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn export_writer_sql_full_writes_ddl_then_inserts() {
+        let path = tmp_path("sql_full.sql");
+        let cols = vec!["id".to_string(), "val".to_string()];
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlFull, cols.clone()).unwrap();
+        writer.write_ddl("CREATE TABLE t (id INT, val TEXT);").unwrap();
+        let rows = vec![make_row(&[
+            ("id", Value::Number(1.into())),
+            ("val", Value::String("x".to_string())),
+        ])];
+        let count = writer.write_rows(&rows, &cols, None, "t", "postgres").unwrap();
+        writer.finish().unwrap();
+        assert_eq!(count, 1);
+        let content = fs::read_to_string(&path).unwrap();
+        let ddl_pos = content.find("CREATE TABLE").unwrap();
+        let dml_pos = content.find("INSERT INTO").unwrap();
+        assert!(ddl_pos < dml_pos, "DDL should appear before DML");
+        assert!(content.contains("VALUES (1, 'x')"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn write_ddl_trims_trailing_whitespace_and_adds_blank_line() {
+        let path = tmp_path("ddl_trim.sql");
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl, vec![]).unwrap();
+        writer.write_ddl("CREATE TABLE t (id INT);   \n\n").unwrap();
+        writer.finish().unwrap();
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.starts_with("CREATE TABLE t (id INT);"));
+        assert!(content.ends_with("\n\n"));
+        let _ = fs::remove_file(path);
+    }
 }
diff --git a/src/App.tsx b/src/App.tsx
index 726b0e30..559567d9 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -825,7 +825,7 @@ export default function App() {
       table: string;
       driver: string;
     },
-    format: "csv" | "json" | "sql",
+    format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
     filePath: string,
   ) => {
     try {
diff --git a/src/components/business/DataGrid/TableView.tsx b/src/components/business/DataGrid/TableView.tsx
index fc606179..57969686 100644
--- a/src/components/business/DataGrid/TableView.tsx
+++ b/src/components/business/DataGrid/TableView.tsx
@@ -1792,7 +1792,7 @@ export function TableView({
                         JSON
                       </DropdownMenuItem>
                       <DropdownMenuItem
-                        onClick={() => void handleExport("current_page", "sql")}
+                        onClick={() => void handleExport("current_page", "sql_dml")}
                       >
                         SQL
                       </DropdownMenuItem>
@@ -1814,7 +1814,7 @@ export function TableView({
                         JSON
                       </DropdownMenuItem>
                       <DropdownMenuItem
-                        onClick={() => void handleExport("filtered", "sql")}
+                        onClick={() => void handleExport("filtered", "sql_dml")}
                       >
                         SQL
                       </DropdownMenuItem>
@@ -1836,7 +1836,7 @@ export function TableView({
                         JSON
                       </DropdownMenuItem>
                       <DropdownMenuItem
-                        onClick={() => void handleExport("full_table", "sql")}
+                        onClick={() => void handleExport("full_table", "sql_dml")}
                       >
                         SQL
                       </DropdownMenuItem>
diff --git a/src/components/business/Editor/SqlEditor.tsx b/src/components/business/Editor/SqlEditor.tsx
index d7c06a2b..82206612 100644
--- a/src/components/business/Editor/SqlEditor.tsx
+++ b/src/components/business/Editor/SqlEditor.tsx
@@ -872,7 +872,7 @@ export function SqlEditor({
                     JSON
                   </DropdownMenuItem>
                   <DropdownMenuItem
-                    onClick={() => void handleExportResult("sql")}
+                    onClick={() => void handleExportResult("sql_dml")}
                   >
                     SQL
                   </DropdownMenuItem>
diff --git a/src/components/business/Sidebar/ConnectionList.tsx b/src/components/business/Sidebar/ConnectionList.tsx
index f7f608ed..3c916bfc 100644
--- a/src/components/business/Sidebar/ConnectionList.tsx
+++ b/src/components/business/Sidebar/ConnectionList.tsx
@@ -309,7 +309,7 @@ interface ConnectionListProps {
       table: string;
       driver: string;
     },
-    format: "csv" | "json" | "sql",
+    format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
     filePath: string,
   ) => void;
   activeTableTarget?: {
@@ -1731,7 +1731,7 @@ export function ConnectionList({
     connection: Connection,
     database: DatabaseInfo,
     table: TableInfo,
-    format: "csv" | "json" | "sql",
+    format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
   ) => {
     if (!onExportTable) return;
     if (!isTauri()) {
@@ -2642,12 +2642,38 @@ export function ConnectionList({
                                       connection,
                                       database,
                                       table,
-                                      "sql",
+                                      "sql_dml",
                                     )
                                   }
                                 >
                                   <Download className="w-4 h-4 mr-2" />
-                                  {t("connection.menu.exportSql")}
+                                  {t("connection.menu.exportSqlDml")}
+                                </ContextMenuItem>
+                                <ContextMenuItem
+                                  onClick={() =>
+                                    void handleTableExport(
+                                      connection,
+                                      database,
+                                      table,
+                                      "sql_ddl",
+                                    )
+                                  }
+                                >
+                                  <Download className="w-4 h-4 mr-2" />
+                                  {t("connection.menu.exportSqlDdl")}
+                                </ContextMenuItem>
+                                <ContextMenuItem
+                                  onClick={() =>
+                                    void handleTableExport(
+                                      connection,
+                                      database,
+                                      table,
+                                      "sql_full",
+                                    )
+                                  }
+                                >
+                                  <Download className="w-4 h-4 mr-2" />
+                                  {t("connection.menu.exportSqlFull")}
                                 </ContextMenuItem>
                               </ContextMenuContent>
                             </ContextMenu>
@@ -2875,12 +2901,38 @@ export function ConnectionList({
                                     connection,
                                     database,
                                     table,
-                                    "sql",
+                                    "sql_dml",
+                                  )
+                                }
+                              >
+                                <Download className="w-4 h-4 mr-2" />
+                                {t("connection.menu.exportSqlDml")}
+                              </ContextMenuItem>
+                              <ContextMenuItem
+                                onClick={() =>
+                                  void handleTableExport(
+                                    connection,
+                                    database,
+                                    table,
+                                    "sql_ddl",
+                                  )
+                                }
+                              >
+                                <Download className="w-4 h-4 mr-2" />
+                                {t("connection.menu.exportSqlDdl")}
+                              </ContextMenuItem>
+                              <ContextMenuItem
+                                onClick={() =>
+                                  void handleTableExport(
+                                    connection,
+                                    database,
+                                    table,
+                                    "sql_full",
                                   )
                                 }
                               >
                                 <Download className="w-4 h-4 mr-2" />
-                                {t("connection.menu.exportSql")}
+                                {t("connection.menu.exportSqlFull")}
                               </ContextMenuItem>
                             </ContextMenuContent>
                           </ContextMenu>
diff --git a/src/components/business/Sidebar/Sidebar.tsx b/src/components/business/Sidebar/Sidebar.tsx
index 07ee6911..3cefc127 100644
--- a/src/components/business/Sidebar/Sidebar.tsx
+++ b/src/components/business/Sidebar/Sidebar.tsx
@@ -39,7 +39,7 @@ interface SidebarProps {
       table: string;
       driver: string;
     },
-    format: "csv" | "json" | "sql",
+    format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
     filePath: string,
   ) => void;
   onSelectSavedQuery: (query: SavedQuery) => void;
diff --git a/src/components/business/Sidebar/connection-list/helpers.tsx b/src/components/business/Sidebar/connection-list/helpers.tsx
index b30c13d3..60a5aba5 100644
--- a/src/components/business/Sidebar/connection-list/helpers.tsx
+++ b/src/components/business/Sidebar/connection-list/helpers.tsx
@@ -12,13 +12,17 @@ export const sanitizeConnectionErrorMessage = (message: string) =>
 
 export const getExportDefaultName = (
   tableName: string,
-  format: "csv" | "json" | "sql",
+  format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
 ) => {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  return `${tableName}_${timestamp}.${format}`;
+  const ext =
+    format === "csv" ? "csv" : format === "json" ? "json" : "sql";
+  return `${tableName}_${timestamp}.${ext}`;
 };
 
-export const getExportFilter = (format: "csv" | "json" | "sql") => {
+export const getExportFilter = (
+  format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
+) => {
   if (format === "csv") {
     return [{ name: "CSV", extensions: ["csv"] }];
   }
diff --git a/src/components/business/Sidebar/connection-list/helpers.unit.test.ts b/src/components/business/Sidebar/connection-list/helpers.unit.test.ts
index b01ccde9..7a8e4e9e 100644
--- a/src/components/business/Sidebar/connection-list/helpers.unit.test.ts
+++ b/src/components/business/Sidebar/connection-list/helpers.unit.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import {
   sanitizeConnectionErrorMessage,
+  getExportDefaultName,
   getExportFilter,
   getConnectionStatusLabel,
 } from "./helpers";
@@ -39,6 +40,38 @@ describe("sanitizeConnectionErrorMessage", () => {
   });
 });
 
+describe("getExportDefaultName", () => {
+  test("uses .csv extension for csv format", () => {
+    const name = getExportDefaultName("users", "csv");
+    expect(name).toMatch(/^users_.*\.csv$/);
+  });
+
+  test("uses .json extension for json format", () => {
+    const name = getExportDefaultName("orders", "json");
+    expect(name).toMatch(/^orders_.*\.json$/);
+  });
+
+  test("uses .sql extension for sql_dml format", () => {
+    const name = getExportDefaultName("users", "sql_dml");
+    expect(name).toMatch(/^users_.*\.sql$/);
+  });
+
+  test("uses .sql extension for sql_ddl format", () => {
+    const name = getExportDefaultName("users", "sql_ddl");
+    expect(name).toMatch(/^users_.*\.sql$/);
+  });
+
+  test("uses .sql extension for sql_full format", () => {
+    const name = getExportDefaultName("users", "sql_full");
+    expect(name).toMatch(/^users_.*\.sql$/);
+  });
+
+  test("includes table name as prefix", () => {
+    const name = getExportDefaultName("my_table", "sql_dml");
+    expect(name.startsWith("my_table_")).toBe(true);
+  });
+});
+
 describe("getExportFilter", () => {
   test("returns csv filter for csv format", () => {
     const filter = getExportFilter("csv");
@@ -50,8 +83,18 @@ describe("getExportFilter", () => {
     expect(filter).toEqual([{ name: "JSON", extensions: ["json"] }]);
   });
 
-  test("returns sql filter for sql format", () => {
-    const filter = getExportFilter("sql");
+  test("returns sql filter for sql_dml format", () => {
+    const filter = getExportFilter("sql_dml");
+    expect(filter).toEqual([{ name: "SQL", extensions: ["sql"] }]);
+  });
+
+  test("returns sql filter for sql_ddl format", () => {
+    const filter = getExportFilter("sql_ddl");
+    expect(filter).toEqual([{ name: "SQL", extensions: ["sql"] }]);
+  });
+
+  test("returns sql filter for sql_full format", () => {
+    const filter = getExportFilter("sql_full");
     expect(filter).toEqual([{ name: "SQL", extensions: ["sql"] }]);
   });
 });
diff --git a/src/lib/i18n/locales/en.ts b/src/lib/i18n/locales/en.ts
index 1308fe3b..d9944565 100644
--- a/src/lib/i18n/locales/en.ts
+++ b/src/lib/i18n/locales/en.ts
@@ -292,7 +292,9 @@ export const en = {
       importSqlReadOnly: "Import SQL (Read-only, unsupported)",
       exportCsv: "Export as CSV",
       exportJson: "Export as JSON",
-      exportSql: "Export as SQL",
+      exportSqlDml: "Export DML (INSERT)",
+      exportSqlDdl: "Export DDL (CREATE)",
+      exportSqlFull: "Export DML & DDL",
     },
     importDialog: {
       title: "Import SQL",
diff --git a/src/lib/i18n/locales/ja.ts b/src/lib/i18n/locales/ja.ts
index 47968fab..e44de40e 100644
--- a/src/lib/i18n/locales/ja.ts
+++ b/src/lib/i18n/locales/ja.ts
@@ -295,7 +295,9 @@ export const ja: Translations = {
       importSqlReadOnly: "SQL をインポート（読み取り専用で未対応）",
       exportCsv: "CSV としてエクスポート",
       exportJson: "JSON としてエクスポート",
-      exportSql: "SQL としてエクスポート",
+      exportSqlDml: "DML をエクスポート (INSERT)",
+      exportSqlDdl: "DDL をエクスポート (CREATE)",
+      exportSqlFull: "DML & DDL をエクスポート",
     },
     importDialog: {
       title: "SQL をインポート",
diff --git a/src/lib/i18n/locales/zh.ts b/src/lib/i18n/locales/zh.ts
index 9b7f6271..f4eb2468 100644
--- a/src/lib/i18n/locales/zh.ts
+++ b/src/lib/i18n/locales/zh.ts
@@ -287,7 +287,9 @@ export const zh: Translations = {
       importSqlReadOnly: "导入 SQL（只读，不支持）",
       exportCsv: "导出为 CSV",
       exportJson: "导出为 JSON",
-      exportSql: "导出为 SQL",
+      exportSqlDml: "导出 DML (INSERT)",
+      exportSqlDdl: "导出 DDL (CREATE)",
+      exportSqlFull: "导出 DML & DDL",
     },
     importDialog: {
       title: "导入 SQL",
diff --git a/src/services/api.ts b/src/services/api.ts
index 21f12d4e..d9cce7de 100644
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -299,7 +299,7 @@ export interface AIChatResponse {
   assistantMessageId: number;
 }
 
-export type TransferFormat = "csv" | "json" | "sql";
+export type TransferFormat = "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full";
 export type ExportScope =
   | "current_page"
   | "filtered"

From 1ac9d0b8cad87a5246bfc750794cff14b61e03ec Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Wed, 8 Apr 2026 18:29:13 +0800
Subject: [PATCH 04/15] fix(mssql): add notice comment to reconstructed DDL
 export

MSSQL DDL is rebuilt from column metadata and lacks foreign keys,
unique constraints, check constraints, and indexes. Add a SQL comment
block at the top of the output to warn users of this limitation.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src-tauri/src/db/drivers/mssql.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src-tauri/src/db/drivers/mssql.rs b/src-tauri/src/db/drivers/mssql.rs
index 70f6bef5..2b3a5884 100644
--- a/src-tauri/src/db/drivers/mssql.rs
+++ b/src-tauri/src/db/drivers/mssql.rs
@@ -734,7 +734,10 @@ impl DatabaseDriver for MssqlDriver {
         }
 
         let ddl = format!(
-            "CREATE TABLE {}.{} (\n{}\n);",
+            "-- Note: This DDL is reconstructed from table metadata and may be incomplete.\n\
+             -- Constraints such as foreign keys, unique constraints, check constraints,\n\
+             -- and indexes are not included.\n\
+             CREATE TABLE {}.{} (\n{}\n);",
             quote_ident(&schema)?,
             quote_ident(&table)?,
             lines.join(",\n")

From ce64a3f62777fbf910fbf0729d6c9f2a20bf6fa4 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Wed, 8 Apr 2026 18:35:56 +0800
Subject: [PATCH 05/15] refactor(transfer): eliminate duplication and dead code
 in SQL export
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extract do_table_export() to replace ~110 lines duplicated between
export_table_data and export_table_data_direct. Remove columns param
from ExportWriter::new (CSV header now written via write_csv_header),
so get_table_metadata is only called when actually fetching rows —
SqlDdl-only mode no longer makes an unnecessary metadata round-trip.
Replace dead SqlDdl arm in write_row with unreachable!().

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src-tauri/src/commands/transfer.rs | 439 +++++++++++++----------------
 1 file changed, 191 insertions(+), 248 deletions(-)

diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
index d595f4aa..17cff28a 100644
--- a/src-tauri/src/commands/transfer.rs
+++ b/src-tauri/src/commands/transfer.rs
@@ -1,9 +1,11 @@
+use crate::db::drivers::DatabaseDriver;
 use crate::state::AppState;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use std::fs::{self, File};
 use std::io::{BufWriter, Write};
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 use tauri::State;
 
 const DEFAULT_CHUNK_SIZE: i64 = 2000;
@@ -62,6 +64,102 @@ struct PreparedImportPlan {
     script_managed_transaction: bool,
 }
 
+async fn do_table_export(
+    db_driver: Arc<dyn DatabaseDriver>,
+    output_path: PathBuf,
+    schema: String,
+    table: String,
+    driver: String,
+    format: ExportFormat,
+    scope: ExportScope,
+    filter: Option<String>,
+    order_by: Option<String>,
+    sort_column: Option<String>,
+    sort_direction: Option<String>,
+    page: Option<i64>,
+    limit: Option<i64>,
+    chunk: i64,
+) -> Result<ExportResult, String> {
+    let mut writer = ExportWriter::new(output_path.clone(), format.clone())?;
+    let mut exported = 0i64;
+
+    if matches!(format, ExportFormat::SqlDdl | ExportFormat::SqlFull) {
+        let ddl = db_driver
+            .get_table_ddl(schema.clone(), table.clone())
+            .await?;
+        writer.write_ddl(&ddl)?;
+    }
+
+    if !matches!(format, ExportFormat::SqlDdl) {
+        let columns: Vec<String> = db_driver
+            .get_table_metadata(schema.clone(), table.clone())
+            .await?
+            .columns
+            .into_iter()
+            .map(|c| c.name)
+            .collect();
+
+        writer.write_csv_header(&columns)?;
+
+        match scope {
+            ExportScope::CurrentPage => {
+                let resp = db_driver
+                    .get_table_data_chunk(
+                        schema.clone(),
+                        table.clone(),
+                        page.unwrap_or(1).max(1),
+                        limit.unwrap_or(50).max(1),
+                        sort_column,
+                        sort_direction,
+                        filter,
+                        order_by,
+                    )
+                    .await?;
+                exported +=
+                    writer.write_rows(&resp.data, &columns, Some(&schema), &table, &driver)?;
+            }
+            ExportScope::Filtered | ExportScope::FullTable => {
+                let (eff_filter, eff_order, eff_sort_col, eff_sort_dir) =
+                    if matches!(scope, ExportScope::Filtered) {
+                        (filter, order_by, sort_column, sort_direction)
+                    } else {
+                        (None, None, None, None)
+                    };
+                let mut current_page = 1;
+                loop {
+                    let resp = db_driver
+                        .get_table_data_chunk(
+                            schema.clone(),
+                            table.clone(),
+                            current_page,
+                            chunk,
+                            eff_sort_col.clone(),
+                            eff_sort_dir.clone(),
+                            eff_filter.clone(),
+                            eff_order.clone(),
+                        )
+                        .await?;
+                    if resp.data.is_empty() {
+                        break;
+                    }
+                    exported +=
+                        writer.write_rows(&resp.data, &columns, Some(&schema), &table, &driver)?;
+                    if exported >= resp.total {
+                        break;
+                    }
+                    current_page += 1;
+                }
+            }
+        }
+    }
+
+    writer.finish()?;
+    Ok(ExportResult {
+        file_path: output_path.to_string_lossy().to_string(),
+        row_count: exported,
+    })
+}
+
 #[tauri::command]
 pub async fn export_table_data(
     state: State<'_, AppState>,
@@ -82,9 +180,7 @@ pub async fn export_table_data(
     chunk_size: Option<i64>,
 ) -> Result<ExportResult, String> {
     let output_path = resolve_output_path(file_path, &table, extension_for_format(&format))?;
-
     let chunk = chunk_size.unwrap_or(DEFAULT_CHUNK_SIZE).max(1);
-
     super::execute_with_retry(&state, id, database, |db_driver| {
         let output_path = output_path.clone();
         let schema = schema.clone();
@@ -97,111 +193,23 @@ pub async fn export_table_data(
         let scope = scope.clone();
         let format = format.clone();
         async move {
-            let columns = db_driver
-                .get_table_metadata(schema.clone(), table.clone())
-                .await?
-                .columns
-                .into_iter()
-                .map(|c| c.name)
-                .collect::<Vec<_>>();
-
-            let mut writer =
-                ExportWriter::new(output_path.clone(), format.clone(), columns.clone())?;
-            let mut exported = 0i64;
-
-            if matches!(format, ExportFormat::SqlDdl | ExportFormat::SqlFull) {
-                let ddl = db_driver
-                    .get_table_ddl(schema.clone(), table.clone())
-                    .await?;
-                writer.write_ddl(&ddl)?;
-            }
-
-            if !matches!(format, ExportFormat::SqlDdl) {
-                match scope {
-                    ExportScope::CurrentPage => {
-                        let use_page = page.unwrap_or(1).max(1);
-                        let use_limit = limit.unwrap_or(50).max(1);
-                        let resp = db_driver
-                            .get_table_data_chunk(
-                                schema.clone(),
-                                table.clone(),
-                                use_page,
-                                use_limit,
-                                sort_column.clone(),
-                                sort_direction.clone(),
-                                filter.clone(),
-                                order_by.clone(),
-                            )
-                            .await?;
-                        exported += writer.write_rows(
-                            &resp.data,
-                            &columns,
-                            Some(&schema),
-                            &table,
-                            &driver,
-                        )?;
-                    }
-                    ExportScope::Filtered | ExportScope::FullTable => {
-                        let filter_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            filter.clone()
-                        } else {
-                            None
-                        };
-                        let order_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            order_by.clone()
-                        } else {
-                            None
-                        };
-                        let sort_col_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            sort_column.clone()
-                        } else {
-                            None
-                        };
-                        let sort_dir_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            sort_direction.clone()
-                        } else {
-                            None
-                        };
-
-                        let mut current_page = 1;
-                        loop {
-                            let resp = db_driver
-                                .get_table_data_chunk(
-                                    schema.clone(),
-                                    table.clone(),
-                                    current_page,
-                                    chunk,
-                                    sort_col_for_scope.clone(),
-                                    sort_dir_for_scope.clone(),
-                                    filter_for_scope.clone(),
-                                    order_for_scope.clone(),
-                                )
-                                .await?;
-                            if resp.data.is_empty() {
-                                break;
-                            }
-
-                            exported += writer.write_rows(
-                                &resp.data,
-                                &columns,
-                                Some(&schema),
-                                &table,
-                                &driver,
-                            )?;
-                            if exported >= resp.total {
-                                break;
-                            }
-                            current_page += 1;
-                        }
-                    }
-                }
-            }
-
-            writer.finish()?;
-            Ok(ExportResult {
-                file_path: output_path.to_string_lossy().to_string(),
-                row_count: exported,
-            })
+            do_table_export(
+                db_driver,
+                output_path,
+                schema,
+                table,
+                driver,
+                format,
+                scope,
+                filter,
+                order_by,
+                sort_column,
+                sort_direction,
+                page,
+                limit,
+                chunk,
+            )
+            .await
         }
     })
     .await
@@ -227,7 +235,6 @@ pub async fn export_table_data_direct(
 ) -> Result<ExportResult, String> {
     let output_path = resolve_output_path(file_path, &table, extension_for_format(&format))?;
     let chunk = chunk_size.unwrap_or(DEFAULT_CHUNK_SIZE).max(1);
-
     super::execute_with_retry_from_app_state(state, id, database, |db_driver| {
         let output_path = output_path.clone();
         let schema = schema.clone();
@@ -240,111 +247,23 @@ pub async fn export_table_data_direct(
         let scope = scope.clone();
         let format = format.clone();
         async move {
-            let columns = db_driver
-                .get_table_metadata(schema.clone(), table.clone())
-                .await?
-                .columns
-                .into_iter()
-                .map(|c| c.name)
-                .collect::<Vec<_>>();
-
-            let mut writer =
-                ExportWriter::new(output_path.clone(), format.clone(), columns.clone())?;
-            let mut exported = 0i64;
-
-            if matches!(format, ExportFormat::SqlDdl | ExportFormat::SqlFull) {
-                let ddl = db_driver
-                    .get_table_ddl(schema.clone(), table.clone())
-                    .await?;
-                writer.write_ddl(&ddl)?;
-            }
-
-            if !matches!(format, ExportFormat::SqlDdl) {
-                match scope {
-                    ExportScope::CurrentPage => {
-                        let use_page = page.unwrap_or(1).max(1);
-                        let use_limit = limit.unwrap_or(50).max(1);
-                        let resp = db_driver
-                            .get_table_data_chunk(
-                                schema.clone(),
-                                table.clone(),
-                                use_page,
-                                use_limit,
-                                sort_column.clone(),
-                                sort_direction.clone(),
-                                filter.clone(),
-                                order_by.clone(),
-                            )
-                            .await?;
-                        exported += writer.write_rows(
-                            &resp.data,
-                            &columns,
-                            Some(&schema),
-                            &table,
-                            &driver,
-                        )?;
-                    }
-                    ExportScope::Filtered | ExportScope::FullTable => {
-                        let filter_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            filter.clone()
-                        } else {
-                            None
-                        };
-                        let order_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            order_by.clone()
-                        } else {
-                            None
-                        };
-                        let sort_col_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            sort_column.clone()
-                        } else {
-                            None
-                        };
-                        let sort_dir_for_scope = if matches!(scope, ExportScope::Filtered) {
-                            sort_direction.clone()
-                        } else {
-                            None
-                        };
-
-                        let mut current_page = 1;
-                        loop {
-                            let resp = db_driver
-                                .get_table_data_chunk(
-                                    schema.clone(),
-                                    table.clone(),
-                                    current_page,
-                                    chunk,
-                                    sort_col_for_scope.clone(),
-                                    sort_dir_for_scope.clone(),
-                                    filter_for_scope.clone(),
-                                    order_for_scope.clone(),
-                                )
-                                .await?;
-                            if resp.data.is_empty() {
-                                break;
-                            }
-
-                            exported += writer.write_rows(
-                                &resp.data,
-                                &columns,
-                                Some(&schema),
-                                &table,
-                                &driver,
-                            )?;
-                            if exported >= resp.total {
-                                break;
-                            }
-                            current_page += 1;
-                        }
-                    }
-                }
-            }
-
-            writer.finish()?;
-            Ok(ExportResult {
-                file_path: output_path.to_string_lossy().to_string(),
-                row_count: exported,
-            })
+            do_table_export(
+                db_driver,
+                output_path,
+                schema,
+                table,
+                driver,
+                format,
+                scope,
+                filter,
+                order_by,
+                sort_column,
+                sort_direction,
+                page,
+                limit,
+                chunk,
+            )
+            .await
         }
     })
     .await
@@ -375,7 +294,8 @@ pub async fn export_query_result(
                 .into_iter()
                 .map(|c| c.name)
                 .collect::<Vec<_>>();
-            let mut writer = ExportWriter::new(output_path.clone(), format, columns.clone())?;
+            let mut writer = ExportWriter::new(output_path.clone(), format)?;
+            writer.write_csv_header(&columns)?;
             let exported =
                 writer.write_rows(&result.data, &columns, None, "query_result", &driver)?;
             writer.finish()?;
@@ -412,7 +332,8 @@ pub async fn export_query_result_direct(
                 .into_iter()
                 .map(|c| c.name)
                 .collect::<Vec<_>>();
-            let mut writer = ExportWriter::new(output_path.clone(), format, columns.clone())?;
+            let mut writer = ExportWriter::new(output_path.clone(), format)?;
+            writer.write_csv_header(&columns)?;
             let exported =
                 writer.write_rows(&result.data, &columns, None, "query_result", &driver)?;
             writer.finish()?;
@@ -1263,28 +1184,15 @@ struct ExportWriter {
 }
 
 impl ExportWriter {
-    fn new(path: PathBuf, format: ExportFormat, columns: Vec<String>) -> Result<Self, String> {
+    fn new(path: PathBuf, format: ExportFormat) -> Result<Self, String> {
         let file =
             File::create(path).map_err(|e| format!("[EXPORT_ERROR] create file failed: {e}"))?;
         let mut writer = BufWriter::new(file);
 
-        match format {
-            ExportFormat::Csv => {
-                let header = columns
-                    .iter()
-                    .map(|c| csv_escape(c))
-                    .collect::<Vec<_>>()
-                    .join(",");
-                writer
-                    .write_all(format!("{header}\n").as_bytes())
-                    .map_err(|e| format!("[EXPORT_ERROR] write csv header failed: {e}"))?;
-            }
-            ExportFormat::Json => {
-                writer
-                    .write_all(b"[\n")
-                    .map_err(|e| format!("[EXPORT_ERROR] write json header failed: {e}"))?;
-            }
-            ExportFormat::SqlDml | ExportFormat::SqlDdl | ExportFormat::SqlFull => {}
+        if matches!(format, ExportFormat::Json) {
+            writer
+                .write_all(b"[\n")
+                .map_err(|e| format!("[EXPORT_ERROR] write json header failed: {e}"))?;
         }
 
         Ok(Self {
@@ -1294,6 +1202,20 @@ impl ExportWriter {
         })
     }
 
+    fn write_csv_header(&mut self, columns: &[String]) -> Result<(), String> {
+        if !matches!(self.format, ExportFormat::Csv) {
+            return Ok(());
+        }
+        let header = columns
+            .iter()
+            .map(|c| csv_escape(c))
+            .collect::<Vec<_>>()
+            .join(",");
+        self.writer
+            .write_all(format!("{header}\n").as_bytes())
+            .map_err(|e| format!("[EXPORT_ERROR] write csv header failed: {e}"))
+    }
+
     fn write_rows(
         &mut self,
         rows: &[Value],
@@ -1370,9 +1292,7 @@ impl ExportWriter {
                     .write_all(statement.as_bytes())
                     .map_err(|e| format!("[EXPORT_ERROR] write sql row failed: {e}"))?;
             }
-            ExportFormat::SqlDdl => {
-                // DDL-only mode: rows are not written
-            }
+            ExportFormat::SqlDdl => unreachable!("SqlDdl rows are never written"),
         }
         Ok(())
     }
@@ -1589,8 +1509,7 @@ mod tests {
             .unwrap()
             .as_nanos();
         let path = std::env::temp_dir().join(format!("dbpaw-transfer-test-{unique}.json"));
-        let mut writer =
-            ExportWriter::new(path.clone(), ExportFormat::Json, vec!["a".to_string()]).unwrap();
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::Json).unwrap();
         let err = writer
             .write_rows(
                 &[Value::String("not-object".to_string())],
@@ -1761,11 +1680,40 @@ mod tests {
         assert_eq!(extension_for_format(&ExportFormat::Json), "json");
     }
 
+    #[test]
+    fn export_writer_csv_writes_header_then_rows() {
+        let path = tmp_path("csv_header.csv");
+        let cols = vec!["id".to_string(), "name".to_string()];
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::Csv).unwrap();
+        writer.write_csv_header(&cols).unwrap();
+        let rows = vec![make_row(&[
+            ("id", Value::Number(1.into())),
+            ("name", Value::String("alice".to_string())),
+        ])];
+        writer.write_rows(&rows, &cols, None, "t", "postgres").unwrap();
+        writer.finish().unwrap();
+        let content = fs::read_to_string(&path).unwrap();
+        assert!(content.starts_with("id,name\n"));
+        assert!(content.contains("1,alice"));
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn write_csv_header_is_noop_for_sql_formats() {
+        let path = tmp_path("sql_noop_header.sql");
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDml).unwrap();
+        writer.write_csv_header(&["id".to_string()]).unwrap();
+        writer.finish().unwrap();
+        let content = fs::read_to_string(&path).unwrap();
+        assert_eq!(content, "");
+        let _ = fs::remove_file(path);
+    }
+
     #[test]
     fn export_writer_sql_dml_writes_insert_statements() {
         let path = tmp_path("sql_dml.sql");
         let cols = vec!["id".to_string(), "name".to_string()];
-        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDml, cols.clone()).unwrap();
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDml).unwrap();
         let rows = vec![
             make_row(&[("id", Value::Number(1.into())), ("name", Value::String("alice".to_string()))]),
             make_row(&[("id", Value::Number(2.into())), ("name", Value::Null)]),
@@ -1782,16 +1730,11 @@ mod tests {
     }
 
     #[test]
-    fn export_writer_sql_ddl_writes_ddl_and_no_rows() {
+    fn export_writer_sql_ddl_writes_only_ddl() {
         let path = tmp_path("sql_ddl.sql");
-        let cols = vec!["id".to_string()];
-        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl, cols.clone()).unwrap();
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl).unwrap();
         writer.write_ddl("CREATE TABLE users (id INTEGER);").unwrap();
-        // In DDL-only mode write_rows is a no-op, but we test write_ddl here
-        let rows = vec![make_row(&[("id", Value::Number(1.into()))])];
-        let count = writer.write_rows(&rows, &cols, Some("public"), "users", "postgres").unwrap();
         writer.finish().unwrap();
-        assert_eq!(count, 1); // write_rows counts rows even if they produce no output
         let content = fs::read_to_string(&path).unwrap();
         assert!(content.contains("CREATE TABLE users (id INTEGER);"));
         assert!(!content.contains("INSERT INTO"));
@@ -1802,7 +1745,7 @@ mod tests {
     fn export_writer_sql_full_writes_ddl_then_inserts() {
         let path = tmp_path("sql_full.sql");
         let cols = vec!["id".to_string(), "val".to_string()];
-        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlFull, cols.clone()).unwrap();
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlFull).unwrap();
         writer.write_ddl("CREATE TABLE t (id INT, val TEXT);").unwrap();
         let rows = vec![make_row(&[
             ("id", Value::Number(1.into())),
@@ -1822,7 +1765,7 @@ mod tests {
     #[test]
     fn write_ddl_trims_trailing_whitespace_and_adds_blank_line() {
         let path = tmp_path("ddl_trim.sql");
-        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl, vec![]).unwrap();
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl).unwrap();
         writer.write_ddl("CREATE TABLE t (id INT);   \n\n").unwrap();
         writer.finish().unwrap();
         let content = fs::read_to_string(&path).unwrap();

From 0d4340d1a03085efc56097da597322cb0252baad Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Thu, 9 Apr 2026 20:20:19 +0800
Subject: [PATCH 06/15] Add StarRocks support via MySQL compatibility

---
 scripts/test-integration.sh                   |   6 +-
 src-tauri/src/commands/connection.rs          |  39 ++-
 src-tauri/src/commands/transfer.rs            |  30 ++-
 src-tauri/src/connection_input/mod.rs         |  19 +-
 src-tauri/src/db/drivers/mod.rs               |  19 +-
 src-tauri/src/db/drivers/mysql.rs             |  77 +++++-
 src-tauri/src/ssh.rs                          |  51 +++-
 src-tauri/tests/common/shared.rs              |   3 +
 src-tauri/tests/common/starrocks_context.rs   |  77 ++++++
 .../tests/starrocks_command_integration.rs    | 103 ++++++++
 src-tauri/tests/starrocks_integration.rs      | 120 +++++++++
 src/App.tsx                                   | 233 +++++++++---------
 .../business/DataGrid/tableView/utils.ts      |   8 +-
 .../DataGrid/tableView/utils.unit.test.ts     |  62 ++++-
 src/components/business/Editor/SqlEditor.tsx  |   2 +
 .../business/Sidebar/ConnectionList.tsx       |  20 +-
 src/lib/connection-form/rules.unit.test.ts    |  11 +-
 src/lib/driver-registry.tsx                   |  17 +-
 src/lib/driver-registry.unit.test.ts          |  16 +-
 src/services/api.unit.test.ts                 |  29 ++-
 20 files changed, 755 insertions(+), 187 deletions(-)
 create mode 100644 src-tauri/tests/common/starrocks_context.rs
 create mode 100644 src-tauri/tests/starrocks_command_integration.rs
 create mode 100644 src-tauri/tests/starrocks_integration.rs

diff --git a/scripts/test-integration.sh b/scripts/test-integration.sh
index b6079307..6a4ccdad 100755
--- a/scripts/test-integration.sh
+++ b/scripts/test-integration.sh
@@ -39,6 +39,10 @@ case "${it_db}" in
     run_integration_test "mysql_command_integration"
     run_integration_test "mysql_stateful_command_integration"
     ;;
+  starrocks)
+    run_integration_test "starrocks_integration"
+    run_integration_test "starrocks_command_integration"
+    ;;
   mariadb)
     run_integration_test "mariadb_integration"
     run_integration_test "mariadb_command_integration"
@@ -89,7 +93,7 @@ case "${it_db}" in
     run_integration_test "oracle_command_integration"
     ;;
   *)
-    echo "[error] Invalid IT_DB='${it_db}'. Expected one of: mysql|mariadb|postgres|clickhouse|mssql|duckdb|sqlite|oracle|all"
+    echo "[error] Invalid IT_DB='${it_db}'. Expected one of: mysql|starrocks|mariadb|postgres|clickhouse|mssql|duckdb|sqlite|oracle|all"
     exit 1
     ;;
 esac
diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rs
index 12483119..e65aa03d 100644
--- a/src-tauri/src/commands/connection.rs
+++ b/src-tauri/src/commands/connection.rs
@@ -267,7 +267,7 @@ pub async fn create_database_by_id(
     }
 
     let exec_res = match driver.as_str() {
-        "mysql" | "mariadb" | "tidb" => {
+        driver if crate::db::drivers::is_mysql_family_driver(driver) => {
             let sql = build_mysql_create_database_sql(&payload, &db_name)?;
             super::execute_with_retry(&state, id, None, |driver| {
                 let sql_clone = sql.clone();
@@ -348,7 +348,7 @@ pub async fn create_database_by_id_direct(
     }
 
     let exec_res = match driver.as_str() {
-        "mysql" | "mariadb" | "tidb" => {
+        driver if crate::db::drivers::is_mysql_family_driver(driver) => {
             let sql = build_mysql_create_database_sql(&payload, &db_name)?;
             super::execute_with_retry_from_app_state(state, id, None, |driver| {
                 let sql_clone = sql.clone();
@@ -425,7 +425,9 @@ pub async fn get_mysql_charsets_by_id(
     id: i64,
 ) -> Result<Vec<String>, String> {
     super::execute_with_retry(&state, id, None, |driver| async move {
-        let result = driver.execute_query("SHOW CHARACTER SET".to_string()).await?;
+        let result = driver
+            .execute_query("SHOW CHARACTER SET".to_string())
+            .await?;
         let mut charsets: Vec<String> = result
             .data
             .iter()
@@ -481,7 +483,9 @@ pub async fn get_mysql_charsets_by_id_direct(
     id: i64,
 ) -> Result<Vec<String>, String> {
     super::execute_with_retry_from_app_state(state, id, None, |driver| async move {
-        let result = driver.execute_query("SHOW CHARACTER SET".to_string()).await?;
+        let result = driver
+            .execute_query("SHOW CHARACTER SET".to_string())
+            .await?;
         let mut charsets: Vec<String> = result
             .data
             .iter()
@@ -870,11 +874,28 @@ mod tests {
             "utf8mb4_0900_ai_ci",
         ];
         for cs in valid {
-            assert!(
-                is_safe_option_token(cs),
-                "expected '{}' to be accepted",
-                cs
-            );
+            assert!(is_safe_option_token(cs), "expected '{}' to be accepted", cs);
         }
     }
+
+    #[test]
+    fn mysql_create_database_sql_is_reusable_for_starrocks_connections() {
+        assert!(crate::db::drivers::is_mysql_family_driver("starrocks"));
+
+        let sql = build_mysql_create_database_sql(
+            &CreateDatabasePayload {
+                name: "analytics".to_string(),
+                if_not_exists: Some(true),
+                charset: None,
+                collation: None,
+                encoding: None,
+                lc_collate: None,
+                lc_ctype: None,
+            },
+            "analytics",
+        )
+        .unwrap();
+
+        assert_eq!(sql, "CREATE DATABASE IF NOT EXISTS `analytics`");
+    }
 }
diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
index 17cff28a..8b8139bb 100644
--- a/src-tauri/src/commands/transfer.rs
+++ b/src-tauri/src/commands/transfer.rs
@@ -565,6 +565,10 @@ fn import_transaction_sql<'a>(
 ) -> Result<(&'a str, &'a str, &'a str), String> {
     match normalized_driver {
         "mysql" | "mariadb" | "tidb" => Ok(("START TRANSACTION", "COMMIT", "ROLLBACK")),
+        "starrocks" => Err(
+            "[UNSUPPORTED] Driver starrocks does not support transactional SQL import in this flow"
+                .to_string(),
+        ),
         "postgres" | "sqlite" | "duckdb" => Ok(("BEGIN", "COMMIT", "ROLLBACK")),
         "mssql" => Ok((
             "BEGIN TRANSACTION",
@@ -1637,6 +1641,7 @@ mod tests {
             ("SELECT 1 FROM DUAL", "COMMIT", "ROLLBACK")
         );
         assert!(import_transaction_sql("clickhouse", "clickhouse").is_err());
+        assert!(import_transaction_sql("starrocks", "starrocks").is_err());
     }
 
     #[test]
@@ -1690,7 +1695,9 @@ mod tests {
             ("id", Value::Number(1.into())),
             ("name", Value::String("alice".to_string())),
         ])];
-        writer.write_rows(&rows, &cols, None, "t", "postgres").unwrap();
+        writer
+            .write_rows(&rows, &cols, None, "t", "postgres")
+            .unwrap();
         writer.finish().unwrap();
         let content = fs::read_to_string(&path).unwrap();
         assert!(content.starts_with("id,name\n"));
@@ -1715,10 +1722,15 @@ mod tests {
         let cols = vec!["id".to_string(), "name".to_string()];
         let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDml).unwrap();
         let rows = vec![
-            make_row(&[("id", Value::Number(1.into())), ("name", Value::String("alice".to_string()))]),
+            make_row(&[
+                ("id", Value::Number(1.into())),
+                ("name", Value::String("alice".to_string())),
+            ]),
             make_row(&[("id", Value::Number(2.into())), ("name", Value::Null)]),
         ];
-        let count = writer.write_rows(&rows, &cols, Some("public"), "users", "postgres").unwrap();
+        let count = writer
+            .write_rows(&rows, &cols, Some("public"), "users", "postgres")
+            .unwrap();
         writer.finish().unwrap();
         assert_eq!(count, 2);
         let content = fs::read_to_string(&path).unwrap();
@@ -1733,7 +1745,9 @@ mod tests {
     fn export_writer_sql_ddl_writes_only_ddl() {
         let path = tmp_path("sql_ddl.sql");
         let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlDdl).unwrap();
-        writer.write_ddl("CREATE TABLE users (id INTEGER);").unwrap();
+        writer
+            .write_ddl("CREATE TABLE users (id INTEGER);")
+            .unwrap();
         writer.finish().unwrap();
         let content = fs::read_to_string(&path).unwrap();
         assert!(content.contains("CREATE TABLE users (id INTEGER);"));
@@ -1746,12 +1760,16 @@ mod tests {
         let path = tmp_path("sql_full.sql");
         let cols = vec!["id".to_string(), "val".to_string()];
         let mut writer = ExportWriter::new(path.clone(), ExportFormat::SqlFull).unwrap();
-        writer.write_ddl("CREATE TABLE t (id INT, val TEXT);").unwrap();
+        writer
+            .write_ddl("CREATE TABLE t (id INT, val TEXT);")
+            .unwrap();
         let rows = vec![make_row(&[
             ("id", Value::Number(1.into())),
             ("val", Value::String("x".to_string())),
         ])];
-        let count = writer.write_rows(&rows, &cols, None, "t", "postgres").unwrap();
+        let count = writer
+            .write_rows(&rows, &cols, None, "t", "postgres")
+            .unwrap();
         writer.finish().unwrap();
         assert_eq!(count, 1);
         let content = fs::read_to_string(&path).unwrap();
diff --git a/src-tauri/src/connection_input/mod.rs b/src-tauri/src/connection_input/mod.rs
index b4dacbfd..3d91ac05 100644
--- a/src-tauri/src/connection_input/mod.rs
+++ b/src-tauri/src/connection_input/mod.rs
@@ -54,7 +54,7 @@ pub fn normalize_connection_form(mut form: ConnectionForm) -> Result<ConnectionF
     validate_port_range("ssh port", form.ssh_port)?;
 
     let driver = form.driver.to_ascii_lowercase();
-    if matches!(driver.as_str(), "mysql" | "mariadb" | "tidb") {
+    if crate::db::drivers::is_mysql_family_driver(&driver) {
         if let Some(host) = form.host.clone() {
             let (normalized_host, normalized_port) = parse_host_embedded_port(&host, form.port);
             form.host = Some(normalized_host);
@@ -96,7 +96,7 @@ mod tests {
     #[test]
     fn normalize_trims_fields_and_parses_mysql_host_port() {
         let form = ConnectionForm {
-            driver: "mysql".to_string(),
+            driver: "starrocks".to_string(),
             host: Some(" 127.0.0.1:3307 ".to_string()),
             port: None,
             username: Some(" root ".to_string()),
@@ -109,6 +109,21 @@ mod tests {
         assert_eq!(normalized.username, Some("root".to_string()));
     }
 
+    #[test]
+    fn normalize_prefers_embedded_starrocks_port_over_existing_port() {
+        let form = ConnectionForm {
+            driver: "starrocks".to_string(),
+            host: Some("127.0.0.1:9031".to_string()),
+            port: Some(9030),
+            username: Some("root".to_string()),
+            ..Default::default()
+        };
+
+        let normalized = normalize_connection_form(form).unwrap();
+        assert_eq!(normalized.host, Some("127.0.0.1".to_string()));
+        assert_eq!(normalized.port, Some(9031));
+    }
+
     #[test]
     fn normalize_prefers_embedded_mysql_port_over_existing_port() {
         let form = ConnectionForm {
diff --git a/src-tauri/src/db/drivers/mod.rs b/src-tauri/src/db/drivers/mod.rs
index 803d6841..bfd007f8 100644
--- a/src-tauri/src/db/drivers/mod.rs
+++ b/src-tauri/src/db/drivers/mod.rs
@@ -19,6 +19,10 @@ pub mod oracle;
 pub mod postgres;
 pub mod sqlite;
 
+pub fn is_mysql_family_driver(driver: &str) -> bool {
+    matches!(driver, "mysql" | "mariadb" | "tidb" | "starrocks")
+}
+
 /// Build a `[CONN_FAILED]` error message with a context-aware hint derived from the
 /// underlying error text, so users are not misled by a generic credential warning
 /// when the actual problem is TLS incompatibility, a network issue, etc.
@@ -26,7 +30,9 @@ pub(crate) fn conn_failed_error(e: &dyn std::fmt::Display) -> String {
     let raw = e.to_string();
     let lower = raw.to_ascii_lowercase();
 
-    let hint = if lower.contains("dpi-1047") || lower.contains("cannot locate a 64-bit oracle client") {
+    let hint = if lower.contains("dpi-1047")
+        || lower.contains("cannot locate a 64-bit oracle client")
+    {
         "hint: Oracle Instant Client is not installed — download it from \
          https://www.oracle.com/database/technologies/instant-client/downloads.html \
          and add the directory containing libclntsh to your library path \
@@ -143,7 +149,7 @@ pub async fn connect(form: &ConnectionForm) -> Result<Box<dyn DatabaseDriver>, S
             let driver = PostgresDriver::connect(form).await?;
             Ok(Box::new(driver) as Box<dyn DatabaseDriver>)
         }
-        "mysql" | "tidb" | "mariadb" => {
+        driver if is_mysql_family_driver(driver) => {
             let driver = MysqlDriver::connect(form).await?;
             Ok(Box::new(driver) as Box<dyn DatabaseDriver>)
         }
@@ -176,7 +182,7 @@ pub async fn connect(form: &ConnectionForm) -> Result<Box<dyn DatabaseDriver>, S
 
 #[cfg(test)]
 mod tests {
-    use super::{conn_failed_error, strip_trailing_statement_terminator};
+    use super::{conn_failed_error, is_mysql_family_driver, strip_trailing_statement_terminator};
 
     #[test]
     fn conn_failed_error_oracle_client_hint() {
@@ -249,4 +255,11 @@ mod tests {
     fn strip_trailing_statement_terminator_keeps_sql_without_semicolon() {
         assert_eq!(strip_trailing_statement_terminator("SELECT 1"), "SELECT 1");
     }
+
+    #[test]
+    fn mysql_family_helper_includes_starrocks() {
+        assert!(is_mysql_family_driver("mysql"));
+        assert!(is_mysql_family_driver("starrocks"));
+        assert!(!is_mysql_family_driver("postgres"));
+    }
 }
diff --git a/src-tauri/src/db/drivers/mysql.rs b/src-tauri/src/db/drivers/mysql.rs
index 4fa891a4..96b6ad8e 100644
--- a/src-tauri/src/db/drivers/mysql.rs
+++ b/src-tauri/src/db/drivers/mysql.rs
@@ -4,11 +4,18 @@ use crate::models::{
     SchemaOverview, TableDataResponse, TableInfo, TableMetadata, TableSchema, TableStructure,
 };
 use async_trait::async_trait;
-use sqlx::{mysql::MySqlPoolOptions, Column, Executor, Row, TypeInfo};
+use sqlx::{
+    mysql::{MySqlConnectOptions, MySqlPoolOptions},
+    Column, Executor, Row, TypeInfo,
+};
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::Path;
 use std::path::PathBuf;
+use std::str::FromStr;
+
+#[cfg(test)]
+use sqlx::ConnectOptions;
 
 use crate::ssh::SshTunnel;
 
@@ -53,7 +60,16 @@ fn build_verify_ca_query_param(ca_path: &Path) -> String {
     )
 }
 
+fn mysql_family_default_port(driver: &str) -> u16 {
+    if driver.eq_ignore_ascii_case("starrocks") {
+        9030
+    } else {
+        3306
+    }
+}
+
 fn normalize_mysql_host_and_port(
+    raw_driver: &str,
     raw_host: &str,
     raw_port: Option<i64>,
 ) -> Result<(String, u16), String> {
@@ -62,7 +78,7 @@ fn normalize_mysql_host_and_port(
         return Err("[VALIDATION_ERROR] host cannot be empty".to_string());
     }
 
-    let mut port = raw_port.unwrap_or(3306);
+    let mut port = raw_port.unwrap_or(i64::from(mysql_family_default_port(raw_driver)));
     if !host.starts_with('[') && host.matches(':').count() == 1 {
         if let Some((host_part, port_part)) = host.rsplit_once(':') {
             let host_part = host_part.trim();
@@ -91,7 +107,7 @@ fn build_dsn_and_ca_path(form: &ConnectionForm) -> Result<(String, Option<PathBu
         .host
         .clone()
         .ok_or("[VALIDATION_ERROR] host cannot be empty")?;
-    let (host, port) = normalize_mysql_host_and_port(&raw_host, form.port)?;
+    let (host, port) = normalize_mysql_host_and_port(&form.driver, &raw_host, form.port)?;
     // Allow database to be empty
     let username = form
         .username
@@ -155,6 +171,26 @@ fn build_dsn_with_ca_path(form: &ConnectionForm) -> Result<(String, Option<PathB
     build_dsn_and_ca_path(form)
 }
 
+fn build_connect_options(dsn: &str, driver: &str) -> Result<MySqlConnectOptions, String> {
+    let mut options =
+        MySqlConnectOptions::from_str(dsn).map_err(|e| format!("[CONN_FAILED] {e}"))?;
+
+    if driver.eq_ignore_ascii_case("starrocks") {
+        // sqlx initializes MySQL connections with:
+        // SET sql_mode=(SELECT CONCAT(@@sql_mode, ...))
+        // plus timezone / SET NAMES session mutations tailored for MySQL.
+        // StarRocks rejects part of this initialization sequence, so skip the
+        // post-connect SET mutations entirely for the StarRocks compatibility path.
+        options = options
+            .pipes_as_concat(false)
+            .no_engine_substitution(false)
+            .timezone(None::<String>)
+            .set_names(false);
+    }
+
+    Ok(options)
+}
+
 fn cleanup_ca_file(path: &Path) {
     let _ = fs::remove_file(path);
 }
@@ -172,7 +208,6 @@ fn is_prepared_protocol_unsupported_error(err: &str) -> bool {
         || lower.contains("preparedoes not support") // PolarDB-X
 }
 
-
 impl Drop for MysqlDriver {
     fn drop(&mut self) {
         cleanup_ca_file_opt(self.ca_cert_path.as_ref());
@@ -196,10 +231,11 @@ impl MysqlDriver {
         }
 
         let (dsn, ca_cert_path) = build_dsn_with_ca_path(&dsn_form)?;
+        let connect_options = build_connect_options(&dsn, &dsn_form.driver)?;
         let pool = MySqlPoolOptions::new()
             .max_connections(5)
             .acquire_timeout(std::time::Duration::from_secs(3))
-            .connect(&dsn)
+            .connect_with(connect_options)
             .await
             .map_err(|e| super::conn_failed_error(&e))?;
 
@@ -1147,6 +1183,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_conn_string_uses_starrocks_default_port_when_port_missing() {
+        let form = ConnectionForm {
+            driver: "starrocks".to_string(),
+            host: Some("localhost".to_string()),
+            port: None,
+            username: Some("root".to_string()),
+            password: Some("password".to_string()),
+            database: Some("analytics".to_string()),
+            ..Default::default()
+        };
+
+        let conn_str = build_dsn(&form).unwrap();
+        assert_eq!(
+            conn_str,
+            "mysql://root:password@localhost:9030/analytics?ssl-mode=DISABLED"
+        );
+    }
+
+    #[test]
+    fn test_starrocks_connect_options_disable_sql_mode_mutations() {
+        let options = build_connect_options(
+            "mysql://root:password@localhost:9030/analytics?ssl-mode=DISABLED",
+            "starrocks",
+        )
+        .unwrap();
+
+        let rendered = options.to_url_lossy().to_string();
+        assert!(rendered.contains("ssl-mode=DISABLED"));
+    }
+
     #[test]
     fn test_conn_string_encodes_credentials() {
         let form = ConnectionForm {
diff --git a/src-tauri/src/ssh.rs b/src-tauri/src/ssh.rs
index 75f7bcb8..459f28d2 100644
--- a/src-tauri/src/ssh.rs
+++ b/src-tauri/src/ssh.rs
@@ -6,6 +6,20 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::thread;
 
+fn default_target_port(driver: &str) -> i64 {
+    if crate::db::drivers::is_mysql_family_driver(driver) {
+        return if driver == "starrocks" { 9030 } else { 3306 };
+    }
+
+    match driver {
+        "mssql" => 1433,
+        "oracle" => 1521,
+        "clickhouse" => 9000,
+        "sqlite" => 0,
+        _ => 5432, // postgres and unknown drivers
+    }
+}
+
 pub struct SshTunnel {
     pub local_port: u16,
     _guard: Arc<TunnelGuard>,
@@ -45,14 +59,8 @@ pub fn start_ssh_tunnel(config: &ConnectionForm) -> Result<SshTunnel, String> {
             .and_then(|v| if v.trim().is_empty() { None } else { Some(v) });
 
     let target_host = config.host.clone().unwrap_or("localhost".to_string());
-    let default_port: i64 = match config.driver.to_ascii_lowercase().as_str() {
-        "mysql" => 3306,
-        "mssql" => 1433,
-        "oracle" => 1521,
-        "clickhouse" => 9000,
-        "sqlite" => 0,
-        _ => 5432, // postgres and unknown drivers
-    };
+    let normalized_driver = config.driver.to_ascii_lowercase();
+    let default_port = default_target_port(&normalized_driver);
     let target_port = config.port.unwrap_or(default_port);
     if target_port < 1 || target_port > 65535 {
         return Err("Target port must be between 1 and 65535".to_string());
@@ -300,6 +308,33 @@ mod tests {
                 "MSSQL default port (1433) should pass validation, got: {e}"
             );
         }
+
+        let config_starrocks = ConnectionForm {
+            driver: "starrocks".to_string(),
+            host: Some("127.0.0.1".to_string()),
+            port: None, // should default to 9030
+            ssh_host: Some("127.0.0.1".to_string()),
+            ssh_port: Some(22),
+            ssh_username: Some("user".to_string()),
+            ssh_password: Some("pass".to_string()),
+            ..Default::default()
+        };
+        let result = start_ssh_tunnel(&config_starrocks);
+        if let Err(e) = result {
+            assert!(
+                !e.contains("Target port must be between 1 and 65535"),
+                "StarRocks default port (9030) should pass validation, got: {e}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_default_target_port_by_driver() {
+        assert_eq!(default_target_port("mysql"), 3306);
+        assert_eq!(default_target_port("mariadb"), 3306);
+        assert_eq!(default_target_port("tidb"), 3306);
+        assert_eq!(default_target_port("starrocks"), 9030);
+        assert_eq!(default_target_port("clickhouse"), 9000);
     }
 
     #[test]
diff --git a/src-tauri/tests/common/shared.rs b/src-tauri/tests/common/shared.rs
index 6e114d31..12299b36 100644
--- a/src-tauri/tests/common/shared.rs
+++ b/src-tauri/tests/common/shared.rs
@@ -5,7 +5,9 @@ use std::process::Command;
 use std::thread::sleep;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
+#[allow(dead_code)]
 const CONNECT_RETRY_ATTEMPTS: usize = 20;
+#[allow(dead_code)]
 const CONNECT_RETRY_DELAY_MS: u64 = 500;
 
 pub fn should_reuse_local_db() -> bool {
@@ -88,6 +90,7 @@ pub fn env_i64_any(names: &[&str], default: i64) -> i64 {
         .unwrap_or(default)
 }
 
+#[allow(dead_code)]
 pub async fn connect_with_retry<T, F, Fut>(mut connect: F) -> T
 where
     F: FnMut() -> Fut,
diff --git a/src-tauri/tests/common/starrocks_context.rs b/src-tauri/tests/common/starrocks_context.rs
new file mode 100644
index 00000000..2e66a90e
--- /dev/null
+++ b/src-tauri/tests/common/starrocks_context.rs
@@ -0,0 +1,77 @@
+mod shared;
+
+use dbpaw_lib::models::ConnectionForm;
+use std::env;
+use std::time::Duration;
+use testcontainers::clients::Cli;
+use testcontainers::core::WaitFor;
+use testcontainers::{Container, GenericImage, RunnableImage};
+
+#[allow(unused_imports)]
+pub use shared::{connect_with_retry, should_reuse_local_db};
+
+pub fn starrocks_form_from_test_context<'a>(
+    docker: Option<&'a Cli>,
+) -> (Option<Container<'a, GenericImage>>, ConnectionForm) {
+    if should_reuse_local_db() {
+        return (None, starrocks_form_from_local_env());
+    }
+    shared::ensure_docker_available();
+
+    let docker = docker.expect("docker client is required when IT_REUSE_LOCAL_DB is not enabled");
+    let image = GenericImage::new("starrocks/allin1-ubuntu", "3.2.10")
+        .with_wait_for(WaitFor::seconds(20))
+        .with_exposed_port(9030);
+    let runnable =
+        RunnableImage::from(image).with_container_name(shared::unique_container_name("starrocks"));
+    let container = docker.run(runnable);
+    let port = container.get_host_port_ipv4(9030);
+
+    shared::wait_for_port("127.0.0.1", port, Duration::from_secs(120));
+
+    let mut form = ConnectionForm {
+        driver: "starrocks".to_string(),
+        host: Some("127.0.0.1".to_string()),
+        port: Some(i64::from(port)),
+        username: Some("root".to_string()),
+        password: Some(String::new()),
+        ..Default::default()
+    };
+    apply_starrocks_env_overrides(&mut form);
+    (Some(container), form)
+}
+
+fn starrocks_form_from_local_env() -> ConnectionForm {
+    let mut form = ConnectionForm {
+        driver: "starrocks".to_string(),
+        host: Some(shared::env_or("STARROCKS_HOST", "localhost")),
+        port: Some(shared::env_i64("STARROCKS_PORT", 9030)),
+        username: Some(shared::env_or("STARROCKS_USER", "root")),
+        password: Some(shared::env_or("STARROCKS_PASSWORD", "")),
+        database: env::var("STARROCKS_DB").ok(),
+        ..Default::default()
+    };
+    apply_starrocks_env_overrides(&mut form);
+    form
+}
+
+fn apply_starrocks_env_overrides(form: &mut ConnectionForm) {
+    if let Ok(host) = env::var("STARROCKS_HOST") {
+        form.host = Some(host);
+    }
+    if let Ok(port) = env::var("STARROCKS_PORT") {
+        form.port = Some(
+            port.parse::<i64>()
+                .expect("STARROCKS_PORT should be a valid number"),
+        );
+    }
+    if let Ok(user) = env::var("STARROCKS_USER") {
+        form.username = Some(user);
+    }
+    if let Ok(password) = env::var("STARROCKS_PASSWORD") {
+        form.password = Some(password);
+    }
+    if let Ok(database) = env::var("STARROCKS_DB") {
+        form.database = Some(database);
+    }
+}
diff --git a/src-tauri/tests/starrocks_command_integration.rs b/src-tauri/tests/starrocks_command_integration.rs
new file mode 100644
index 00000000..2b0a9215
--- /dev/null
+++ b/src-tauri/tests/starrocks_command_integration.rs
@@ -0,0 +1,103 @@
+#[path = "common/starrocks_context.rs"]
+mod starrocks_context;
+
+use dbpaw_lib::commands::connection::{self, CreateDatabasePayload};
+use dbpaw_lib::db::drivers::mysql::MysqlDriver;
+use dbpaw_lib::db::drivers::DatabaseDriver;
+use dbpaw_lib::db::local::LocalDb;
+use dbpaw_lib::models::ConnectionForm;
+use dbpaw_lib::state::AppState;
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+use testcontainers::clients::Cli;
+use tokio::time::{sleep, Duration};
+
+fn unique_name(prefix: &str) -> String {
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("time should be after unix epoch")
+        .as_millis();
+    format!("{}_{}", prefix, millis)
+}
+
+async fn wait_until_starrocks_ready(form: &ConnectionForm) {
+    let mut last_error = String::new();
+    for _ in 0..90 {
+        match connection::test_connection_ephemeral(form.clone()).await {
+            Ok(_) => return,
+            Err(err) => {
+                last_error = err;
+                sleep(Duration::from_secs(1)).await;
+            }
+        }
+    }
+    panic!("starrocks is not ready for command tests: {last_error}");
+}
+
+async fn init_state_with_local_db() -> AppState {
+    let state = AppState::new();
+    let local_db_dir = std::env::temp_dir().join(unique_name("dbpaw_starrocks_stateful_it"));
+    let db = LocalDb::init_with_app_dir(&local_db_dir)
+        .await
+        .expect("failed to initialize local db");
+    let mut lock = state.local_db.lock().await;
+    *lock = Some(Arc::new(db));
+    drop(lock);
+    state
+}
+
+async fn create_starrocks_connection_for_state(
+    state: &AppState,
+    base_form: &ConnectionForm,
+) -> i64 {
+    let mut form = base_form.clone();
+    form.name = Some(unique_name("starrocks-command"));
+    let created = connection::create_connection_direct(state, form)
+        .await
+        .expect("create_connection should succeed");
+    created.id
+}
+
+async fn drop_database_if_exists(form: &ConnectionForm, db_name: &str) {
+    let driver = MysqlDriver::connect(form)
+        .await
+        .expect("failed to connect starrocks driver for cleanup");
+    let _ = driver
+        .execute_query(format!("DROP DATABASE IF EXISTS `{}`", db_name))
+        .await;
+    driver.close().await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_starrocks_command_create_database_by_id_success() {
+    let docker = (!starrocks_context::should_reuse_local_db()).then(Cli::default);
+    let (_container, form) = starrocks_context::starrocks_form_from_test_context(docker.as_ref());
+    wait_until_starrocks_ready(&form).await;
+
+    let state = init_state_with_local_db().await;
+    let conn_id = create_starrocks_connection_for_state(&state, &form).await;
+
+    let db_name = unique_name("dbpaw_starrocks_cmd_db");
+    let payload = CreateDatabasePayload {
+        name: db_name.clone(),
+        if_not_exists: Some(true),
+        charset: None,
+        collation: None,
+        encoding: None,
+        lc_collate: None,
+        lc_ctype: None,
+    };
+
+    connection::create_database_by_id_direct(&state, conn_id, payload)
+        .await
+        .expect("create_database_by_id should succeed");
+
+    let dbs = connection::list_databases_by_id_direct(&state, conn_id)
+        .await
+        .expect("list_databases_by_id should succeed");
+    assert!(dbs.iter().any(|d| d == &db_name));
+
+    drop_database_if_exists(&form, &db_name).await;
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
diff --git a/src-tauri/tests/starrocks_integration.rs b/src-tauri/tests/starrocks_integration.rs
new file mode 100644
index 00000000..e01dd64a
--- /dev/null
+++ b/src-tauri/tests/starrocks_integration.rs
@@ -0,0 +1,120 @@
+#[path = "common/starrocks_context.rs"]
+mod starrocks_context;
+
+use dbpaw_lib::db::drivers::mysql::MysqlDriver;
+use dbpaw_lib::db::drivers::DatabaseDriver;
+use std::time::{SystemTime, UNIX_EPOCH};
+use testcontainers::clients::Cli;
+
+fn unique_name(prefix: &str) -> String {
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("time should be after unix epoch")
+        .as_millis();
+    format!("{}_{}", prefix, millis)
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_starrocks_integration_flow() {
+    let docker = (!starrocks_context::should_reuse_local_db()).then(Cli::default);
+    let (_container, form) = starrocks_context::starrocks_form_from_test_context(docker.as_ref());
+    let driver: MysqlDriver =
+        starrocks_context::connect_with_retry(|| MysqlDriver::connect(&form)).await;
+
+    driver
+        .test_connection()
+        .await
+        .expect("test_connection failed");
+
+    let dbs = driver
+        .list_databases()
+        .await
+        .expect("list_databases failed");
+    assert!(!dbs.is_empty(), "list_databases returned empty");
+
+    let db_name = unique_name("dbpaw_starrocks_it");
+    let table_name = "events";
+    let qualified = format!("`{}`.`{}`", db_name, table_name);
+
+    driver
+        .execute_query(format!("CREATE DATABASE IF NOT EXISTS `{}`", db_name))
+        .await
+        .expect("create database failed");
+
+    let _ = driver
+        .execute_query(format!("DROP TABLE IF EXISTS {}", qualified))
+        .await;
+
+    driver
+        .execute_query(format!("CREATE TABLE {} (id INT, name STRING)", qualified))
+        .await
+        .expect("create table failed");
+
+    driver
+        .execute_query(format!(
+            "INSERT INTO {} (id, name) VALUES (1, 'hello')",
+            qualified
+        ))
+        .await
+        .expect("insert failed");
+
+    let tables = driver
+        .list_tables(Some(db_name.clone()))
+        .await
+        .expect("list_tables failed");
+    assert!(
+        tables.iter().any(|t| t.name == table_name),
+        "list_tables should include {}",
+        table_name
+    );
+
+    let metadata = driver
+        .get_table_metadata(db_name.clone(), table_name.to_string())
+        .await
+        .expect("get_table_metadata failed");
+    assert!(
+        metadata.columns.iter().any(|c| c.name == "name"),
+        "metadata should include name column"
+    );
+
+    let ddl = driver
+        .get_table_ddl(db_name.clone(), table_name.to_string())
+        .await
+        .expect("get_table_ddl failed");
+    assert!(
+        ddl.to_uppercase().contains("CREATE TABLE"),
+        "DDL should contain CREATE TABLE"
+    );
+
+    let result = driver
+        .execute_query(format!("SELECT id, name FROM {} WHERE id = 1", qualified))
+        .await
+        .expect("select failed");
+    assert_eq!(result.row_count, 1);
+    assert_eq!(
+        result.data[0]["name"],
+        serde_json::Value::String("hello".to_string())
+    );
+
+    let table_data = driver
+        .get_table_data(
+            db_name.clone(),
+            table_name.to_string(),
+            1,
+            100,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        .expect("get_table_data failed");
+    assert_eq!(table_data.total, 1);
+    assert_eq!(table_data.data.len(), 1);
+
+    let _ = driver
+        .execute_query(format!("DROP DATABASE IF EXISTS `{}`", db_name))
+        .await;
+    driver.close().await;
+}
diff --git a/src/App.tsx b/src/App.tsx
index 559567d9..c840a179 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -22,6 +22,7 @@ import { TableMetadataView } from "@/components/business/Metadata/TableMetadataV
 import { SqlExecutionLogsDropdown } from "@/components/business/SqlLogs/SqlExecutionLogsDialog";
 import { FileCode, Table, X, Settings, Sparkles } from "lucide-react";
 import { Button } from "@/components/ui/button";
+import { isMysqlFamilyDriver } from "@/lib/driver-registry";
 import {
   ContextMenu,
   ContextMenuContent,
@@ -187,10 +188,7 @@ export default function App() {
     schemaOverride?: string,
   ) => {
     const isDatabaseScoped =
-      driver === "mysql" ||
-      driver === "tidb" ||
-      driver === "mariadb" ||
-      driver === "clickhouse";
+      (driver && isMysqlFamilyDriver(driver as any)) || driver === "clickhouse";
     const normalizedSchemaOverride = (schemaOverride || "").trim();
     return {
       schema: isDatabaseScoped
@@ -1619,123 +1617,126 @@ export default function App() {
                     >
                       <ErrorBoundary>
                         {tab.type === "editor" ? (
-                        <Suspense
-                          fallback={
-                            <LazyPanelFallback label={t("common.loading")} />
-                          }
-                        >
-                          <SqlEditor
-                            databaseName={tab.database}
-                            availableDatabases={tab.availableDatabases}
-                            onExecute={(sql) => handleExecuteQuery(tab.id, sql)}
-                            onCancel={() =>
-                              tab.connectionId && tab.activeQueryId
-                                ? api.query.cancel(
-                                    String(tab.connectionId),
-                                    tab.activeQueryId,
-                                  )
-                                : Promise.resolve(false)
+                          <Suspense
+                            fallback={
+                              <LazyPanelFallback label={t("common.loading")} />
                             }
-                            isExecuting={!!tab.activeQueryId}
-                            queryResults={tab.queryResults}
-                            value={tab.sqlContent}
-                            onChange={(sql) => handleSqlChange(tab.id, sql)}
-                            onDatabaseChange={(database) =>
-                              void handleEditorDatabaseChange(tab.id, database)
+                          >
+                            <SqlEditor
+                              databaseName={tab.database}
+                              availableDatabases={tab.availableDatabases}
+                              onExecute={(sql) =>
+                                handleExecuteQuery(tab.id, sql)
+                              }
+                              onCancel={() =>
+                                tab.connectionId && tab.activeQueryId
+                                  ? api.query.cancel(
+                                      String(tab.connectionId),
+                                      tab.activeQueryId,
+                                    )
+                                  : Promise.resolve(false)
+                              }
+                              isExecuting={!!tab.activeQueryId}
+                              queryResults={tab.queryResults}
+                              value={tab.sqlContent}
+                              onChange={(sql) => handleSqlChange(tab.id, sql)}
+                              onDatabaseChange={(database) =>
+                                void handleEditorDatabaseChange(
+                                  tab.id,
+                                  database,
+                                )
+                              }
+                              connectionId={tab.connectionId}
+                              driver={tab.driver}
+                              schemaOverview={tab.schemaOverview}
+                              savedQueryId={tab.savedQueryId}
+                              initialName={
+                                isDefaultQueryTitle(tab.title) ? "" : tab.title
+                              }
+                              initialDescription={tab.savedQueryDescription}
+                              onSaveSuccess={(savedQuery) => {
+                                setQueriesLastUpdated(Date.now());
+                                setTabs((prev) =>
+                                  prev.map((t) => {
+                                    if (t.id === tab.id) {
+                                      return {
+                                        ...t,
+                                        savedQueryId: savedQuery.id,
+                                        title: savedQuery.name,
+                                        savedQueryDescription:
+                                          savedQuery.description || undefined,
+                                        sqlContent: savedQuery.query,
+                                        lastSavedSql: savedQuery.query,
+                                        isDirty: false,
+                                      };
+                                    }
+                                    return t;
+                                  }),
+                                );
+                              }}
+                            />
+                          </Suspense>
+                        ) : tab.type === "table" ? (
+                          <TableView
+                            isLoading={tab.isLoading}
+                            data={tab.data}
+                            columns={tab.columns}
+                            total={tab.total}
+                            page={tab.page}
+                            pageSize={tab.pageSize}
+                            executionTimeMs={tab.executionTimeMs}
+                            onPageChange={(p) => handlePageChange(tab.id, p)}
+                            onPageSizeChange={(size) =>
+                              handlePageSizeChange(tab.id, size)
                             }
-                            connectionId={tab.connectionId}
-                            driver={tab.driver}
-                            schemaOverview={tab.schemaOverview}
-                            savedQueryId={tab.savedQueryId}
-                            initialName={
-                              isDefaultQueryTitle(tab.title) ? "" : tab.title
+                            sortColumn={tab.sortColumn}
+                            sortDirection={tab.sortDirection}
+                            onSortChange={(col, dir) =>
+                              handleSortChange(tab.id, col, dir)
+                            }
+                            filter={tab.filter}
+                            orderBy={tab.orderBy}
+                            onFilterChange={(f, ob) =>
+                              handleFilterChange(tab.id, f, ob)
+                            }
+                            onOpenDDL={handleOpenTableDDL}
+                            onDataRefresh={(params) =>
+                              handleTableRefresh(tab.id, params)
                             }
-                            initialDescription={tab.savedQueryDescription}
-                            onSaveSuccess={(savedQuery) => {
-                              setQueriesLastUpdated(Date.now());
-                              setTabs((prev) =>
-                                prev.map((t) => {
-                                  if (t.id === tab.id) {
-                                    return {
-                                      ...t,
-                                      savedQueryId: savedQuery.id,
-                                      title: savedQuery.name,
-                                      savedQueryDescription:
-                                        savedQuery.description || undefined,
-                                      sqlContent: savedQuery.query,
-                                      lastSavedSql: savedQuery.query,
-                                      isDirty: false,
-                                    };
+                            onCreateQuery={handleCreateQuery}
+                            tableContext={
+                              tab.connectionId &&
+                              tab.database &&
+                              tab.tableName &&
+                              tab.driver
+                                ? {
+                                    connectionId: tab.connectionId,
+                                    database: tab.database,
+                                    schema:
+                                      isMysqlFamilyDriver(tab.driver as any) ||
+                                      tab.driver === "clickhouse"
+                                        ? tab.database
+                                        : tab.driver === "mssql"
+                                          ? "dbo"
+                                          : tab.driver === "duckdb"
+                                            ? "main"
+                                            : "public",
+                                    table: tab.tableName,
+                                    driver: tab.driver,
                                   }
-                                  return t;
-                                }),
-                              );
-                            }}
+                                : undefined
+                            }
+                          />
+                        ) : tab.connectionId &&
+                          tab.database &&
+                          tab.schema &&
+                          tab.tableName ? (
+                          <TableMetadataView
+                            connectionId={tab.connectionId}
+                            database={tab.database}
+                            schema={tab.schema}
+                            table={tab.tableName}
                           />
-                        </Suspense>
-                      ) : tab.type === "table" ? (
-                        <TableView
-                          isLoading={tab.isLoading}
-                          data={tab.data}
-                          columns={tab.columns}
-                          total={tab.total}
-                          page={tab.page}
-                          pageSize={tab.pageSize}
-                          executionTimeMs={tab.executionTimeMs}
-                          onPageChange={(p) => handlePageChange(tab.id, p)}
-                          onPageSizeChange={(size) =>
-                            handlePageSizeChange(tab.id, size)
-                          }
-                          sortColumn={tab.sortColumn}
-                          sortDirection={tab.sortDirection}
-                          onSortChange={(col, dir) =>
-                            handleSortChange(tab.id, col, dir)
-                          }
-                          filter={tab.filter}
-                          orderBy={tab.orderBy}
-                          onFilterChange={(f, ob) =>
-                            handleFilterChange(tab.id, f, ob)
-                          }
-                          onOpenDDL={handleOpenTableDDL}
-                          onDataRefresh={(params) =>
-                            handleTableRefresh(tab.id, params)
-                          }
-                          onCreateQuery={handleCreateQuery}
-                          tableContext={
-                            tab.connectionId &&
-                            tab.database &&
-                            tab.tableName &&
-                            tab.driver
-                              ? {
-                                  connectionId: tab.connectionId,
-                                  database: tab.database,
-                                  schema:
-                                    tab.driver === "mysql" ||
-                                    tab.driver === "tidb" ||
-                                    tab.driver === "mariadb" ||
-                                    tab.driver === "clickhouse"
-                                      ? tab.database
-                                      : tab.driver === "mssql"
-                                        ? "dbo"
-                                        : tab.driver === "duckdb"
-                                          ? "main"
-                                          : "public",
-                                  table: tab.tableName,
-                                  driver: tab.driver,
-                                }
-                              : undefined
-                          }
-                        />
-                      ) : tab.connectionId &&
-                        tab.database &&
-                        tab.schema &&
-                        tab.tableName ? (
-                        <TableMetadataView
-                          connectionId={tab.connectionId}
-                          database={tab.database}
-                          schema={tab.schema}
-                          table={tab.tableName}
-                        />
                         ) : null}
                       </ErrorBoundary>
                     </TabsContent>
diff --git a/src/components/business/DataGrid/tableView/utils.ts b/src/components/business/DataGrid/tableView/utils.ts
index 6e781f6b..c301a0c9 100644
--- a/src/components/business/DataGrid/tableView/utils.ts
+++ b/src/components/business/DataGrid/tableView/utils.ts
@@ -1,3 +1,5 @@
+import { isMysqlFamilyDriver } from "@/lib/driver-registry";
+
 export interface SearchMatch {
   row: number;
   col: string;
@@ -138,9 +140,7 @@ export function escapeSQL(value: string): string {
 
 export function quoteIdent(driver: string | undefined, name: string): string {
   if (
-    driver === "mysql" ||
-    driver === "tidb" ||
-    driver === "mariadb" ||
+    (driver && isMysqlFamilyDriver(driver as any)) ||
     driver === "clickhouse"
   ) {
     return `\`${name}\``;
@@ -246,7 +246,7 @@ export function getQualifiedTableName(
   schema: string,
   table: string,
 ): string {
-  if (driver === "mysql" || driver === "tidb" || driver === "mariadb") {
+  if (isMysqlFamilyDriver(driver as any)) {
     return quoteIdent(driver, table);
   }
 
diff --git a/src/components/business/DataGrid/tableView/utils.unit.test.ts b/src/components/business/DataGrid/tableView/utils.unit.test.ts
index d2184a45..ea7b3369 100644
--- a/src/components/business/DataGrid/tableView/utils.unit.test.ts
+++ b/src/components/business/DataGrid/tableView/utils.unit.test.ts
@@ -30,6 +30,7 @@ describe("formatSQLValue", () => {
     expect(formatSQLValue("false", true, "execution", "mysql")).toBe("FALSE");
     expect(formatSQLValue("true", true, "execution", "tidb")).toBe("TRUE");
     expect(formatSQLValue("false", true, "execution", "mariadb")).toBe("FALSE");
+    expect(formatSQLValue("true", true, "execution", "starrocks")).toBe("TRUE");
   });
 
   test("throws for invalid boolean in execution mode", () => {
@@ -131,6 +132,12 @@ describe("getQualifiedTableName", () => {
     );
   });
 
+  test("uses unqualified table with backticks for starrocks", () => {
+    expect(getQualifiedTableName("starrocks", "analytics", "events")).toBe(
+      "`events`",
+    );
+  });
+
   test("does not qualify sqlite main/public schema", () => {
     expect(getQualifiedTableName("sqlite", "main", "users")).toBe('"users"');
     expect(getQualifiedTableName("sqlite", "public", "users")).toBe('"users"');
@@ -208,6 +215,7 @@ describe("quoteIdent", () => {
     expect(quoteIdent("mysql", "my_table")).toBe("`my_table`");
     expect(quoteIdent("tidb", "my_table")).toBe("`my_table`");
     expect(quoteIdent("mariadb", "my_table")).toBe("`my_table`");
+    expect(quoteIdent("starrocks", "my_table")).toBe("`my_table`");
     expect(quoteIdent("clickhouse", "my_table")).toBe("`my_table`");
   });
 
@@ -292,15 +300,28 @@ describe("collectSearchMatches", () => {
 
   test("skips null and undefined cell values", () => {
     const withNulls = [{ id: null, name: undefined }];
-    const matches = collectSearchMatches(withNulls, ["id", "name"], "null", identity);
+    const matches = collectSearchMatches(
+      withNulls,
+      ["id", "name"],
+      "null",
+      identity,
+    );
     expect(matches).toEqual([]);
   });
 });
 
 describe("calculateAutoColumnWidths", () => {
   test("returns empty object for empty data or columns", () => {
-    expect(calculateAutoColumnWidths({ data: [], columns: ["a"], columnWidths: {} })).toEqual({});
-    expect(calculateAutoColumnWidths({ data: [{ a: 1 }], columns: [], columnWidths: {} })).toEqual({});
+    expect(
+      calculateAutoColumnWidths({ data: [], columns: ["a"], columnWidths: {} }),
+    ).toEqual({});
+    expect(
+      calculateAutoColumnWidths({
+        data: [{ a: 1 }],
+        columns: [],
+        columnWidths: {},
+      }),
+    ).toEqual({});
   });
 
   test("skips columns with a pre-set width", () => {
@@ -415,7 +436,12 @@ describe("formatCellValue", () => {
   });
 
   test("object with many keys → shows first 2 keys and remainder count", () => {
-    const result = formatCellValue({ id: 1, name: "x", role: "admin", score: 99 });
+    const result = formatCellValue({
+      id: 1,
+      name: "x",
+      role: "admin",
+      score: 99,
+    });
     expect(result).toMatch(/^\{id, name, \.\.\. \+2\}$/);
   });
 
@@ -438,17 +464,19 @@ describe("formatCellValue: integration with collectSearchMatches", () => {
       { id: 2, meta: { role: "user", tags: [] } },
     ];
     const identity = (_row: number, _col: string, val: any) => val;
-    const matches = collectSearchMatches(data, ["id", "meta"], "admin", identity);
+    const matches = collectSearchMatches(
+      data,
+      ["id", "meta"],
+      "admin",
+      identity,
+    );
     expect(matches.length).toBe(1);
     expect(matches[0].row).toBe(0);
     expect(matches[0].col).toBe("meta");
   });
 
   test("array fields are searchable by content", () => {
-    const data = [
-      { tags: ["read", "write"] },
-      { tags: ["read"] },
-    ];
+    const data = [{ tags: ["read", "write"] }, { tags: ["read"] }];
     const identity = (_row: number, _col: string, val: any) => val;
     const matches = collectSearchMatches(data, ["tags"], "write", identity);
     expect(matches.length).toBe(1);
@@ -480,7 +508,9 @@ describe("formatCellValue: PostgreSQL array column output", () => {
   });
 
   test("text array displays as compact JSON string array", () => {
-    expect(formatCellValue(["postgres", "arrays"])).toBe('["postgres","arrays"]');
+    expect(formatCellValue(["postgres", "arrays"])).toBe(
+      '["postgres","arrays"]',
+    );
   });
 
   test("bool array displays as compact JSON", () => {
@@ -492,7 +522,10 @@ describe("formatCellValue: PostgreSQL array column output", () => {
   });
 
   test("jsonb array (array of objects) displays as full JSON", () => {
-    const val = [{ source: "web", valid: true }, { source: "app", valid: false }];
+    const val = [
+      { source: "web", valid: true },
+      { source: "app", valid: false },
+    ];
     expect(formatCellValue(val)).toBe(JSON.stringify(val));
   });
 
@@ -537,7 +570,12 @@ describe("collectSearchMatches: PostgreSQL array columns are searchable", () =>
   const identity = (_row: number, _col: string, val: any) => val;
 
   test("finds match inside text array content", () => {
-    const matches = collectSearchMatches(data, ["id", "tags"], "jsonb", identity);
+    const matches = collectSearchMatches(
+      data,
+      ["id", "tags"],
+      "jsonb",
+      identity,
+    );
     expect(matches.length).toBe(1);
     expect(matches[0].row).toBe(0);
     expect(matches[0].col).toBe("tags");
diff --git a/src/components/business/Editor/SqlEditor.tsx b/src/components/business/Editor/SqlEditor.tsx
index 82206612..aaaa9202 100644
--- a/src/components/business/Editor/SqlEditor.tsx
+++ b/src/components/business/Editor/SqlEditor.tsx
@@ -372,6 +372,7 @@ export function SqlEditor({
         mysql: "mysql",
         tidb: "mysql",
         mariadb: "mysql",
+        starrocks: "mysql",
         sqlite: "sqlite",
         duckdb: "sqlite",
         clickhouse: "sql",
@@ -517,6 +518,7 @@ export function SqlEditor({
       case "mysql":
       case "tidb":
       case "mariadb":
+      case "starrocks":
         return MySQL;
       case "sqlite":
       case "duckdb":
diff --git a/src/components/business/Sidebar/ConnectionList.tsx b/src/components/business/Sidebar/ConnectionList.tsx
index 3c916bfc..64755cc3 100644
--- a/src/components/business/Sidebar/ConnectionList.tsx
+++ b/src/components/business/Sidebar/ConnectionList.tsx
@@ -166,7 +166,6 @@ const defaultForm: ConnectionForm = {
   sshUsername: "",
 };
 
-
 const defaultCreateDatabaseForm: CreateDatabaseForm = {
   name: "",
   ifNotExists: true,
@@ -451,15 +450,18 @@ export function ConnectionList({
     [connections, createDbConnectionId],
   );
   const createDbTargetDriver = createDbTargetConnection?.type;
-  const isMySqlFamilyCreateDb =
-    createDbTargetDriver === "mysql" ||
-    createDbTargetDriver === "mariadb" ||
-    createDbTargetDriver === "tidb";
+  const isMySqlFamilyCreateDb = createDbTargetDriver
+    ? isMysqlFamilyDriver(createDbTargetDriver as any)
+    : false;
   const isPostgresCreateDb = createDbTargetDriver === "postgres";
   const isMssqlCreateDb = createDbTargetDriver === "mssql";
 
   useEffect(() => {
-    if (!isCreateDbDialogOpen || !isMySqlFamilyCreateDb || !createDbConnectionId)
+    if (
+      !isCreateDbDialogOpen ||
+      !isMySqlFamilyCreateDb ||
+      !createDbConnectionId
+    )
       return;
     setLoadingMysqlOptions(true);
     api.connections
@@ -470,7 +472,11 @@ export function ConnectionList({
   }, [isCreateDbDialogOpen, isMySqlFamilyCreateDb, createDbConnectionId]);
 
   useEffect(() => {
-    if (!isCreateDbDialogOpen || !isMySqlFamilyCreateDb || !createDbConnectionId)
+    if (
+      !isCreateDbDialogOpen ||
+      !isMySqlFamilyCreateDb ||
+      !createDbConnectionId
+    )
       return;
     api.connections
       .getMysqlCollations(
diff --git a/src/lib/connection-form/rules.unit.test.ts b/src/lib/connection-form/rules.unit.test.ts
index ee3ee846..21daf857 100644
--- a/src/lib/connection-form/rules.unit.test.ts
+++ b/src/lib/connection-form/rules.unit.test.ts
@@ -15,6 +15,7 @@ describe("isMysqlFamilyDriver", () => {
     expect(isMysqlFamilyDriver("mysql")).toBe(true);
     expect(isMysqlFamilyDriver("mariadb")).toBe(true);
     expect(isMysqlFamilyDriver("tidb")).toBe(true);
+    expect(isMysqlFamilyDriver("starrocks")).toBe(true);
   });
 
   test("rejects non-mysql drivers", () => {
@@ -38,12 +39,14 @@ describe("isFileBasedDriver", () => {
 describe("allowsHostWithPort / requiresPasswordOnCreate", () => {
   test("only mysql family allows host:port notation", () => {
     expect(allowsHostWithPort("mysql")).toBe(true);
+    expect(allowsHostWithPort("starrocks")).toBe(true);
     expect(allowsHostWithPort("postgres")).toBe(false);
   });
 
   test("non-mysql drivers require password on create", () => {
     expect(requiresPasswordOnCreate("postgres")).toBe(true);
     expect(requiresPasswordOnCreate("mysql")).toBe(false);
+    expect(requiresPasswordOnCreate("starrocks")).toBe(false);
   });
 });
 
@@ -144,14 +147,14 @@ describe("normalizeConnectionFormInput", () => {
 
   test("uses embedded host port even when a default port is already set", () => {
     const normalized = normalizeConnectionFormInput({
-      driver: "mysql",
-      host: " db:3307 ",
-      port: 3306,
+      driver: "starrocks",
+      host: " db:9031 ",
+      port: 9030,
       password: "",
     } as any);
 
     expect(normalized.host).toBe("db");
-    expect(normalized.port).toBe(3307);
+    expect(normalized.port).toBe(9031);
   });
 
   test("does not split host:port for non-mysql drivers", () => {
diff --git a/src/lib/driver-registry.tsx b/src/lib/driver-registry.tsx
index 71044fd5..24e25277 100644
--- a/src/lib/driver-registry.tsx
+++ b/src/lib/driver-registry.tsx
@@ -18,6 +18,7 @@ const DRIVER_IDS = [
   "mysql",
   "mariadb",
   "tidb",
+  "starrocks",
   "sqlite",
   "duckdb",
   "clickhouse",
@@ -102,6 +103,18 @@ export const DRIVER_REGISTRY: DriverConfig[] = [
     importCapability: "supported",
     icon: () => renderSimpleIcon(siMysql),
   },
+  {
+    id: "starrocks",
+    label: "StarRocks",
+    defaultPort: 9030,
+    isFileBased: false,
+    isMysqlFamily: true,
+    supportsSSLCA: true,
+    supportsSchemaBrowsing: false,
+    supportsCreateDatabase: true,
+    importCapability: "unsupported",
+    icon: () => <Database className="w-4 h-4" />,
+  },
   {
     id: "sqlite",
     label: "SQLite",
@@ -190,7 +203,9 @@ export const getConnectionIcon = (
 ): ReactNode => {
   const config = DRIVER_REGISTRY.find((d) => d.id === driver);
   if (config) return config.icon();
-  const normalized = String(driver || "").trim().toLowerCase();
+  const normalized = String(driver || "")
+    .trim()
+    .toLowerCase();
   if (normalized === "postgresql" || normalized === "pgsql")
     return getConnectionIcon("postgres");
   if (normalized === "sqlite3") return getConnectionIcon("sqlite");
diff --git a/src/lib/driver-registry.unit.test.ts b/src/lib/driver-registry.unit.test.ts
index 8b13331a..a8ef772d 100644
--- a/src/lib/driver-registry.unit.test.ts
+++ b/src/lib/driver-registry.unit.test.ts
@@ -15,18 +15,19 @@ import {
 // ─── Registry completeness ────────────────────────────────────────────────────
 
 describe("DRIVER_REGISTRY", () => {
-  test("contains all 9 supported drivers", () => {
+  test("contains all 10 supported drivers", () => {
     const ids = DRIVER_REGISTRY.map((d) => d.id);
     expect(ids).toContain("postgres");
     expect(ids).toContain("mysql");
     expect(ids).toContain("mariadb");
     expect(ids).toContain("tidb");
+    expect(ids).toContain("starrocks");
     expect(ids).toContain("sqlite");
     expect(ids).toContain("duckdb");
     expect(ids).toContain("clickhouse");
     expect(ids).toContain("mssql");
     expect(ids).toContain("oracle");
-    expect(DRIVER_REGISTRY).toHaveLength(9);
+    expect(DRIVER_REGISTRY).toHaveLength(10);
   });
 
   test("has no duplicate IDs", () => {
@@ -99,6 +100,7 @@ describe("getDriverConfig", () => {
   test("returns the correct config for each driver", () => {
     expect(getDriverConfig("postgres").label).toBe("PostgreSQL");
     expect(getDriverConfig("mysql").label).toBe("MySQL");
+    expect(getDriverConfig("starrocks").label).toBe("StarRocks");
     expect(getDriverConfig("mssql").label).toBe("SQL Server");
     expect(getDriverConfig("clickhouse").label).toBe("ClickHouse");
     expect(getDriverConfig("duckdb").label).toBe("DuckDB");
@@ -113,6 +115,7 @@ describe("getDefaultPort", () => {
     expect(getDefaultPort("mysql")).toBe(3306);
     expect(getDefaultPort("mariadb")).toBe(3306);
     expect(getDefaultPort("tidb")).toBe(4000);
+    expect(getDefaultPort("starrocks")).toBe(9030);
     expect(getDefaultPort("clickhouse")).toBe(8123);
     expect(getDefaultPort("mssql")).toBe(1433);
   });
@@ -137,6 +140,7 @@ describe("isFileBasedDriver", () => {
       "mysql",
       "mariadb",
       "tidb",
+      "starrocks",
       "clickhouse",
       "mssql",
     ];
@@ -153,6 +157,7 @@ describe("isMysqlFamilyDriver", () => {
     expect(isMysqlFamilyDriver("mysql")).toBe(true);
     expect(isMysqlFamilyDriver("mariadb")).toBe(true);
     expect(isMysqlFamilyDriver("tidb")).toBe(true);
+    expect(isMysqlFamilyDriver("starrocks")).toBe(true);
   });
 
   test("returns false for non-MySQL drivers", () => {
@@ -177,6 +182,7 @@ describe("supportsSSLCA", () => {
     expect(supportsSSLCA("mysql")).toBe(true);
     expect(supportsSSLCA("mariadb")).toBe(true);
     expect(supportsSSLCA("tidb")).toBe(true);
+    expect(supportsSSLCA("starrocks")).toBe(true);
   });
 
   test("returns false for drivers without SSL CA support", () => {
@@ -195,6 +201,7 @@ describe("supportsCreateDatabase", () => {
     expect(supportsCreateDatabase("mysql")).toBe(true);
     expect(supportsCreateDatabase("mariadb")).toBe(true);
     expect(supportsCreateDatabase("tidb")).toBe(true);
+    expect(supportsCreateDatabase("starrocks")).toBe(true);
     expect(supportsCreateDatabase("clickhouse")).toBe(true);
     expect(supportsCreateDatabase("mssql")).toBe(true);
   });
@@ -218,6 +225,7 @@ describe("supportsSchemaBrowsing", () => {
       "mysql",
       "mariadb",
       "tidb",
+      "starrocks",
       "sqlite",
       "duckdb",
       "clickhouse",
@@ -241,6 +249,10 @@ describe("importCapability", () => {
     );
   });
 
+  test("starrocks import is unsupported", () => {
+    expect(getDriverConfig("starrocks").importCapability).toBe("unsupported");
+  });
+
   test("all other drivers are supported", () => {
     const supported: Driver[] = [
       "postgres",
diff --git a/src/services/api.unit.test.ts b/src/services/api.unit.test.ts
index 9bd63923..7b236364 100644
--- a/src/services/api.unit.test.ts
+++ b/src/services/api.unit.test.ts
@@ -67,6 +67,7 @@ describe("normalizeImportDriver", () => {
       "mysql",
       "mariadb",
       "tidb",
+      "starrocks",
       "sqlite",
       "duckdb",
       "mssql",
@@ -93,6 +94,10 @@ describe("getImportDriverCapability", () => {
     );
   });
 
+  test("starrocks import is unsupported", () => {
+    expect(getImportDriverCapability("starrocks")).toBe("unsupported");
+  });
+
   test("all writable drivers are supported", () => {
     const supported = [
       "postgres",
@@ -168,13 +173,23 @@ describe("invoke: Tauri environment", () => {
     tauriInvokeImpl = async (cmd, args) => {
       capturedCmd = cmd;
       capturedArgs = args;
-      return { data: [], rowCount: 0, columns: [], timeTakenMs: 0, success: true };
+      return {
+        data: [],
+        rowCount: 0,
+        columns: [],
+        timeTakenMs: 0,
+        success: true,
+      };
     };
 
     await api.query.execute(42, "SELECT 1", "mydb", "sql_editor");
 
     expect(capturedCmd).toBe("execute_query");
-    expect(capturedArgs).toMatchObject({ id: 42, query: "SELECT 1", database: "mydb" });
+    expect(capturedArgs).toMatchObject({
+      id: 42,
+      query: "SELECT 1",
+      database: "mydb",
+    });
   });
 
   test("tauriInvoke error propagates to caller", async () => {
@@ -247,7 +262,10 @@ describe("api command mapping", () => {
     ["list_sql_execution_logs", () => api.sqlLogs.list()],
     ["list_tables", () => api.metadata.listTables(1)],
     ["get_table_ddl", () => api.metadata.getTableDDL(1, "db", "public", "t")],
-    ["get_table_metadata", () => api.metadata.getTableMetadata(1, "db", "public", "t")],
+    [
+      "get_table_metadata",
+      () => api.metadata.getTableMetadata(1, "db", "public", "t"),
+    ],
     ["get_connections", () => api.connections.list()],
     ["create_connection", () => api.connections.create({ driver: "postgres" })],
     ["delete_connection", () => api.connections.delete(1)],
@@ -258,10 +276,7 @@ describe("api command mapping", () => {
     ["ai_list_conversations", () => api.ai.conversations.list()],
     ["cancel_query", () => api.query.cancel("uuid-abc", "qid-1")],
     ["get_mysql_charsets_by_id", () => api.connections.getMysqlCharsets(1)],
-    [
-      "get_mysql_collations_by_id",
-      () => api.connections.getMysqlCollations(1),
-    ],
+    ["get_mysql_collations_by_id", () => api.connections.getMysqlCollations(1)],
     [
       "get_mysql_collations_by_id",
       () => api.connections.getMysqlCollations(1, "utf8mb4"),

From 1ccb9ab5f944dc52b65941b6135de0c5863290a5 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Thu, 9 Apr 2026 20:31:00 +0800
Subject: [PATCH 07/15] Change table header click to copy and double-click to
 sort

---
 .../business/DataGrid/TableView.tsx           | 52 +++++++++++++++++-
 .../business/DataGrid/tableView/utils.ts      | 36 ++++++++++++
 .../DataGrid/tableView/utils.unit.test.ts     | 55 +++++++++++++++++++
 src/lib/i18n/locales/en.ts                    |  8 +++
 src/lib/i18n/locales/ja.ts                    |  9 +++
 src/lib/i18n/locales/zh.ts                    |  8 +++
 6 files changed, 167 insertions(+), 1 deletion(-)

diff --git a/src/components/business/DataGrid/TableView.tsx b/src/components/business/DataGrid/TableView.tsx
index 57969686..7ca53059 100644
--- a/src/components/business/DataGrid/TableView.tsx
+++ b/src/components/business/DataGrid/TableView.tsx
@@ -76,6 +76,7 @@ import {
   calculateAutoColumnWidths,
   canMutateClickHouseTable,
   collectSearchMatches,
+  createSingleAndDoubleClickHandler,
   escapeSQL,
   cellValueToString,
   formatCellValue,
@@ -180,6 +181,9 @@ export function TableView({
   const [columnWidths, setColumnWidths] = useState<Record<string, number>>({});
   const columnWidthsRef = useRef<Record<string, number>>({});
   columnWidthsRef.current = columnWidths;
+  const headerClickStateRef = useRef<
+    Record<string, { timerId: ReturnType<typeof setTimeout> | null }>
+  >({});
 
   // Reset column widths when columns definition changes (e.g. switching tables)
   const prevColumnsRef = useRef<string>("");
@@ -649,6 +653,26 @@ export function TableView({
     });
   }, []);
 
+  const handleHeaderCopy = useCallback(
+    (column: string) => {
+      void navigator.clipboard
+        .writeText(column)
+        .then(() => {
+          toast.success(
+            t("tableView.toast.columnNameCopied", {
+              column,
+            }),
+          );
+        })
+        .catch((error) => {
+          toast.error("Failed to copy", {
+            description: error instanceof Error ? error.message : String(error),
+          });
+        });
+    },
+    [t],
+  );
+
   const selectSingleRow = useCallback((rowIndex: number) => {
     const nextSelectedRows = new Set([rowIndex]);
     selectedRowsRef.current = nextSelectedRows;
@@ -1358,6 +1382,18 @@ export function TableView({
     document.body.style.cursor = "col-resize";
   };
 
+  useEffect(() => {
+    const clickStates = headerClickStateRef.current;
+    return () => {
+      Object.values(clickStates).forEach((state) => {
+        if (state.timerId) {
+          clearTimeout(state.timerId);
+          state.timerId = null;
+        }
+      });
+    };
+  }, []);
+
   useEffect(() => {
     return () => {
       document.removeEventListener("mousemove", handleMouseMove);
@@ -1935,6 +1971,17 @@ export function TableView({
                 const direction = isSorted ? activeSortDirection : undefined;
                 const comment = columnComments[column]?.trim();
                 const headerTooltip = comment || column;
+                const headerActionLabel = t("tableView.header.actionHint", {
+                  column,
+                });
+                const headerClickState =
+                  headerClickStateRef.current[column] ??
+                  (headerClickStateRef.current[column] = { timerId: null });
+                const headerInteraction = createSingleAndDoubleClickHandler(
+                  headerClickState,
+                  () => handleHeaderCopy(column),
+                  () => handleSortClick(column),
+                );
                 return (
                   <th
                     key={column}
@@ -1951,7 +1998,10 @@ export function TableView({
                       <button
                         type="button"
                         className="flex items-center gap-1 cursor-pointer hover:text-foreground transition-colors min-w-0 flex-1"
-                        onClick={() => handleSortClick(column)}
+                        title={`${headerTooltip}\n${headerActionLabel}`}
+                        aria-label={headerActionLabel}
+                        onClick={headerInteraction.handleClick}
+                        onDoubleClick={headerInteraction.handleDoubleClick}
                       >
                         <span className="truncate" title={headerTooltip}>
                           {column}
diff --git a/src/components/business/DataGrid/tableView/utils.ts b/src/components/business/DataGrid/tableView/utils.ts
index c301a0c9..3ed607f1 100644
--- a/src/components/business/DataGrid/tableView/utils.ts
+++ b/src/components/business/DataGrid/tableView/utils.ts
@@ -14,6 +14,42 @@ export interface InsertColumnMeta {
   primaryKey?: boolean;
 }
 
+export interface HeaderInteractionState {
+  timerId: ReturnType<typeof setTimeout> | null;
+}
+
+export function createSingleAndDoubleClickHandler(
+  state: HeaderInteractionState,
+  onSingleClick: () => void,
+  onDoubleClick: () => void,
+  delayMs = 250,
+) {
+  return {
+    handleClick() {
+      if (state.timerId) {
+        clearTimeout(state.timerId);
+      }
+      state.timerId = setTimeout(() => {
+        state.timerId = null;
+        onSingleClick();
+      }, delayMs);
+    },
+    handleDoubleClick() {
+      if (state.timerId) {
+        clearTimeout(state.timerId);
+        state.timerId = null;
+      }
+      onDoubleClick();
+    },
+    cancelPendingClick() {
+      if (state.timerId) {
+        clearTimeout(state.timerId);
+        state.timerId = null;
+      }
+    },
+  };
+}
+
 export function isInsertColumnRequired(
   column: Pick<InsertColumnMeta, "nullable" | "defaultValue">,
 ): boolean {
diff --git a/src/components/business/DataGrid/tableView/utils.unit.test.ts b/src/components/business/DataGrid/tableView/utils.unit.test.ts
index ea7b3369..86449a3e 100644
--- a/src/components/business/DataGrid/tableView/utils.unit.test.ts
+++ b/src/components/business/DataGrid/tableView/utils.unit.test.ts
@@ -5,6 +5,7 @@ import {
   calculateAutoColumnWidths,
   canMutateClickHouseTable,
   collectSearchMatches,
+  createSingleAndDoubleClickHandler,
   escapeSQL,
   formatCellValue,
   formatInsertSQLValue,
@@ -271,6 +272,60 @@ describe("sortRows", () => {
   });
 });
 
+describe("createSingleAndDoubleClickHandler", () => {
+  test("runs single-click action after delay", async () => {
+    const calls: string[] = [];
+    const state = { timerId: null };
+    const handler = createSingleAndDoubleClickHandler(
+      state,
+      () => calls.push("copy"),
+      () => calls.push("sort"),
+      10,
+    );
+
+    handler.handleClick();
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(calls).toEqual(["copy"]);
+    expect(state.timerId).toBeNull();
+  });
+
+  test("double click cancels pending single-click action", () => {
+    const calls: string[] = [];
+    const state = { timerId: null };
+    const handler = createSingleAndDoubleClickHandler(
+      state,
+      () => calls.push("copy"),
+      () => calls.push("sort"),
+      20,
+    );
+
+    handler.handleClick();
+    handler.handleDoubleClick();
+
+    expect(calls).toEqual(["sort"]);
+    expect(state.timerId).toBeNull();
+  });
+
+  test("cancelPendingClick clears pending single-click action", async () => {
+    const calls: string[] = [];
+    const state = { timerId: null };
+    const handler = createSingleAndDoubleClickHandler(
+      state,
+      () => calls.push("copy"),
+      () => calls.push("sort"),
+      10,
+    );
+
+    handler.handleClick();
+    handler.cancelPendingClick();
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(calls).toEqual([]);
+    expect(state.timerId).toBeNull();
+  });
+});
+
 describe("collectSearchMatches", () => {
   const data = [
     { id: 1, name: "Alice" },
diff --git a/src/lib/i18n/locales/en.ts b/src/lib/i18n/locales/en.ts
index d9944565..f3d28b89 100644
--- a/src/lib/i18n/locales/en.ts
+++ b/src/lib/i18n/locales/en.ts
@@ -429,6 +429,14 @@ export const en = {
     },
     untitled: "Untitled",
   },
+  tableView: {
+    header: {
+      actionHint: "Click to copy column name, double-click to sort {{column}}",
+    },
+    toast: {
+      columnNameCopied: "Copied column name: {{column}}",
+    },
+  },
 } as const;
 
 type DeepStringify<T> = {
diff --git a/src/lib/i18n/locales/ja.ts b/src/lib/i18n/locales/ja.ts
index e44de40e..c9b5c548 100644
--- a/src/lib/i18n/locales/ja.ts
+++ b/src/lib/i18n/locales/ja.ts
@@ -390,6 +390,15 @@ export const ja: Translations = {
     send: "送信",
     sendMessage: "メッセージを送信",
   },
+  tableView: {
+    header: {
+      actionHint:
+        "{{column}} をクリックで列名コピー、ダブルクリックで並び替え",
+    },
+    toast: {
+      columnNameCopied: "列名をコピーしました: {{column}}",
+    },
+  },
   tableSelector: {
     emptyLabel: "テーブルスキーマを選択（データなし）",
     selectedLabel: "スキーマ: {{count}} 件選択中",
diff --git a/src/lib/i18n/locales/zh.ts b/src/lib/i18n/locales/zh.ts
index f4eb2468..af01d678 100644
--- a/src/lib/i18n/locales/zh.ts
+++ b/src/lib/i18n/locales/zh.ts
@@ -375,6 +375,14 @@ export const zh: Translations = {
     send: "发送",
     sendMessage: "发送消息",
   },
+  tableView: {
+    header: {
+      actionHint: "单击复制字段名，双击按 {{column}} 排序",
+    },
+    toast: {
+      columnNameCopied: "已复制字段名：{{column}}",
+    },
+  },
   tableSelector: {
     emptyLabel: "选择表结构（不含数据）",
     selectedLabel: "已选结构：{{count}} 项",

From b2e52430f08c560821d16b60d2405cd358b838b2 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Thu, 9 Apr 2026 20:41:56 +0800
Subject: [PATCH 08/15] Refine data grid toolbar labels

---
 .../business/DataGrid/TableView.tsx           | 63 +++++++++----------
 1 file changed, 31 insertions(+), 32 deletions(-)

diff --git a/src/components/business/DataGrid/TableView.tsx b/src/components/business/DataGrid/TableView.tsx
index 7ca53059..511c377f 100644
--- a/src/components/business/DataGrid/TableView.tsx
+++ b/src/components/business/DataGrid/TableView.tsx
@@ -1711,22 +1711,35 @@ export function TableView({
 
             <div className="flex items-center gap-1.5">
               {tableContext && onCreateQuery && (
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-6 gap-1 px-2 text-xs hover:bg-muted/60"
-                  onClick={() =>
-                    onCreateQuery(
-                      tableContext.connectionId,
-                      tableContext.database,
-                      tableContext.driver,
-                    )
-                  }
-                  title={t("connection.menu.newQuery")}
-                >
-                  <SquareTerminal className="w-3.5 h-3.5" />
-                  {t("connection.menu.newQuery")}
-                </Button>
+                <>
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    className="h-6 gap-1 px-2 text-xs hover:bg-muted/60"
+                    onClick={() =>
+                      onCreateQuery(
+                        tableContext.connectionId,
+                        tableContext.database,
+                        tableContext.driver,
+                      )
+                    }
+                    title={t("connection.menu.newQuery")}
+                  >
+                    <SquareTerminal className="w-3.5 h-3.5" />
+                    {t("connection.menu.newQuery")}
+                  </Button>
+
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    className="h-6 gap-1 px-2 hover:bg-muted/60"
+                    onClick={handleShowDDL}
+                    title="View Table Structure (DDL)"
+                  >
+                    <FileCode className="w-3.5 h-3.5" />
+                    <span className="text-xs font-medium leading-none">ddl</span>
+                  </Button>
+                </>
               )}
               {(canInsert || canUpdateDelete) && (
                 <>
@@ -1734,20 +1747,19 @@ export function TableView({
                     <Button
                       variant="ghost"
                       size="sm"
-                      className="h-6 gap-1 px-2 text-xs hover:bg-muted/60"
+                      className="h-6 w-6 p-0 hover:bg-muted/60"
                       onClick={handleAddDraftRow}
                       disabled={isSaving || isDeleting}
                       title="Add a new row draft"
                     >
                       <Plus className="w-3.5 h-3.5" />
-                      Add
                     </Button>
                   )}
                   {canUpdateDelete && (
                     <Button
                       variant="ghost"
                       size="sm"
-                      className="h-6 gap-1 px-2 text-xs hover:bg-destructive/10 text-destructive disabled:text-muted-foreground"
+                      className="h-6 w-6 p-0 hover:bg-destructive/10 text-destructive disabled:text-muted-foreground"
                       onClick={() => setDeleteDialogOpen(true)}
                       disabled={!selectedRows.size || isSaving || isDeleting}
                       title={
@@ -1757,7 +1769,6 @@ export function TableView({
                       }
                     >
                       <Trash2 className="w-3.5 h-3.5" />
-                      Delete
                     </Button>
                   )}
                 </>
@@ -1880,18 +1891,6 @@ export function TableView({
                   </DropdownMenuSub>
                 </DropdownMenuContent>
               </DropdownMenu>
-
-              {tableContext && (
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-6 w-6 p-0 hover:bg-muted/60"
-                  onClick={handleShowDDL}
-                  title="View Table Structure (DDL)"
-                >
-                  <FileCode className="w-3.5 h-3.5" />
-                </Button>
-              )}
             </div>
           </div>
 

From 20a2d73751d0a2fb6bd840d95b66703cb4d4cf56 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Thu, 9 Apr 2026 21:01:50 +0800
Subject: [PATCH 09/15] Restore desktop debug entrypoints

---
 src-tauri/Cargo.toml |  2 +-
 src-tauri/src/lib.rs | 33 ++++++++++++++++++++++++++++++++-
 src/main.tsx         |  6 +++---
 3 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 76ff1e4c..0fe96189 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -18,7 +18,7 @@ crate-type = ["staticlib", "cdylib", "rlib"]
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = [] }
+tauri = { version = "2", features = ["devtools"] }
 tauri-plugin-opener = "2"
 tauri-plugin-dialog = "2"
 tauri-plugin-fs = "2"
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 7f1d7d6b..e23ab94e 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -22,6 +22,18 @@ pub fn run() {
         .on_menu_event(|app, event| {
             if event.id() == "settings" {
                 let _ = app.emit("open-settings", ());
+            } else if event.id() == "debug_reload" {
+                if let Some(window) = app.get_webview_window("main") {
+                    let _ = window.reload();
+                }
+            } else if event.id() == "debug_toggle_devtools" {
+                if let Some(window) = app.get_webview_window("main") {
+                    if window.is_devtools_open() {
+                        window.close_devtools();
+                    } else {
+                        window.open_devtools();
+                    }
+                }
             }
         })
         .manage(AppState::new())
@@ -35,6 +47,7 @@ pub fn run() {
                 if let Err(e) = (|| -> tauri::Result<()> {
                     let app_menu = Submenu::new(&handle, "App", true)?;
                     let edit_menu = Submenu::new(&handle, "Edit", true)?;
+                    let developer_menu = Submenu::new(&handle, "Developer", true)?;
 
                     let about = PredefinedMenuItem::about(&handle, None, None)?;
                     let settings = MenuItem::with_id(
@@ -69,6 +82,20 @@ pub fn run() {
                     let copy = PredefinedMenuItem::copy(&handle, None)?;
                     let paste = PredefinedMenuItem::paste(&handle, None)?;
                     let select_all = PredefinedMenuItem::select_all(&handle, None)?;
+                    let reload = MenuItem::with_id(
+                        &handle,
+                        "debug_reload",
+                        "Reload",
+                        true,
+                        Some("CmdOrCtrl+R"),
+                    )?;
+                    let toggle_devtools = MenuItem::with_id(
+                        &handle,
+                        "debug_toggle_devtools",
+                        "Toggle DevTools",
+                        true,
+                        Some("Alt+CmdOrCtrl+I"),
+                    )?;
 
                     edit_menu.append(&undo)?;
                     edit_menu.append(&redo)?;
@@ -78,7 +105,11 @@ pub fn run() {
                     edit_menu.append(&paste)?;
                     edit_menu.append(&select_all)?;
 
-                    let menu = Menu::with_items(&handle, &[&app_menu, &edit_menu])?;
+                    developer_menu.append(&reload)?;
+                    developer_menu.append(&toggle_devtools)?;
+
+                    let menu =
+                        Menu::with_items(&handle, &[&app_menu, &edit_menu, &developer_menu])?;
                     app.set_menu(menu)?;
                     Ok(())
                 })() {
diff --git a/src/main.tsx b/src/main.tsx
index 5c4af3e8..af07b995 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -12,9 +12,9 @@ const renderApp = async () => {
   if (import.meta.env.PROD) {
     document.addEventListener("contextmenu", (event) => {
       const target = event.target as HTMLElement | null;
-      const allowNative = target?.closest(
-        'input, textarea, [contenteditable="true"]',
-      );
+      const allowNative =
+        event.altKey ||
+        target?.closest('input, textarea, [contenteditable="true"]');
       if (!allowNative) {
         event.preventDefault();
       }

From 056ff81b27c6ee5ff80e5e57b0112580c45fd030 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Fri, 10 Apr 2026 18:06:21 +0800
Subject: [PATCH 10/15] fix(ci): pin bun version to 1.3.10 to fix lockfile
 mismatch

Freeze bun version to match local development environment,
preventing --frozen-lockfile errors due to version differences.
---
 .github/workflows/build-multiplatform.yml | 2 +-
 .github/workflows/ci.yml                  | 4 ++--
 .github/workflows/release.yml             | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build-multiplatform.yml b/.github/workflows/build-multiplatform.yml
index 79c4d0c8..fc21034d 100644
--- a/.github/workflows/build-multiplatform.yml
+++ b/.github/workflows/build-multiplatform.yml
@@ -30,7 +30,7 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: '1.3.10'
 
       - name: Cache Bun dependencies
         uses: actions/cache@v4
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 29a31554..b612f621 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,7 +22,7 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: '1.3.10'
 
       - name: Cache Bun dependencies
         uses: actions/cache@v4
@@ -76,7 +76,7 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: '1.3.10'
 
       - name: Cache Bun dependencies
         uses: actions/cache@v4
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 167de31a..aed62e3c 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -120,7 +120,7 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: '1.3.10'
 
       - name: Cache Bun dependencies
         uses: actions/cache@v4

From 4270ae7e5639902ebb8030ea99c866cf690c222a Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Fri, 10 Apr 2026 18:10:27 +0800
Subject: [PATCH 11/15] Fix SQL script parsing across drivers

---
 src-tauri/src/commands/query.rs               |  70 +++
 src-tauri/src/commands/transfer.rs            | 573 +++++++++++++++++-
 src-tauri/src/db/drivers/postgres.rs          |  73 +++
 .../mysql_stateful_command_integration.rs     | 102 ++++
 src-tauri/tests/oracle_command_integration.rs | 106 +++-
 .../postgres_stateful_command_integration.rs  | 104 ++++
 src-tauri/tests/sqlite_command_integration.rs | 113 +++-
 7 files changed, 1130 insertions(+), 11 deletions(-)

diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
index 196a61f6..a4ce0f82 100644
--- a/src-tauri/src/commands/query.rs
+++ b/src-tauri/src/commands/query.rs
@@ -76,6 +76,39 @@ fn skip_backtick_quote(bytes: &[u8], mut i: usize) -> usize {
     i
 }
 
+fn parse_dollar_quote_tag(bytes: &[u8], start: usize) -> Option<usize> {
+    if bytes.get(start) != Some(&b'$') {
+        return None;
+    }
+    let mut i = start + 1;
+    while i < bytes.len() && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
+        i += 1;
+    }
+    if bytes.get(i) == Some(&b'$') {
+        Some(i)
+    } else {
+        None
+    }
+}
+
+fn skip_dollar_quote(bytes: &[u8], start: usize) -> usize {
+    let Some(tag_end) = parse_dollar_quote_tag(bytes, start) else {
+        return start + 1;
+    };
+    let tag = &bytes[start..=tag_end];
+    let tag_len = tag.len();
+    let mut i = tag_end + 1;
+
+    while i + tag_len <= bytes.len() {
+        if &bytes[i..i + tag_len] == tag {
+            return i + tag_len;
+        }
+        i += 1;
+    }
+
+    bytes.len()
+}
+
 fn skip_line_comment(bytes: &[u8], mut i: usize) -> usize {
     i += 2;
     while i < bytes.len() && bytes[i] != b'\n' {
@@ -148,6 +181,13 @@ fn is_single_statement(sql: &str) -> bool {
             i = skip_backtick_quote(bytes, i);
             continue;
         }
+        if b == b'$' {
+            let next = skip_dollar_quote(bytes, i);
+            if next != i + 1 {
+                i = next;
+                continue;
+            }
+        }
         if b == b'(' {
             depth += 1;
             i += 1;
@@ -216,6 +256,13 @@ fn collect_top_level_keywords(sql: &str) -> Vec<String> {
             i = skip_backtick_quote(bytes, i);
             continue;
         }
+        if b == b'$' {
+            let next = skip_dollar_quote(bytes, i);
+            if next != i + 1 {
+                i = next;
+                continue;
+            }
+        }
         if b == b'(' {
             depth += 1;
             i += 1;
@@ -338,6 +385,13 @@ fn has_top_level_limit(sql: &str) -> bool {
             i = skip_backtick_quote(bytes, i);
             continue;
         }
+        if b == b'$' {
+            let next = skip_dollar_quote(bytes, i);
+            if next != i + 1 {
+                i = next;
+                continue;
+            }
+        }
         if b == b'(' {
             depth += 1;
             i += 1;
@@ -1215,6 +1269,12 @@ mod tests {
         assert!(is_single_statement("SELECT 'a; b'"));
         assert!(is_single_statement("SELECT \"a; b\""));
         assert!(is_single_statement("SELECT `a; b`"));
+        assert!(is_single_statement(
+            "CREATE FUNCTION f() RETURNS void AS $$ BEGIN PERFORM 1; END; $$ LANGUAGE plpgsql;"
+        ));
+        assert!(is_single_statement(
+            "CREATE FUNCTION f() RETURNS text AS $tag$ BEGIN RETURN ';'; END; $tag$ LANGUAGE plpgsql;"
+        ));
         assert!(!is_single_statement("SELECT 1; SELECT 2"));
     }
 
@@ -1234,6 +1294,16 @@ mod tests {
         assert!(tokens.contains(&"from".to_string()));
     }
 
+    #[test]
+    fn collect_top_level_keywords_skips_dollar_quoted_bodies() {
+        let tokens = collect_top_level_keywords(
+            "CREATE FUNCTION f() RETURNS void AS $$ BEGIN SELECT 1; END; $$ LANGUAGE plpgsql",
+        );
+        assert_eq!(tokens.first().map(String::as_str), Some("create"));
+        assert!(tokens.contains(&"function".to_string()));
+        assert!(!tokens.iter().any(|token| token == "begin" || token == "end"));
+    }
+
     #[test]
     fn statement_kind_for_limit_guard_classifies_with_queries() {
         assert_eq!(
diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
index 8b8139bb..9d73d514 100644
--- a/src-tauri/src/commands/transfer.rs
+++ b/src-tauri/src/commands/transfer.rs
@@ -931,19 +931,469 @@ enum SqlScanState {
     BlockComment,
 }
 
+fn starts_with_chars(chars: &[char], idx: usize, needle: &[char]) -> bool {
+    if idx + needle.len() > chars.len() {
+        return false;
+    }
+    for (offset, ch) in needle.iter().enumerate() {
+        if chars[idx + offset] != *ch {
+            return false;
+        }
+    }
+    true
+}
+
+fn line_start_index(chars: &[char], idx: usize) -> usize {
+    let mut start = idx;
+    while start > 0 && chars[start - 1] != '\n' {
+        start -= 1;
+    }
+    start
+}
+
+fn parse_mysql_delimiter_command(chars: &[char], idx: usize) -> Option<(String, usize)> {
+    let line_start = line_start_index(chars, idx);
+    let mut cursor = line_start;
+    while cursor < chars.len() && matches!(chars[cursor], ' ' | '\t' | '\r') {
+        cursor += 1;
+    }
+    if cursor != idx {
+        return None;
+    }
+
+    let keyword: Vec<char> = "DELIMITER".chars().collect();
+    if !starts_with_chars(chars, cursor, &keyword) {
+        return None;
+    }
+
+    let mut after_keyword = cursor + keyword.len();
+    if after_keyword < chars.len() && chars[after_keyword] != ' ' && chars[after_keyword] != '\t' {
+        return None;
+    }
+    while after_keyword < chars.len() && matches!(chars[after_keyword], ' ' | '\t') {
+        after_keyword += 1;
+    }
+    if after_keyword >= chars.len() || matches!(chars[after_keyword], '\n' | '\r') {
+        return None;
+    }
+
+    let mut line_end = after_keyword;
+    while line_end < chars.len() && !matches!(chars[line_end], '\n' | '\r') {
+        line_end += 1;
+    }
+
+    let delimiter: String = chars[after_keyword..line_end]
+        .iter()
+        .collect::<String>()
+        .trim()
+        .to_string();
+    if delimiter.is_empty() {
+        return None;
+    }
+
+    let mut next_idx = line_end;
+    if next_idx < chars.len() && chars[next_idx] == '\r' {
+        next_idx += 1;
+    }
+    if next_idx < chars.len() && chars[next_idx] == '\n' {
+        next_idx += 1;
+    }
+
+    Some((delimiter, next_idx))
+}
+
+fn sqlite_trigger_state(sql: &str) -> (bool, bool) {
+    let chars: Vec<char> = sql.chars().collect();
+    let mut state = SqlScanState::Normal;
+    let mut i = 0usize;
+    let mut tokens = Vec::new();
+    let mut trigger_begin_seen = false;
+    let mut trigger_block_depth = 0i32;
+    let mut case_depth = 0i32;
+    let mut last_word: Option<String> = None;
+
+    while i < chars.len() {
+        match &state {
+            SqlScanState::Normal => {
+                let ch = chars[i];
+                let next = chars.get(i + 1).copied();
+                if ch == '-' && next == Some('-') {
+                    state = SqlScanState::LineComment;
+                    i += 2;
+                    continue;
+                }
+                if ch == '/' && next == Some('*') {
+                    state = SqlScanState::BlockComment;
+                    i += 2;
+                    continue;
+                }
+                if ch == '\'' {
+                    state = SqlScanState::SingleQuoted;
+                    i += 1;
+                    continue;
+                }
+                if ch == '"' {
+                    state = SqlScanState::DoubleQuoted;
+                    i += 1;
+                    continue;
+                }
+                if ch == '`' {
+                    state = SqlScanState::BacktickQuoted;
+                    i += 1;
+                    continue;
+                }
+                if ch.is_ascii_alphabetic() || ch == '_' {
+                    let start = i;
+                    i += 1;
+                    while i < chars.len() && (chars[i].is_ascii_alphanumeric() || chars[i] == '_') {
+                        i += 1;
+                    }
+                    let token = chars[start..i]
+                        .iter()
+                        .collect::<String>()
+                        .to_ascii_lowercase();
+                    tokens.push(token.clone());
+
+                    if trigger_begin_seen {
+                        match token.as_str() {
+                            "case" => case_depth += 1,
+                            "begin" => trigger_block_depth += 1,
+                            "end" => {
+                                if case_depth > 0 {
+                                    case_depth -= 1;
+                                } else if trigger_block_depth > 0 {
+                                    trigger_block_depth -= 1;
+                                }
+                            }
+                            _ => {}
+                        }
+                    } else if token == "begin" {
+                        let is_create_trigger = matches!(
+                            tokens.as_slice(),
+                            [first, second, ..] if first == "create"
+                                && (second == "trigger"
+                                    || ((second == "temp" || second == "temporary")
+                                        && tokens.get(2).map(String::as_str) == Some("trigger")))
+                        );
+                        if is_create_trigger {
+                            trigger_begin_seen = true;
+                            trigger_block_depth = 1;
+                        }
+                    }
+
+                    last_word = Some(token);
+                    continue;
+                }
+                i += 1;
+            }
+            SqlScanState::SingleQuoted => {
+                if chars[i] == '\\' && chars.get(i + 1).is_some() {
+                    i += 2;
+                    continue;
+                }
+                if chars[i] == '\'' {
+                    if chars.get(i + 1) == Some(&'\'') {
+                        i += 2;
+                        continue;
+                    }
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::DoubleQuoted => {
+                if chars[i] == '"' {
+                    if chars.get(i + 1) == Some(&'"') {
+                        i += 2;
+                        continue;
+                    }
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::BacktickQuoted => {
+                if chars[i] == '`' {
+                    if chars.get(i + 1) == Some(&'`') {
+                        i += 2;
+                        continue;
+                    }
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::LineComment => {
+                if chars[i] == '\n' {
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::BlockComment => {
+                if chars[i] == '*' && chars.get(i + 1) == Some(&'/') {
+                    state = SqlScanState::Normal;
+                    i += 2;
+                } else {
+                    i += 1;
+                }
+            }
+            SqlScanState::DollarQuoted(_) => {
+                state = SqlScanState::Normal;
+            }
+        }
+    }
+
+    let is_trigger = trigger_begin_seen;
+    let ready_to_terminate = is_trigger
+        && trigger_block_depth == 0
+        && case_depth == 0
+        && last_word.as_deref() == Some("end");
+    (is_trigger, ready_to_terminate)
+}
+
+fn oracle_plsql_state(sql: &str) -> (bool, bool) {
+    let chars: Vec<char> = sql.chars().collect();
+    let mut state = SqlScanState::Normal;
+    let mut i = 0usize;
+    let mut tokens = Vec::new();
+    let mut block_depth = 0i32;
+    let mut case_depth = 0i32;
+    let mut last_word: Option<String> = None;
+    let mut is_oracle_block = false;
+
+    while i < chars.len() {
+        match &state {
+            SqlScanState::Normal => {
+                let ch = chars[i];
+                let next = chars.get(i + 1).copied();
+                if ch == '-' && next == Some('-') {
+                    state = SqlScanState::LineComment;
+                    i += 2;
+                    continue;
+                }
+                if ch == '/' && next == Some('*') {
+                    state = SqlScanState::BlockComment;
+                    i += 2;
+                    continue;
+                }
+                if ch == '\'' {
+                    state = SqlScanState::SingleQuoted;
+                    i += 1;
+                    continue;
+                }
+                if ch == '"' {
+                    state = SqlScanState::DoubleQuoted;
+                    i += 1;
+                    continue;
+                }
+                if ch == '`' {
+                    state = SqlScanState::BacktickQuoted;
+                    i += 1;
+                    continue;
+                }
+                if ch.is_ascii_alphabetic() || ch == '_' {
+                    let start = i;
+                    i += 1;
+                    while i < chars.len() && (chars[i].is_ascii_alphanumeric() || chars[i] == '_') {
+                        i += 1;
+                    }
+                    let token = chars[start..i]
+                        .iter()
+                        .collect::<String>()
+                        .to_ascii_lowercase();
+                    tokens.push(token.clone());
+
+                    if !is_oracle_block {
+                        let second = tokens.get(1).map(String::as_str);
+                        let third = tokens.get(2).map(String::as_str);
+                        let fourth = tokens.get(3).map(String::as_str);
+                        is_oracle_block =
+                            matches!(tokens.first().map(String::as_str), Some("declare") | Some("begin"))
+                                || (tokens.first().map(String::as_str) == Some("create")
+                                    && second == Some("or")
+                                    && third == Some("replace")
+                                    && matches!(
+                                        fourth,
+                                        Some("function")
+                                            | Some("procedure")
+                                            | Some("trigger")
+                                            | Some("package")
+                                            | Some("type")
+                                    ));
+                    }
+
+                    if is_oracle_block {
+                        match token.as_str() {
+                            "case" => case_depth += 1,
+                            "begin" => block_depth += 1,
+                            "end" => {
+                                if case_depth > 0 {
+                                    case_depth -= 1;
+                                } else if block_depth > 0 {
+                                    block_depth -= 1;
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+
+                    last_word = Some(token);
+                    continue;
+                }
+                i += 1;
+            }
+            SqlScanState::SingleQuoted => {
+                if chars[i] == '\\' && chars.get(i + 1).is_some() {
+                    i += 2;
+                    continue;
+                }
+                if chars[i] == '\'' {
+                    if chars.get(i + 1) == Some(&'\'') {
+                        i += 2;
+                        continue;
+                    }
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::DoubleQuoted => {
+                if chars[i] == '"' {
+                    if chars.get(i + 1) == Some(&'"') {
+                        i += 2;
+                        continue;
+                    }
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::BacktickQuoted => {
+                if chars[i] == '`' {
+                    if chars.get(i + 1) == Some(&'`') {
+                        i += 2;
+                        continue;
+                    }
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::LineComment => {
+                if chars[i] == '\n' {
+                    state = SqlScanState::Normal;
+                }
+                i += 1;
+            }
+            SqlScanState::BlockComment => {
+                if chars[i] == '*' && chars.get(i + 1) == Some(&'/') {
+                    state = SqlScanState::Normal;
+                    i += 2;
+                } else {
+                    i += 1;
+                }
+            }
+            SqlScanState::DollarQuoted(_) => {
+                state = SqlScanState::Normal;
+            }
+        }
+    }
+
+    let ready_to_terminate =
+        is_oracle_block && block_depth == 0 && case_depth == 0 && last_word.as_deref() == Some("end");
+    (is_oracle_block, ready_to_terminate)
+}
+
+fn parse_oracle_slash_terminator(chars: &[char], idx: usize) -> Option<usize> {
+    let line_start = line_start_index(chars, idx);
+    let mut cursor = line_start;
+    while cursor < chars.len() && matches!(chars[cursor], ' ' | '\t' | '\r') {
+        cursor += 1;
+    }
+    if cursor != idx || chars.get(idx) != Some(&'/') {
+        return None;
+    }
+
+    let mut line_end = idx + 1;
+    while line_end < chars.len() && !matches!(chars[line_end], '\n' | '\r') {
+        if !matches!(chars[line_end], ' ' | '\t') {
+            return None;
+        }
+        line_end += 1;
+    }
+
+    let mut next_idx = line_end;
+    if next_idx < chars.len() && chars[next_idx] == '\r' {
+        next_idx += 1;
+    }
+    if next_idx < chars.len() && chars[next_idx] == '\n' {
+        next_idx += 1;
+    }
+
+    Some(next_idx)
+}
+
 fn parse_sql_statements(sql: &str, driver: &str) -> Result<Vec<String>, String> {
     let mysql_style_hash_comment = matches!(driver, "mysql" | "mariadb" | "tidb");
+    let mysql_style_delimiter = mysql_style_hash_comment;
+    let sqlite_style_trigger = driver == "sqlite";
+    let oracle_style_block = driver == "oracle";
     let chars: Vec<char> = sql.chars().collect();
     let mut out = Vec::new();
     let mut current = String::new();
     let mut state = SqlScanState::Normal;
+    let mut delimiter = ";".to_string();
     let mut i = 0usize;
 
     while i < chars.len() {
         match &state {
             SqlScanState::Normal => {
+                if mysql_style_delimiter {
+                    if let Some((next_delimiter, next_idx)) = parse_mysql_delimiter_command(&chars, i)
+                    {
+                        delimiter = next_delimiter;
+                        i = next_idx;
+                        continue;
+                    }
+                }
+                if oracle_style_block {
+                    if let Some(next_idx) = parse_oracle_slash_terminator(&chars, i) {
+                        let (is_block, ready_to_terminate) = oracle_plsql_state(current.trim());
+                        if is_block && ready_to_terminate {
+                            let statement = current.trim();
+                            if !statement.is_empty() {
+                                out.push(statement.to_string());
+                            }
+                            current.clear();
+                            i = next_idx;
+                            continue;
+                        }
+                    }
+                }
+
                 let ch = chars[i];
                 let next = chars.get(i + 1).copied();
+                let delimiter_chars: Vec<char> = delimiter.chars().collect();
+
+                if starts_with_chars(&chars, i, &delimiter_chars) {
+                    if sqlite_style_trigger && delimiter == ";" {
+                        let (is_trigger, ready_to_terminate) = sqlite_trigger_state(current.trim());
+                        if is_trigger && !ready_to_terminate {
+                            current.push(ch);
+                            i += delimiter_chars.len();
+                            continue;
+                        }
+                    }
+                    if oracle_style_block && delimiter == ";" {
+                        let (is_block, _) = oracle_plsql_state(current.trim());
+                        if is_block {
+                            current.push(ch);
+                            i += delimiter_chars.len();
+                            continue;
+                        }
+                    }
+                    let statement = current.trim();
+                    if !statement.is_empty() {
+                        out.push(statement.to_string());
+                    }
+                    current.clear();
+                    i += delimiter_chars.len();
+                    continue;
+                }
 
                 if ch == '-' && next == Some('-') {
                     state = SqlScanState::LineComment;
@@ -986,15 +1436,6 @@ fn parse_sql_statements(sql: &str, driver: &str) -> Result<Vec<String>, String>
                         continue;
                     }
                 }
-                if ch == ';' {
-                    let statement = current.trim();
-                    if !statement.is_empty() {
-                        out.push(statement.to_string());
-                    }
-                    current.clear();
-                    i += 1;
-                    continue;
-                }
                 current.push(ch);
                 i += 1;
             }
@@ -1560,6 +2001,120 @@ mod tests {
         assert_eq!(statements[1], "SELECT '#not_comment'");
     }
 
+    #[test]
+    fn parse_sql_statements_supports_mysql_delimiter_blocks() {
+        let sql = r#"
+            DELIMITER $$
+            CREATE PROCEDURE p_demo()
+            BEGIN
+                SELECT 1;
+                SELECT 'semi;inside';
+            END$$
+            DELIMITER ;
+            SELECT 2;
+        "#;
+
+        let statements = parse_sql_statements(sql, "mysql").unwrap();
+        assert_eq!(statements.len(), 2);
+        assert!(statements[0].starts_with("CREATE PROCEDURE p_demo()"));
+        assert!(statements[0].contains("SELECT 1;"));
+        assert!(statements[0].contains("SELECT 'semi;inside';"));
+        assert_eq!(statements[1], "SELECT 2");
+    }
+
+    #[test]
+    fn parse_sql_statements_ignores_mysql_delimiter_inside_strings() {
+        let sql = r#"
+            DELIMITER //
+            CREATE TRIGGER trg_demo BEFORE INSERT ON demo
+            FOR EACH ROW
+            BEGIN
+                SET @note = 'DELIMITER // should stay';
+            END//
+            DELIMITER ;
+        "#;
+
+        let statements = parse_sql_statements(sql, "mysql").unwrap();
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].contains("DELIMITER // should stay"));
+        assert!(statements[0].contains("END"));
+    }
+
+    #[test]
+    fn parse_sql_statements_supports_sqlite_trigger_blocks() {
+        let sql = r#"
+            CREATE TRIGGER trg_demo
+            AFTER INSERT ON demo
+            BEGIN
+                INSERT INTO audit_log(message) VALUES ('first;value');
+                UPDATE demo SET touched_at = CURRENT_TIMESTAMP WHERE rowid = NEW.rowid;
+            END;
+            SELECT 1;
+        "#;
+
+        let statements = parse_sql_statements(sql, "sqlite").unwrap();
+        assert_eq!(statements.len(), 2);
+        assert!(statements[0].starts_with("CREATE TRIGGER trg_demo"));
+        assert!(statements[0].contains("VALUES ('first;value');"));
+        assert!(statements[0].contains("UPDATE demo SET touched_at = CURRENT_TIMESTAMP"));
+        assert_eq!(statements[1], "SELECT 1");
+    }
+
+    #[test]
+    fn parse_sql_statements_keeps_sqlite_case_end_inside_trigger_body() {
+        let sql = r#"
+            CREATE TRIGGER trg_case
+            AFTER UPDATE ON demo
+            BEGIN
+                UPDATE demo
+                SET status = CASE WHEN NEW.id > 10 THEN 'big' ELSE 'small' END;
+            END;
+        "#;
+
+        let statements = parse_sql_statements(sql, "sqlite").unwrap();
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].contains("CASE WHEN NEW.id > 10 THEN 'big' ELSE 'small' END;"));
+        assert!(statements[0].ends_with("END"));
+    }
+
+    #[test]
+    fn parse_sql_statements_supports_oracle_create_or_replace_blocks() {
+        let sql = r#"
+            CREATE OR REPLACE PROCEDURE p_demo IS
+            BEGIN
+                INSERT INTO audit_log(message) VALUES ('first;value');
+                UPDATE audit_log SET message = 'done' WHERE message = 'first;value';
+            END;
+            /
+            SELECT 1 FROM DUAL;
+        "#;
+
+        let statements = parse_sql_statements(sql, "oracle").unwrap();
+        assert_eq!(statements.len(), 2);
+        assert!(statements[0].starts_with("CREATE OR REPLACE PROCEDURE p_demo IS"));
+        assert!(statements[0].contains("VALUES ('first;value');"));
+        assert!(statements[0].contains("END;"));
+        assert_eq!(statements[1], "SELECT 1 FROM DUAL");
+    }
+
+    #[test]
+    fn parse_sql_statements_supports_oracle_case_end_inside_block() {
+        let sql = r#"
+            CREATE OR REPLACE FUNCTION f_demo RETURN VARCHAR2 IS
+                v_result VARCHAR2(10);
+            BEGIN
+                v_result := CASE WHEN 1 = 1 THEN 'yes' ELSE 'no' END;
+                RETURN v_result;
+            END;
+            /
+        "#;
+
+        let statements = parse_sql_statements(sql, "oracle").unwrap();
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].contains("CASE WHEN 1 = 1 THEN 'yes' ELSE 'no' END;"));
+        assert!(statements[0].ends_with("END;"));
+    }
+
     #[test]
     fn parse_mssql_batches_splits_on_go_lines_only() {
         let sql = r#"
diff --git a/src-tauri/src/db/drivers/postgres.rs b/src-tauri/src/db/drivers/postgres.rs
index ad351af4..7814ff21 100644
--- a/src-tauri/src/db/drivers/postgres.rs
+++ b/src-tauri/src/db/drivers/postgres.rs
@@ -364,6 +364,39 @@ fn skip_backtick_quote(bytes: &[u8], mut i: usize) -> usize {
     i
 }
 
+fn parse_dollar_quote_tag(bytes: &[u8], start: usize) -> Option<usize> {
+    if bytes.get(start) != Some(&b'$') {
+        return None;
+    }
+    let mut i = start + 1;
+    while i < bytes.len() && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
+        i += 1;
+    }
+    if bytes.get(i) == Some(&b'$') {
+        Some(i)
+    } else {
+        None
+    }
+}
+
+fn skip_dollar_quote(bytes: &[u8], start: usize) -> usize {
+    let Some(tag_end) = parse_dollar_quote_tag(bytes, start) else {
+        return start + 1;
+    };
+    let tag = &bytes[start..=tag_end];
+    let tag_len = tag.len();
+    let mut i = tag_end + 1;
+
+    while i + tag_len <= bytes.len() {
+        if &bytes[i..i + tag_len] == tag {
+            return i + tag_len;
+        }
+        i += 1;
+    }
+
+    bytes.len()
+}
+
 fn skip_line_comment(bytes: &[u8], mut i: usize) -> usize {
     i += 2;
     while i < bytes.len() && bytes[i] != b'\n' {
@@ -431,6 +464,13 @@ fn split_sql_statements(sql: &str) -> Vec<String> {
             i = skip_backtick_quote(bytes, i);
             continue;
         }
+        if b == b'$' {
+            let next = skip_dollar_quote(bytes, i);
+            if next != i + 1 {
+                i = next;
+                continue;
+            }
+        }
         if b == b'(' {
             depth += 1;
             i += 1;
@@ -1489,6 +1529,39 @@ CREATE TABLE pg_data_type_test (
         assert!(statements[1].starts_with("CREATE TABLE pg_data_type_test"));
     }
 
+    #[test]
+    fn test_split_sql_statements_keeps_postgres_dollar_quoted_function_intact() {
+        let sql = r#"
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER LANGUAGE PLPGSQL AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$;
+"#;
+        let statements = split_sql_statements(sql);
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].contains("NEW.updated_at = CURRENT_TIMESTAMP;"));
+        assert!(statements[0].ends_with("$$"));
+    }
+
+    #[test]
+    fn test_split_sql_statements_keeps_tagged_dollar_quoted_function_intact() {
+        let sql = r#"
+CREATE FUNCTION demo()
+RETURNS text LANGUAGE plpgsql AS $body$
+BEGIN
+    RETURN 'ok';
+END;
+$body$;
+"#;
+        let statements = split_sql_statements(sql);
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].contains("RETURN 'ok';"));
+        assert!(statements[0].ends_with("$body$"));
+    }
+
     #[test]
     fn test_is_high_precision_pg_type() {
         assert!(is_high_precision_pg_type("bigint", "int8"));
diff --git a/src-tauri/tests/mysql_stateful_command_integration.rs b/src-tauri/tests/mysql_stateful_command_integration.rs
index 07e7e767..bf6b893a 100644
--- a/src-tauri/tests/mysql_stateful_command_integration.rs
+++ b/src-tauri/tests/mysql_stateful_command_integration.rs
@@ -740,6 +740,108 @@ async fn test_mysql_command_transfer_export_and_import_minimal_flow() {
     let _ = connection::delete_connection_direct(&state, conn_id).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn test_mysql_command_import_sql_file_supports_delimiter_script() {
+    let docker = (!mysql_context::should_reuse_local_db()).then(Cli::default);
+    let (_mysql_container, form) = mysql_context::mysql_form_from_test_context(docker.as_ref());
+    wait_until_mysql_ready(&form).await;
+    let state = init_state_with_local_db().await;
+    let conn_id = create_mysql_connection_for_state(&state, &form, "import-delimiter").await;
+    let schema = form
+        .database
+        .clone()
+        .unwrap_or_else(|| "test_db".to_string());
+
+    let proc_table = unique_name("dbpaw_import_proc_tbl");
+    let audit_table = unique_name("dbpaw_import_audit_tbl");
+    let proc_name = unique_name("dbpaw_import_proc");
+    let trigger_name = unique_name("dbpaw_import_trg");
+    let base = std::env::temp_dir().join(unique_name("dbpaw_mysql_import_it"));
+    fs::create_dir_all(&base).expect("create temp transfer dir should succeed");
+    let import_sql_path = base.join("import.sql");
+
+    let import_sql = format!(
+        r#"
+CREATE TABLE `{proc_table}` (id INT PRIMARY KEY, name VARCHAR(64));
+CREATE TABLE `{audit_table}` (entry_id INT PRIMARY KEY AUTO_INCREMENT, source_id INT, action_name VARCHAR(32));
+DELIMITER $$
+CREATE PROCEDURE `{proc_name}`()
+BEGIN
+    INSERT INTO `{proc_table}` (id, name) VALUES (1, 'from_proc');
+END$$
+CREATE TRIGGER `{trigger_name}` AFTER INSERT ON `{proc_table}`
+FOR EACH ROW
+BEGIN
+    INSERT INTO `{audit_table}` (source_id, action_name) VALUES (NEW.id, 'insert');
+END$$
+DELIMITER ;
+"#
+    );
+    fs::write(&import_sql_path, import_sql).expect("write import sql file should succeed");
+
+    let import_result = transfer::import_sql_file_direct(
+        &state,
+        conn_id,
+        Some(schema.clone()),
+        import_sql_path.to_string_lossy().to_string(),
+        "mysql".to_string(),
+    )
+    .await
+    .expect("import_sql_file should succeed");
+    assert_eq!(
+        import_result.success_statements,
+        import_result.total_statements
+    );
+    assert!(import_result.error.is_none());
+
+    let driver = MysqlDriver::connect(&form)
+        .await
+        .expect("failed to connect mysql driver for verification");
+    driver
+        .execute_query(format!("CALL `{}`()", proc_name))
+        .await
+        .expect("call imported procedure should succeed");
+    driver
+        .execute_query(format!(
+            "INSERT INTO `{}` (id, name) VALUES (2, 'direct')",
+            proc_table
+        ))
+        .await
+        .expect("direct insert into imported mysql table should succeed");
+
+    let verify = driver
+        .execute_query(format!(
+            "SELECT COUNT(*) AS c FROM `{}`.`{}`",
+            schema, audit_table
+        ))
+        .await
+        .expect("verify mysql trigger should succeed");
+    let count = verify.data[0]["c"]
+        .as_str()
+        .and_then(|v| v.parse::<i64>().ok())
+        .expect("audit count should parse");
+    assert_eq!(count, 2);
+
+    let _ = driver
+        .execute_query(format!("DROP TRIGGER IF EXISTS `{}`", trigger_name))
+        .await;
+    let _ = driver
+        .execute_query(format!("DROP PROCEDURE IF EXISTS `{}`", proc_name))
+        .await;
+    let _ = driver
+        .execute_query(format!("DROP TABLE IF EXISTS `{}`.`{}`", schema, proc_table))
+        .await;
+    let _ = driver
+        .execute_query(format!("DROP TABLE IF EXISTS `{}`.`{}`", schema, audit_table))
+        .await;
+    driver.close().await;
+
+    let _ = fs::remove_file(import_sql_path);
+    let _ = fs::remove_dir_all(base);
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
+
 #[tokio::test]
 #[ignore]
 async fn test_mysql_command_ai_minimal_provider_conversation_and_chat_flow() {
diff --git a/src-tauri/tests/oracle_command_integration.rs b/src-tauri/tests/oracle_command_integration.rs
index 8ac73961..8ae950db 100644
--- a/src-tauri/tests/oracle_command_integration.rs
+++ b/src-tauri/tests/oracle_command_integration.rs
@@ -1,9 +1,13 @@
 #[path = "common/oracle_context.rs"]
 mod oracle_context;
 
-use dbpaw_lib::commands::{connection, metadata, query};
+use dbpaw_lib::commands::{connection, metadata, query, transfer};
 use dbpaw_lib::db::drivers::oracle::OracleDriver;
 use dbpaw_lib::db::drivers::DatabaseDriver;
+use dbpaw_lib::db::local::LocalDb;
+use dbpaw_lib::state::AppState;
+use std::fs;
+use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 fn unique_table_name(prefix: &str) -> String {
@@ -14,6 +18,31 @@ fn unique_table_name(prefix: &str) -> String {
     format!("{prefix}_{ms}")
 }
 
+async fn init_state_with_local_db() -> AppState {
+    let state = AppState::new();
+    let local_db_dir = std::env::temp_dir().join(unique_table_name("dbpaw_oracle_localdb_it"));
+    let db = LocalDb::init_with_app_dir(&local_db_dir)
+        .await
+        .expect("failed to initialize local db");
+    let mut lock = state.local_db.lock().await;
+    *lock = Some(Arc::new(db));
+    drop(lock);
+    state
+}
+
+async fn create_oracle_connection_for_state(
+    state: &AppState,
+    base_form: &dbpaw_lib::models::ConnectionForm,
+    suffix: &str,
+) -> i64 {
+    let mut form = base_form.clone();
+    form.name = Some(format!("oracle-stateful-{suffix}"));
+    let created = connection::create_connection_direct(state, form)
+        .await
+        .expect("create_connection should succeed");
+    created.id
+}
+
 async fn prepare_test_table(schema: &str, table: &str, form: &dbpaw_lib::models::ConnectionForm) {
     let driver = OracleDriver::connect(form)
         .await
@@ -254,6 +283,81 @@ async fn test_oracle_command_get_table_data_pagination_works() {
     cleanup_table(&schema, &table, &form).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn test_oracle_command_import_sql_file_supports_create_or_replace_script() {
+    let form = oracle_context::oracle_form_from_test_context();
+    let schema = form
+        .schema
+        .clone()
+        .expect("ORACLE_SCHEMA must be set")
+        .to_uppercase();
+    let state = init_state_with_local_db().await;
+    let conn_id = create_oracle_connection_for_state(&state, &form, "import-plsql").await;
+
+    let table = unique_table_name("DBPAW_IMPORT_ORA_TBL").to_uppercase();
+    let proc_name = unique_table_name("DBPAW_IMPORT_ORA_PROC").to_uppercase();
+    let base = std::env::temp_dir().join(unique_table_name("dbpaw_oracle_import_it"));
+    fs::create_dir_all(&base).expect("create temp transfer dir should succeed");
+    let import_sql_path = base.join("import.sql");
+
+    let import_sql = format!(
+        r#"
+CREATE TABLE "{schema}"."{table}" (id NUMBER(10) PRIMARY KEY, name VARCHAR2(64));
+CREATE OR REPLACE PROCEDURE "{schema}"."{proc_name}" IS
+BEGIN
+    INSERT INTO "{schema}"."{table}" (id, name) VALUES (1, 'from_proc');
+END;
+/
+"#
+    );
+    fs::write(&import_sql_path, import_sql).expect("write import sql file should succeed");
+
+    let import_result = transfer::import_sql_file_direct(
+        &state,
+        conn_id,
+        Some(schema.clone()),
+        import_sql_path.to_string_lossy().to_string(),
+        "oracle".to_string(),
+    )
+    .await
+    .expect("import_sql_file should succeed");
+    assert_eq!(
+        import_result.success_statements,
+        import_result.total_statements
+    );
+    assert!(import_result.error.is_none());
+
+    let driver = OracleDriver::connect(&form)
+        .await
+        .expect("connect for oracle import verification");
+    driver
+        .execute_query(format!(r#"BEGIN "{schema}"."{proc_name}"(); END;"#))
+        .await
+        .expect("calling imported oracle procedure should succeed");
+    let verify = driver
+        .execute_query(format!(r#"SELECT COUNT(*) AS C FROM "{schema}"."{table}""#))
+        .await
+        .expect("verify oracle imported procedure should succeed");
+    let count = verify.data[0]["C"]
+        .as_i64()
+        .or_else(|| verify.data[0]["C"].as_str().and_then(|v| v.parse::<i64>().ok()))
+        .expect("oracle count should be numeric");
+    assert_eq!(count, 1);
+
+    let _ = driver
+        .execute_query(format!(r#"DROP PROCEDURE "{schema}"."{proc_name}""#))
+        .await;
+    let _ = driver
+        .execute_query(format!(r#"DROP TABLE "{schema}"."{table}""#))
+        .await;
+    driver.close().await;
+
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+    let _ = fs::remove_file(import_sql_path);
+    let _ = fs::remove_dir_all(base);
+}
+
 #[tokio::test]
 #[ignore]
 async fn test_oracle_command_get_table_data_invalid_pagination_returns_error() {
diff --git a/src-tauri/tests/postgres_stateful_command_integration.rs b/src-tauri/tests/postgres_stateful_command_integration.rs
index fe1cc684..51385564 100644
--- a/src-tauri/tests/postgres_stateful_command_integration.rs
+++ b/src-tauri/tests/postgres_stateful_command_integration.rs
@@ -734,6 +734,110 @@ async fn test_postgres_command_transfer_export_and_import_minimal_flow() {
     let _ = connection::delete_connection_direct(&state, conn_id).await;
 }
 
+#[tokio::test]
+#[ignore]
+async fn test_postgres_command_import_sql_file_supports_function_trigger_script() {
+    let docker = (!postgres_context::should_reuse_local_db()).then(Cli::default);
+    let (_container, form) = postgres_context::postgres_form_from_test_context(docker.as_ref());
+    wait_until_postgres_ready(&form).await;
+    let state = init_state_with_local_db().await;
+    let conn_id = create_postgres_connection_for_state(&state, &form, "import-trigger").await;
+    let database = form
+        .database
+        .clone()
+        .unwrap_or_else(|| "postgres".to_string());
+    let schema = "public".to_string();
+    let table = unique_name("dbpaw_import_pg_tbl");
+    let func_name = unique_name("dbpaw_import_pg_fn");
+    let trigger_name = unique_name("dbpaw_import_pg_trg");
+    let qualified = format!("\"{}\".\"{}\"", schema, table);
+    let base = std::env::temp_dir().join(unique_name("dbpaw_postgres_import_it"));
+    fs::create_dir_all(&base).expect("create temp transfer dir should succeed");
+    let import_sql_path = base.join("import.sql");
+
+    let import_sql = format!(
+        r#"
+CREATE TABLE {qualified} (
+    id INT PRIMARY KEY,
+    name TEXT,
+    touch_count INT DEFAULT 0
+);
+CREATE OR REPLACE FUNCTION "{schema}"."{func_name}"()
+RETURNS TRIGGER LANGUAGE plpgsql AS $$
+BEGIN
+    NEW.touch_count = COALESCE(NEW.touch_count, 0) + 1;
+    RETURN NEW;
+END;
+$$;
+CREATE TRIGGER "{trigger_name}"
+BEFORE INSERT OR UPDATE ON {qualified}
+FOR EACH ROW
+EXECUTE FUNCTION "{schema}"."{func_name}"();
+"#
+    );
+    fs::write(&import_sql_path, import_sql).expect("write import sql file should succeed");
+
+    let import_result = transfer::import_sql_file_direct(
+        &state,
+        conn_id,
+        Some(database.clone()),
+        import_sql_path.to_string_lossy().to_string(),
+        "postgres".to_string(),
+    )
+    .await
+    .expect("import_sql_file should succeed");
+    assert_eq!(
+        import_result.success_statements,
+        import_result.total_statements
+    );
+    assert!(import_result.error.is_none());
+
+    let driver = PostgresDriver::connect(&form)
+        .await
+        .expect("failed to connect postgres driver for verification");
+    driver
+        .execute_query(format!(
+            "INSERT INTO {} (id, name) VALUES (1, 'alpha')",
+            qualified
+        ))
+        .await
+        .expect("insert into imported postgres table should succeed");
+    driver
+        .execute_query(format!(
+            "UPDATE {} SET name = 'beta' WHERE id = 1",
+            qualified
+        ))
+        .await
+        .expect("update imported postgres table should succeed");
+    let verify = driver
+        .execute_query(format!(
+            "SELECT touch_count AS c FROM {} WHERE id = 1",
+            qualified
+        ))
+        .await
+        .expect("verify postgres trigger should succeed");
+    let count = verify.data[0]["c"]
+        .as_str()
+        .and_then(|v| v.parse::<i64>().ok())
+        .expect("touch_count should parse");
+    assert_eq!(count, 2);
+
+    let _ = driver
+        .execute_query(format!("DROP TABLE IF EXISTS {}", qualified))
+        .await;
+    let _ = driver
+        .execute_query(format!(
+            "DROP FUNCTION IF EXISTS \"{}\".\"{}\"()",
+            schema, func_name
+        ))
+        .await;
+    driver.close().await;
+
+    let _ = fs::remove_file(import_sql_path);
+    let _ = fs::remove_dir_all(base);
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+}
+
 #[tokio::test]
 #[ignore]
 async fn test_postgres_command_ai_minimal_provider_conversation_and_chat_flow() {
diff --git a/src-tauri/tests/sqlite_command_integration.rs b/src-tauri/tests/sqlite_command_integration.rs
index 8f031a47..4663dd67 100644
--- a/src-tauri/tests/sqlite_command_integration.rs
+++ b/src-tauri/tests/sqlite_command_integration.rs
@@ -1,9 +1,13 @@
-use dbpaw_lib::commands::{connection, metadata, query};
+use dbpaw_lib::commands::{connection, metadata, query, transfer};
 use dbpaw_lib::db::drivers::sqlite::SqliteDriver;
 use dbpaw_lib::db::drivers::DatabaseDriver;
+use dbpaw_lib::db::local::LocalDb;
 use dbpaw_lib::models::ConnectionForm;
+use dbpaw_lib::state::AppState;
 use std::env;
+use std::fs;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 use uuid::Uuid;
 
@@ -24,6 +28,31 @@ fn unique_table_name(prefix: &str) -> String {
     format!("{}_{}", prefix, millis)
 }
 
+async fn init_state_with_local_db() -> AppState {
+    let state = AppState::new();
+    let local_db_dir = std::env::temp_dir().join(unique_table_name("dbpaw_sqlite_localdb_it"));
+    let db = LocalDb::init_with_app_dir(&local_db_dir)
+        .await
+        .expect("failed to initialize local db");
+    let mut lock = state.local_db.lock().await;
+    *lock = Some(Arc::new(db));
+    drop(lock);
+    state
+}
+
+async fn create_sqlite_connection_for_state(
+    state: &AppState,
+    base_form: &ConnectionForm,
+    suffix: &str,
+) -> i64 {
+    let mut form = base_form.clone();
+    form.name = Some(format!("sqlite-stateful-{suffix}"));
+    let created = connection::create_connection_direct(state, form)
+        .await
+        .expect("create_connection should succeed");
+    created.id
+}
+
 async fn prepare_query_test_table(form: &ConnectionForm, table: &str) {
     let driver = SqliteDriver::connect(form)
         .await
@@ -258,6 +287,88 @@ async fn test_sqlite_command_execute_by_conn_insert_affects_rows() {
     let _ = std::fs::remove_file(db_path);
 }
 
+#[tokio::test]
+#[ignore]
+async fn test_sqlite_command_import_sql_file_supports_trigger_script() {
+    let db_path = sqlite_test_path();
+    let db_path_str = db_path.to_string_lossy().to_string();
+    let form = ConnectionForm {
+        driver: "sqlite".to_string(),
+        file_path: Some(db_path_str.clone()),
+        ..Default::default()
+    };
+
+    let state = init_state_with_local_db().await;
+    let conn_id = create_sqlite_connection_for_state(&state, &form, "import-trigger").await;
+    let base = std::env::temp_dir().join(unique_table_name("dbpaw_sqlite_import_it"));
+    fs::create_dir_all(&base).expect("create temp transfer dir should succeed");
+    let import_sql_path = base.join("import.sql");
+
+    let source_table = unique_table_name("dbpaw_sqlite_src");
+    let audit_table = unique_table_name("dbpaw_sqlite_audit");
+    let trigger_name = unique_table_name("dbpaw_sqlite_trg");
+    let import_sql = format!(
+        r#"
+CREATE TABLE {source_table} (id INTEGER PRIMARY KEY, name TEXT);
+CREATE TABLE {audit_table} (entry_id INTEGER PRIMARY KEY AUTOINCREMENT, source_id INTEGER, action TEXT);
+CREATE TRIGGER {trigger_name}
+AFTER INSERT ON {source_table}
+BEGIN
+    INSERT INTO {audit_table}(source_id, action) VALUES (NEW.id, 'insert');
+END;
+"#
+    );
+    fs::write(&import_sql_path, import_sql).expect("write import sql file should succeed");
+
+    let import_result = transfer::import_sql_file_direct(
+        &state,
+        conn_id,
+        Some("main".to_string()),
+        import_sql_path.to_string_lossy().to_string(),
+        "sqlite".to_string(),
+    )
+    .await
+    .expect("import_sql_file should succeed");
+    assert_eq!(
+        import_result.success_statements,
+        import_result.total_statements
+    );
+    assert!(import_result.error.is_none());
+
+    let driver = SqliteDriver::connect(&form)
+        .await
+        .expect("failed to connect sqlite driver for verification");
+    driver
+        .execute_query(format!(
+            "INSERT INTO {} (id, name) VALUES (1, 'alpha')",
+            source_table
+        ))
+        .await
+        .expect("insert into imported sqlite table should succeed");
+    let verify = driver
+        .execute_query(format!("SELECT COUNT(*) AS c FROM {}", audit_table))
+        .await
+        .expect("verify sqlite trigger should succeed");
+    let count = verify.data[0]["c"]
+        .as_i64()
+        .or_else(|| verify.data[0]["c"].as_str().and_then(|v| v.parse::<i64>().ok()))
+        .expect("audit count should be numeric");
+    assert_eq!(count, 1);
+
+    let _ = driver
+        .execute_query(format!("DROP TABLE IF EXISTS {}", source_table))
+        .await;
+    let _ = driver
+        .execute_query(format!("DROP TABLE IF EXISTS {}", audit_table))
+        .await;
+    driver.close().await;
+
+    let _ = connection::delete_connection_direct(&state, conn_id).await;
+    let _ = fs::remove_file(import_sql_path);
+    let _ = fs::remove_dir_all(base);
+    let _ = fs::remove_file(db_path);
+}
+
 #[tokio::test]
 #[ignore]
 async fn test_sqlite_command_get_table_data_by_conn_pagination_works() {

From 6d8a69efd2ef1cdae1f47f51d74bd4244b9e31cf Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Fri, 10 Apr 2026 18:51:19 +0800
Subject: [PATCH 12/15] feat(datagrid): add inline column comment display
 toggle

Add a settings switch (default off) to show field comments in small text
below the column name in table headers. Comments are truncated to avoid
affecting column width. Supports en/zh/ja i18n.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 src/App.tsx                                   |  5 +++
 .../business/DataGrid/TableView.tsx           | 37 ++++++++++++-------
 src/components/settings/SettingsDialog.tsx    | 29 ++++++++++++++-
 src/lib/i18n/locales/en.ts                    |  6 +++
 src/lib/i18n/locales/ja.ts                    |  6 +++
 src/lib/i18n/locales/zh.ts                    |  6 +++
 6 files changed, 74 insertions(+), 15 deletions(-)

diff --git a/src/App.tsx b/src/App.tsx
index c840a179..f2f5bc00 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -234,6 +234,7 @@ export default function App() {
   const [isUnsavedConfirmOpen, setIsUnsavedConfirmOpen] = useState(false);
   const [isCloseSaveDialogOpen, setIsCloseSaveDialogOpen] = useState(false);
   const [sidebarLayout, setSidebarLayout] = useState<SidebarLayoutMode>("tabs");
+  const [showColumnComments, setShowColumnComments] = useState(false);
   const closeSaveCompletedRef = useRef(false);
   const unsavedConfirmActionRef = useRef<"save" | "discard" | null>(null);
   const schemaOverviewRequestKeysRef = useRef<Map<string, string>>(new Map());
@@ -268,6 +269,7 @@ export default function App() {
         setSidebarLayout(layout === "tree" ? "tree" : "tabs");
       },
     );
+    void getSetting("showColumnComments", false).then(setShowColumnComments);
   }, []);
 
   const sensors = useSensors(
@@ -1726,6 +1728,7 @@ export default function App() {
                                   }
                                 : undefined
                             }
+                            showColumnComments={showColumnComments}
                           />
                         ) : tab.connectionId &&
                           tab.database &&
@@ -1821,6 +1824,8 @@ export default function App() {
             onOpenChange={setOpenSettings}
             sidebarLayout={sidebarLayout}
             onSidebarLayoutChange={setSidebarLayout}
+            showColumnComments={showColumnComments}
+            onShowColumnCommentsChange={setShowColumnComments}
           />
         </Suspense>
       )}
diff --git a/src/components/business/DataGrid/TableView.tsx b/src/components/business/DataGrid/TableView.tsx
index 511c377f..a5fb6ee8 100644
--- a/src/components/business/DataGrid/TableView.tsx
+++ b/src/components/business/DataGrid/TableView.tsx
@@ -148,6 +148,7 @@ interface TableViewProps {
     driver: string;
   };
   isLoading?: boolean;
+  showColumnComments?: boolean;
 }
 
 export function TableView({
@@ -171,6 +172,7 @@ export function TableView({
   onCreateQuery,
   tableContext,
   isLoading,
+  showColumnComments = false,
 }: TableViewProps) {
   const { t } = useTranslation();
   const PAGE_SIZE_OPTIONS = ["10", "50", "100", "200", "500", "1000"] as const;
@@ -1996,26 +1998,33 @@ export function TableView({
                     <div className="flex items-center justify-between pr-2">
                       <button
                         type="button"
-                        className="flex items-center gap-1 cursor-pointer hover:text-foreground transition-colors min-w-0 flex-1"
+                        className="flex flex-col items-start cursor-pointer hover:text-foreground transition-colors min-w-0 flex-1 overflow-hidden"
                         title={`${headerTooltip}\n${headerActionLabel}`}
                         aria-label={headerActionLabel}
                         onClick={headerInteraction.handleClick}
                         onDoubleClick={headerInteraction.handleDoubleClick}
                       >
-                        <span className="truncate" title={headerTooltip}>
-                          {column}
-                        </span>
-                        <span className="flex-shrink-0 w-3.5 h-3.5 flex items-center justify-center">
-                          {isSorted ? (
-                            direction === "asc" ? (
-                              <ChevronUp className="w-3.5 h-3.5 text-primary" />
+                        <div className="flex items-center gap-1 w-full">
+                          <span className="truncate" title={headerTooltip}>
+                            {column}
+                          </span>
+                          <span className="flex-shrink-0 w-3.5 h-3.5 flex items-center justify-center">
+                            {isSorted ? (
+                              direction === "asc" ? (
+                                <ChevronUp className="w-3.5 h-3.5 text-primary" />
+                              ) : (
+                                <ChevronDown className="w-3.5 h-3.5 text-primary" />
+                              )
                             ) : (
-                              <ChevronDown className="w-3.5 h-3.5 text-primary" />
-                            )
-                          ) : (
-                            <ArrowUpDown className="w-3 h-3 text-muted-foreground/40 opacity-0 group-hover:opacity-100 transition-opacity" />
-                          )}
-                        </span>
+                              <ArrowUpDown className="w-3 h-3 text-muted-foreground/40 opacity-0 group-hover:opacity-100 transition-opacity" />
+                            )}
+                          </span>
+                        </div>
+                        {showColumnComments && comment && (
+                          <span className="block truncate text-[10px] text-muted-foreground/60 leading-tight font-normal">
+                            {comment}
+                          </span>
+                        )}
                       </button>
                       <div
                         className="absolute right-0 top-0 bottom-0 w-1 cursor-col-resize hover:bg-primary/50 group-hover:bg-muted-foreground/20 select-none touch-none"
diff --git a/src/components/settings/SettingsDialog.tsx b/src/components/settings/SettingsDialog.tsx
index 1dc3d961..350ff665 100644
--- a/src/components/settings/SettingsDialog.tsx
+++ b/src/components/settings/SettingsDialog.tsx
@@ -60,6 +60,8 @@ interface SettingsDialogProps {
   onOpenChange: (open: boolean) => void;
   sidebarLayout?: "tabs" | "tree";
   onSidebarLayoutChange?: (layout: "tabs" | "tree") => void;
+  showColumnComments?: boolean;
+  onShowColumnCommentsChange?: (v: boolean) => void;
 }
 
 type SettingsSection = "general" | "layout" | "ai" | "shortcuts" | "about";
@@ -229,12 +231,15 @@ export function SettingsDialog({
   onOpenChange,
   sidebarLayout = "tabs",
   onSidebarLayoutChange,
+  showColumnComments: showColumnCommentsProp = false,
+  onShowColumnCommentsChange,
 }: SettingsDialogProps) {
   const { t } = useTranslation();
   const { theme, setTheme, fontSizePx, setFontSizePx } = useTheme();
   const [activeSection, setActiveSection] =
     useState<SettingsSection>("general");
   const [autoUpdate, setAutoUpdate] = useState(true);
+  const [showColumnComments, setShowColumnComments] = useState(false);
   const [checking, setChecking] = useState(false);
   const [updateTaskState, setUpdateTaskState] = useState<UpdateTaskState>(
     getUpdateTaskSnapshot().state,
@@ -274,6 +279,7 @@ export function SettingsDialog({
       setActiveSection("general");
       setFontSizeInput(String(fontSizePx));
       setLayoutMode(sidebarLayout);
+      setShowColumnComments(showColumnCommentsProp);
       getSetting("autoUpdate", true).then(setAutoUpdate);
       api.ai.providers
         .list()
@@ -291,7 +297,7 @@ export function SettingsDialog({
           toast.error(t("settings.aiProviders.loadFailed"));
         });
     }
-  }, [fontSizePx, open, sidebarLayout, t]);
+  }, [fontSizePx, open, showColumnCommentsProp, sidebarLayout, t]);
 
   useEffect(() => {
     setFontSizeInput(String(fontSizePx));
@@ -373,6 +379,12 @@ export function SettingsDialog({
     await saveSetting("autoUpdate", checked);
   };
 
+  const toggleShowColumnComments = async (checked: boolean) => {
+    setShowColumnComments(checked);
+    await saveSetting("showColumnComments", checked);
+    onShowColumnCommentsChange?.(checked);
+  };
+
   const handleSaveProvider = async () => {
     try {
       const selectedOption =
@@ -623,6 +635,21 @@ export function SettingsDialog({
                       <span className="text-sm text-muted-foreground">px</span>
                     </div>
                   </div>
+
+                  <div className="flex items-center justify-between">
+                    <div className="space-y-1">
+                      <Label className="text-base">
+                        {t("settings.dataGrid.showColumnComments")}
+                      </Label>
+                      <p className="text-xs text-muted-foreground">
+                        {t("settings.dataGrid.showColumnCommentsDescription")}
+                      </p>
+                    </div>
+                    <Switch
+                      checked={showColumnComments}
+                      onCheckedChange={toggleShowColumnComments}
+                    />
+                  </div>
                 </div>
 
                 <Separator />
diff --git a/src/lib/i18n/locales/en.ts b/src/lib/i18n/locales/en.ts
index f3d28b89..86eac42a 100644
--- a/src/lib/i18n/locales/en.ts
+++ b/src/lib/i18n/locales/en.ts
@@ -101,6 +101,12 @@ export const en = {
       fontSizeDescription:
         "Adjust global text size across the app (Range: {{min}}-{{max}}px)",
     },
+    dataGrid: {
+      title: "Data Grid",
+      showColumnComments: "Show Column Comments",
+      showColumnCommentsDescription:
+        "Display column comments in small text below the column name in table headers",
+    },
     layout: {
       title: "Layout",
       modeTitle: "Sidebar Layout",
diff --git a/src/lib/i18n/locales/ja.ts b/src/lib/i18n/locales/ja.ts
index c9b5c548..c862af32 100644
--- a/src/lib/i18n/locales/ja.ts
+++ b/src/lib/i18n/locales/ja.ts
@@ -103,6 +103,12 @@ export const ja: Translations = {
       fontSizeDescription:
         "アプリ全体の文字サイズを調整します（範囲：{{min}}-{{max}}px）",
     },
+    dataGrid: {
+      title: "データグリッド",
+      showColumnComments: "カラムコメントを表示",
+      showColumnCommentsDescription:
+        "テーブルヘッダーの列名の下に小さなテキストでカラムコメントを表示します",
+    },
     layout: {
       title: "レイアウト",
       modeTitle: "サイドバー配置",
diff --git a/src/lib/i18n/locales/zh.ts b/src/lib/i18n/locales/zh.ts
index af01d678..d4c21871 100644
--- a/src/lib/i18n/locales/zh.ts
+++ b/src/lib/i18n/locales/zh.ts
@@ -101,6 +101,12 @@ export const zh: Translations = {
       fontSizeTitle: "字体大小",
       fontSizeDescription: "调整应用全局文字大小（范围：{{min}}-{{max}}px）",
     },
+    dataGrid: {
+      title: "数据表格",
+      showColumnComments: "显示字段注释",
+      showColumnCommentsDescription:
+        "在表头列名下方以小字体显示字段的 Comment 注释",
+    },
     layout: {
       title: "布局",
       modeTitle: "侧边栏布局",

From a72ce6d93abb469dea9efe306f32471ceb59198f Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Fri, 10 Apr 2026 18:56:00 +0800
Subject: [PATCH 13/15] ci: extract upgradelink-upload into standalone workflow

Move the upgradelink-upload job out of release.yml into a dedicated
workflow (.github/workflows/upgradelink-upload.yml) triggered manually
via workflow_dispatch with a required tag input.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/release.yml            | 29 ------------------------
 .github/workflows/upgradelink-upload.yml | 29 ++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 29 deletions(-)
 create mode 100644 .github/workflows/upgradelink-upload.yml

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index aed62e3c..999b49df 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -392,32 +392,3 @@ jobs:
             merged/latest.json
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  upgradelink-upload:
-    needs: release
-    permissions:
-      contents: read
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Resolve release tag
-        id: release_meta
-        shell: bash
-        env:
-          TAG_NAME: ${{ inputs.tag || github.ref_name }}
-        run: |
-          set -euo pipefail
-          echo "release_tag=${TAG_NAME}" >> "$GITHUB_OUTPUT"
-
-      - name: Upload latest.json to UpgradeLink
-        uses: toolsetlink/upgradelink-action@3.0.2
-        with:
-          access_key: ${{ secrets.UPGRADE_LINK_ACCESS_KEY }}
-          access_secret: ${{ secrets.UPGRADE_LINK_ACCESS_SECRET }}
-          config: |
-            {
-              "app_type": "tauri",
-              "request": {
-                "app_key": "${{ secrets.UPGRADE_LINK_TAURI_KEY }}",
-                "latest_json_url": "https://github.com/${{ github.repository }}/releases/download/${{ steps.release_meta.outputs.release_tag }}/latest.json"
-              }
-            }
diff --git a/.github/workflows/upgradelink-upload.yml b/.github/workflows/upgradelink-upload.yml
new file mode 100644
index 00000000..1e856da5
--- /dev/null
+++ b/.github/workflows/upgradelink-upload.yml
@@ -0,0 +1,29 @@
+name: UpgradeLink Upload
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag to upload (e.g. v1.2.3)"
+        required: true
+        type: string
+
+jobs:
+  upgradelink-upload:
+    permissions:
+      contents: read
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Upload latest.json to UpgradeLink
+        uses: toolsetlink/upgradelink-action@3.0.2
+        with:
+          access_key: ${{ secrets.UPGRADE_LINK_ACCESS_KEY }}
+          access_secret: ${{ secrets.UPGRADE_LINK_ACCESS_SECRET }}
+          config: |
+            {
+              "app_type": "tauri",
+              "request": {
+                "app_key": "${{ secrets.UPGRADE_LINK_TAURI_KEY }}",
+                "latest_json_url": "https://github.com/${{ github.repository }}/releases/download/${{ inputs.tag }}/latest.json"
+              }
+            }

From ff3fbf6f0147bc03f9871cef135694a11de1087c Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Fri, 10 Apr 2026 18:58:26 +0800
Subject: [PATCH 14/15] chore: format code

---
 src-tauri/src/commands/query.rs               |   4 +-
 src-tauri/src/commands/transfer.rs            |  37 +++---
 src-tauri/src/db/drivers/oracle.rs            |  23 ++--
 .../tests/mariadb_command_integration.rs      |  15 ++-
 .../mysql_stateful_command_integration.rs     |  34 +++---
 src-tauri/tests/oracle_command_integration.rs |  24 ++--
 src-tauri/tests/oracle_integration.rs         |  25 ++--
 src-tauri/tests/postgres_integration.rs       |  40 +++++--
 src-tauri/tests/sqlite_command_integration.rs |   6 +-
 src/components/ErrorBoundary.tsx              |   6 +-
 .../business/DataGrid/ComplexValueViewer.tsx  |  59 +++++++---
 .../business/DataGrid/TableView.tsx           |  42 +++++--
 src/components/business/Sidebar/Sidebar.tsx   |   5 +-
 .../Sidebar/connection-list/helpers.tsx       |   3 +-
 src/lib/connection-form/rules.ts              |   5 +-
 src/lib/i18n/locales/ja.ts                    |   3 +-
 src/services/api.ts                           |   7 +-
 src/services/mocks.ts                         | 108 +++++++++++++++---
 18 files changed, 312 insertions(+), 134 deletions(-)

diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
index a4ce0f82..35aa835a 100644
--- a/src-tauri/src/commands/query.rs
+++ b/src-tauri/src/commands/query.rs
@@ -1301,7 +1301,9 @@ mod tests {
         );
         assert_eq!(tokens.first().map(String::as_str), Some("create"));
         assert!(tokens.contains(&"function".to_string()));
-        assert!(!tokens.iter().any(|token| token == "begin" || token == "end"));
+        assert!(!tokens
+            .iter()
+            .any(|token| token == "begin" || token == "end"));
     }
 
     #[test]
diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
index 9d73d514..8428a5ac 100644
--- a/src-tauri/src/commands/transfer.rs
+++ b/src-tauri/src/commands/transfer.rs
@@ -1204,19 +1204,21 @@ fn oracle_plsql_state(sql: &str) -> (bool, bool) {
                         let second = tokens.get(1).map(String::as_str);
                         let third = tokens.get(2).map(String::as_str);
                         let fourth = tokens.get(3).map(String::as_str);
-                        is_oracle_block =
-                            matches!(tokens.first().map(String::as_str), Some("declare") | Some("begin"))
-                                || (tokens.first().map(String::as_str) == Some("create")
-                                    && second == Some("or")
-                                    && third == Some("replace")
-                                    && matches!(
-                                        fourth,
-                                        Some("function")
-                                            | Some("procedure")
-                                            | Some("trigger")
-                                            | Some("package")
-                                            | Some("type")
-                                    ));
+                        is_oracle_block = matches!(
+                            tokens.first().map(String::as_str),
+                            Some("declare") | Some("begin")
+                        ) || (tokens.first().map(String::as_str)
+                            == Some("create")
+                            && second == Some("or")
+                            && third == Some("replace")
+                            && matches!(
+                                fourth,
+                                Some("function")
+                                    | Some("procedure")
+                                    | Some("trigger")
+                                    | Some("package")
+                                    | Some("type")
+                            ));
                     }
 
                     if is_oracle_block {
@@ -1293,8 +1295,10 @@ fn oracle_plsql_state(sql: &str) -> (bool, bool) {
         }
     }
 
-    let ready_to_terminate =
-        is_oracle_block && block_depth == 0 && case_depth == 0 && last_word.as_deref() == Some("end");
+    let ready_to_terminate = is_oracle_block
+        && block_depth == 0
+        && case_depth == 0
+        && last_word.as_deref() == Some("end");
     (is_oracle_block, ready_to_terminate)
 }
 
@@ -1343,7 +1347,8 @@ fn parse_sql_statements(sql: &str, driver: &str) -> Result<Vec<String>, String>
         match &state {
             SqlScanState::Normal => {
                 if mysql_style_delimiter {
-                    if let Some((next_delimiter, next_idx)) = parse_mysql_delimiter_command(&chars, i)
+                    if let Some((next_delimiter, next_idx)) =
+                        parse_mysql_delimiter_command(&chars, i)
                     {
                         delimiter = next_delimiter;
                         i = next_idx;
diff --git a/src-tauri/src/db/drivers/oracle.rs b/src-tauri/src/db/drivers/oracle.rs
index a11d461e..a7638c76 100644
--- a/src-tauri/src/db/drivers/oracle.rs
+++ b/src-tauri/src/db/drivers/oracle.rs
@@ -186,9 +186,8 @@ impl OracleDriver {
         let cfg = self.config.clone();
         tokio::task::spawn_blocking(move || {
             let connect_string = build_connect_string(&cfg);
-            let conn =
-                oracle::Connection::connect(&cfg.username, &cfg.password, &connect_string)
-                    .map_err(|e| conn_failed_error(&e))?;
+            let conn = oracle::Connection::connect(&cfg.username, &cfg.password, &connect_string)
+                .map_err(|e| conn_failed_error(&e))?;
             f(conn)
         })
         .await
@@ -414,9 +413,10 @@ impl DatabaseDriver for OracleDriver {
                     if let (Some(name), Some(col_name)) = (idx_name, col_name) {
                         let unique = is_unique.unwrap_or(0) == 1;
                         let pos = position.unwrap_or(0);
-                        let entry = idx_map
-                            .entry(name)
-                            .or_insert((unique, idx_type.clone(), Vec::new()));
+                        let entry =
+                            idx_map
+                                .entry(name)
+                                .or_insert((unique, idx_type.clone(), Vec::new()));
                         entry.0 = unique;
                         if entry.1.is_none() {
                             entry.1 = idx_type;
@@ -704,7 +704,8 @@ impl DatabaseDriver for OracleDriver {
                     .map_err(|e| format!("[QUERY_ERROR] {e}"))?;
                 let row_count = stmt.row_count().unwrap_or(0) as i64;
                 // Commit so the change is visible after the connection closes.
-                conn.commit().map_err(|e| format!("[QUERY_ERROR] commit failed: {e}"))?;
+                conn.commit()
+                    .map_err(|e| format!("[QUERY_ERROR] commit failed: {e}"))?;
                 Ok(QueryResult {
                     row_count,
                     data: vec![],
@@ -751,10 +752,10 @@ impl DatabaseDriver for OracleDriver {
                 if let (Some(sn), Some(tn), Some(cn), Some(ct)) =
                     (schema_name, table_name, col_name, col_type)
                 {
-                    table_map
-                        .entry((sn, tn))
-                        .or_default()
-                        .push(ColumnSchema { name: cn, r#type: ct });
+                    table_map.entry((sn, tn)).or_default().push(ColumnSchema {
+                        name: cn,
+                        r#type: ct,
+                    });
                 }
             }
             let mut tables: Vec<TableSchema> = table_map
diff --git a/src-tauri/tests/mariadb_command_integration.rs b/src-tauri/tests/mariadb_command_integration.rs
index 7940a60d..55c959db 100644
--- a/src-tauri/tests/mariadb_command_integration.rs
+++ b/src-tauri/tests/mariadb_command_integration.rs
@@ -364,8 +364,14 @@ async fn test_mariadb_show_character_set_returns_standard_charsets() {
         .collect();
 
     assert!(!charsets.is_empty(), "charset list must not be empty");
-    assert!(charsets.iter().any(|c| c == "utf8mb4"), "utf8mb4 must be present");
-    assert!(charsets.iter().any(|c| c == "latin1"), "latin1 must be present");
+    assert!(
+        charsets.iter().any(|c| c == "utf8mb4"),
+        "utf8mb4 must be present"
+    );
+    assert!(
+        charsets.iter().any(|c| c == "latin1"),
+        "latin1 must be present"
+    );
     assert!(
         charsets.iter().all(|c| !c.trim().is_empty()),
         "all charset names must be non-empty"
@@ -401,7 +407,10 @@ async fn test_mariadb_show_collation_for_utf8mb4_returns_matching_collations() {
         })
         .collect();
 
-    assert!(!collations.is_empty(), "utf8mb4 collation list must not be empty");
+    assert!(
+        !collations.is_empty(),
+        "utf8mb4 collation list must not be empty"
+    );
     assert!(
         collations.iter().any(|c| c == "utf8mb4_general_ci"),
         "utf8mb4_general_ci must be present"
diff --git a/src-tauri/tests/mysql_stateful_command_integration.rs b/src-tauri/tests/mysql_stateful_command_integration.rs
index bf6b893a..19333688 100644
--- a/src-tauri/tests/mysql_stateful_command_integration.rs
+++ b/src-tauri/tests/mysql_stateful_command_integration.rs
@@ -830,10 +830,16 @@ DELIMITER ;
         .execute_query(format!("DROP PROCEDURE IF EXISTS `{}`", proc_name))
         .await;
     let _ = driver
-        .execute_query(format!("DROP TABLE IF EXISTS `{}`.`{}`", schema, proc_table))
+        .execute_query(format!(
+            "DROP TABLE IF EXISTS `{}`.`{}`",
+            schema, proc_table
+        ))
         .await;
     let _ = driver
-        .execute_query(format!("DROP TABLE IF EXISTS `{}`.`{}`", schema, audit_table))
+        .execute_query(format!(
+            "DROP TABLE IF EXISTS `{}`.`{}`",
+            schema, audit_table
+        ))
         .await;
     driver.close().await;
 
@@ -977,10 +983,7 @@ async fn test_mysql_command_get_charsets_by_id_returns_standard_charsets() {
         charsets.iter().any(|c| c == "utf8mb4"),
         "utf8mb4 must be present"
     );
-    assert!(
-        charsets.iter().any(|c| c == "utf8"),
-        "utf8 must be present"
-    );
+    assert!(charsets.iter().any(|c| c == "utf8"), "utf8 must be present");
     assert!(
         charsets.iter().any(|c| c == "latin1"),
         "latin1 must be present"
@@ -1043,18 +1046,17 @@ async fn test_mysql_command_get_collations_by_id_with_charset_returns_only_match
     let (_mysql_container, form) = mysql_context::mysql_form_from_test_context(docker.as_ref());
     wait_until_mysql_ready(&form).await;
     let state = init_state_with_local_db().await;
-    let conn_id =
-        create_mysql_connection_for_state(&state, &form, "get-collations-filtered").await;
+    let conn_id = create_mysql_connection_for_state(&state, &form, "get-collations-filtered").await;
 
-    let collations = connection::get_mysql_collations_by_id_direct(
-        &state,
-        conn_id,
-        Some("utf8mb4".to_string()),
-    )
-    .await
-    .expect("get_mysql_collations_by_id should succeed with charset filter");
+    let collations =
+        connection::get_mysql_collations_by_id_direct(&state, conn_id, Some("utf8mb4".to_string()))
+            .await
+            .expect("get_mysql_collations_by_id should succeed with charset filter");
 
-    assert!(!collations.is_empty(), "utf8mb4 collation list must not be empty");
+    assert!(
+        !collations.is_empty(),
+        "utf8mb4 collation list must not be empty"
+    );
     assert!(
         collations.iter().any(|c| c == "utf8mb4_general_ci"),
         "utf8mb4_general_ci must be present"
diff --git a/src-tauri/tests/oracle_command_integration.rs b/src-tauri/tests/oracle_command_integration.rs
index 8ae950db..0dc57d06 100644
--- a/src-tauri/tests/oracle_command_integration.rs
+++ b/src-tauri/tests/oracle_command_integration.rs
@@ -216,9 +216,7 @@ async fn test_oracle_command_execute_insert_affects_rows() {
         .expect("CREATE TABLE");
     driver.close().await;
 
-    let sql = format!(
-        "INSERT INTO \"{schema}\".\"{table}\" (id, name) VALUES (1, 'alpha')"
-    );
+    let sql = format!("INSERT INTO \"{schema}\".\"{table}\" (id, name) VALUES (1, 'alpha')");
     let result = query::execute_by_conn_direct(form.clone(), sql)
         .await
         .expect("INSERT should succeed");
@@ -266,14 +264,12 @@ async fn test_oracle_command_get_table_data_pagination_works() {
     }
     driver.close().await;
 
-    let page1 =
-        query::get_table_data_by_conn(form.clone(), schema.clone(), table.clone(), 1, 2)
-            .await
-            .expect("page 1 should succeed");
-    let page2 =
-        query::get_table_data_by_conn(form.clone(), schema.clone(), table.clone(), 2, 2)
-            .await
-            .expect("page 2 should succeed");
+    let page1 = query::get_table_data_by_conn(form.clone(), schema.clone(), table.clone(), 1, 2)
+        .await
+        .expect("page 1 should succeed");
+    let page2 = query::get_table_data_by_conn(form.clone(), schema.clone(), table.clone(), 2, 2)
+        .await
+        .expect("page 2 should succeed");
 
     assert_eq!(page1.total, 3);
     assert_eq!(page1.limit, 2);
@@ -341,7 +337,11 @@ END;
         .expect("verify oracle imported procedure should succeed");
     let count = verify.data[0]["C"]
         .as_i64()
-        .or_else(|| verify.data[0]["C"].as_str().and_then(|v| v.parse::<i64>().ok()))
+        .or_else(|| {
+            verify.data[0]["C"]
+                .as_str()
+                .and_then(|v| v.parse::<i64>().ok())
+        })
         .expect("oracle count should be numeric");
     assert_eq!(count, 1);
 
diff --git a/src-tauri/tests/oracle_integration.rs b/src-tauri/tests/oracle_integration.rs
index 02c216e4..bb84b256 100644
--- a/src-tauri/tests/oracle_integration.rs
+++ b/src-tauri/tests/oracle_integration.rs
@@ -96,7 +96,10 @@ async fn test_oracle_integration_flow() {
         "structure should have columns"
     );
     assert!(
-        structure.columns.iter().any(|c| c.name == "ID" && c.primary_key),
+        structure
+            .columns
+            .iter()
+            .any(|c| c.name == "ID" && c.primary_key),
         "ID column should be marked as primary key"
     );
     assert!(
@@ -126,16 +129,7 @@ async fn test_oracle_integration_flow() {
 
     // get_table_data
     let result = driver
-        .get_table_data(
-            schema.clone(),
-            table.clone(),
-            1,
-            10,
-            None,
-            None,
-            None,
-            None,
-        )
+        .get_table_data(schema.clone(), table.clone(), 1, 10, None, None, None, None)
         .await
         .expect("get_table_data should succeed");
     assert_eq!(result.total, 1, "total should be 1");
@@ -148,9 +142,7 @@ async fn test_oracle_integration_flow() {
 
     // execute_query SELECT
     let qr = driver
-        .execute_query(format!(
-            "SELECT id, name FROM \"{schema}\".\"{table}\""
-        ))
+        .execute_query(format!("SELECT id, name FROM \"{schema}\".\"{table}\""))
         .await
         .expect("execute_query SELECT should succeed");
     assert!(qr.success);
@@ -250,5 +242,8 @@ async fn test_oracle_integration_connection_failure() {
     let result = OracleDriver::connect(&form).await;
     assert!(result.is_err(), "wrong password should fail");
     let err = result.err().expect("should have an error");
-    assert!(err.contains("[CONN_FAILED]"), "error should be tagged CONN_FAILED");
+    assert!(
+        err.contains("[CONN_FAILED]"),
+        "error should be tagged CONN_FAILED"
+    );
 }
diff --git a/src-tauri/tests/postgres_integration.rs b/src-tauri/tests/postgres_integration.rs
index 025581bf..88561143 100644
--- a/src-tauri/tests/postgres_integration.rs
+++ b/src-tauri/tests/postgres_integration.rs
@@ -872,8 +872,14 @@ async fn test_postgres_array_types_decoded_as_json_arrays() {
 
     let floats8 = r1["floats8"].as_array().expect("floats8 should be array");
     assert_eq!(floats8.len(), 2);
-    assert!(floats8[0].as_f64().map(|v| (v - 3.14).abs() < 0.01).unwrap_or(false),
-        "floats8[0] should be ~3.14, got {:?}", floats8[0]);
+    assert!(
+        floats8[0]
+            .as_f64()
+            .map(|v| (v - 3.14).abs() < 0.01)
+            .unwrap_or(false),
+        "floats8[0] should be ~3.14, got {:?}",
+        floats8[0]
+    );
 
     let texts = r1["texts"].as_array().expect("texts should be array");
     assert_eq!(texts.len(), 2);
@@ -894,22 +900,42 @@ async fn test_postgres_array_types_decoded_as_json_arrays() {
     let r2 = &result.data[1];
 
     let ints2_null = r2["ints2"].as_array().expect("ints2 row2 should be array");
-    assert_eq!(ints2_null[0], serde_json::Value::Null, "first element should be NULL");
+    assert_eq!(
+        ints2_null[0],
+        serde_json::Value::Null,
+        "first element should be NULL"
+    );
     assert_eq!(ints2_null[1].as_i64().unwrap_or(-1), 5);
 
     let ints4_null = r2["ints4"].as_array().expect("ints4 row2 should be array");
-    assert_eq!(ints4_null[0], serde_json::Value::Null, "first int4 element should be NULL");
+    assert_eq!(
+        ints4_null[0],
+        serde_json::Value::Null,
+        "first int4 element should be NULL"
+    );
 
     let texts_null = r2["texts"].as_array().expect("texts row2 should be array");
     assert_eq!(texts_null[0].as_str().unwrap_or(""), "x");
-    assert_eq!(texts_null[1], serde_json::Value::Null, "middle text element should be NULL");
+    assert_eq!(
+        texts_null[1],
+        serde_json::Value::Null,
+        "middle text element should be NULL"
+    );
     assert_eq!(texts_null[2].as_str().unwrap_or(""), "z");
 
     let bools_null = r2["bools"].as_array().expect("bools row2 should be array");
-    assert_eq!(bools_null[0], serde_json::Value::Null, "bool element should be NULL");
+    assert_eq!(
+        bools_null[0],
+        serde_json::Value::Null,
+        "bool element should be NULL"
+    );
 
     // column-level NULL (entire array is NULL)
-    assert_eq!(r2["ints8"], serde_json::Value::Null, "whole ints8 column should be NULL");
+    assert_eq!(
+        r2["ints8"],
+        serde_json::Value::Null,
+        "whole ints8 column should be NULL"
+    );
 
     // ---- row 3: empty arrays ----
     let r3 = &result.data[2];
diff --git a/src-tauri/tests/sqlite_command_integration.rs b/src-tauri/tests/sqlite_command_integration.rs
index 4663dd67..9b9d5a29 100644
--- a/src-tauri/tests/sqlite_command_integration.rs
+++ b/src-tauri/tests/sqlite_command_integration.rs
@@ -351,7 +351,11 @@ END;
         .expect("verify sqlite trigger should succeed");
     let count = verify.data[0]["c"]
         .as_i64()
-        .or_else(|| verify.data[0]["c"].as_str().and_then(|v| v.parse::<i64>().ok()))
+        .or_else(|| {
+            verify.data[0]["c"]
+                .as_str()
+                .and_then(|v| v.parse::<i64>().ok())
+        })
         .expect("audit count should be numeric");
     assert_eq!(count, 1);
 
diff --git a/src/components/ErrorBoundary.tsx b/src/components/ErrorBoundary.tsx
index 1677b0f0..960a3c11 100644
--- a/src/components/ErrorBoundary.tsx
+++ b/src/components/ErrorBoundary.tsx
@@ -19,7 +19,11 @@ export class ErrorBoundary extends Component<Props, State> {
   }
 
   componentDidCatch(error: Error, info: ErrorInfo) {
-    console.error("[ErrorBoundary] Uncaught render error:", error, info.componentStack);
+    console.error(
+      "[ErrorBoundary] Uncaught render error:",
+      error,
+      info.componentStack,
+    );
   }
 
   render() {
diff --git a/src/components/business/DataGrid/ComplexValueViewer.tsx b/src/components/business/DataGrid/ComplexValueViewer.tsx
index 708daf60..49456256 100644
--- a/src/components/business/DataGrid/ComplexValueViewer.tsx
+++ b/src/components/business/DataGrid/ComplexValueViewer.tsx
@@ -25,7 +25,8 @@ function TreeNode({
   depth?: number;
 }) {
   const [expanded, setExpanded] = useState(depth < 2);
-  const isComplex = value !== null && value !== undefined && typeof value === "object";
+  const isComplex =
+    value !== null && value !== undefined && typeof value === "object";
   const isArr = Array.isArray(value);
 
   if (!isComplex) {
@@ -38,7 +39,9 @@ function TreeNode({
         className="flex items-baseline py-[2px] text-xs font-mono leading-5"
         style={{ paddingLeft: depth * 14 + 18 }}
       >
-        <span className="text-blue-500 dark:text-blue-400 mr-1 shrink-0">{label}</span>
+        <span className="text-blue-500 dark:text-blue-400 mr-1 shrink-0">
+          {label}
+        </span>
         <span className="text-muted-foreground mr-1 shrink-0">:</span>
         <span
           className={
@@ -98,7 +101,10 @@ function TableView({ value }: { value: unknown }) {
     const arr = value as unknown[];
     const allObjects =
       arr.length > 0 &&
-      arr.every((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+      arr.every(
+        (item) =>
+          item !== null && typeof item === "object" && !Array.isArray(item),
+      );
 
     const keys = allObjects
       ? Array.from(new Set(arr.flatMap((item) => Object.keys(item as object))))
@@ -110,21 +116,31 @@ function TableView({ value }: { value: unknown }) {
           <tr className="border-b border-border bg-muted/60">
             {keys ? (
               keys.map((k) => (
-                <th key={k} className="text-left px-3 py-1.5 text-muted-foreground font-medium">
+                <th
+                  key={k}
+                  className="text-left px-3 py-1.5 text-muted-foreground font-medium"
+                >
                   {k}
                 </th>
               ))
             ) : (
               <>
-                <th className="text-left px-3 py-1.5 text-muted-foreground font-medium w-14">#</th>
-                <th className="text-left px-3 py-1.5 text-muted-foreground font-medium">value</th>
+                <th className="text-left px-3 py-1.5 text-muted-foreground font-medium w-14">
+                  #
+                </th>
+                <th className="text-left px-3 py-1.5 text-muted-foreground font-medium">
+                  value
+                </th>
               </>
             )}
           </tr>
         </thead>
         <tbody>
           {arr.map((row, i) => (
-            <tr key={i} className="border-b border-border/40 hover:bg-muted/40 transition-colors">
+            <tr
+              key={i}
+              className="border-b border-border/40 hover:bg-muted/40 transition-colors"
+            >
               {keys ? (
                 keys.map((k) => {
                   const v = (row as Record<string, unknown>)[k];
@@ -140,7 +156,9 @@ function TableView({ value }: { value: unknown }) {
               ) : (
                 <>
                   <td className="px-3 py-1.5 text-muted-foreground">{i}</td>
-                  <td className={`px-3 py-1.5 ${row === null ? "text-muted-foreground italic" : ""}`}>
+                  <td
+                    className={`px-3 py-1.5 ${row === null ? "text-muted-foreground italic" : ""}`}
+                  >
                     {cellText(row)}
                   </td>
                 </>
@@ -157,15 +175,26 @@ function TableView({ value }: { value: unknown }) {
       <table className="text-xs font-mono w-full border-collapse">
         <thead>
           <tr className="border-b border-border bg-muted/60">
-            <th className="text-left px-3 py-1.5 text-muted-foreground font-medium w-2/5">key</th>
-            <th className="text-left px-3 py-1.5 text-muted-foreground font-medium">value</th>
+            <th className="text-left px-3 py-1.5 text-muted-foreground font-medium w-2/5">
+              key
+            </th>
+            <th className="text-left px-3 py-1.5 text-muted-foreground font-medium">
+              value
+            </th>
           </tr>
         </thead>
         <tbody>
           {Object.entries(value as Record<string, unknown>).map(([k, v]) => (
-            <tr key={k} className="border-b border-border/40 hover:bg-muted/40 transition-colors">
-              <td className="px-3 py-1.5 text-blue-500 dark:text-blue-400">{k}</td>
-              <td className={`px-3 py-1.5 ${v === null ? "text-muted-foreground italic" : ""}`}>
+            <tr
+              key={k}
+              className="border-b border-border/40 hover:bg-muted/40 transition-colors"
+            >
+              <td className="px-3 py-1.5 text-blue-500 dark:text-blue-400">
+                {k}
+              </td>
+              <td
+                className={`px-3 py-1.5 ${v === null ? "text-muted-foreground italic" : ""}`}
+              >
                 {cellText(v)}
               </td>
             </tr>
@@ -211,7 +240,9 @@ export function ComplexValueViewer({
 
         {/* Header */}
         <div className="flex items-center gap-2 px-4 h-11 border-b shrink-0 pr-12">
-          <span className="font-mono text-sm font-medium truncate min-w-0">{columnName}</span>
+          <span className="font-mono text-sm font-medium truncate min-w-0">
+            {columnName}
+          </span>
           <span className="text-[10px] uppercase tracking-wide text-muted-foreground bg-muted px-1.5 py-0.5 rounded shrink-0">
             {typeLabel}
           </span>
diff --git a/src/components/business/DataGrid/TableView.tsx b/src/components/business/DataGrid/TableView.tsx
index a5fb6ee8..1e05a301 100644
--- a/src/components/business/DataGrid/TableView.tsx
+++ b/src/components/business/DataGrid/TableView.tsx
@@ -577,7 +577,9 @@ export function TableView({
       // Check if there's a pending change for this cell
       const key = `${rowIndex}_${col}`;
       const pending = pendingChanges.get(key);
-      const value = pending ? pending.newValue : cellValueToString(currentValue);
+      const value = pending
+        ? pending.newValue
+        : cellValueToString(currentValue);
       setEditingCell({ row: rowIndex, col });
       setEditValue(value);
       setSelectedCell({ row: rowIndex, col });
@@ -1739,7 +1741,9 @@ export function TableView({
                     title="View Table Structure (DDL)"
                   >
                     <FileCode className="w-3.5 h-3.5" />
-                    <span className="text-xs font-medium leading-none">ddl</span>
+                    <span className="text-xs font-medium leading-none">
+                      ddl
+                    </span>
                   </Button>
                 </>
               )}
@@ -1841,7 +1845,9 @@ export function TableView({
                         JSON
                       </DropdownMenuItem>
                       <DropdownMenuItem
-                        onClick={() => void handleExport("current_page", "sql_dml")}
+                        onClick={() =>
+                          void handleExport("current_page", "sql_dml")
+                        }
                       >
                         SQL
                       </DropdownMenuItem>
@@ -1885,7 +1891,9 @@ export function TableView({
                         JSON
                       </DropdownMenuItem>
                       <DropdownMenuItem
-                        onClick={() => void handleExport("full_table", "sql_dml")}
+                        onClick={() =>
+                          void handleExport("full_table", "sql_dml")
+                        }
                       >
                         SQL
                       </DropdownMenuItem>
@@ -2149,7 +2157,11 @@ export function TableView({
                                 {displayValue !== null &&
                                 displayValue !== undefined ? (
                                   <span
-                                    className={modified ? "text-orange-600 dark:text-orange-400" : ""}
+                                    className={
+                                      modified
+                                        ? "text-orange-600 dark:text-orange-400"
+                                        : ""
+                                    }
                                   >
                                     {formatCellValue(displayValue)}
                                   </span>
@@ -2165,10 +2177,22 @@ export function TableView({
                                     onMouseDown={(e) => e.stopPropagation()}
                                     onClick={(e) => {
                                       e.stopPropagation();
-                                      setComplexViewer({ value: displayValue, columnName: column });
+                                      setComplexViewer({
+                                        value: displayValue,
+                                        columnName: column,
+                                      });
                                     }}
                                   >
-                                    <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                                    <svg
+                                      width="12"
+                                      height="12"
+                                      viewBox="0 0 24 24"
+                                      fill="none"
+                                      stroke="currentColor"
+                                      strokeWidth="2"
+                                      strokeLinecap="round"
+                                      strokeLinejoin="round"
+                                    >
                                       <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
                                     </svg>
                                   </button>
@@ -2371,7 +2395,9 @@ export function TableView({
           value={complexViewer.value}
           columnName={complexViewer.columnName}
           open={true}
-          onOpenChange={(open) => { if (!open) setComplexViewer(null); }}
+          onOpenChange={(open) => {
+            if (!open) setComplexViewer(null);
+          }}
         />
       )}
 
diff --git a/src/components/business/Sidebar/Sidebar.tsx b/src/components/business/Sidebar/Sidebar.tsx
index 3cefc127..996cee9a 100644
--- a/src/components/business/Sidebar/Sidebar.tsx
+++ b/src/components/business/Sidebar/Sidebar.tsx
@@ -98,7 +98,10 @@ export function Sidebar({
         className="h-full flex flex-col"
       >
         <TabsList className="w-full grid grid-cols-2 overflow-hidden">
-          <TabsTrigger value="connections" className="min-w-0 max-w-none truncate">
+          <TabsTrigger
+            value="connections"
+            className="min-w-0 max-w-none truncate"
+          >
             {t("sidebar.tabs.connections")}
           </TabsTrigger>
           <TabsTrigger value="queries" className="min-w-0 max-w-none truncate">
diff --git a/src/components/business/Sidebar/connection-list/helpers.tsx b/src/components/business/Sidebar/connection-list/helpers.tsx
index 60a5aba5..bd2dcd8f 100644
--- a/src/components/business/Sidebar/connection-list/helpers.tsx
+++ b/src/components/business/Sidebar/connection-list/helpers.tsx
@@ -15,8 +15,7 @@ export const getExportDefaultName = (
   format: "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full",
 ) => {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const ext =
-    format === "csv" ? "csv" : format === "json" ? "json" : "sql";
+  const ext = format === "csv" ? "csv" : format === "json" ? "json" : "sql";
   return `${tableName}_${timestamp}.${ext}`;
 };
 
diff --git a/src/lib/connection-form/rules.ts b/src/lib/connection-form/rules.ts
index 52769c32..f9023ffd 100644
--- a/src/lib/connection-form/rules.ts
+++ b/src/lib/connection-form/rules.ts
@@ -1,8 +1,5 @@
 import type { ConnectionForm, Driver } from "@/services/api";
-import {
-  isMysqlFamilyDriver,
-  isFileBasedDriver,
-} from "@/lib/driver-registry";
+import { isMysqlFamilyDriver, isFileBasedDriver } from "@/lib/driver-registry";
 
 export { isMysqlFamilyDriver, isFileBasedDriver };
 
diff --git a/src/lib/i18n/locales/ja.ts b/src/lib/i18n/locales/ja.ts
index c862af32..4ce27966 100644
--- a/src/lib/i18n/locales/ja.ts
+++ b/src/lib/i18n/locales/ja.ts
@@ -398,8 +398,7 @@ export const ja: Translations = {
   },
   tableView: {
     header: {
-      actionHint:
-        "{{column}} をクリックで列名コピー、ダブルクリックで並び替え",
+      actionHint: "{{column}} をクリックで列名コピー、ダブルクリックで並び替え",
     },
     toast: {
       columnNameCopied: "列名をコピーしました: {{column}}",
diff --git a/src/services/api.ts b/src/services/api.ts
index d9cce7de..b91be7c6 100644
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -299,7 +299,12 @@ export interface AIChatResponse {
   assistantMessageId: number;
 }
 
-export type TransferFormat = "csv" | "json" | "sql_dml" | "sql_ddl" | "sql_full";
+export type TransferFormat =
+  | "csv"
+  | "json"
+  | "sql_dml"
+  | "sql_ddl"
+  | "sql_full";
 export type ExportScope =
   | "current_page"
   | "filtered"
diff --git a/src/services/mocks.ts b/src/services/mocks.ts
index c0f317b5..d0c406a6 100644
--- a/src/services/mocks.ts
+++ b/src/services/mocks.ts
@@ -213,7 +213,12 @@ export const mockTableData = {
       created_at: "2024-01-15 10:30:00",
       updated_at: "2024-01-15 10:30:00",
       // object with 4 keys → abbreviated as {role, department, ... +2}
-      metadata: { role: "admin", department: "engineering", level: 5, active: true },
+      metadata: {
+        role: "admin",
+        department: "engineering",
+        level: 5,
+        active: true,
+      },
       // array with 3 items → [3 items]
       tags: ["vip", "beta-tester", "early-adopter"],
       settings: null,
@@ -230,7 +235,11 @@ export const mockTableData = {
       // array with 1 item → inline JSON
       tags: ["newsletter"],
       // nested object → tree view shows expand/collapse
-      settings: { theme: "dark", lang: "zh", notifications: { email: true, sms: false } },
+      settings: {
+        theme: "dark",
+        lang: "zh",
+        notifications: { email: true, sms: false },
+      },
     },
     {
       id: 3,
@@ -253,7 +262,11 @@ export const mockTableData = {
       created_at: "2024-01-18 09:15:00",
       updated_at: "2024-01-18 09:15:00",
       // object containing a nested array
-      metadata: { role: "moderator", permissions: ["read", "write", "delete"], score: 88 },
+      metadata: {
+        role: "moderator",
+        permissions: ["read", "write", "delete"],
+        score: 88,
+      },
       tags: ["moderator", "trusted"],
       settings: null,
     },
@@ -265,10 +278,18 @@ export const mockTableData = {
       created_at: "2024-01-19 16:50:00",
       updated_at: "2024-01-19 16:50:00",
       // array of objects → table view renders as multi-column table
-      metadata: [{ key: "plan", value: "pro" }, { key: "trial", value: false }],
+      metadata: [
+        { key: "plan", value: "pro" },
+        { key: "trial", value: false },
+      ],
       tags: ["pro"],
       // object with 4 keys → tree/table view
-      settings: { theme: "system", lang: "ja", timezone: "Asia/Tokyo", fontSize: 14 },
+      settings: {
+        theme: "system",
+        lang: "ja",
+        timezone: "Asia/Tokyo",
+        fontSize: 14,
+      },
     },
     {
       id: 6,
@@ -451,7 +472,10 @@ export const mockArrayTypeData: QueryResult = {
       scores: [95, 87, 72],
       flags: [true, false, true],
       readings: [3.14, 2.72, 1.41],
-      metadata_list: [{ source: "web", valid: true }, { source: "app", valid: false }],
+      metadata_list: [
+        { source: "web", valid: true },
+        { source: "app", valid: false },
+      ],
     },
     {
       id: 2,
@@ -761,9 +785,7 @@ export async function mockExecuteQuery(
   // Return different data based on query type
   if (lower.includes("select")) {
     // Dedicated array-type dataset: SELECT * FROM pg_arrays
-    const isArrayQuery =
-      lower.includes("pg_arrays") ||
-      lower.includes("array");
+    const isArrayQuery = lower.includes("pg_arrays") || lower.includes("array");
     // Dedicated complex-type dataset: SELECT * FROM json_test
     const isComplexQuery =
       !isArrayQuery &&
@@ -772,7 +794,11 @@ export async function mockExecuteQuery(
         lower.includes("jsonb") ||
         lower.includes("complex"));
     const result = {
-      ...(isArrayQuery ? mockArrayTypeData : isComplexQuery ? mockComplexTypeData : mockQueryResult),
+      ...(isArrayQuery
+        ? mockArrayTypeData
+        : isComplexQuery
+          ? mockComplexTypeData
+          : mockQueryResult),
       timeTakenMs: Math.floor(Math.random() * 100) + 20,
     };
     appendSqlExecutionLog({
@@ -896,7 +922,12 @@ const mockArrayTestTableMetadata: TableMetadata = {
     { name: "scores", type: "int4[]", nullable: true, primaryKey: false },
     { name: "flags", type: "bool[]", nullable: true, primaryKey: false },
     { name: "readings", type: "float8[]", nullable: true, primaryKey: false },
-    { name: "metadata_list", type: "jsonb[]", nullable: true, primaryKey: false },
+    {
+      name: "metadata_list",
+      type: "jsonb[]",
+      nullable: true,
+      primaryKey: false,
+    },
   ],
   indexes: [],
   foreignKeys: [],
@@ -948,12 +979,47 @@ export async function mockListDatabasesById(_id: number): Promise<string[]> {
 export async function mockGetMysqlCharsets(_id: number): Promise<string[]> {
   await new Promise((resolve) => setTimeout(resolve, 50));
   return [
-    "armscii8", "ascii", "big5", "binary", "cp1250", "cp1251", "cp1256",
-    "cp1257", "cp850", "cp852", "cp866", "cp932", "dec8", "eucjpms", "euckr",
-    "gb18030", "gb2312", "gbk", "geostd8", "greek", "hebrew", "hp8",
-    "keybcs2", "koi8r", "koi8u", "latin1", "latin2", "latin5", "latin7",
-    "macce", "macroman", "sjis", "swe7", "tis620", "ucs2", "ujis", "utf16",
-    "utf16le", "utf32", "utf8", "utf8mb4",
+    "armscii8",
+    "ascii",
+    "big5",
+    "binary",
+    "cp1250",
+    "cp1251",
+    "cp1256",
+    "cp1257",
+    "cp850",
+    "cp852",
+    "cp866",
+    "cp932",
+    "dec8",
+    "eucjpms",
+    "euckr",
+    "gb18030",
+    "gb2312",
+    "gbk",
+    "geostd8",
+    "greek",
+    "hebrew",
+    "hp8",
+    "keybcs2",
+    "koi8r",
+    "koi8u",
+    "latin1",
+    "latin2",
+    "latin5",
+    "latin7",
+    "macce",
+    "macroman",
+    "sjis",
+    "swe7",
+    "tis620",
+    "ucs2",
+    "ujis",
+    "utf16",
+    "utf16le",
+    "utf32",
+    "utf8",
+    "utf8mb4",
   ];
 }
 
@@ -967,8 +1033,12 @@ export async function mockGetMysqlCollations(
   await new Promise((resolve) => setTimeout(resolve, 50));
   const all: Record<string, string[]> = {
     utf8mb4: [
-      "utf8mb4_0900_ai_ci", "utf8mb4_0900_as_ci", "utf8mb4_0900_as_cs",
-      "utf8mb4_bin", "utf8mb4_general_ci", "utf8mb4_unicode_ci",
+      "utf8mb4_0900_ai_ci",
+      "utf8mb4_0900_as_ci",
+      "utf8mb4_0900_as_cs",
+      "utf8mb4_bin",
+      "utf8mb4_general_ci",
+      "utf8mb4_unicode_ci",
       "utf8mb4_unicode_520_ci",
     ],
     utf8: ["utf8_bin", "utf8_general_ci", "utf8_unicode_ci"],

From d64114a20ffb5042b711081c6326f659a5dfc981 Mon Sep 17 00:00:00 2001
From: codeErrorSleep <qiushaotest@qq.com>
Date: Fri, 10 Apr 2026 19:00:22 +0800
Subject: [PATCH 15/15] chore: update version to v0.3.3

---
 package.json              | 2 +-
 src-tauri/tauri.conf.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 6331011d..1f9a343b 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
     "url": "git+https://github.com/codeErrorSleep/dbpaw.git"
   },
   "private": true,
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 869d8ad0..90fb4142 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "DbPaw",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "identifier": "com.father.dbpaw",
   "build": {
     "beforeDevCommand": "bun run dev",