25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(clickhouse): handle CTE INSERT command responses
lcq9289989e8e7fc59
diff --git a/crates/dbx-drivers/src/db/clickhouse_driver.rs b/crates/dbx-drivers/src/db/clickhouse_driver.rsindex 61ce49f4ed..6a9effbb3b 100644--- a/crates/dbx-drivers/src/db/clickhouse_driver.rs+++ b/crates/dbx-drivers/src/db/clickhouse_driver.rs@@ -1,3 +1,4 @@+use dbx_sql_core::sql_risk::{classify_sql_risk_for_database, SqlRisk};use futures::StreamExt;use reqwest::{Certificate, Client as HttpClient};use serde::Deserialize;@@ -7,6 +8,7 @@ use tokio_util::sync::CancellationToken;use super::{http_client_builder, with_connection_timeout};use crate::execution::{canceled_error, MAX_ROWS};+use crate::models::connection::DatabaseType;use crate::sql::starts_with_executable_sql_keyword;use crate::types::{ColumnInfo, DatabaseInfo, IndexInfo, ObjectStatistics, QueryResult, TableInfo};@@ -847,7 +849,10 @@ pub async fn execute_query_with_max_rows(let start = Instant::now();let row_limit = query_result_row_limit(max_rows);- if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"]) {+ // WITH can prefix INSERT as well as SELECT; successful writes return no JSON result set.+ let is_cte_write = starts_with_executable_sql_keyword(sql, &["WITH"])+ && classify_sql_risk_for_database(sql, DatabaseType::ClickHouse).is_ok_and(|risk| risk != SqlRisk::ReadOnly);+ if !is_cte_write && starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"]) {let result = ch_query_with_limit(client, sql, Some(database), QueryResultLimit::Limited(row_limit + 1)).await?;Ok(limited_query_result(result, start.elapsed().as_millis(), Some(row_limit)))} else {@@ -1141,6 +1146,70 @@ mod tests {(format!("http://{address}"), server)}+ #[tokio::test]+ async fn cte_insert_accepts_empty_command_response_without_result_limits() {+ let sql = "WITH a AS (SELECT 1 AS eid), b AS (SELECT 1 AS eid) \+ INSERT INTO test123(eid) SELECT b.eid FROM a LEFT JOIN b ON a.eid = b.eid";+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (mut socket, _) = listener.accept().await.unwrap();+ let request = read_http_request(&mut socket).await;+ write_http_response(&mut socket, "200 OK", "").await;+ request+ });+ let client = ChClient::new(&format!("http://{address}"), None, None, Duration::from_secs(5));+ let result = execute_query_with_max_rows(&client, "default", sql, Some(2)).await;+ let request = server.await.unwrap();++ let result = result.expect("successful CTE INSERT returns an empty command response, not JSON");+ assert!(result.columns.is_empty());+ assert!(result.rows.is_empty());+ assert!(!result.truncated);+ let target = request.lines().next().unwrap();+ assert!(!target.contains("max_result_rows"), "writes must not inherit query result limits");+ assert!(!target.contains("result_overflow_mode"));+ assert!(request.ends_with(sql));+ }++ #[tokio::test]+ async fn cte_select_preserves_result_decoding_and_limits() {+ for sql in [+ "WITH a AS (SELECT 1 AS eid) SELECT eid FROM a",+ "/* INSERT INTO t */ WITH 'INSERT INTO t' AS label SELECT 1 AS eid",+ "WITH a AS (SELECT 1 AS `insert`) SELECT `insert` AS eid FROM a",+ "WITH a AS (SELECT 1 AS insert) SELECT insert AS eid FROM a",+ "WITH replace('a', 'a', 'b') AS label SELECT 1 AS eid",+ "EXPLAIN WITH a AS (SELECT 1) INSERT INTO t SELECT * FROM a",+ ] {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ let (mut socket, _) = listener.accept().await.unwrap();+ let request = read_http_request(&mut socket).await;+ write_http_response(+ &mut socket,+ "200 OK",+ r#"{"meta":[{"name":"eid","type":"UInt64"}],"data":[[1],[2],[3]],"rows":3}"#,+ )+ .await;+ request+ });+ let client = ChClient::new(&format!("http://{address}"), None, None, Duration::from_secs(5));+ let result = execute_query_with_max_rows(&client, "default", sql, Some(2)).await.unwrap();+ let request = server.await.unwrap();++ assert_eq!(result.columns, vec!["eid"], "{sql}");+ assert_eq!(result.column_types, vec!["UInt64"], "{sql}");+ assert_eq!(result.rows, vec![vec![serde_json::json!(1)], vec![serde_json::json!(2)]], "{sql}");+ assert!(result.truncated, "{sql}");+ let target = request.lines().next().unwrap();+ assert!(target.contains("max_result_rows=3"), "{sql}");+ assert!(target.contains("result_overflow_mode=break"), "{sql}");+ assert!(request.ends_with(sql));+ }+ }+#[test]fn query_url_for_result_sets_adds_row_limit_break_settings() {let url = build_query_url(diff --git a/crates/dbx-drivers/tests/live_clickhouse_cte_insert.rs b/crates/dbx-drivers/tests/live_clickhouse_cte_insert.rsnew file mode 100644index 0000000000..86a5e5088c--- /dev/null+++ b/crates/dbx-drivers/tests/live_clickhouse_cte_insert.rs@@ -0,0 +1,71 @@+use dbx_drivers::db::clickhouse_driver::{execute_query, execute_query_with_max_rows, ChClient};+use std::time::Duration;++#[tokio::test]+#[ignore = "requires DBX_LIVE_CLICKHOUSE_* env vars pointing at a disposable ClickHouse 25.8.24 HTTP database with DDL/write access"]+async fn live_clickhouse_cte_insert_accepts_command_response() {+ let host = std::env::var("DBX_LIVE_CLICKHOUSE_HOST").expect("DBX_LIVE_CLICKHOUSE_HOST");+ let port = std::env::var("DBX_LIVE_CLICKHOUSE_PORT").expect("DBX_LIVE_CLICKHOUSE_PORT");+ let user = std::env::var("DBX_LIVE_CLICKHOUSE_USER").expect("DBX_LIVE_CLICKHOUSE_USER");+ let password = std::env::var("DBX_LIVE_CLICKHOUSE_PASSWORD").expect("DBX_LIVE_CLICKHOUSE_PASSWORD");+ let database = std::env::var("DBX_LIVE_CLICKHOUSE_DATABASE").expect("DBX_LIVE_CLICKHOUSE_DATABASE");+ let client = ChClient::new(&format!("http://{host}:{port}"), Some(user), Some(password), Duration::from_secs(30));+ let table = format!("dbx_issue_13303_{}", uuid::Uuid::new_v4().simple());+ execute_query(+ &client,+ &database,+ &format!(+ "CREATE TABLE {table} (`timestamp` DateTime64(9, 'UTC'), eid UInt64,) \+ ENGINE = MergeTree() PARTITION BY toYYYYMMDD(timestamp) ORDER BY (timestamp)"+ ),+ )+ .await+ .expect("create isolated issue #13303 table");+ execute_query(&client, &database, &format!("INSERT INTO {table} VALUES ('2026-10-23 00:00:00.123456789', 42)"))+ .await+ .expect("seed one row with DateTime64(9) precision");+ let original_sql = format!(+ "WITH a AS (SELECT timestamp, eid FROM {table}), \+ b AS (SELECT timestamp, eid FROM {table}) \+ INSERT INTO {table} (`timestamp`, eid) \+ VALUES (SELECT a.`timestamp`, b.eid FROM a LEFT JOIN b ON a.eid = b.eid)"+ );+ let original_result = execute_query_with_max_rows(&client, &database, &original_sql, Some(1)).await;+ // The report's VALUES (SELECT ...) form is rejected by ClickHouse 25.8.24.21.+ // Use its valid INSERT ... SELECT equivalent to isolate the driver's response handling.+ let sql = format!(+ "WITH a AS (SELECT timestamp, eid FROM {table}), \+ b AS (SELECT timestamp, eid FROM {table}) \+ INSERT INTO {table} (`timestamp`, eid) \+ SELECT a.`timestamp`, b.eid FROM a LEFT JOIN b ON a.eid = b.eid"+ );+ let result = execute_query_with_max_rows(&client, &database, &sql, Some(1)).await;+ let count = execute_query(&client, &database, &format!("SELECT count() AS n FROM {table}")).await;+ let selected = execute_query_with_max_rows(+ &client,+ &database,+ &format!("WITH a AS (SELECT eid FROM {table}) SELECT eid FROM a"),+ Some(1),+ )+ .await;+ let cleanup = execute_query(&client, &database, &format!("DROP TABLE {table} SYNC")).await;+ cleanup.expect("drop isolated issue #13303 table");+ let original_error = original_result.expect_err("invalid VALUES subquery must remain an error");+ assert!(original_error.contains("Code: 62"), "{original_error}");+ let result = result.unwrap_or_else(|error| {+ panic!(+ "issue #13303 CTE INSERT failed: {error}; rows after execution: {:?}",+ count.as_ref().map(|result| &result.rows)+ )+ });+ assert!(result.columns.is_empty());+ assert!(result.rows.is_empty());+ assert!(!result.truncated);+ let count = count.unwrap();+ let count = &count.rows[0][0];+ assert_eq!(count.as_u64().or_else(|| count.as_str()?.parse().ok()), Some(2));+ let selected = selected.unwrap();+ assert_eq!(selected.columns, vec!["eid"]);+ assert_eq!(selected.rows.len(), 1);+ assert!(selected.truncated);+}