Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

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.rs
index 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.rs
new file mode 100644
index 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);
+}