The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(database): add ClickHouse data sources (#865)
kkmihaie04e5dd57d8e
diff --git a/Cargo.lock b/Cargo.lockindex 428910432..ec56cb175 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4154,8 +4154,11 @@ dependencies = ["dirs 6.0.0","futures","ide-core",+ "ide-http","ide-ssh","parking_lot",+ "reqwest",+ "rustls","serde","serde_json","specta",@@ -4166,6 +4169,7 @@ dependencies = ["tokio-util","toml 0.9.12+spec-1.1.0","tracing",+ "uuid",][[package]]@@ -7133,6 +7137,7 @@ dependencies = ["rustls-platform-verifier","serde","serde_json",+ "serde_urlencoded","sync_wrapper","tokio","tokio-rustls",@@ -7491,6 +7496,12 @@ dependencies = ["wait-timeout",]+[[package]]+name = "ryu"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"+[[package]]name = "saa"version = "5.6.2"@@ -7795,6 +7806,18 @@ dependencies = ["serde_core",]+[[package]]+name = "serde_urlencoded"+version = "0.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"+dependencies = [+ "form_urlencoded",+ "itoa",+ "ryu",+ "serde",+]+[[package]]name = "serde_with"version = "3.24.0"diff --git a/crates/ide-db/Cargo.toml b/crates/ide-db/Cargo.tomlindex 6a5cb4407..8f9853930 100644--- a/crates/ide-db/Cargo.toml+++ b/crates/ide-db/Cargo.toml@@ -8,7 +8,7 @@ license.workspace = true[dependencies]ide-core.workspace = trueserde.workspace = true-serde_json.workspace = true+serde_json = { workspace = true, features = ["raw_value"] }specta.workspace = truetoml.workspace = truetokio.workspace = true@@ -21,6 +21,10 @@ bb8.workspace = truetokio-util = { workspace = true, features = ["compat"] }dirs.workspace = trueide-ssh.workspace = true+ide-http.workspace = true+reqwest = { workspace = true, features = ["query"] }+rustls.workspace = true+uuid.workspace = true[dev-dependencies]tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }diff --git a/crates/ide-db/src/clickhouse.rs b/crates/ide-db/src/clickhouse.rsnew file mode 100644index 000000000..34e869dce--- /dev/null+++ b/crates/ide-db/src/clickhouse.rs@@ -0,0 +1,844 @@+use crate::conn::{QueryResult, ResultColumn, Setup};+use crate::source::{DataSource, DbSslMode, DbTxMode};+use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};+use parking_lot::RwLock;+use reqwest::{Client, RequestBuilder, StatusCode, Url};+use std::sync::Arc;+use std::time::{Duration, Instant};+use tokio::sync::Mutex;++#[derive(Clone)]+pub struct ClickhousePool(Arc<State>);++struct State {+ client: RwLock<Option<Client>>,+ endpoint: Url,+ user: String,+ password: String,+ database: String,+ settings: Vec<(String, String)>,+ read_only: bool,+ session_id: String,+ session: Mutex<bool>,+ closed: CancellationToken,+}++/// The response format: a names line, a types line, then one JSON array per row, so rows past+/// the grid's limit are skipped without being parsed.+const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";++pub(crate) fn transaction_error() -> IdeError {+ IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")+}++impl ClickhousePool {+ pub(crate) async fn connect(source: &DataSource, password: Option<&str>, setup: Setup) -> IdeResult<Self> {+ if source.options.transaction == DbTxMode::Manual {+ return Err(transaction_error());+ }+ for (name, _) in &setup.params {+ if reserved_setting(name) {+ return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));+ }+ }+ let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);+ let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];+ if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {+ return Err(IdeError::invalid(+ "ClickHouse TLS certificate files require an SSL mode of Require, Verify CA, or Verify Full",+ ));+ }+ let host = source.host.trim();+ if host.is_empty() || host.contains(['/', '@', '?', '#']) {+ return Err(IdeError::invalid("ClickHouse host must contain only a hostname or IP address"));+ }+ let host = if host.contains(':') && !host.starts_with('[') { format!("[{host}]") } else { host.to_owned() };+ let scheme = if secure { "https" } else { "http" };+ let port = source.port.unwrap_or(if secure { 8443 } else { 8123 });+ let endpoint = Url::parse(&format!("{scheme}://{host}:{port}/"))+ .map_err(|_| IdeError::invalid("invalid ClickHouse HTTP host or port"))?;+ let timeout = setup.connect_timeout.unwrap_or(Duration::from_secs(30));+ let _ = rustls::crypto::ring::default_provider().install_default();+ let mut builder = Client::builder()+ .connect_timeout(timeout)+ .pool_max_idle_per_host(4)+ .redirect(reqwest::redirect::Policy::none())+ .user_agent(concat!("OpenIDEA/", env!("CARGO_PKG_VERSION")));+ let ca = source.ssl_ca_file.trim();+ if !ca.is_empty() {+ let pem = read_pem(ca, "CA certificate")?;+ let certificates = reqwest::Certificate::from_pem_bundle(&pem)+ .map_err(|_| IdeError::invalid("invalid ClickHouse CA certificate PEM"))?;+ if certificates.is_empty() {+ return Err(IdeError::invalid("ClickHouse CA certificate PEM contains no certificates"));+ }+ builder = builder.tls_certs_only(certificates);+ }+ if source.ssl == DbSslMode::VerifyCa {+ if ca.is_empty() {+ return Err(IdeError::invalid("ClickHouse Verify CA requires a CA certificate file"));+ }+ builder = builder.tls_danger_accept_invalid_hostnames(true);+ }+ let cert = source.ssl_cert_file.trim();+ let key = source.ssl_key_file.trim();+ if cert.is_empty() != key.is_empty() {+ return Err(IdeError::invalid("ClickHouse client TLS requires both certificate and key files"));+ }+ if !cert.is_empty() {+ let mut pem = read_pem(cert, "client certificate")?;+ pem.push(b'\n');+ pem.extend(read_pem(key, "client key")?);+ let identity = reqwest::Identity::from_pem(&pem)+ .map_err(|_| IdeError::invalid("invalid ClickHouse client certificate or key PEM"))?;+ builder = builder.identity(identity);+ }+ let proxy = ide_core::proxy_settings::proxy();+ let client = ide_http::client::with_proxy(builder, &proxy).build().map_err(http_error)?;+ let database = if source.options.default_schema.trim().is_empty() {+ source.database.trim()+ } else {+ source.options.default_schema.trim()+ };+ let pool = Self(Arc::new(State {+ client: RwLock::new(Some(client)),+ endpoint,+ user: if source.user.is_empty() { "default".into() } else { source.user.clone() },+ password: password.unwrap_or_default().to_owned(),+ database: if database.is_empty() { "default".into() } else { database.into() },+ settings: setup.params,+ read_only: source.read_only,+ session_id: uuid::Uuid::new_v4().to_string(),+ session: Mutex::new(false),+ closed: CancellationToken::new(),+ }));+ let cancel = CancellationToken::new();+ let initialize = async {+ pool.execute("SELECT 1", 1, &cancel).await?;+ for sql in setup.statements {+ pool.execute(&sql, 0, &cancel).await?;+ }+ Ok(pool.clone())+ };+ tokio::pin!(initialize);+ tokio::select! {+ result = &mut initialize => {+ if result.is_err() {+ pool.close();+ }+ result+ },+ () = tokio::time::sleep(timeout) => {+ cancel.cancel();+ let _ = initialize.await;+ pool.close();+ Err(IdeError::new(ErrorKind::TimedOut, "timed out connecting to ClickHouse HTTP"))+ }+ }+ }++ pub fn close(&self) {+ self.0.closed.cancel();+ self.0.client.write().take();+ }++ pub fn is_closed(&self) -> bool {+ self.0.closed.is_cancelled()+ }++ fn client(&self) -> IdeResult<Client> {+ self.0.client.read().clone().ok_or_else(|| IdeError::new(ErrorKind::Io, "ClickHouse connection is closed"))+ }++ fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {+ let mut request = client+ .post(self.0.endpoint.clone())+ .basic_auth(&self.0.user, Some(&self.0.password))+ .header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")+ .query(&self.0.settings)+ .query(&[+ ("session_id", self.0.session_id.clone()),+ ("session_timeout", "3600".into()),+ ("query_id", query_id.to_owned()),+ ("default_format", FORMAT.into()),+ ("output_format_json_quote_denormals", "1".into()),+ ("max_result_rows", max_rows.saturating_add(1).to_string()),+ ("result_overflow_mode", "break".into()),+ ]);+ if initialized {+ request = request.query(&[("session_check", "1")]);+ } else {+ request = request.query(&[("database", &self.0.database)]);+ }+ if self.0.read_only {+ request = request.query(&[("readonly", "1")]);+ }+ request+ }++ pub async fn execute(&self, sql: &str, max_rows: usize, cancel: &CancellationToken) -> IdeResult<QueryResult> {+ if transaction_statement(sql) {+ return Err(transaction_error());+ }+ let mut session = tokio::select! {+ biased;+ () = cancel.cancelled() => return Err(IdeError::cancelled()),+ () = self.0.closed.cancelled() => return Err(IdeError::new(ErrorKind::Io, "ClickHouse connection is closed")),+ session = self.0.session.lock() => session,+ };+ let client = self.client()?;+ let query_id = uuid::Uuid::new_v4().to_string();+ let request = self.request(&client, &query_id, max_rows, *session).body(sql.to_owned());+ let started = Instant::now();+ let fetch = async {+ let mut response = request.send().await.map_err(http_error)?;+ let execution_ms = started.elapsed().as_secs_f64() * 1000.0;+ let status = response.status();+ let header = |name: &str| response.headers().get(name).and_then(|v| v.to_str().ok()).map(str::to_owned);+ let exception_code = header("X-ClickHouse-Exception-Code");+ let format = header("X-ClickHouse-Format");+ let affected = header("X-ClickHouse-Summary")+ .and_then(|v| serde_json::from_str::<serde_json::Value>(&v).ok())+ .and_then(|v| {+ v.get("written_rows")+ .and_then(|n| n.as_str().and_then(|n| n.parse::<u64>().ok()).or_else(|| n.as_u64()))+ });+ if !status.is_success() || exception_code.as_deref().is_some_and(|code| code != "0") {+ let body = response.bytes().await.map_err(http_error)?;+ return Err(self.server_error(status, exception_code.as_deref(), &body));+ }+ let (columns, rows, has_more) = if format.as_deref().is_some_and(|f| f != FORMAT) {+ let body = response.bytes().await.map_err(http_error)?;+ if !body.iter().all(u8::is_ascii_whitespace) {+ return Err(IdeError::invalid(+ "ClickHouse result grids need the default output format; remove the query's FORMAT clause",+ ));+ }+ (Vec::new(), Vec::new(), false)+ } else {+ let mut reader = RowReader::new(max_rows);+ while let Some(chunk) = response.chunk().await.map_err(http_error)? {+ reader.push(&chunk)?;+ }+ reader.finish().map_err(|error| self.redact_error(error))?+ };+ let affected = if columns.is_empty() { affected.map(|n| n as f64) } else { None };+ Ok(QueryResult {+ statement: sql.to_owned(),+ columns,+ rows,+ affected,+ has_more,+ elapsed_ms: started.elapsed().as_secs_f64() * 1000.0,+ execution_ms,+ })+ };+ let result = tokio::select! {+ biased;+ () = cancel.cancelled() => None,+ () = self.0.closed.cancelled() => None,+ result = fetch => Some(result),+ };+ match result {+ Some(result) => {+ if result.is_ok() {+ *session = true;+ }+ result+ }+ None => {+ let killed = self.kill(&client, &query_id).await;+ match killed {+ Ok(()) => Err(IdeError::cancelled()),+ Err(error) => Err(IdeError::new(+ ErrorKind::Cancelled,+ format!("cancelled locally; ClickHouse server cancellation failed: {}", error.message),+ )),+ }+ }+ }+ }++ async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {+ let response = client+ .post(self.0.endpoint.clone())+ .basic_auth(&self.0.user, Some(&self.0.password))+ .timeout(Duration::from_secs(3))+ .body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))+ .send()+ .await+ .map_err(http_error)?;+ let status = response.status();+ let code = response+ .headers()+ .get("X-ClickHouse-Exception-Code")+ .and_then(|value| value.to_str().ok())+ .map(str::to_owned);+ let body = response.bytes().await.map_err(http_error)?;+ if status.is_success() && !code.as_deref().is_some_and(|code| code != "0") && !body.starts_with(b"Code:") {+ Ok(())+ } else {+ Err(self.server_error(status, code.as_deref(), &body))+ }+ }++ fn redact_error(&self, mut error: IdeError) -> IdeError {+ if !self.0.password.is_empty() {+ error.message = error.message.replace(&self.0.password, "[redacted]");+ }+ error+ }++ fn server_error(&self, status: StatusCode, code: Option<&str>, body: &[u8]) -> IdeError {+ let message = String::from_utf8_lossy(body);+ let message: String = exception_text(&message).chars().take(16_384).collect();+ let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)+ || matches!(code, Some("193" | "194" | "195" | "516" | "497"));+ let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };+ let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {+ "ClickHouse HTTP session expired; reconnect to restore session settings"+ } else {+ detail+ };+ self.redact_error(IdeError::new(+ if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },+ format!("ClickHouse HTTP {}: {detail}", status.as_u16()),+ ))+ }+}++type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);++/// Decodes a streamed [`FORMAT`] body. Keeps the first `max_rows` rows; later rows only set+/// `has_more` and are read past unparsed, so a grid limit bounds memory however large the+/// block `result_overflow_mode=break` lets the server send. A line that is not a JSON array+/// starts the exception ClickHouse writes when a query fails mid-stream.+struct RowReader {+ max_rows: usize,+ pending: Vec<u8>,+ names: Option<Vec<String>>,+ types: Option<Vec<String>>,+ rows: Vec<Vec<Option<String>>>,+ more: bool,+ exception: Option<String>,+}++impl RowReader {+ fn new(max_rows: usize) -> Self {+ Self { max_rows, pending: Vec::new(), names: None, types: None, rows: Vec::new(), more: false, exception: None }+ }++ fn push(&mut self, chunk: &[u8]) -> IdeResult<()> {+ self.pending.extend_from_slice(chunk);+ let buffer = std::mem::take(&mut self.pending);+ let mut start = 0;+ while let Some(end) = buffer[start..].iter().position(|&b| b == b'\n') {+ self.line(&buffer[start..start + end])?;+ start += end + 1;+ }+ self.pending = buffer[start..].to_vec();+ Ok(())+ }++ fn line(&mut self, line: &[u8]) -> IdeResult<()> {+ if let Some(exception) = &mut self.exception {+ if exception.len() < 16_384 {+ exception.push_str(&String::from_utf8_lossy(line));+ exception.push('\n');+ }+ return Ok(());+ }+ let text = line.trim_ascii();+ if text.is_empty() {+ return Ok(());+ }+ if text[0] != b'[' {+ self.exception = Some(format!("{}\n", String::from_utf8_lossy(line)));+ return Ok(());+ }+ if self.names.is_some() && self.types.is_some() && self.rows.len() >= self.max_rows {+ self.more = true;+ return Ok(());+ }+ let Ok(values) = serde_json::from_slice::<Vec<Box<serde_json::value::RawValue>>>(text) else {+ self.exception = Some(format!("{}\n", String::from_utf8_lossy(line)));+ return Ok(());+ };+ let protocol = |message: String| IdeError::new(ErrorKind::Protocol, message);+ let header = |values: Vec<Box<serde_json::value::RawValue>>| {+ values+ .iter()+ .map(|v| serde_json::from_str::<String>(v.get()))+ .collect::<Result<Vec<_>, _>>()+ .map_err(|e| protocol(format!("invalid ClickHouse result header: {e}")))+ };+ let Some(names) = &self.names else {+ self.names = Some(header(values)?);+ return Ok(());+ };+ if self.types.is_none() {+ self.types = Some(header(values)?);+ return Ok(());+ }+ if values.len() != names.len() {+ return Err(protocol("ClickHouse result row width does not match its metadata".into()));+ }+ let row = values+ .into_iter()+ .map(|value| {+ let text = value.get();+ if text == "null" {+ Ok(None)+ } else if text.starts_with('"') {+ serde_json::from_str::<String>(text).map(Some).map_err(|e| protocol(e.to_string()))+ } else {+ Ok(Some(text.to_owned()))+ }+ })+ .collect::<IdeResult<_>>()?;+ self.rows.push(row);+ Ok(())+ }++ fn finish(mut self) -> IdeResult<DecodedResult> {+ let rest = std::mem::take(&mut self.pending);+ self.line(&rest)?;+ if let Some(exception) = self.exception {+ return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));+ }+ let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };+ let types = self.types.unwrap_or_default();+ if types.len() != names.len() {+ return Err(IdeError::new(ErrorKind::Protocol, "ClickHouse result types do not match its columns"));+ }+ let columns = names.into_iter().zip(types).map(|(name, type_name)| ResultColumn { name, type_name }).collect();+ Ok((columns, self.rows, self.more))+ }+}++/// The server's message in a failed response: rows already streamed and the+/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.+fn exception_text(body: &str) -> &str {+ let Some(at) = body.find("Code:") else { return body.trim() };+ let text = &body[at..];+ match text.find("\n__exception__") {+ // The line before the closing marker is `<length> <tag>`.+ Some(end) => text[..end].trim_end().rsplit_once('\n').map_or(text[..end].trim(), |(message, _)| message.trim()),+ None => text.trim(),+ }+}++fn http_error(error: reqwest::Error) -> IdeError {+ use std::error::Error;+ let kind = if error.is_timeout() { ErrorKind::TimedOut } else { ErrorKind::Io };+ let error = error.without_url();+ let mut message = error.to_string();+ let mut source = error.source();+ while let Some(error) = source {+ let detail = error.to_string();+ if !message.contains(&detail) {+ message.push_str(": ");+ message.push_str(&detail);+ }+ source = error.source();+ }+ IdeError::new(kind, format!("ClickHouse HTTP: {message}"))+}++fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {+ std::fs::read(ide_ssh::expand(path))+ .map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))+}++fn reserved_setting(name: &str) -> bool {+ let name = name.to_ascii_lowercase();+ name.starts_with("output_format_json_")+ || matches!(+ name.as_str(),+ "user"+ | "password"+ | "query"+ | "database"+ | "session_id"+ | "session_check"+ | "session_timeout"+ | "query_id"+ | "default_format"+ | "max_result_rows"+ | "result_overflow_mode"+ | "readonly"+ )+}++fn transaction_statement(sql: &str) -> bool {+ let mut sql = sql.trim_start();+ loop {+ if let Some(rest) = sql.strip_prefix("--").or_else(|| sql.strip_prefix('#')) {+ sql = rest.split_once('\n').map_or("", |(_, rest)| rest).trim_start();+ } else if let Some(rest) = sql.strip_prefix("/*") {+ sql = rest.split_once("*/").map_or("", |(_, rest)| rest).trim_start();+ } else {+ break;+ }+ }+ let mut words = sql.split(|c: char| !c.is_ascii_alphanumeric() && c != '_').filter(|s| !s.is_empty());+ let first = words.next().unwrap_or_default();+ ["BEGIN", "COMMIT", "ROLLBACK", "SAVEPOINT", "RELEASE"].iter().any(|s| first.eq_ignore_ascii_case(s))+ || (first.eq_ignore_ascii_case("START") && words.next().is_some_and(|s| s.eq_ignore_ascii_case("TRANSACTION")))+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::conn::Pool;+ use crate::source::{DbDriver, DbOptions, DbProperty};+ use tokio::io::{AsyncReadExt, AsyncWriteExt};++ const ONE: &str = "[\"1\"]\n[\"UInt8\"]\n[1]\n";++ async fn read_request(stream: &mut tokio::net::TcpStream) -> String {+ let mut bytes = Vec::new();+ let mut buffer = [0; 4096];+ loop {+ let count = tokio::time::timeout(Duration::from_secs(5), stream.read(&mut buffer)).await.unwrap().unwrap();+ assert!(count > 0, "request ended early");+ bytes.extend_from_slice(&buffer[..count]);+ if let Some(end) = bytes.windows(4).position(|s| s == b"\r\n\r\n") {+ let header = String::from_utf8_lossy(&bytes[..end]);+ let length: usize = header+ .lines()+ .find_map(|line| {+ line.to_ascii_lowercase().strip_prefix("content-length:").map(|v| v.trim().parse().unwrap())+ })+ .unwrap_or(0);+ if bytes.len() >= end + 4 + length {+ return String::from_utf8(bytes).unwrap();+ }+ }+ }+ }++ async fn reply(stream: &mut tokio::net::TcpStream, status: &str, headers: &str, body: &str) {+ let response =+ format!("HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n{headers}\r\n{body}", body.len());+ stream.write_all(response.as_bytes()).await.unwrap();+ }++ async fn server(+ responses: Vec<(&'static str, &'static str, &'static str)>,+ ) -> (u16, tokio::task::JoinHandle<Vec<String>>) {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let port = listener.local_addr().unwrap().port();+ let task = tokio::spawn(async move {+ let mut requests = Vec::new();+ for (status, headers, body) in responses {+ let (mut stream, _) =+ tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();+ requests.push(read_request(&mut stream).await);+ reply(&mut stream, status, headers, body).await;+ }+ requests+ });+ (port, task)+ }++ fn source(port: u16) -> DataSource {+ DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }+ }++ fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {+ let mut reader = RowReader::new(max_rows);+ for part in body.chunks(chunk) {+ reader.push(part)?;+ }+ reader.finish()+ }++ #[test]+ fn rows_preserve_precision_nulls_and_strings_across_chunks() {+ let body = concat!(+ r#"["n", "d", "v", "v", "v"]"#,+ "\n",+ r#"["UInt64", "Decimal(38, 9)", "Nullable(String)", "Nullable(String)", "Nullable(String)"]"#,+ "\n",+ r#"[18446744073709551615, 12345678901234567890.123456789, null, "null", "ᴺᵁᴸᴸ"]"#,+ );+ for chunk in [1, 7, body.len()] {+ let (columns, rows, more) = decode(body.as_bytes(), 1, chunk).unwrap();+ assert_eq!(columns.len(), 5);+ assert_eq!(columns[1].type_name, "Decimal(38, 9)");+ assert_eq!(+ rows[0],+ vec![+ Some("18446744073709551615".into()),+ Some("12345678901234567890.123456789".into()),+ None,+ Some("null".into()),+ Some("ᴺᵁᴸᴸ".into()),+ ]+ );+ assert!(!more);+ }+ let (columns, rows, more) = decode(b"[\"x\"]\n[\"String\"]\n", 0, 64).unwrap();+ assert_eq!(columns[0].name, "x");+ assert!(rows.is_empty() && !more);+ assert_eq!(decode(b"", 5, 64).unwrap().0.len(), 0);+ assert!(decode(b"[\"x\"]\n[\"UInt8\"]\n[1, 2]\n", 1, 64).is_err());+ }++ #[test]+ fn rows_past_the_limit_are_skipped_but_a_later_exception_still_fails() {+ let mut body = String::from("[\"n\"]\n[\"UInt64\"]\n");+ for n in 0..1000 {+ body.push_str(&format!("[{n}]\n"));+ }+ let (_, rows, more) = decode(body.as_bytes(), 2, 4096).unwrap();+ assert_eq!(rows, vec![vec![Some("0".into())], vec![Some("1".into())]]);+ assert!(more);+ body.push_str("\n__exception__\nabcdefgh\nCode: 395. DB::Exception: Value passed to 'throwIf' is non-zero\n");+ body.push_str("62 abcdefgh\n__exception__\n");+ let error = decode(body.as_bytes(), 2, 4096).unwrap_err();+ assert_eq!(error.message, "ClickHouse: Code: 395. DB::Exception: Value passed to 'throwIf' is non-zero");+ let multiline = "Code: 62. DB::Exception: Syntax error\nat line 2";+ assert_eq!(exception_text(multiline), multiline);+ }++ #[tokio::test]+ async fn http_requests_use_auth_settings_limits_and_a_shared_session() {+ let (port, requests) = server(vec![+ ("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),+ ("200 OK", "", ""),+ (+ "200 OK",+ "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",+ "[\"n\"]\n[\"UInt64\"]\n[\"1\"]\n[\"2\"]\n[\"3\"]\n",+ ),+ ])+ .await;+ let source = DataSource {+ user: "reader".into(),+ read_only: true,+ options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },+ properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],+ ..source(port)+ };+ let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();+ pool.execute("USE other", 0, &CancellationToken::new()).await.unwrap();+ let result = pool.execute("SELECT number FROM numbers(3)", 1, &CancellationToken::new()).await.unwrap();+ assert_eq!(result.rows, vec![vec![Some("1".into())]]);+ assert!(result.has_more && result.affected.is_none());+ let requests = requests.await.unwrap();+ let target = |request: &String| {+ Url::parse(&format!(+ "http://localhost{}",+ request.lines().next().unwrap().split_whitespace().nth(1).unwrap()+ ))+ .unwrap()+ };+ let urls: Vec<_> = requests.iter().map(target).collect();+ let value = |url: &Url, key: &str| url.query_pairs().find(|(k, _)| k == key).map(|(_, v)| v.into_owned());+ assert_eq!(value(&urls[0], "database").as_deref(), Some("analytics"));+ assert_eq!(value(&urls[1], "database"), None);+ assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));+ assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));+ assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));+ assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));+ for (request, url) in requests.iter().zip(&urls) {+ assert!(request.starts_with("POST /?"));+ assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));+ assert!(!url.as_str().contains("reader") && !url.as_str().contains("mock-password"));+ assert_eq!(value(url, "readonly").as_deref(), Some("1"));+ assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));+ assert_eq!(value(url, "max_threads").as_deref(), Some("2"));+ }+ assert!(requests[0].ends_with("SELECT 1"));+ assert!(pool.transaction(&[]).await.is_err());+ let cancel = CancellationToken::new();+ cancel.cancel();+ assert_eq!(pool.execute("SELECT 1", 1, &cancel).await.unwrap_err().kind, ErrorKind::Cancelled);+ pool.close().await;+ assert!(pool.is_closed());+ assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());+ }++ #[tokio::test]+ async fn sequential_queries_reuse_the_http_connection() {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let port = listener.local_addr().unwrap().port();+ let task = tokio::spawn(async move {+ let (mut stream, _) = listener.accept().await.unwrap();+ for _ in 0..2 {+ read_request(&mut stream).await;+ let response = format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{ONE}", ONE.len());+ stream.write_all(response.as_bytes()).await.unwrap();+ }+ });+ let pool = Pool::connect(&source(port), None, None).await.unwrap();+ assert_eq!(+ pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap().rows,+ vec![vec![Some("1".into())]]+ );+ task.await.unwrap();+ }++ #[tokio::test]+ async fn server_errors_keep_details_and_hide_passwords() {+ let (port, requests) = server(vec![(+ "403 Forbidden",+ "X-ClickHouse-Exception-Code: 516\r\n",+ "Code: 516. DB::Exception: bad mock-password",+ )])+ .await;+ let error = match Pool::connect(&source(port), Some("mock-password"), None).await {+ Ok(_) => panic!("expected login failure"),+ Err(error) => error,+ };+ assert_eq!(error.kind, ErrorKind::PermissionDenied);+ assert!(error.message.contains("516") && error.message.contains("[redacted]"));+ assert!(!error.message.contains("mock-password"));+ requests.await.unwrap();+ let (port, requests) = server(vec![("200 OK", "", "Code: 241. DB::Exception: memory limit")]).await;+ let error = match Pool::connect(&source(port), None, None).await {+ Ok(_) => panic!("expected late query failure"),+ Err(error) => error,+ };+ assert!(error.message.contains("memory limit"));+ requests.await.unwrap();+ let (port, requests) = server(vec![(+ "500 Internal Server Error",+ "X-ClickHouse-Exception-Code: 395\r\n",+ "[\"1\"]\n[\"UInt8\"]\n[1]\n\n__exception__\ntag\nCode: 395. DB::Exception: thrown\n32 tag\n__exception__\n",+ )])+ .await;+ let error = match Pool::connect(&source(port), None, None).await {+ Ok(_) => panic!("expected mid-stream failure"),+ Err(error) => error,+ };+ assert_eq!(error.message, "ClickHouse HTTP 500: Code: 395. DB::Exception: thrown");+ requests.await.unwrap();+ }++ #[tokio::test]+ async fn cancellation_sends_kill_outside_the_busy_session() {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let port = listener.local_addr().unwrap().port();+ let (started, received) = tokio::sync::oneshot::channel();+ let server = tokio::spawn(async move {+ let (mut health, _) = listener.accept().await.unwrap();+ read_request(&mut health).await;+ reply(&mut health, "200 OK", "", ONE).await;+ drop(health);+ let (mut query, _) = listener.accept().await.unwrap();+ let request = read_request(&mut query).await;+ started.send(()).unwrap();+ let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();+ let kill_request = read_request(&mut kill).await;+ reply(&mut kill, "200 OK", "", "").await;+ (request, kill_request)+ });+ let pool = Pool::connect(&source(port), None, None).await.unwrap();+ let cancel = CancellationToken::new();+ let query = pool.execute("SELECT sleep(30)", 1, &cancel);+ let cancelled = async {+ received.await.unwrap();+ cancel.cancel();+ };+ let (result, ()) = tokio::join!(query, cancelled);+ assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);+ let (query, kill) = server.await.unwrap();+ let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();+ let url = Url::parse(&format!("http://localhost{target}")).unwrap();+ let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();+ assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));+ assert!(!kill.contains("session_id="));+ }++ #[tokio::test]+ async fn unsupported_settings_and_transactions_fail_before_connecting() {+ for statement in ["BEGIN", "-- comment\n COMMIT", "/* comment */ ROLLBACK", "START TRANSACTION", "SAVEPOINT s"]+ {+ assert!(transaction_statement(statement));+ }+ assert!(!transaction_statement("SELECT 'BEGIN'"));+ let sources = [+ DataSource { options: DbOptions { transaction: DbTxMode::Manual, ..Default::default() }, ..source(1) },+ DataSource {+ properties: vec![DbProperty { name: "statement_cache_capacity".into(), value: "4".into() }],+ ..source(1)+ },+ DataSource { properties: vec![DbProperty { name: "password".into(), value: "x".into() }], ..source(1) },+ DataSource { ssl_ca_file: "unused.pem".into(), ..source(1) },+ DataSource { ssl: DbSslMode::VerifyCa, ..source(1) },+ DataSource { ssl: DbSslMode::Require, ssl_cert_file: "unused.pem".into(), ..source(1) },+ ];+ for source in sources {+ let error = match Pool::connect(&source, None, None).await {+ Ok(_) => panic!("unsupported settings were accepted"),+ Err(error) => error,+ };+ assert_eq!(error.kind, ErrorKind::InvalidInput);+ }+ }++ #[tokio::test]+ #[ignore = "requires CLICKHOUSE_TEST_HOST, CLICKHOUSE_TEST_USER, and CLICKHOUSE_TEST_PASSWORD"]+ async fn clickhouse_cloud_transport() {+ let source = DataSource {+ driver: DbDriver::Clickhouse,+ host: std::env::var("CLICKHOUSE_TEST_HOST").expect("CLICKHOUSE_TEST_HOST"),+ port: Some(std::env::var("CLICKHOUSE_TEST_PORT").ok().and_then(|v| v.parse().ok()).unwrap_or(8443)),+ user: std::env::var("CLICKHOUSE_TEST_USER").expect("CLICKHOUSE_TEST_USER"),+ ssl: DbSslMode::Require,+ options: DbOptions {+ time_zone: "UTC".into(),+ startup_script: "SET max_threads = 2".into(),+ ..Default::default()+ },+ properties: vec![DbProperty { name: "max_block_size".into(), value: "50".into() }],+ ..Default::default()+ };+ let password = std::env::var("CLICKHOUSE_TEST_PASSWORD").expect("CLICKHOUSE_TEST_PASSWORD");+ let pool = Pool::connect(&source, Some(&password), None).await.unwrap();+ let cancel = CancellationToken::new();+ let settings = pool+ .execute("SELECT getSetting('max_threads'), getSetting('max_block_size'), timezone()", 1, &cancel)+ .await+ .unwrap();+ assert_eq!(settings.rows, vec![vec![Some("2".into()), Some("50".into()), Some("UTC".into())]]);+ let result = pool.execute("SELECT toUInt64('18446744073709551615') AS n, CAST(NULL AS Nullable(String)) AS missing, CAST('ᴺᵁᴸᴸ' AS Nullable(String)) AS text, 'a\\nb' AS lines", 1, &cancel).await.unwrap();+ assert_eq!(+ result.rows,+ vec![vec![Some("18446744073709551615".into()), None, Some("ᴺᵁᴸᴸ".into()), Some("a\nb".into())]]+ );+ assert_eq!(result.columns[1].type_name, "Nullable(String)");+ let limited = pool.execute("SELECT number FROM numbers(100)", 2, &cancel).await.unwrap();+ assert_eq!(limited.rows.len(), 2);+ assert!(limited.has_more);+ let marker = format!("transport_cancel_{}", uuid::Uuid::new_v4().simple());+ let sql = format!("SELECT sleepEachRow(0.05) FROM numbers(50) /* {marker} */");+ let stop = CancellationToken::new();+ let query = pool.execute(&sql, 1, &stop);+ let cancel_query = async {+ tokio::time::sleep(Duration::from_millis(500)).await;+ stop.cancel();+ };+ let (cancelled, ()) = tokio::join!(query, cancel_query);+ let cancelled = cancelled.unwrap_err();+ assert_eq!(cancelled.kind, ErrorKind::Cancelled);+ assert_eq!(cancelled.message, "cancelled");+ let active = pool.execute(&format!("SELECT count() FROM system.processes WHERE position(query, '{marker}') > 0 AND query_id != currentQueryID()"), 1, &cancel).await.unwrap();+ assert_eq!(active.rows, vec![vec![Some("0".into())]]);+ let table = format!("transport_test_{}", uuid::Uuid::new_v4().simple());+ pool.execute(&format!("CREATE TEMPORARY TABLE {table} (n UInt8)"), 0, &cancel).await.unwrap();+ let continuity = async {+ pool.execute(&format!("INSERT INTO {table} VALUES (7)"), 0, &cancel).await?;+ pool.execute(&format!("SELECT n FROM {table}"), 1, &cancel).await+ }+ .await;+ let cleanup = pool.execute(&format!("DROP TEMPORARY TABLE {table}"), 0, &cancel).await;+ assert_eq!(continuity.unwrap().rows, vec![vec![Some("7".into())]]);+ cleanup.unwrap();+ pool.close().await;+ assert!(pool.is_closed());+ }+}diff --git a/crates/ide-db/src/conn.rs b/crates/ide-db/src/conn.rsindex aa9fd7f43..94bd01348 100644--- a/crates/ide-db/src/conn.rs+++ b/crates/ide-db/src/conn.rs@@ -106,6 +106,7 @@ pub enum Pool {Postgres(PgPool),Mysql(MySqlPool),SqlServer(Bb8Pool<MssqlConnectionManager>),+ Clickhouse(crate::clickhouse::ClickhousePool),}/// Runs `$body` with `$p` bound to the concrete pool of each driver.@@ -115,7 +116,7 @@ macro_rules! with_pool {Pool::Sqlite($p) => $body,Pool::Postgres($p) => $body,Pool::Mysql($p) => $body,- Pool::SqlServer(_) => unreachable!(),+ Pool::SqlServer(_) | Pool::Clickhouse(_) => unreachable!(),}};}@@ -503,6 +504,9 @@ impl Setup {value.parse::<u64>().map_err(|_| IdeError::invalid(format!("{what} must be a whole number: {value}")))};match (source.driver, name.to_ascii_lowercase().as_str()) {+ (DbDriver::Clickhouse, "statement_cache_capacity") => {+ return Err(IdeError::invalid("ClickHouse HTTP does not support statement caching"));+ }(_, "statement_cache_capacity") => s.statement_cache = Some(number(&name)? as usize),(_, "connect_timeout") => s.connect_timeout = Some(Duration::from_secs(number(&name)?)),(DbDriver::Postgres, "application_name") => s.application_name = Some(value.to_owned()),@@ -512,6 +516,9 @@ impl Setup {_ => s.params.push((name, value.to_owned())),}}+ if source.driver == DbDriver::Clickhouse && !o.time_zone.trim().is_empty() {+ s.params.push(("session_timezone".into(), o.time_zone.trim().into()));+ }let script = o.startup_script.trim();if !script.is_empty() {s.statements.extend(crate::split::split(script, source.driver).into_iter().map(|st| st.text));@@ -527,6 +534,7 @@ impl Pool {Pool::Postgres(_) => DbDriver::Postgres,Pool::Mysql(_) => DbDriver::Mysql,Pool::SqlServer(_) => DbDriver::SqlServer,+ Pool::Clickhouse(_) => DbDriver::Clickhouse,}}@@ -534,6 +542,9 @@ impl Pool {pub async fn connect(source: &DataSource, password: Option<&str>, root: Option<&Path>) -> IdeResult<Self> {const MAX: u32 = 4;let setup = Setup::of(source)?;+ if source.driver == DbDriver::Clickhouse {+ return crate::clickhouse::ClickhousePool::connect(source, password, setup).await.map(Pool::Clickhouse);+ }let timeout = setup.connect_timeout.unwrap_or(Duration::from_secs(30));let init = Arc::new(setup.statements);// Runs the session statements (startup script…) on every new connection.@@ -695,12 +706,14 @@ impl Pool {conn.query("SELECT 1", &[]).await.map_err(mssql_err)?.into_results().await.map_err(mssql_err)?;Ok(Pool::SqlServer(pool))}+ DbDriver::Clickhouse => unreachable!(),}}pub async fn close(&self) {match self {Pool::SqlServer(_) => {}+ Pool::Clickhouse(p) => p.close(),_ => with_pool!(self, p => p.close().await),}}@@ -708,12 +721,16 @@ impl Pool {pub fn is_closed(&self) -> bool {match self {Pool::SqlServer(_) => false,+ Pool::Clickhouse(p) => p.is_closed(),_ => with_pool!(self, p => p.is_closed()),}}/// Runs `sql` (no row limit beyond `max`), for introspection: cells are text (see [`Cells::Text`]).pub async fn rows(&self, sql: &str, max: usize) -> IdeResult<Vec<Vec<Option<String>>>> {+ if let Pool::Clickhouse(p) = self {+ return Ok(p.execute(sql, max, &CancellationToken::new()).await?.rows);+ }let fetched: IdeResult<Fetched> = match self {Pool::SqlServer(p) => {let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;@@ -727,6 +744,9 @@ impl Pool {/// Runs one statement and keeps at most `max_rows` rows. Cancelling stops/// the statement on the server (PostgreSQL, MySQL) and drops the connection.pub async fn execute(&self, sql: &str, max_rows: usize, cancel: &CancellationToken) -> IdeResult<QueryResult> {+ if let Pool::Clickhouse(p) = self {+ return p.execute(sql, max_rows, cancel).await;+ }let mut conn = Held::acquire(self).await?;let r = conn.execute(self, sql, max_rows, cancel).await;if cancel.is_cancelled() {@@ -740,6 +760,7 @@ impl Pool {/// row when flagged (table editor submits).pub async fn transaction(&self, statements: &[(String, bool)]) -> IdeResult<u64> {match self {+ Pool::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),Pool::SqlServer(p) => {let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;let result = async {@@ -790,6 +811,7 @@ pub enum Held {Postgres(PoolConnection<Postgres>),Mysql(PoolConnection<MySql>),SqlServer(Box<bb8::PooledConnection<'static, MssqlConnectionManager>>),+ Clickhouse(crate::clickhouse::ClickhousePool),}impl Held {@@ -799,6 +821,12 @@ impl Held {Pool::Postgres(p) => Held::Postgres(p.acquire().await.map_err(db_err)?),Pool::Mysql(p) => Held::Mysql(p.acquire().await.map_err(db_err)?),Pool::SqlServer(p) => Held::SqlServer(Box::new(p.get_owned().await.map_err(mssql_pool_err)?)),+ Pool::Clickhouse(p) => {+ if p.is_closed() {+ return Err(IdeError::new(ErrorKind::Io, "ClickHouse connection is closed"));+ }+ Held::Clickhouse(p.clone())+ }})}@@ -806,13 +834,14 @@ impl Held {pub async fn command(&mut self, sql: &str) -> IdeResult<()> {match self {Held::SqlServer(c) => mssql_command(c, sql).await,+ Held::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),other => {let sql = sqlx::AssertSqlSafe(sql.to_owned());match other {Held::Sqlite(c) => sqlx::raw_sql(sql).execute(&mut **c).await.map(drop),Held::Postgres(c) => sqlx::raw_sql(sql).execute(&mut **c).await.map(drop),Held::Mysql(c) => sqlx::raw_sql(sql).execute(&mut **c).await.map(drop),- Held::SqlServer(_) => unreachable!(),+ Held::SqlServer(_) | Held::Clickhouse(_) => unreachable!(),}.map_err(db_err)}@@ -833,6 +862,7 @@ impl Held {Held::SqlServer(mut c) => {c.0.take();}+ Held::Clickhouse(_) => {}}}@@ -845,6 +875,9 @@ impl Held {max_rows: usize,cancel: &CancellationToken,) -> IdeResult<QueryResult> {+ if let Held::Clickhouse(c) = self {+ return c.execute(sql, max_rows, cancel).await;+ }let started = Instant::now();// `$id`: the query naming the server process, `$kill`: how another connection stops it.macro_rules! run {@@ -887,6 +920,7 @@ impl Held {() = cancel.cancelled() => return Err(IdeError::cancelled()),}}+ Held::Clickhouse(_) => unreachable!(),};let (columns, rows, affected, has_more, first) = fetched;let elapsed_ms = started.elapsed().as_secs_f64() * 1000.0;@@ -907,7 +941,7 @@ pub fn begin_statement(driver: DbDriver) -> &'static str {match driver {DbDriver::Mysql => "START TRANSACTION",DbDriver::SqlServer => "BEGIN TRAN",- DbDriver::Sqlite | DbDriver::Postgres => "BEGIN",+ DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse => "BEGIN",}}diff --git a/crates/ide-db/src/lib.rs b/crates/ide-db/src/lib.rsindex 5f7034c5e..f12f6a63f 100644--- a/crates/ide-db/src/lib.rs+++ b/crates/ide-db/src/lib.rs@@ -2,6 +2,7 @@//! execution ([`conn`]), introspection, table data paging / editing ([`sql`])//! and statement splitting ([`split`]), for SQLite, PostgreSQL and MySQL/MariaDB.+mod clickhouse;pub mod conn;pub mod history;pub mod plan;@@ -547,12 +548,14 @@ impl DbManager {})?;let version = match source.driver {DbDriver::Sqlite => "SELECT 'SQLite ' || sqlite_version()",- DbDriver::Postgres => "SELECT version()",+ DbDriver::Postgres | DbDriver::Clickhouse => "SELECT version()",DbDriver::Mysql => "SELECT CONCAT(@@version_comment, ' ', VERSION())",DbDriver::SqlServer => "SELECT @@VERSION",};- let v = pool.rows(version, 1).await.ok().and_then(|r| r.into_iter().next()?.into_iter().next()?);+ let result = pool.rows(version, 1).await;pool.close().await;+ let rows = if source.driver == DbDriver::Clickhouse { result? } else { result.unwrap_or_default() };+ let v = rows.into_iter().next().and_then(|r| r.into_iter().next().flatten());Ok(v.unwrap_or_else(|| "Connected".into()))}@@ -701,8 +704,11 @@ impl DbManager {_ => indexes.push(IndexInfo { name, unique: flag(&unique), columns: vec![col] }),}}- let fk_rows =- pool.rows(&sql::table_foreign_keys(driver, schema, table), MAX_META_ROWS).await.unwrap_or_default();+ let fk_rows = if driver == DbDriver::Clickhouse {+ Vec::new()+ } else {+ pool.rows(&sql::table_foreign_keys(driver, schema, table), MAX_META_ROWS).await.unwrap_or_default()+ };let mut foreign_keys = group_foreign_keys(fk_rows, &[]);// SQLite keys that reference the primary key implicitly: look it up.for k in foreign_keys.iter_mut().filter(|k| k.ref_columns.is_empty()) {@@ -715,13 +721,15 @@ impl DbManager {.collect();}foreign_keys.retain(|k| k.columns.len() == k.ref_columns.len());- let triggers = pool- .rows(&sql::triggers(driver, schema, table), MAX_META_ROWS)- .await- .unwrap_or_else(|e| {+ let trigger_rows = if driver == DbDriver::Clickhouse {+ Vec::new()+ } else {+ pool.rows(&sql::triggers(driver, schema, table), MAX_META_ROWS).await.unwrap_or_else(|e| {tracing::warn!("triggers: {}", e.message);Vec::new()})+ };+ let triggers = trigger_rows.into_iter().filter_map(|r| {let mut it = r.into_iter();@@ -822,6 +830,11 @@ impl DbManager {let ddl = cells(pool.rows(&q, 1).await?, 1).into_iter().next();ddl.map(|d| format!("{d};\n")).ok_or_else(missing)}+ DbDriver::Clickhouse => {+ let q = format!("SHOW CREATE TABLE {}", sql::qualified(driver, schema, name));+ let ddl = cells(pool.rows(&q, 1).await?, 0).into_iter().next();+ ddl.map(|d| format!("{};\n", d.trim_end().trim_end_matches(';'))).ok_or_else(missing)+ }DbDriver::SqlServer => {let obj = format!("{}.{}", schema, name).replace('\'', "''");let ddl = cells(pool.rows(&format!("SELECT OBJECT_DEFINITION(OBJECT_ID('{}'))", obj), 1).await?, 0)@@ -902,10 +915,14 @@ impl DbManager {}}// Foreign keys are a nicety (JOIN completion): a server that refuses the catalog query still completes.- let fk_rows = pool.rows(sql::foreign_keys(driver), MAX_META_ROWS).await.unwrap_or_else(|e| {- tracing::warn!("foreign keys: {}", e.message);+ let fk_rows = if driver == DbDriver::Clickhouse {Vec::new()- });+ } else {+ pool.rows(sql::foreign_keys(driver), MAX_META_ROWS).await.unwrap_or_else(|e| {+ tracing::warn!("foreign keys: {}", e.message);+ Vec::new()+ })+ };let foreign_keys = group_foreign_keys(fk_rows, &tables);let default_schema = match sql::current_schema(driver) {None => "main".to_owned(),@@ -980,6 +997,9 @@ impl DbManager {let Some(session) = session else {return pool.execute(statement, max_rows, cancel).await;};+ if pool.driver() == DbDriver::Clickhouse {+ return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));+ }let mut held = session.lock().await;if held.is_none() {let mut conn = Held::acquire(&pool).await?;@@ -998,8 +1018,11 @@ impl DbManager {/// Switches `id` between auto-commit and manual commit. Leaving manual/// mode rolls back what was not committed.- pub async fn set_manual_commit(&self, id: &str, manual: bool) {+ pub async fn set_manual_commit(&self, id: &str, manual: bool) -> IdeResult<()> {if manual {+ if self.source(id)?.driver == DbDriver::Clickhouse {+ return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));+ }self.sessions.lock().entry(id.to_owned()).or_default();} else {let session = self.sessions.lock().remove(id);@@ -1007,10 +1030,14 @@ impl DbManager {end_session(&s).await;}}+ Ok(())}/// Commits (or rolls back) the open transaction of a manual-commit data source.pub async fn finish_transaction(&self, id: &str, commit: bool) -> IdeResult<()> {+ if self.source(id).is_ok_and(|s| s.driver == DbDriver::Clickhouse) {+ return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));+ }let session = self.sessions.lock().get(id).cloned();let Some(session) = session else { return Ok(()) };let mut held = session.lock().await;@@ -1052,6 +1079,9 @@ impl DbManager {/// Applies the table editor's pending changes in one transaction.pub async fn apply_edits(&self, id: &str, schema: &str, table: &str, edits: &[DbRowEdit]) -> IdeResult<u64> {+ if self.source(id)?.driver == DbDriver::Clickhouse {+ return Err(IdeError::invalid("ClickHouse table editing is unsupported"));+ }let pool = self.pool(id).await?;let driver = pool.driver();let statements = edits@@ -1064,3 +1094,37 @@ impl DbManager {pool.transaction(&statements).await}}++#[cfg(test)]+mod tests {+ use super::*;++ #[tokio::test]+ async fn clickhouse_rejects_manual_transactions_and_table_edits_without_connecting() {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path().to_path_buf();+ let ssh = Arc::new(SshManager::new(root.join("ssh-passwords.json")));+ let db = DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);+ db.save_sources(vec![DataSource {+ id: "clickhouse".into(),+ name: "clickhouse".into(),+ driver: DbDriver::Clickhouse,+ host: "127.0.0.1".into(),+ port: Some(1),+ ..Default::default()+ }])+ .await+ .unwrap();+ let error = db.set_manual_commit("clickhouse", true).await.unwrap_err();+ assert!(error.message.contains("manual transactions are unsupported"));+ assert!(db.sessions.lock().is_empty());+ for commit in [false, true] {+ let error = db.finish_transaction("clickhouse", commit).await.unwrap_err();+ assert!(error.message.contains("manual transactions are unsupported"));+ }+ let error = db.apply_edits("clickhouse", "default", "events", &[]).await.unwrap_err();+ assert!(error.message.contains("table editing is unsupported"));+ assert!(!db.is_connected("clickhouse"));+ db.set_manual_commit("clickhouse", false).await.unwrap();+ }+}diff --git a/crates/ide-db/src/plan.rs b/crates/ide-db/src/plan.rsindex af3789137..32b217b6e 100644--- a/crates/ide-db/src/plan.rs+++ b/crates/ide-db/src/plan.rs@@ -35,6 +35,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {match driver {DbDriver::Sqlite => format!("EXPLAIN QUERY PLAN {s}"),DbDriver::Postgres => format!("EXPLAIN (FORMAT JSON) {s}"),+ DbDriver::Clickhouse => format!("EXPLAIN json = 1 {s}"),DbDriver::Mysql => format!("EXPLAIN {s}"),DbDriver::SqlServer => format!("SET SHOWPLAN_TEXT ON; {s}"),}@@ -44,7 +45,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {pub fn parse(driver: DbDriver, result: &QueryResult) -> IdeResult<Vec<PlanNode>> {match driver {DbDriver::Sqlite => Ok(sqlite(&result.rows)),- DbDriver::Postgres => {+ DbDriver::Postgres | DbDriver::Clickhouse => {let text: String =result.rows.iter().filter_map(|r| r.first().cloned().flatten()).collect::<Vec<_>>().join("\n");let json: Value = serde_json::from_str(&text).map_err(|e| IdeError::invalid(format!("plan: {e}")))?;@@ -199,6 +200,7 @@ mod tests {assert_eq!(explain_statement(DbDriver::Sqlite, "select 1;"), "EXPLAIN QUERY PLAN select 1");assert_eq!(explain_statement(DbDriver::Postgres, " select 1 "), "EXPLAIN (FORMAT JSON) select 1");assert_eq!(explain_statement(DbDriver::Mysql, "select 1"), "EXPLAIN select 1");+ assert_eq!(explain_statement(DbDriver::Clickhouse, " select 1;"), "EXPLAIN json = 1 select 1");assert_eq!(explain_statement(DbDriver::SqlServer, "select 1"), "SET SHOWPLAN_TEXT ON; select 1");}@@ -254,6 +256,21 @@ mod tests {assert_eq!((plan[3].parent, plan[3].operation.as_str()), (Some(2), "Seq Scan"));}+ #[test]+ fn reads_clickhouse_json_plans_and_rejects_invalid_json() {+ let json = r#"[{"Plan": {"Node Type": "Expression", "Node Id": "Expression_5",+ "Description": "Project names", "Plans": [+ {"Node Type": "ReadFromMergeTree", "Node Id": "ReadFromMergeTree_0",+ "Description": "default.events"}+ ]}}]"#;+ let plan = parse(DbDriver::Clickhouse, &result(&["explain"], vec![vec![Some(json)]])).unwrap();+ assert_eq!(plan.len(), 2);+ assert_eq!((plan[0].parent, plan[0].operation.as_str()), (None, "Expression"));+ assert_eq!((plan[1].parent, plan[1].operation.as_str()), (Some(0), "ReadFromMergeTree"));+ assert!(plan[1].properties.iter().any(|p| p.name == "Description" && p.value == "default.events"));+ assert!(parse(DbDriver::Clickhouse, &result(&["explain"], vec![vec![Some("invalid")]])).is_err());+ }+#[test]fn reads_mysql_rows() {let r = result(diff --git a/crates/ide-db/src/source.rs b/crates/ide-db/src/source.rsindex a3590ae6e..c048430d8 100644--- a/crates/ide-db/src/source.rs+++ b/crates/ide-db/src/source.rs@@ -18,6 +18,7 @@ pub enum DbDriver {Mysql,/// Microsoft SQL Server.SqlServer,+ Clickhouse,}impl DbDriver {@@ -27,6 +28,7 @@ impl DbDriver {DbDriver::Postgres => Some(5432),DbDriver::Mysql => Some(3306),DbDriver::SqlServer => Some(1433),+ DbDriver::Clickhouse => Some(8123),}}}@@ -253,6 +255,7 @@ pub fn scheme_driver(scheme: &str) -> Option<DbDriver> {"mysql" | "mariadb" | "tidb" | "singlestore" | "memsql" | "oceanbase" => Some(DbDriver::Mysql),"sqlserver" | "mssql" | "mssqlserver" => Some(DbDriver::SqlServer),"sqlite" | "sqlite3" => Some(DbDriver::Sqlite),+ "clickhouse" | "http" | "https" => Some(DbDriver::Clickhouse),_ => None,}}@@ -260,7 +263,7 @@ pub fn scheme_driver(scheme: &str) -> Option<DbDriver> {/// Parses `scheme://[user[:password]@]host[:port][/database][?k=v&…]`, `jdbc:` forms/// included, and `sqlite:path`.pub fn parse_url(raw: &str) -> IdeResult<ParsedUrl> {- let bad = || IdeError::invalid(format!("not a database URL: {raw}"));+ let bad = || IdeError::invalid("invalid database URL");let url = raw.trim();let url = url.strip_prefix("jdbc:").or_else(|| url.strip_prefix("JDBC:")).unwrap_or(url);let (scheme, rest) = url.split_once(':').ok_or_else(bad)?;@@ -367,6 +370,15 @@ impl DataSource {}properties.append(&mut s.properties);s.properties = properties;+ if s.driver == DbDriver::Clickhouse {+ let raw_url = self.url.trim().to_ascii_lowercase();+ let url = raw_url.strip_prefix("jdbc:").unwrap_or(&raw_url);+ if url.starts_with("https://") {+ s.ssl = DbSslMode::VerifyFull;+ } else if url.starts_with("http://") {+ s.ssl = DbSslMode::Disable;+ }+ }Ok(s)}@@ -519,4 +531,31 @@ mod tests {assert!(DataSource { url: "mysql://h/db".into(), ..s.clone() }.resolved().is_err());assert_eq!(DataSource { url_only: false, ..s }.resolved().unwrap().host, "localhost");}++ #[test]+ fn clickhouse_urls_resolve_http_https_and_credentials() {+ assert_eq!(DbDriver::Clickhouse.default_port(), Some(8123));+ let source = DataSource {+ driver: DbDriver::Clickhouse,+ url_only: true,+ url: "https://reader:s%[email protected]:8443/analytics?max_execution_time=30".into(),+ ..Default::default()+ };+ let resolved = source.resolved().unwrap();+ assert_eq!(resolved.host, "db.example");+ assert_eq!(resolved.port, Some(8443));+ assert_eq!(resolved.database, "analytics");+ assert_eq!(resolved.user, "reader");+ assert_eq!(resolved.ssl, DbSslMode::VerifyFull);+ assert_eq!(source.url_password().as_deref(), Some("s@cret"));+ assert_eq!(resolved.properties[0].name, "max_execution_time");+ let http = DataSource { url: "http://localhost/default".into(), ..source.clone() }.resolved().unwrap();+ assert_eq!(http.ssl, DbSslMode::Disable);+ let jdbc = DataSource { url: "jdbc:clickhouse://localhost/analytics".into(), ..source.clone() };+ assert_eq!(jdbc.resolved().unwrap().database, "analytics");+ let secure = DataSource { url: "https://db.example/default?sslmode=disable".into(), ..source };+ assert_eq!(secure.resolved().unwrap().ssl, DbSslMode::VerifyFull);+ let error = parse_url("clickhouse://reader:[email protected]:invalid/default").unwrap_err();+ assert!(!error.message.contains("secret"));+ }}diff --git a/crates/ide-db/src/split.rs b/crates/ide-db/src/split.rsindex e9cdbc84f..b2ee3a108 100644--- a/crates/ide-db/src/split.rs+++ b/crates/ide-db/src/split.rs@@ -28,6 +28,7 @@ enum State {/// Every statement of `text` that contains more than whitespace and comments.pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {let mysql = driver == DbDriver::Mysql;+ let clickhouse = driver == DbDriver::Clickhouse;let chars: Vec<(usize, char)> = text.char_indices().collect();// UTF-16 offset of each char index (plus the end).let mut u16_at = Vec::with_capacity(chars.len() + 1);@@ -81,7 +82,7 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {state = State::Double;has_code = true;}- '`' if mysql => {+ '`' if mysql || clickhouse => {state = State::Backtick;has_code = true;}@@ -117,7 +118,7 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {_ => {}},State::Single => {- if mysql && c == '\\' {+ if (mysql || clickhouse) && c == '\\' {i += 1;} else if c == '\'' {if next == Some('\'') {@@ -128,7 +129,9 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {}}State::Double => {- if c == '"' {+ if clickhouse && c == '\\' {+ i += 1;+ } else if c == '"' {if next == Some('"') {i += 1;} else {@@ -137,7 +140,9 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {}}State::Backtick => {- if c == '`' {+ if clickhouse && (c == '\\' || (c == '`' && next == Some('`'))) {+ i += 1;+ } else if c == '`' {state = State::Code;}}@@ -224,6 +229,12 @@ mod tests {assert_eq!(texts(sql, DbDriver::Mysql), vec!["select `a;b`, 'it\\'s;' from t # x;y", "select 2"]);}+ #[test]+ fn clickhouse_backticks_and_escaped_quotes_keep_statements_intact() {+ let query = r#"SELECT `a\`;b`, "c\";d", 'it\'s;safe'; SELECT 2"#;+ assert_eq!(texts(query, DbDriver::Clickhouse), vec![r#"SELECT `a\`;b`, "c\";d", 'it\'s;safe'"#, "SELECT 2"]);+ }+#[test]fn postgres_dollar_quotes() {let sql =diff --git a/crates/ide-db/src/sql.rs b/crates/ide-db/src/sql.rsindex 79d6c1ec5..bd281a859 100644--- a/crates/ide-db/src/sql.rs+++ b/crates/ide-db/src/sql.rs@@ -7,6 +7,7 @@ use specta::Type;pub fn quote_ident(driver: DbDriver, name: &str) -> String {match driver {+ DbDriver::Clickhouse => format!("`{}`", name.replace('\\', "\\\\").replace('`', "\\`")),DbDriver::Mysql => format!("`{}`", name.replace('`', "``")),DbDriver::SqlServer => format!("[{}]", name.replace(']', "]]")),_ => format!("\"{}\"", name.replace('"', "\"\"")),@@ -15,7 +16,7 @@ pub fn quote_ident(driver: DbDriver, name: &str) -> String {pub fn quote_literal(driver: DbDriver, value: &str) -> String {let mut s = value.replace('\'', "''");- if driver == DbDriver::Mysql {+ if matches!(driver, DbDriver::Mysql | DbDriver::Clickhouse) {s = s.replace('\\', "\\\\");}format!("'{s}'")@@ -48,6 +49,10 @@ pub const INTERNAL_DATABASES: &[&str] = &["rdsadmin", "azure_maintenance", "azurpub fn schemas(driver: DbDriver, system: bool) -> &'static str {match driver {DbDriver::Sqlite => "SELECT name FROM pragma_database_list WHERE name <> 'temp' ORDER BY seq",+ DbDriver::Clickhouse if system => "SELECT name FROM system.databases ORDER BY name",+ DbDriver::Clickhouse => {+ "SELECT name FROM system.databases WHERE lower(name) NOT IN ('system', 'information_schema') ORDER BY name"+ }DbDriver::Postgres if system => {"SELECT schema_name FROM information_schema.schemata \WHERE schema_name NOT LIKE 'pg\\_toast%' AND schema_name NOT LIKE 'pg\\_temp%' ORDER BY 1"@@ -73,6 +78,12 @@ pub fn schemas(driver: DbDriver, system: bool) -> &'static str {/// Rows: `name, kind` where kind is `table`, `view` or `materialized view`.pub fn tables(driver: DbDriver, schema: &str) -> String {match driver {+ DbDriver::Clickhouse => format!(+ "SELECT name, CASE engine WHEN 'View' THEN 'view' WHEN 'MaterializedView' THEN 'materialized view' \+ WHEN 'WindowView' THEN 'view' ELSE 'table' END FROM system.tables \+ WHERE database = {} AND is_temporary = 0 ORDER BY name",+ quote_literal(driver, schema)+ ),DbDriver::Sqlite => format!("SELECT name, type FROM {}.sqlite_master WHERE type IN ('table', 'view') \AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY name",@@ -101,6 +112,12 @@ pub fn tables(driver: DbDriver, schema: &str) -> String {pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));match driver {+ DbDriver::Clickhouse => format!(+ "SELECT name, type, CASE WHEN startsWith(type, 'Nullable(') \+ OR startsWith(type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, \+ if(default_kind = '', NULL, default_expression), is_in_primary_key \+ FROM system.columns WHERE database = {s} AND table = {t} ORDER BY position"+ ),DbDriver::Sqlite => format!("SELECT name, type, CASE WHEN \"notnull\" = 0 THEN 'YES' ELSE 'NO' END, dflt_value, \CASE WHEN pk > 0 THEN 1 ELSE 0 END FROM pragma_table_info({t}, {s}) ORDER BY cid"@@ -138,6 +155,12 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));match driver {+ DbDriver::Clickhouse => format!(+ "SELECT * FROM (SELECT 'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression \+ FROM system.tables WHERE database = {s} AND name = {t} AND primary_key != '' \+ UNION ALL SELECT name, 0, expr FROM system.data_skipping_indices \+ WHERE database = {s} AND table = {t}) ORDER BY index_name"+ ),DbDriver::Sqlite => format!("SELECT il.name, il.\"unique\", ii.name FROM pragma_index_list({t}, {s}) il \JOIN pragma_index_info(il.name, {s}) ii ORDER BY il.name, ii.seqno"@@ -169,6 +192,15 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {/// for SQL completion, grouped by table in column order.pub fn completion_columns(driver: DbDriver) -> &'static str {match driver {+ DbDriver::Clickhouse => {+ "SELECT c.database, c.table, CASE t.engine WHEN 'View' THEN 'view' \+ WHEN 'MaterializedView' THEN 'materialized view' WHEN 'WindowView' THEN 'view' ELSE 'table' END, \+ c.name, c.type, CASE WHEN startsWith(c.type, 'Nullable(') \+ OR startsWith(c.type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, c.is_in_primary_key, 1 \+ FROM system.columns c JOIN system.tables t ON t.database = c.database AND t.name = c.table \+ WHERE lower(c.database) NOT IN ('system', 'information_schema') AND t.is_temporary = 0 \+ ORDER BY c.database, c.table, c.position LIMIT 50000"+ }DbDriver::Sqlite => {"SELECT 'main', m.name, m.type, p.name, p.type, CASE WHEN p.\"notnull\" = 0 THEN 'YES' ELSE 'NO' END, \CASE WHEN p.pk > 0 THEN 1 ELSE 0 END, \@@ -221,6 +253,7 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {/// when the key references the primary key implicitly.pub fn foreign_keys(driver: DbDriver) -> &'static str {match driver {+ DbDriver::Clickhouse => "SELECT '', '', '', '', '', '', '' WHERE 0",DbDriver::Sqlite => {"SELECT 'main', m.name, f.id, f.\"from\", 'main', f.\"table\", f.\"to\" \FROM sqlite_master m JOIN pragma_foreign_key_list(m.name) f \@@ -258,6 +291,7 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String {let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));match driver {+ DbDriver::Clickhouse => foreign_keys(driver).to_owned(),DbDriver::Sqlite => format!("SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\" FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"),@@ -276,6 +310,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String/// The schema unqualified names resolve to (`None`: always `main`).pub fn current_schema(driver: DbDriver) -> Option<&'static str> {match driver {+ DbDriver::Clickhouse => Some("SELECT currentDatabase()"),DbDriver::Sqlite => None,DbDriver::Postgres => Some("SELECT current_schema()"),DbDriver::Mysql => Some("SELECT DATABASE()"),@@ -362,6 +397,9 @@ fn where_key(driver: DbDriver, key: &[CellValue]) -> String {/// The DML statement for `edit`. Values are written as quoted literals, which/// every supported database coerces to the column type.pub fn edit_statement(driver: DbDriver, schema: &str, table: &str, edit: &DbRowEdit) -> Result<String, String> {+ if driver == DbDriver::Clickhouse {+ return Err("ClickHouse table editing is unsupported: primary keys do not uniquely identify rows and edits require transactions".into());+ }let target = qualified(driver, schema, table);match edit {DbRowEdit::Update { key, values } => {@@ -450,6 +488,7 @@ pub fn postgres_ddl_indexes(oid: u32) -> String {pub fn triggers(driver: DbDriver, schema: &str, table: &str) -> String {let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));match driver {+ DbDriver::Clickhouse => "SELECT '', '', '' WHERE 0".to_owned(),DbDriver::Sqlite => format!("SELECT name, sql FROM {}.sqlite_master WHERE type = 'trigger' AND tbl_name = {t} ORDER BY name",quote_ident(driver, schema)@@ -492,7 +531,7 @@ pub fn sqlite_trigger_event(sql: &str) -> (String, String) {pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {let s = quote_literal(driver, schema);match driver {- DbDriver::Sqlite => None,+ DbDriver::Sqlite | DbDriver::Clickhouse => None,// Functions of extensions are left out, as in IDEA.DbDriver::Postgres => Some(format!("SELECT p.proname, CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END, \@@ -625,6 +664,71 @@ mod tests {assert_eq!(quote_literal(DbDriver::Mysql, "it's \\"), "'it''s \\\\'");}+ #[test]+ fn clickhouse_escapes_backslashes_and_delimiters() {+ let driver = DbDriver::Clickhouse;+ assert_eq!(quote_literal(driver, r"path\O'Brien"), r"'path\\O''Brien'");+ assert_eq!(quote_literal(driver, r"\' OR 1 = 1 --"), r"'\\'' OR 1 = 1 --'");+ assert_eq!(quote_ident(driver, r"a\`b"), r"`a\\\`b`");+ assert_eq!(qualified(driver, "data base", "event`log"), r"`data base`.`event\`log`");+ }++ #[test]+ fn clickhouse_metadata_preserves_types_defaults_and_nonunique_keys() {+ let driver = DbDriver::Clickhouse;+ assert_eq!(schemas(driver, true), "SELECT name FROM system.databases ORDER BY name");+ assert!(schemas(driver, false).contains("lower(name) NOT IN ('system', 'information_schema')"));+ assert_eq!(current_schema(driver), Some("SELECT currentDatabase()"));+ let relations = tables(driver, "event's\\db");+ assert!(relations.contains("WHEN 'MaterializedView' THEN 'materialized view'"));+ assert!(relations.contains(r"WHERE database = 'event''s\\db' AND is_temporary = 0"));+ let fields = columns(driver, "default", "events");+ assert!(fields.starts_with("SELECT name, type, CASE WHEN startsWith(type, 'Nullable(')"));+ assert!(fields.contains("startsWith(type, 'LowCardinality(Nullable(')"));+ assert!(fields.contains("if(default_kind = '', NULL, default_expression), is_in_primary_key"));+ assert!(fields.ends_with("WHERE database = 'default' AND table = 'events' ORDER BY position"));+ let keys = indexes(driver, "default", "events");+ assert!(keys.contains("'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression"));+ assert!(keys.contains("SELECT name, 0, expr FROM system.data_skipping_indices"));+ let completion = completion_columns(driver);+ assert!(completion.contains("c.is_in_primary_key, 1"));+ assert!(completion.contains("ORDER BY c.database, c.table, c.position LIMIT 50000"));+ }++ #[test]+ fn clickhouse_has_no_foreign_key_trigger_or_schema_routine_catalogs() {+ let driver = DbDriver::Clickhouse;+ assert_eq!(foreign_keys(driver), "SELECT '', '', '', '', '', '', '' WHERE 0");+ assert_eq!(table_foreign_keys(driver, "default", "events"), foreign_keys(driver));+ assert_eq!(triggers(driver, "default", "events"), "SELECT '', '', '' WHERE 0");+ assert!(routines(driver, "default").is_none());+ assert!(sequences(driver, "default").is_none());+ assert!(object_ddl(driver, "default", crate::DbObjectKind::Trigger, "t").is_none());+ }++ #[test]+ fn clickhouse_pages_quote_keys_and_fetch_one_extra_row() {+ let sort = [SortKey { column: "event`id".into(), descending: true }];+ assert_eq!(+ table_page(DbDriver::Clickhouse, "default", "events", Some("WHERE id > 3"), &sort, 50, 25),+ r"SELECT * FROM `default`.`events` WHERE id > 3 ORDER BY `event\`id` DESC LIMIT 26 OFFSET 50"+ );+ }++ #[test]+ fn clickhouse_keys_never_enable_transactional_table_edits() {+ let key = vec![cv("id", Some("1"))];+ for edit in [+ DbRowEdit::Update { key: key.clone(), values: vec![cv("name", Some("new"))] },+ DbRowEdit::Delete { key },+ DbRowEdit::Insert { values: vec![cv("name", Some("new"))] },+ DbRowEdit::Insert { values: vec![] },+ ] {+ let error = edit_statement(DbDriver::Clickhouse, "default", "events", &edit).unwrap_err();+ assert!(error.contains("primary keys do not uniquely identify rows"));+ }+ }+#[test]fn pages() {let sort = [SortKey { column: "id".into(), descending: true }];diff --git a/crates/ide-db/tests/clickhouse.rs b/crates/ide-db/tests/clickhouse.rsnew file mode 100644index 000000000..d19a9ff16--- /dev/null+++ b/crates/ide-db/tests/clickhouse.rs@@ -0,0 +1,136 @@+use ide_core::{CancellationToken, IdeError, IdeResult};+use ide_db::{CellValue, DataSource, DbDriver, DbManager, DbRowEdit, DbSslMode, SortKey, sql};+use std::sync::Arc;+use std::time::{SystemTime, UNIX_EPOCH};++fn check(condition: bool, message: &str) -> IdeResult<()> {+ if condition { Ok(()) } else { Err(IdeError::invalid(message)) }+}++#[tokio::test]+#[ignore = "requires CLICKHOUSE_TEST_HOST, CLICKHOUSE_TEST_USER, and CLICKHOUSE_TEST_PASSWORD"]+async fn clickhouse_cloud_manager_catalogs_and_session_table() -> IdeResult<()> {+ let tmp = tempfile::tempdir()?;+ let root = tmp.path().to_path_buf();+ let ssh = Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));+ let db = DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);+ let mut source = DataSource {+ id: "clickhouse".into(),+ name: "clickhouse".into(),+ driver: DbDriver::Clickhouse,+ host: std::env::var("CLICKHOUSE_TEST_HOST").expect("set CLICKHOUSE_TEST_HOST"),+ port: Some(+ std::env::var("CLICKHOUSE_TEST_PORT")+ .map(|value| value.parse().expect("numeric CLICKHOUSE_TEST_PORT"))+ .unwrap_or(8443),+ ),+ user: std::env::var("CLICKHOUSE_TEST_USER").expect("set CLICKHOUSE_TEST_USER"),+ database: "default".into(),+ ssl: DbSslMode::VerifyFull,+ ..Default::default()+ };+ source.introspection.show_system = true;+ let password = std::env::var("CLICKHOUSE_TEST_PASSWORD").expect("set CLICKHOUSE_TEST_PASSWORD");+ check(!db.test(&source, Some(password.clone()), None).await?.is_empty(), "missing server version")?;+ db.save_sources(vec![source]).await?;+ db.set_password("clickhouse", Some(password), false).await?;+ let cancel = CancellationToken::new();+ let suffix = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();+ let name = format!("manager_test_{}_{suffix}", std::process::id());+ let table = sql::quote_ident(DbDriver::Clickhouse, &name);+ db.execute(+ "clickhouse",+ &format!(+ "CREATE TEMPORARY TABLE {table} (id UInt64, label Nullable(String) DEFAULT NULL, \+ category LowCardinality(Nullable(String)) DEFAULT NULL, items Array(Nullable(UInt8)), \+ label_size UInt64 ALIAS length(ifNull(label, ''))) ENGINE = Memory"+ ),+ 0,+ &cancel,+ )+ .await?;+ let checked: IdeResult<()> = async {+ db.execute(+ "clickhouse",+ &format!("INSERT INTO {table} (id, label, items) VALUES (1, 'first', [1, NULL]), (1, NULL, [])"),+ 0,+ &cancel,+ )+ .await?;+ let schemas = db.schemas("clickhouse").await?;+ check(schemas.iter().any(|schema| schema == "default"), "default database missing")?;+ check(schemas.iter().any(|schema| schema == "system"), "system database missing")?;+ let tables = db.tables("clickhouse", "system").await?;+ check(tables.iter().any(|table| table.name == "one"), "system table listing missing one")?;+ let details = db.table_details("clickhouse", "", &name).await?;+ check(details.columns.len() == 5, "temporary table columns missing")?;+ for (name, data_type, nullable) in [+ ("id", "UInt64", false),+ ("label", "Nullable(String)", true),+ ("category", "LowCardinality(Nullable(String))", true),+ ("items", "Array(Nullable(UInt8))", false),+ ] {+ check(+ details+ .columns+ .iter()+ .any(|column| column.name == name && column.data_type == data_type && column.nullable == nullable),+ "column type or nullability mismatch",+ )?;+ }+ check(+ details.columns.iter().any(|column| column.name == "label" && column.default.as_deref() == Some("NULL")),+ "explicit default expression missing",+ )?;+ check(details.indexes.iter().all(|index| !index.unique), "ClickHouse index reported unique")?;+ check(details.foreign_keys.is_empty() && details.triggers.is_empty(), "unsupported table objects returned")?;+ let sort = [SortKey { column: "id".into(), descending: false }];+ let first = db.table_page("clickhouse", "", &name, None, &sort, 0, 1, &cancel).await?;+ check(first.result.rows.len() == 1 && first.result.has_more, "first page limit failed")?;+ let second = db.table_page("clickhouse", "", &name, None, &sort, 1, 1, &cancel).await?;+ check(second.result.rows.len() == 1 && !second.result.has_more, "page offset failed")?;+ let ddl = db.ddl("clickhouse", "", &name).await?;+ check(ddl.contains(&name) && ddl.contains("Memory"), "temporary table DDL missing")?;+ let completion = db.completion("clickhouse").await?;+ check(completion.default_schema == "default", "completion default database mismatch")?;+ check(completion.foreign_keys.is_empty(), "completion returned unsupported foreign keys")?;+ if let Some(table) = completion.tables.first() {+ let details = db.table_details("clickhouse", &table.schema, &table.name).await?;+ check(+ table.columns.iter().all(|column| {+ details.columns.iter().any(|field| field.name == column.name && field.data_type == column.data_type)+ }),+ "completion columns differ from catalog",+ )?;+ }+ let plan = db.explain("clickhouse", &format!("SELECT id FROM {table}"), &cancel).await?;+ check(!plan.is_empty(), "query plan missing")?;+ let value = r"path\O'Brien";+ let result = db+ .execute("clickhouse", &format!("SELECT {}", sql::quote_literal(DbDriver::Clickhouse, value)), 1, &cancel)+ .await?;+ check(result.rows == vec![vec![Some(value.to_owned())]], "quoted literal changed value")?;+ let edits = [DbRowEdit::Update {+ key: vec![CellValue { column: "id".into(), value: Some("1".into()) }],+ values: vec![CellValue { column: "label".into(), value: Some("changed".into()) }],+ }];+ check(+ db.apply_edits("clickhouse", "", &name, &edits)+ .await+ .err()+ .is_some_and(|error| error.message.contains("table editing is unsupported")),+ "supplied row key authorized table editing",+ )?;+ check(db.set_manual_commit("clickhouse", true).await.is_err(), "manual transactions were accepted")?;+ for commit in [false, true] {+ check(db.finish_transaction("clickhouse", commit).await.is_err(), "transaction control was accepted")?;+ }+ Ok(())+ }+ .await;+ let cleanup = db.execute("clickhouse", &format!("DROP TEMPORARY TABLE {table}"), 0, &cancel).await;+ db.disconnect("clickhouse").await;+ checked?;+ cleanup?;+ Ok(())+}diff --git a/crates/ide-db/tests/sqlite.rs b/crates/ide-db/tests/sqlite.rsindex f340ee536..b800cd154 100644--- a/crates/ide-db/tests/sqlite.rs+++ b/crates/ide-db/tests/sqlite.rs@@ -197,7 +197,7 @@ async fn count(db: &DbManager) -> String {async fn manual_commit_keeps_a_transaction_until_commit_or_rollback() -> IdeResult<()> {let (_tmp, db) = setup().await;let c = CancellationToken::new();- db.set_manual_commit("s1", true).await;+ db.set_manual_commit("s1", true).await.unwrap();db.execute("s1", "INSERT INTO users (name) VALUES ('dee')", 1, &c).await?;// The session sees its own change.assert_eq!(count(&db).await, "4");@@ -208,10 +208,10 @@ async fn manual_commit_keeps_a_transaction_until_commit_or_rollback() -> IdeResudb.finish_transaction("s1", true).await?;// Leaving manual mode rolls back what is still open.db.execute("s1", "DELETE FROM users", 1, &c).await?;- db.set_manual_commit("s1", false).await;+ db.set_manual_commit("s1", false).await.unwrap();assert_eq!(count(&db).await, "4");// Disconnecting with an open transaction does not hang.- db.set_manual_commit("s1", true).await;+ db.set_manual_commit("s1", true).await.unwrap();db.execute("s1", "DELETE FROM users", 1, &c).await?;db.disconnect("s1").await;assert_eq!(count(&db).await, "4");diff --git a/crates/ide-host/src/ops/db.rs b/crates/ide-host/src/ops/db.rsindex 63c8419a0..102bf2742 100644--- a/crates/ide-host/src/ops/db.rs+++ b/crates/ide-host/src/ops/db.rs@@ -216,8 +216,7 @@ pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {/// manual mode rolls back what was not committed).pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {let db = host.project(window)?.db.clone();- db.set_manual_commit(id, manual).await;- Ok(())+ db.set_manual_commit(id, manual).await}/// Commits or rolls back the open transaction of a manual-commit data source.diff --git a/e2e/clickhouse-source.spec.ts b/e2e/clickhouse-source.spec.tsnew file mode 100644index 000000000..8a29e09ea--- /dev/null+++ b/e2e/clickhouse-source.spec.ts@@ -0,0 +1,42 @@+import { expect, test } from "./fixtures";++test("configures a ClickHouse HTTP source and keeps transaction controls unavailable", async ({+ workbench: page,+}, info) => {+ await page.evaluate(async () => {+ const storePath = "/src/features/database/store.ts";+ const bindingsPath = "/src/bindings.ts";+ const { useDatabase } = await import(storePath);+ const { commands } = await import(bindingsPath);+ commands.dbTest = async (source: unknown) => {+ document.documentElement.dataset.testedSource = JSON.stringify(source);+ return { status: "ok", data: "ClickHouse" };+ };+ useDatabase.setState({ dialog: { kind: "source", source: null } });+ });+ const dialog = page.getByRole("dialog", { name: "New Data Source", exact: true });+ await dialog.getByRole("button", { name: "Data source type", exact: true }).click();+ await page.getByRole("option", { name: "ClickHouse", exact: true }).click();+ await expect(dialog.locator("#db-port")).toHaveValue("8123");+ await expect(dialog.locator("#db-user")).toHaveValue("default");+ await expect(dialog.locator("#db-database")).toHaveValue("default");+ await expect(dialog.locator("#db-url")).toHaveValue("http://localhost:8123/default");+ await dialog.locator("#db-url").fill("https://[email protected]:8443/analytics");+ await expect(dialog.locator("#db-host")).toHaveValue("db.example");+ await expect(dialog.locator("#db-port")).toHaveValue("8443");+ await expect(dialog.locator("#db-user")).toHaveValue("reader");+ await expect(dialog.locator("#db-database")).toHaveValue("analytics");+ await dialog.getByRole("button", { name: "Test Connection", exact: true }).click();+ await expect(dialog.getByRole("status")).toHaveText("Succeeded: ClickHouse");+ expect(await page.evaluate(() => JSON.parse(document.documentElement.dataset.testedSource!))).toMatchObject({+ driver: "clickhouse",+ host: "db.example",+ port: 8443,+ user: "reader",+ database: "analytics",+ ssl: "verifyFull",+ });+ await dialog.screenshot({ path: info.outputPath("clickhouse-source.png") });+ await dialog.getByRole("tab", { name: "Options", exact: true }).click();+ await expect(dialog.getByRole("button", { name: "Transaction control", exact: true })).toBeDisabled();+});diff --git a/src/bindings.ts b/src/bindings.tsindex ab0d32e51..f8cde1141 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -2405,7 +2405,7 @@ export type DbDriver = "sqlite" | "postgres" |/** MySQL and MariaDB. */"mysql" |/** Microsoft SQL Server. */-"sqlServer";+"sqlServer" | "clickhouse";/** `schema.table (columns) REFERENCES ref_schema.ref_table (ref_columns)`. */export type DbForeignKey = {diff --git a/src/features/database/ObjectDialogs.tsx b/src/features/database/ObjectDialogs.tsxindex 08fb56d4d..648e7ec13 100644--- a/src/features/database/ObjectDialogs.tsx+++ b/src/features/database/ObjectDialogs.tsx@@ -269,6 +269,7 @@ const TYPES: Record<DbDriver, string[]> = {"bit","varbinary(max)",],+ clickhouse: ["UInt64", "Int64", "Float64", "String", "Bool", "Date", "DateTime", "UUID", "Nullable(String)"],};interface ModifyProps {@@ -328,7 +329,8 @@ function ModifyTableForm({const driver = driverOf(id);const [name, setName] = useState(table ?? "table_name");const [columns, setColumns] = useState<ColumnDraft[]>(() => {- if (!initial) return [{ ...blankColumn(driver, 1), name: "id", primaryKey: true, notNull: true }];+ if (!initial)+ return [{ ...blankColumn(driver, 1), name: "id", primaryKey: driver !== "clickhouse", notNull: true }];const drafts = initial.map(draftOf);if (addColumn) drafts.push(blankColumn(driver, drafts.length + 1));return drafts;@@ -448,14 +450,18 @@ function ModifyTableForm({disabled={current.dropped || locked}onChange={(e) => patch({ dataType: e.target.value })}/>- <span />- <Checkbox- checked={current.notNull}- disabled={current.dropped || locked}- onChange={(notNull) => patch({ notNull })}- label="Not null"- />- {!table && (+ {driver !== "clickhouse" && (+ <>+ <span />+ <Checkbox+ checked={current.notNull}+ disabled={current.dropped || locked}+ onChange={(notNull) => patch({ notNull })}+ label="Not null"+ />+ </>+ )}+ {!table && driver !== "clickhouse" && (<><span /><Checkboxdiff --git a/src/features/database/SourceDialog.tsx b/src/features/database/SourceDialog.tsxindex 8bc85a994..205ec5234 100644--- a/src/features/database/SourceDialog.tsx+++ b/src/features/database/SourceDialog.tsx@@ -73,6 +73,10 @@ const SSH_AUTH: Array<SelectOption<SshAuth>> = [/** Driver property names the Advanced tab suggests, and what the backend does with them. */const PROPERTIES: Record<string, { names: string[]; hint: string }> = {+ clickhouse: {+ names: ["max_execution_time", "max_threads", "connect_timeout"],+ hint: "ClickHouse settings sent with each HTTP request. connect_timeout is in seconds.",+ },postgres: {names: ["statement_timeout",@@ -376,6 +380,7 @@ export function SourceDialog({const vendor = vendorOf(s);const sqlite = s.driver === "sqlite";const postgres = s.driver === "postgres";+ const clickhouse = s.driver === "clickhouse";const urlOnly = !sqlite && !!s.urlOnly;const parsedUrl = urlOnly ? parseSourceUrl(s.url ?? "") : null;const urlValid = !!parsedUrl && parsedUrl.source.driver === s.driver;@@ -398,7 +403,20 @@ export function SourceDialog({setS((x) => {const old = vendorOf(x);const port = x.port == null || x.port === old.port ? v.port : x.port;- return { ...x, driver: v.driver, vendor: v.id === v.driver ? "" : v.id, port, ssl: v.ssl ?? x.ssl };+ return {+ ...x,+ driver: v.driver,+ vendor: v.id === v.driver ? "" : v.id,+ port,+ ssl: v.ssl ?? (v.driver === "clickhouse" ? "disable" : x.ssl),+ ...(v.driver === "clickhouse"+ ? {+ user: x.user || "default",+ database: x.database || "default",+ options: { ...blankOptions(), ...x.options, transaction: "auto" as const },+ }+ : {}),+ };});};@@ -614,8 +632,9 @@ export function SourceDialog({<Selectaria-label="Transaction control"className={styles.narrowSelect}- value={options.transaction ?? "auto"}- options={TX}+ value={clickhouse ? "auto" : (options.transaction ?? "auto")}+ options={clickhouse ? TX.filter((option) => option.value === "auto") : TX}+ disabled={clickhouse}onChange={(transaction) => setOptions({ transaction })}/>{postgres && (@@ -640,7 +659,9 @@ export function SourceDialog({id="db-time-zone"value={options.timeZone ?? ""}placeholder={- postgres ? "Server default, e.g. UTC or Europe/Berlin" : "UTC (+00:00), e.g. Europe/Berlin or +08:00"+ postgres || clickhouse+ ? "Server default, e.g. UTC or Europe/Berlin"+ : "UTC (+00:00), e.g. Europe/Berlin or +08:00"}onChange={(e) => setOptions({ timeZone: e.target.value })}/>@@ -679,9 +700,11 @@ export function SourceDialog({placeholder={postgres? "SET statement_timeout = '30s';"- : sqlite- ? "PRAGMA foreign_keys = ON;"- : "SET SESSION sql_mode = 'ANSI';"+ : clickhouse+ ? "SET max_execution_time = 30;"+ : sqlite+ ? "PRAGMA foreign_keys = ON;"+ : "SET SESSION sql_mode = 'ANSI';"}onChange={(e) => setOptions({ startupScript: e.target.value })}/>@@ -834,8 +857,17 @@ export function SourceDialog({aria-label="SSL mode"className={styles.narrowSelect}value={s.ssl ?? "prefer"}- options={SSL}- onChange={(ssl) => set({ ssl })}+ options={clickhouse ? SSL.filter((mode) => mode.value !== "prefer") : SSL}+ onChange={(ssl) => {+ const secure = ssl !== "disable" && ssl !== "prefer";+ const oldSecure = s.ssl !== "disable" && s.ssl !== "prefer";+ set({+ ssl,+ ...(clickhouse && (s.port == null || s.port === (oldSecure ? 8443 : 8123))+ ? { port: secure ? 8443 : 8123 }+ : {}),+ });+ }}/><FileFieldid="db-ssl-ca"diff --git a/src/features/database/TableEditor.tsx b/src/features/database/TableEditor.tsxindex 65adc30e0..599456844 100644--- a/src/features/database/TableEditor.tsx+++ b/src/features/database/TableEditor.tsx@@ -89,7 +89,8 @@ export function TableEditor({ input }: { input: EditorInput }) {const names = columns.map((c) => c.name);const pk = page?.details.columns.filter((c) => c.primaryKey).map((c) => c.name) ?? [];const fkColumns = new Set(page?.details.foreignKeys.flatMap((k) => k.columns) ?? []);- const editable = pk.length > 0 && !sourceById(ref.id)?.readOnly;+ const source = sourceById(ref.id);+ const editable = pk.length > 0 && !source?.readOnly && source?.driver !== "clickhouse";const loaded = page?.result.rows.length ?? 0;const rowCount = loaded + edits.inserts.length;const gridColumns = useMemo(@@ -149,7 +150,7 @@ export function TableEditor({ input }: { input: EditorInput }) {});const submit = async () => {- if (!page) return;+ if (!page || !editable) return;try {const n = await call(commands.dbApplyEdits(ref.id, ref.schema, ref.table, buildRowEdits(names, page.result.rows, pk, edits)),@@ -300,7 +301,11 @@ export function TableEditor({ input }: { input: EditorInput }) {</div>{page && !editable && (<div className={styles.notice}>- {pk.length ? tx("Read-only data source.") : tx("Read-only: the table has no primary key to identify rows.")}+ {source?.driver === "clickhouse"+ ? tx("Use the query console to change ClickHouse data.")+ : pk.length+ ? tx("Read-only data source.")+ : tx("Read-only: the table has no primary key to identify rows.")}</div>)}{error ? (diff --git a/src/features/database/console.tsx b/src/features/database/console.tsxindex b770dfc49..5a0e83341 100644--- a/src/features/database/console.tsx+++ b/src/features/database/console.tsx@@ -230,6 +230,7 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {const pending = useDatabase((s) => !!bound && s.pendingTx.has(bound));const databases = useDatabase((s) => s.databases);const boundId = bound ? splitTarget(bound).id : null;+ const supportsTransactions = sourceById(boundId)?.driver !== "clickhouse";useEffect(() => {if (boundId && listsDatabases(sourceById(boundId)) && !useDatabase.getState().databases[boundId])void loadDatabases(boundId);@@ -291,18 +292,22 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {options={ROW_LIMITS.map((v) => ({ value: v, label: tx`${Number(v).toLocaleString("en")} rows` }))}onChange={(v) => useDatabase.setState({ maxRows: Number(v) })}/>- <span className={styles.toolbarSeparator} />- <Select- aria-label="Transaction mode"- value={manual ? "manual" : "auto"}- options={[- { value: "auto", label: "Tx: Auto" },- { value: "manual", label: "Tx: Manual" },- ]}- onChange={(v) => bound && void setManualCommit(bound, v === "manual")}- disabled={!bound}- />- {manual && (+ {supportsTransactions && (+ <>+ <span className={styles.toolbarSeparator} />+ <Select+ aria-label="Transaction mode"+ value={manual ? "manual" : "auto"}+ options={[+ { value: "auto", label: "Tx: Auto" },+ { value: "manual", label: "Tx: Manual" },+ ]}+ onChange={(v) => bound && void setManualCommit(bound, v === "manual")}+ disabled={!bound}+ />+ </>+ )}+ {supportsTransactions && manual && (<><IconButtonicon="commit"diff --git a/src/features/database/database.test.ts b/src/features/database/database.test.tsindex 72c4cb60a..2f421f8bd 100644--- a/src/features/database/database.test.ts+++ b/src/features/database/database.test.ts@@ -102,6 +102,12 @@ describe("export formats", () => {);});+ it("preserves backslashes in ClickHouse SQL exports", () => {+ expect(exportData("sql", { ...data, driver: "clickhouse", rows: [["1", "C:\\new\\file's"]] })).toBe(+ `INSERT INTO "order items" (id, name) VALUES (1, 'C:\\\\new\\\\file''s');`,+ );+ });+it("writes a Markdown table, numbers right-aligned", () => {expect(exportData("markdown", { ...data, rows: [["1", "a|b"]] })).toBe("| id | name |\n| --: | --- |\n| 1 | a\\|b |",@@ -184,7 +190,9 @@ describe("data source types", () => {});expect(vendorPreset(vendorById("postgres")!)).toEqual({ driver: "postgres", vendor: "", port: 5432 });expect(vendorPreset(vendorById("supabase")!).ssl).toBe("require");- expect(VENDORS.every((v) => ["postgres", "mysql", "sqlite", "sqlServer"].includes(v.driver))).toBe(true);+ expect(VENDORS.every((v) => ["postgres", "mysql", "sqlite", "sqlServer", "clickhouse"].includes(v.driver))).toBe(+ true,+ );const labels = VENDORS.map((v) => v.label);expect(labels).toEqual([...labels].sort((a, b) => a.localeCompare(b)));});@@ -227,6 +235,36 @@ describe("data source types", () => {expect(parseSourceUrl("redshift://r.example:5439/dev")?.source.vendor).toBe("redshift");expect(parseSourceUrl("postgresql://h:70000/db")).toBeNull();});++ it("adds ClickHouse with native HTTP defaults and HTTPS cloud URLs", () => {+ expect(vendorPreset(vendorById("clickhouse")!)).toEqual({+ driver: "clickhouse",+ vendor: "",+ port: 8123,+ user: "default",+ database: "default",+ ssl: "disable",+ });+ expect(sourceUrl({ driver: "clickhouse", host: "localhost", database: "default" })).toBe(+ "http://localhost:8123/default",+ );+ expect(sourceUrl({ driver: "clickhouse", host: "db.example", ssl: "verifyFull", database: "analytics" })).toBe(+ "https://db.example:8443/analytics",+ );+ const parsed = parseSourceUrl("https://reader:s%[email protected]:8443/analytics?max_execution_time=30");+ expect(parsed?.source).toMatchObject({+ driver: "clickhouse",+ host: "db.example",+ port: 8443,+ database: "analytics",+ user: "reader",+ ssl: "verifyFull",+ });+ expect(parsed?.password).toBe("s@cret");+ expect(parseSourceUrl("http://localhost/default")?.source.ssl).toBe("disable");+ expect(parseSourceUrl("jdbc:clickhouse://localhost/default")?.source.driver).toBe("clickhouse");+ expect(parseSourceUrl("https://db.example/default?sslmode=disable")?.source.ssl).toBe("verifyFull");+ });});describe("Schemas tab", () => {diff --git a/src/features/database/export.ts b/src/features/database/export.tsindex 09277d39b..0aea5bb60 100644--- a/src/features/database/export.ts+++ b/src/features/database/export.ts@@ -79,7 +79,11 @@ export function exportData(}case "sql": {const literal = (v: Cell, i: number) =>- v === null ? "NULL" : numeric[i] && Number.isFinite(Number(v)) ? v : `'${v.replace(/'/g, "''")}'`;+ v === null+ ? "NULL"+ : numeric[i] && Number.isFinite(Number(v))+ ? v+ : `'${(d.driver === "clickhouse" ? v.replace(/\\/g, "\\\\") : v).replace(/'/g, "''")}'`;const head = `INSERT INTO ${quoteIdent(d.table, d.driver)} (${names.map((n) => quoteIdent(n, d.driver)).join(", ")}) VALUES`;return d.rows.map((r) => `${head} (${r.map(literal).join(", ")});`).join("\n");}diff --git a/src/features/database/model.ts b/src/features/database/model.tsindex df89c13df..397144bfe 100644--- a/src/features/database/model.ts+++ b/src/features/database/model.ts@@ -390,6 +390,10 @@ export function parseSourceUrl(raw: string): { source: Partial<DataSource>; pass}}source.user = user;+ if (vendor.driver === "clickhouse") {+ if (m[1]!.toLowerCase() === "https") source.ssl = "verifyFull";+ else if (m[1]!.toLowerCase() === "http") source.ssl = "disable";+ }if (properties.length) source.properties = properties;return { source, password };}diff --git a/src/features/database/objects.test.ts b/src/features/database/objects.test.tsindex 1d3265e73..229c67fa9 100644--- a/src/features/database/objects.test.ts+++ b/src/features/database/objects.test.ts@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";import type { DbColumnInfo } from "@/platform/ipc";import {alterTableSql,+ canDrop,+ canModifyTable,createTableSql,draftOf,dropSql,@@ -10,6 +12,7 @@ import {renameSql,scriptSql,truncateSql,+ quoteIdent,type ColumnDraft,} from "./objects";@@ -29,6 +32,51 @@ const users = [];describe("database object SQL", () => {+ it("uses ClickHouse object syntax and escapes identifiers", () => {+ expect(quoteIdent("clickhouse", 'a\\b"c')).toBe('"a\\\\b\\"c"');+ expect(ident("clickhouse", "price$usd")).toBe('"price$usd"');+ expect(renameSql("clickhouse", { kind: "table", schema: "default", name: "users" }, "people")).toBe(+ 'rename table "default".users to "default".people;',+ );+ expect(+ dropSql("clickhouse", { kind: "schema", schema: "", name: "analytics" }, { ifExists: true, cascade: true }),+ ).toBe("drop database if exists analytics;");+ expect(+ dropSql(+ "clickhouse",+ { kind: "materializedView", schema: "default", name: "totals" },+ { ifExists: true, cascade: true },+ ),+ ).toBe('drop table if exists "default".totals;');+ expect(truncateSql("clickhouse", "default", "users", { restartIdentity: true, cascade: true })).toBe(+ 'truncate table "default".users;',+ );+ expect(canDrop("clickhouse", { kind: "index", schema: "default", name: "ix" })).toBe(false);+ expect(canModifyTable("clickhouse")).toBe(false);+ expect(alterTableSql("clickhouse", "default", "users", "people", users.map(draftOf))).toEqual([]);+ });++ it("creates ClickHouse MergeTree tables without a relational primary key", () => {+ const drafts = [col("id", "UInt64", { primaryKey: true, nullable: false }), col("name", "Nullable(String)")].map(+ draftOf,+ );+ expect(createTableSql("clickhouse", "default", "people", drafts)).toBe(+ 'create table "default".people\n(\n id UInt64,\n name Nullable(String)\n)\nengine = MergeTree\norder by tuple();\n',+ );+ });++ it("writes guarded ClickHouse mutation templates without unique key assumptions", () => {+ expect(scriptSql("clickhouse", "update", "default", "users", users)).toBe(+ 'alter table "default".users\nupdate email = ?,\n name = ?\nwhere 1 = 0;\n',+ );+ expect(scriptSql("clickhouse", "delete", "default", "users", users)).toBe(+ 'alter table "default".users\ndelete\nwhere 1 = 0;\n',+ );+ expect(() => scriptSql("clickhouse", "update", "default", "users", users.slice(0, 1))).toThrow(+ "ClickHouse sorting key columns cannot be updated.",+ );+ });+it("quotes only when needed", () => {expect(ident("postgres", "users")).toBe("users");expect(ident("postgres", "Users")).toBe('"Users"');diff --git a/src/features/database/objects.ts b/src/features/database/objects.tsindex 6b0b98206..d2fc8fb3f 100644--- a/src/features/database/objects.ts+++ b/src/features/database/objects.ts@@ -6,6 +6,7 @@import type { DbColumnInfo, DbDriver } from "@/platform/ipc";export function quoteIdent(driver: DbDriver, name: string): string {+ if (driver === "clickhouse") return `"${name.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;if (driver === "mysql") return `\`${name.replace(/`/g, "``")}\``;if (driver === "sqlServer") return `[${name.replace(/]/g, "]]")}]`;return `"${name.replace(/"/g, '""')}"`;@@ -13,7 +14,12 @@ export function quoteIdent(driver: DbDriver, name: string): string {/** Quotes only when needed: lower-case (PostgreSQL) / plain words stay bare, like IDEA's generated SQL. */export function ident(driver: DbDriver, name: string): string {- const plain = driver === "postgres" ? /^[a-z_][a-z0-9_$]*$/ : /^[A-Za-z_][A-Za-z0-9_$]*$/;+ const plain =+ driver === "postgres"+ ? /^[a-z_][a-z0-9_$]*$/+ : driver === "clickhouse"+ ? /^[A-Za-z_][A-Za-z0-9_]*$/+ : /^[A-Za-z_][A-Za-z0-9_$]*$/;return plain.test(name) && !RESERVED.has(name.toUpperCase()) ? name : quoteIdent(driver, name);}@@ -83,7 +89,8 @@ export function renameSql(driver: DbDriver, o: DbObjectRef, to: string): stringif (driver === "postgres") return `alter view ${q} rename to ${ident(driver, to)};`;return `rename table ${q} to ${qualifiedName(driver, o.schema, to)};`;default:- if (driver === "mysql") return `rename table ${q} to ${qualifiedName(driver, o.schema, to)};`;+ if (driver === "mysql" || driver === "clickhouse")+ return `rename table ${q} to ${qualifiedName(driver, o.schema, to)};`;return `alter table ${q} rename to ${ident(driver, to)};`;}}@@ -94,7 +101,12 @@ export interface DropOptions {cascade: boolean;}-export const canDrop = (driver: DbDriver, o: DbObjectRef) => !(o.kind === "schema" && driver === "sqlite");+export const canDrop = (driver: DbDriver, o: DbObjectRef) =>+ driver === "clickhouse"+ ? ["table", "view", "materializedView", "column", "schema"].includes(o.kind)+ : !(o.kind === "schema" && driver === "sqlite");++export const canModifyTable = (driver: DbDriver) => driver !== "clickhouse";/** IDEA's Confirm Drop preview. */export function dropSql(driver: DbDriver, o: DbObjectRef, opts: DropOptions): string {@@ -108,8 +120,9 @@ export function dropSql(driver: DbDriver, o: DbObjectRef, opts: DropOptions): streturn `drop index ${ident(driver, o.name)} on ${qualifiedName(driver, o.schema, o.table ?? "")};`;return `drop index ${ifExists}${qualifiedName(driver, o.schema, o.name)}${cascade};`;case "schema":- return `drop ${driver === "mysql" ? "database" : "schema"} ${ifExists}${ident(driver, o.name)}${cascade};`;+ return `drop ${driver === "mysql" || driver === "clickhouse" ? "database" : "schema"} ${ifExists}${ident(driver, o.name)}${cascade};`;case "materializedView":+ if (driver === "clickhouse") return `drop table ${ifExists}${qualifiedName(driver, o.schema, o.name)};`;return `drop materialized view ${ifExists}${qualifiedName(driver, o.schema, o.name)}${cascade};`;case "function":case "procedure": {@@ -134,7 +147,7 @@ export function truncateSql(): string {const q = qualifiedName(driver, schema, table);if (driver === "sqlite") return `delete from ${q};`;- if (driver === "mysql" || driver === "sqlServer") return `truncate table ${q};`;+ if (driver === "mysql" || driver === "sqlServer" || driver === "clickhouse") return `truncate table ${q};`;return `truncate table ${q}${opts.restartIdentity ? " restart identity" : ""}${opts.cascade ? " cascade" : ""};`;}@@ -169,9 +182,14 @@ export function scriptSql(return `insert into ${q} (${names.join(", ")})\nvalues (${names.map(() => "?").join(", ")});\n`;case "update": {const set = columns.filter((c) => !c.primaryKey).map((c) => `${ident(driver, c.name)} = ?`);+ if (driver === "clickhouse") {+ if (!set.length) throw new Error("ClickHouse sorting key columns cannot be updated.");+ return `alter table ${q}\nupdate ${set.join(",\n ")}\nwhere 1 = 0;\n`;+ }return `update ${q}\nset ${(set.length ? set : names.map((n) => `${n} = ?`)).join(",\n ")}\nwhere ${where};\n`;}case "delete":+ if (driver === "clickhouse") return `alter table ${q}\ndelete\nwhere 1 = 0;\n`;return `delete\nfrom ${q}\nwhere ${where};\n`;}}@@ -205,9 +223,9 @@ export function draftOf(c: DbColumnInfo, key: number): ColumnDraft {}function columnDefinition(driver: DbDriver, c: ColumnDraft): string {- let s = `${ident(driver, c.name)} ${c.dataType.trim() || (driver === "sqlite" ? "TEXT" : "text")}`;+ let s = `${ident(driver, c.name)} ${c.dataType.trim() || (driver === "clickhouse" ? "String" : driver === "sqlite" ? "TEXT" : "text")}`;if (c.default.trim()) s += ` default ${c.default.trim()}`;- if (c.notNull) s += " not null";+ if (c.notNull && driver !== "clickhouse") s += " not null";return s;}@@ -221,8 +239,8 @@ export function createTableSql(const live = columns.filter((c) => !c.dropped && c.name.trim());const keys = live.filter((c) => c.primaryKey).map((c) => ident(driver, c.name));const items = live.map((c) => ` ${columnDefinition(driver, c)}`);- if (keys.length) items.push(` primary key (${keys.join(", ")})`);- return `create table ${qualifiedName(driver, schema, name)}\n(\n${items.join(",\n")}\n);\n`;+ if (keys.length && driver !== "clickhouse") items.push(` primary key (${keys.join(", ")})`);+ return `create table ${qualifiedName(driver, schema, name)}\n(\n${items.join(",\n")}\n)${driver === "clickhouse" ? "\nengine = MergeTree\norder by tuple()" : ""};\n`;}/** Whether `alterTableSql` can express changing column `c` (SQLite only renames, adds and drops). */@@ -242,6 +260,7 @@ export function alterTableSql(name: string,columns: readonly ColumnDraft[],): string[] {+ if (!canModifyTable(driver)) return [];const out: string[] = [];const q = () => qualifiedName(driver, schema, table);for (const c of columns) {diff --git a/src/features/database/sql/analyze.ts b/src/features/database/sql/analyze.tsindex fb0332e34..a984796b0 100644--- a/src/features/database/sql/analyze.ts+++ b/src/features/database/sql/analyze.ts@@ -174,7 +174,7 @@ export function analyze(text: string, pos: number, driver: DbDriver, lexed: Lexeblocks.forEach((g, depth) => {// Within an enclosing block, the "caret" is the paren of the block nested in it.const [ra, rb] = blockRange(st, parens, g, depth === 0 ? nb : blocks[depth - 1]!);- for (const r of parseRefs(st, parens, g, ra, rb, ctes, depth)) {+ for (const r of parseRefs(st, parens, g, ra, rb, ctes, depth, driver)) {refs.push(r.ref);if (depth === 0) refEnds.set(r.end, r.ref);}@@ -362,6 +362,7 @@ function parseRefs(b: number,ctes: TableRef[],depth: number,+ driver: DbDriver,): Array<{ ref: TableRef; end: number }> {const out: Array<{ ref: TableRef; end: number }> = [];const level = parens.level(g, a, b);@@ -409,7 +410,10 @@ function parseRefs(const name = identName(last);const schema = parts.length > 1 ? identName(parts.at(-2)!) : null;const al = alias(st, k, b);- const cte = schema === null ? ctes.find((c) => c.name.toLowerCase() === name.toLowerCase()) : undefined;+ const cte =+ schema === null+ ? ctes.find((c) => (driver === "clickhouse" ? c.name === name : c.name.toLowerCase() === name.toLowerCase()))+ : undefined;out.push({ref: {schema,diff --git a/src/features/database/sql/complete.ts b/src/features/database/sql/complete.tsindex 0ef084d40..f2adf0467 100644--- a/src/features/database/sql/complete.ts+++ b/src/features/database/sql/complete.ts@@ -7,7 +7,15 @@*/import type { DbCompletion, DbCompletionColumn, DbCompletionTable, DbDriver } from "@/platform/ipc";import type { Analysis, Clause, TableRef } from "./analyze";-import { DATA_TYPES, functions, isReserved, joinKeywords, predicateKeywords, statementStarters } from "./dialect";+import {+ DATA_TYPES,+ functions,+ isReserved,+ joinKeywords,+ nameMatcher,+ predicateKeywords,+ statementStarters,+} from "./dialect";export type CandidateKind =| "table"@@ -55,13 +63,16 @@ export function shouldAutoCompleteSql(analysis: Analysis): boolean {const MAX_ALL_COLUMNS = 3000;-const eq = (a: string | null | undefined, b: string | null | undefined) =>- !!a && !!b && a.toLowerCase() === b.toLowerCase();-/** `name`, quoted when the dialect needs it (case, characters, reserved words). */export function quoteIdent(name: string, driver: DbDriver): string {- const plain = driver === "postgres" ? /^[a-z_][a-z0-9_$]*$/ : /^[A-Za-z_][A-Za-z0-9_$]*$/;+ const plain =+ driver === "postgres"+ ? /^[a-z_][a-z0-9_$]*$/+ : driver === "clickhouse"+ ? /^[A-Za-z_][A-Za-z0-9_]*$/+ : /^[A-Za-z_][A-Za-z0-9_$]*$/;if (plain.test(name) && !isReserved(name)) return name;+ if (driver === "clickhouse") return `"${name.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;const q = driver === "mysql" ? "`" : '"';return q + name.split(q).join(q + q) + q;}@@ -94,6 +105,7 @@ export interface CompletionInput {}export function sqlCandidates({ model, analysis: a, driver, sourceName }: CompletionInput): SqlCandidate[] {+ const eq = nameMatcher(driver);const ctx = a.context;if (ctx.kind === "none") return [];const typedLower = /[a-z]/.test(a.prefix.text) && !/[A-Z]/.test(a.prefix.text);@@ -224,7 +236,7 @@ export function sqlCandidates({ model, analysis: a, driver, sourceName }: Compleelse {if (ctx.ref.viaJoin) {out.push(- ...conditionCandidates(a, model, ctx.ref, kw).map((c) => ({+ ...conditionCandidates(a, model, ctx.ref, kw, driver).map((c) => ({...c,label: `${kw("ON")} ${c.label}`,insert: `${kw("ON")} ${c.insert ?? c.label}`,@@ -238,7 +250,7 @@ export function sqlCandidates({ model, analysis: a, driver, sourceName }: Comple}case "joinCondition":- out.push(...conditionCandidates(a, model, ctx.ref, kw));+ out.push(...conditionCandidates(a, model, ctx.ref, kw, driver));columnContext("on");return out;@@ -322,7 +334,7 @@ export function sqlCandidates({ model, analysis: a, driver, sourceName }: Compleif (!visible.some((r) => eq(r.name, c.name))) out.push({ label: c.name, kind: "table", tail: "(CTE)", boost: 0 });const fnBoost = clause === "select" || clause === "having" ? 15 : 8;for (const f of functions(driver)) {- const name = lower ? f.name : f.name.toUpperCase();+ const name = lower || driver === "clickhouse" ? f.name : f.name.toUpperCase();out.push({label: name,kind: "function",@@ -372,7 +384,7 @@ function clauseKeywords(clause: Clause, driver: DbDriver, a: Analysis): string[]case "returning":return ["AS"];default:- return [...pred, ...DATA_TYPES[driver].map((t) => t.toUpperCase())];+ return [...pred, ...DATA_TYPES[driver].map((t) => (driver === "clickhouse" ? t : t.toUpperCase()))];}}@@ -390,6 +402,7 @@ function joinCandidates(kw: Kw,): SqlCandidate[] {if (!model) return [];+ const eq = nameMatcher(driver);const out: SqlCandidate[] = [];const q = (n: string) => quoteIdent(n, driver);const seen = new Set<string>();@@ -446,8 +459,15 @@ function joinCandidates(}/** `JOIN t x ON |` → conditions relating `ref` to the other tables in scope. */-function conditionCandidates(a: Analysis, model: DbCompletion | null, ref: TableRef, kw: Kw): SqlCandidate[] {+function conditionCandidates(+ a: Analysis,+ model: DbCompletion | null,+ ref: TableRef,+ kw: Kw,+ driver: DbDriver,+): SqlCandidate[] {if (!model || ref.kind !== "table") return [];+ const eq = nameMatcher(driver);const out: SqlCandidate[] = [];const find = (r: TableRef) =>model.tables.find((t) => eq(t.name, r.name) && (r.schema ? eq(t.schema, r.schema) : true));diff --git a/src/features/database/sql/dialect.ts b/src/features/database/sql/dialect.tsindex e66afaaf0..ca7c01e91 100644--- a/src/features/database/sql/dialect.ts+++ b/src/features/database/sql/dialect.ts@@ -24,6 +24,9 @@ export function isReserved(word: string): boolean {return RESERVED.has(word.toUpperCase());}+export const nameMatcher = (driver: DbDriver) => (a: string | null | undefined, b: string | null | undefined) =>+ !!a && !!b && (driver === "clickhouse" ? a === b : a.toLowerCase() === b.toLowerCase());+/** Clause keywords: a word in this set ends a table alias or expression. */export const CLAUSE_WORDS = new Set((@@ -34,6 +37,30 @@ export const CLAUSE_WORDS = new Set();export function statementStarters(driver: DbDriver): string[] {+ if (driver === "clickhouse")+ return [+ "SELECT",+ "INSERT INTO",+ "WITH",+ "CREATE TABLE",+ "CREATE VIEW",+ "CREATE MATERIALIZED VIEW",+ "CREATE DATABASE",+ "ALTER TABLE",+ "DROP TABLE",+ "DROP VIEW",+ "DROP DATABASE",+ "RENAME TABLE",+ "TRUNCATE TABLE",+ "EXPLAIN",+ "SHOW DATABASES",+ "SHOW TABLES",+ "SHOW CREATE TABLE",+ "DESCRIBE TABLE",+ "USE",+ "SET",+ "OPTIMIZE TABLE",+ ];const common = ["SELECT","INSERT INTO",@@ -177,6 +204,33 @@ export const DATA_TYPES: Record<DbDriver, string[]> = {"VARBINARY","XML",],+ clickhouse: [+ "UInt64",+ "UInt32",+ "UInt16",+ "UInt8",+ "Int64",+ "Int32",+ "Float64",+ "Float32",+ "Decimal",+ "String",+ "FixedString",+ "Bool",+ "Date",+ "Date32",+ "DateTime",+ "DateTime64",+ "UUID",+ "IPv4",+ "IPv6",+ "Array",+ "Tuple",+ "Map",+ "Nullable",+ "LowCardinality",+ "JSON",+ ],};const f = (name: string, params: string, returns?: string, aggregate?: boolean): SqlFunction => ({@@ -297,6 +351,38 @@ const FUNCTIONS: Record<DbDriver, SqlFunction[]> = {f("row_number", "", "bigint"),f("rank", "", "bigint"),],+ clickhouse: [+ f("count", "*", "UInt64", true),+ f("sum", "expr", undefined, true),+ f("avg", "expr", "Float64", true),+ f("min", "expr", undefined, true),+ f("max", "expr", undefined, true),+ f("uniq", "expr", "UInt64", true),+ f("uniqExact", "expr", "UInt64", true),+ f("groupArray", "expr", "Array", true),+ f("argMax", "arg, value", undefined, true),+ f("coalesce", "value, ..."),+ f("ifNull", "a, b"),+ f("nullIf", "a, b"),+ f("lower", "text", "String"),+ f("upper", "text", "String"),+ f("length", "value", "UInt64"),+ f("concat", "value, ...", "String"),+ f("substring", "text, start, length", "String"),+ f("replaceAll", "text, pattern, replacement", "String"),+ f("abs", "number"),+ f("round", "number, digits"),+ f("toString", "expr", "String"),+ f("toUInt64", "expr", "UInt64"),+ f("toDate", "expr", "Date"),+ f("toDateTime", "expr", "DateTime"),+ f("toStartOfDay", "datetime", "DateTime"),+ f("now", "", "DateTime"),+ f("today", "", "Date"),+ f("arrayJoin", "array"),+ f("tuple", "value, ...", "Tuple"),+ f("cast", "expr AS type"),+ ],};export function functions(driver: DbDriver): SqlFunction[] {diff --git a/src/features/database/sql/lexer.ts b/src/features/database/sql/lexer.tsindex 3072ff2fc..b4137450a 100644--- a/src/features/database/sql/lexer.ts+++ b/src/features/database/sql/lexer.ts@@ -16,6 +16,7 @@ export interface Token {to: number;/** Upper-cased `text` of words, for keyword checks. */upper: string;+ value?: string;}export interface Lexed {@@ -30,13 +31,23 @@ const TWO_CHAR = new Set(["::", "<=", ">=", "<>", "!=", "||", "->", "=>", ":="])export function lex(text: string, driver: DbDriver = "sqlite"): Lexed {const mysql = driver === "mysql";+ const clickhouse = driver === "clickhouse";const tokens: Token[] = [];const comments: Lexed["comments"] = [];const n = text.length;let i = 0;const push = (kind: TokenKind, from: number, to: number) => {const t = text.slice(from, to);- tokens.push({ kind, text: t, from, to, upper: kind === "word" ? t.toUpperCase() : t });+ tokens.push({+ kind,+ text: t,+ from,+ to,+ upper: kind === "word" ? t.toUpperCase() : t,+ ...(kind === "quoted" && clickhouse+ ? { value: t.slice(1, t.endsWith(t[0]!) ? -1 : undefined).replace(/\\([\\'"`])/g, "$1") }+ : {}),+ });};/** End of a quoted run starting at `i` (closing char doubled = escaped). */const quoted = (start: number, close: string, backslash: boolean): number => {@@ -67,15 +78,15 @@ export function lex(text: string, driver: DbDriver = "sqlite"): Lexed {comments.push({ from: i, to, open: end < 0 });i = to;} else if (c === "'") {- const to = quoted(i, "'", mysql);+ const to = quoted(i, "'", mysql || clickhouse);push("string", i, to);i = to;} else if (c === '"') {- const to = quoted(i, '"', false);+ const to = quoted(i, '"', clickhouse);push(mysql ? "string" : "quoted", i, to);i = to;- } else if (c === "`" && mysql) {- const to = quoted(i, "`", false);+ } else if (c === "`" && (mysql || clickhouse)) {+ const to = quoted(i, "`", clickhouse);push("quoted", i, to);i = to;} else if (c === "$" && driver === "postgres") {@@ -146,6 +157,7 @@ function closed(t: Token): boolean {/** The identifier a word / quoted token names (quotes removed, doubled quotes collapsed). */export function identName(t: Token): string {if (t.kind !== "quoted") return t.text;+ if (t.value !== undefined) return t.value;const q = t.text[0]!;const body = t.text.endsWith(q) && t.text.length > 1 ? t.text.slice(1, -1) : t.text.slice(1);return body.split(q + q).join(q);diff --git a/src/features/database/sql/params.ts b/src/features/database/sql/params.tsindex c773c8b8d..8c82e78d3 100644--- a/src/features/database/sql/params.ts+++ b/src/features/database/sql/params.ts@@ -21,7 +21,18 @@ export function findParams(text: string, driver: DbDriver, numbered = 0): SqlParconst toks = lex(text, driver).tokens;const out: SqlParam[] = [];let positional = numbered;+ let typedEnd = -1;toks.forEach((t, i) => {+ if (t.from < typedEnd) return;+ if (driver === "clickhouse" && t.kind === "punct" && t.text === "{") {+ const end = toks.slice(i + 1).find((candidate) => candidate.kind === "punct" && candidate.text === "}");+ const name = end ? text.slice(t.from, end.to) : "";+ if (end && /^\{[A-Za-z_][A-Za-z0-9_]*\s*:\s*[^{}]+\}$/.test(name)) {+ out.push({ name, from: t.from, to: end.to });+ typedEnd = end.to;+ return;+ }+ }if (t.kind === "param") {// MySQL `@var` / `@@var` are session variables.if (driver === "mysql" && t.text.startsWith("@")) return;diff --git a/src/features/database/sql/resolve.ts b/src/features/database/sql/resolve.tsindex 4287f0c2e..6c160ee7b 100644--- a/src/features/database/sql/resolve.ts+++ b/src/features/database/sql/resolve.ts@@ -7,7 +7,7 @@*/import type { DbCompletion, DbCompletionColumn, DbCompletionTable, DbDriver } from "@/platform/ipc";import { analyze, type TableRef } from "./analyze";-import { CLAUSE_WORDS, DATA_TYPES, functions, isReserved } from "./dialect";+import { CLAUSE_WORDS, DATA_TYPES, functions, isReserved, nameMatcher } from "./dialect";import { identName, lex, type Lexed, type Token } from "./lexer";export type SqlSymbol =@@ -49,14 +49,13 @@ const NOT_COLUMNS = new Set().split(" "),);-const eq = (a: string | null | undefined, b: string | null | undefined) =>- !!a && !!b && a.toLowerCase() === b.toLowerCase();-export function findTable(model: DbCompletion | null,schema: string | null,name: string,+ driver: DbDriver = "sqlite",): DbCompletionTable | undefined {+ const eq = nameMatcher(driver);const tables = model?.tables ?? [];if (schema) return tables.find((t) => eq(t.schema, schema) && eq(t.name, name));return (@@ -126,6 +125,7 @@ export class SqlResolver {/** Resolves token `i`; `null` when it is no name (keywords, function names…). */resolve(i: number): Resolved | null {+ const eq = nameMatcher(this.driver);const toks = this.lexed.tokens;const t = toks[i]!;if (!isName(t) || (t.kind === "word" && CLAUSE_WORDS.has(t.upper))) return null;@@ -166,7 +166,7 @@ export class SqlResolver {const schema = qualifier?.at(-1) ?? null;const cte = schema ? undefined : a.ctes.find((c) => eq(c.name, name));if (cte) return { ...span, symbol: { kind: "cte", name: cte.name, def: { from: cte.from, to: cte.to } } };- const table = findTable(this.model, schema, name);+ const table = findTable(this.model, schema, name, this.driver);if (table) return { ...span, symbol: { kind: "table", table } };if (!loaded || (a.verb !== "DROP" && a.verb !== "ALTER" && !checked)) return { ...span, symbol: null };if (schema && !this.model!.tables.some((x) => eq(x.schema, schema))) return { ...span, symbol: null };@@ -228,7 +228,7 @@ export class SqlResolver {clause !== "other" &&clause !== "values" &&clause !== "limit" &&- !this.outputAliases(i).has(name.toLowerCase());+ !this.outputAliases(i).has(this.driver === "clickhouse" ? name : name.toLowerCase());return judged? { ...span, symbol: null, problem: `Unable to resolve column '${name}'` }: { ...span, symbol: null };@@ -247,15 +247,17 @@ export class SqlResolver {}private schema(name: string, span: Span): Resolved {+ const eq = nameMatcher(this.driver);return { ...span, symbol: this.model?.tables.some((x) => eq(x.schema, name)) ? { kind: "schema", name } : null };}private findRef(refs: readonly TableRef[], schema: string | null, name: string): TableRef | undefined {+ const eq = nameMatcher(this.driver);return refs.find((r) => (r.alias ? eq(r.alias, name) : eq(r.name, name) && (!schema || eq(r.schema, schema))));}private refSymbol(ref: TableRef): SqlSymbol {- const table = ref.kind === "table" ? findTable(this.model, ref.schema, ref.name) : undefined;+ const table = ref.kind === "table" ? findTable(this.model, ref.schema, ref.name, this.driver) : undefined;if (ref.alias && ref.aliasAt) return { kind: "alias", name: ref.alias, def: ref.aliasAt, table };if (table) return { kind: "table", table };return { kind: "cte", name: ref.name, def: { from: ref.from, to: ref.to } };@@ -264,12 +266,12 @@ export class SqlResolver {/** Columns of a FROM item; `null` when unknown (not in the model, `select *` subqueries). */private columnsOf(ref: TableRef): Array<{ name: string; column?: DbCompletionColumn }> | null {if (ref.columns) return ref.columns.length ? ref.columns.map((name) => ({ name })) : null;- const table = findTable(this.model, ref.schema, ref.name);+ const table = findTable(this.model, ref.schema, ref.name, this.driver);return table ? table.columns.map((c) => ({ name: c.name, column: c })) : null;}private columnSymbol(ref: TableRef, col: { name: string; column?: DbCompletionColumn }): SqlSymbol {- const table = ref.kind === "table" ? findTable(this.model, ref.schema, ref.name) : undefined;+ const table = ref.kind === "table" ? findTable(this.model, ref.schema, ref.name, this.driver) : undefined;return { kind: "column", name: col.name, column: col.column, table, owner: ref.alias ?? ref.name };}@@ -287,7 +289,7 @@ export class SqlResolver {prev.kind === "number" ||prev.kind === "string")- out.add(identName(t).toLowerCase());+ out.add(this.driver === "clickhouse" ? identName(t) : identName(t).toLowerCase());}return out;}diff --git a/src/features/database/sql/sql.test.ts b/src/features/database/sql/sql.test.tsindex 907ea5f0d..ec7457764 100644--- a/src/features/database/sql/sql.test.ts+++ b/src/features/database/sql/sql.test.ts@@ -1,8 +1,9 @@import { describe, expect, it } from "vitest";-import type { DbCompletion } from "@/platform/ipc";+import type { DbCompletion, DbDriver } from "@/platform/ipc";import { analyze, templateContexts, valuesSlot } from "./analyze";import { aliasFor, quoteIdent, sqlCandidates, type SqlCandidate } from "./complete";-import { inLiteral, lex } from "./lexer";+import { identName, inLiteral, lex } from "./lexer";+import { DATA_TYPES, statementStarters } from "./dialect";import { bindParams, findParams } from "./params";import { SqlResolver } from "./resolve";@@ -65,17 +66,13 @@ const model: DbCompletion = {};/** Analysis at the `|` of `sql`. */-function at(sql: string, driver: "sqlite" | "postgres" | "mysql" = "sqlite") {+function at(sql: string, driver: DbDriver = "sqlite") {const pos = sql.indexOf("|");const text = sql.slice(0, pos) + sql.slice(pos + 1);return analyze(text, pos, driver);}-function complete(- sql: string,- driver: "sqlite" | "postgres" | "mysql" = "sqlite",- m: DbCompletion = model,-): SqlCandidate[] {+function complete(sql: string, driver: DbDriver = "sqlite", m: DbCompletion = model): SqlCandidate[] {return sqlCandidates({ model: m, analysis: at(sql, driver), driver, sourceName: "shop" }).sort((a, b) => b.boost - a.boost,);@@ -83,6 +80,14 @@ function complete(const labels = (c: SqlCandidate[], kind?: string) => c.filter((x) => !kind || x.kind === kind).map((x) => x.label);describe("lexer", () => {+ it("reads ClickHouse backticks and escaped quotes without exposing literal parameters", () => {+ const sql = String.raw`select "a\\b\"c", ` + "`my column`" + String.raw`, 'it\'s ?; text', ?`;+ const tokens = lex(sql, "clickhouse").tokens;+ expect(identName(tokens[1]!)).toBe('a\\b"c');+ expect(tokens.filter((t) => t.kind === "quoted").map(identName)).toEqual(['a\\b"c', "my column"]);+ expect(findParams(sql, "clickhouse").map((p) => p.name)).toEqual(["?1"]);+ });+it("skips comments and knows literals", () => {const l = lex("select 'a;b', \"Col\" -- c\nfrom t /* x */ where a::int = $1", "postgres");expect(l.tokens.map((t) => t.text)).toEqual([@@ -164,6 +169,42 @@ describe("analysis", () => {});describe("completion candidates", () => {+ it("keeps ClickHouse schema, table and column names distinct by case", () => {+ const catalog: DbCompletion = {+ defaultSchema: "analytics",+ foreignKeys: [],+ tables: [+ { schema: "analytics", name: "Events", kind: "table", columns: [col("UpperOnly")] },+ { schema: "analytics", name: "events", kind: "table", columns: [col("Value"), col("value")] },+ { schema: "Analytics", name: "events", kind: "table", columns: [col("OtherSchema")] },+ ],+ };+ expect(labels(complete("select e.| from events e", "clickhouse", catalog))).toEqual(["Value", "value"]);+ expect(labels(complete("select e.| from Events e", "clickhouse", catalog))).toEqual(["UpperOnly"]);+ expect(labels(complete("select e.| from Analytics.events e", "clickhouse", catalog))).toEqual(["OtherSchema"]);+ const problems = (sql: string) => new SqlResolver(sql, "clickhouse", catalog).problems().map((p) => p.message);+ expect(problems("select Value, value from events")).toEqual([]);+ expect(problems("select VALUE from events")).toEqual(["Unable to resolve column 'VALUE'"]);+ expect(problems("select UpperOnly from events")).toEqual(["Unable to resolve column 'UpperOnly'"]);+ expect(problems("select OtherSchema from Analytics.events")).toEqual([]);+ expect(problems("select OtherSchema from analytics.events")).toEqual(["Unable to resolve column 'OtherSchema'"]);+ expect(+ at("with Events as (select 1 as UpperOnly) select | from events e", "clickhouse").refs.find(+ (ref) => ref.name === "events",+ )?.kind,+ ).toBe("table");+ });++ it("offers ClickHouse SQL and keeps case-sensitive function and type names", () => {+ expect(statementStarters("clickhouse")).toEqual(expect.arrayContaining(["SHOW DATABASES", "ALTER TABLE"]));+ expect(statementStarters("clickhouse")).not.toEqual(expect.arrayContaining(["BEGIN", "SET search_path TO"]));+ expect(DATA_TYPES.clickhouse).toContain("UInt64");+ expect(complete("SELECT | FROM users", "clickhouse").find((c) => c.label === "toDateTime")).toMatchObject({+ snippet: "toDateTime(${})",+ });+ expect(quoteIdent('a\\b"c', "clickhouse")).toBe('"a\\\\b\\"c"');+ });+it("offers statement starters in the user's case", () => {expect(labels(complete("|"))).toContain("SELECT");expect(labels(complete("select 1; ins|"))).toContain("insert into");@@ -388,6 +429,15 @@ describe("resolve", () => {});describe("params", () => {+ it("binds whole ClickHouse typed parameters without treating their types as names", () => {+ const sql = "select {value:UInt64}, {label: Nullable(String)}, '{skip:String}'";+ const params = findParams(sql, "clickhouse");+ expect(params.map((p) => p.name)).toEqual(["{value:UInt64}", "{label: Nullable(String)}"]);+ expect(bindParams(sql, params, { "{value:UInt64}": "12", "{label: Nullable(String)}": "'test'" })).toBe(+ "select 12, 'test', '{skip:String}'",+ );+ });+it("finds parameters per dialect and binds values", () => {const names = (sql: string, driver: "sqlite" | "postgres" | "mysql" = "sqlite", n = 0) =>findParams(sql, driver, n).map((p) => p.name);diff --git a/src/features/database/store.ts b/src/features/database/store.tsindex 654475dd5..e5e133170 100644--- a/src/features/database/store.ts+++ b/src/features/database/store.ts@@ -353,7 +353,11 @@ const lastUsed = new Map<string, number>();/** Options › Transaction control: a manual data source's consoles start in manual commit. */function applyConnectDefaults(id: string) {- if (sourceById(id)?.options?.transaction === "manual" && !useDatabase.getState().manualCommit.has(id))+ if (+ sourceById(id)?.driver !== "clickhouse" &&+ sourceById(id)?.options?.transaction === "manual" &&+ !useDatabase.getState().manualCommit.has(id)+ )void setManualCommit(id, true).catch(() => {});}@@ -944,6 +948,7 @@ function setPending(id: string, pending: boolean) {/** Commits or rolls back the open transaction of a manual-commit data source. */export async function finishTransaction(id: string, commit: boolean): Promise<boolean> {+ if (sourceById(id)?.driver === "clickhouse") return false;try {await call(commands.dbFinishTransaction(id, commit));log("statement", commit ? "commit" : "rollback", `${promptOf(id)}>`);@@ -975,6 +980,7 @@ async function askEndTransaction(source: DataSource): Promise<boolean | null> {* whether to commit or roll them back.*/export async function setManualCommit(id: string, manual: boolean): Promise<void> {+ if (sourceById(id)?.driver === "clickhouse" && manual) return;const st = useDatabase.getState();if (manual === st.manualCommit.has(id)) return;if (!manual && st.pendingTx.has(id)) {diff --git a/src/features/database/table-editor.test.tsx b/src/features/database/table-editor.test.tsxnew file mode 100644index 000000000..98c1da0c6--- /dev/null+++ b/src/features/database/table-editor.test.tsx@@ -0,0 +1,90 @@+import { act, fireEvent, render, screen } from "@testing-library/react";+import { beforeEach, describe, expect, it, vi } from "vitest";+import type { DbDriver, DbTablePage } from "@/platform/ipc";+import { TableEditor } from "./TableEditor";+import { tableInput } from "./tableInput";++const backend = vi.hoisted(() => ({+ driver: "clickhouse" as DbDriver,+ page: vi.fn(),+ applyEdits: vi.fn(),+}));++vi.mock("@/platform/ipc", async (importOriginal) => {+ const actual = await importOriginal<typeof import("@/platform/ipc")>();+ return { ...actual, commands: { ...actual.commands, dbTablePage: backend.page, dbApplyEdits: backend.applyEdits } };+});++vi.mock("./store", () => ({+ sourceById: () => ({ driver: backend.driver, readOnly: false }),+ withConnection: (_id: string, run: () => unknown) => run(),+ openDialog: vi.fn(),+}));++vi.mock("@tanstack/react-virtual", () => ({+ useVirtualizer: ({ count }: { count: number }) => ({+ getTotalSize: () => count * 24,+ getVirtualItems: () => Array.from({ length: count }, (_, index) => ({ index, start: index * 24, key: index })),+ scrollToIndex: () => {},+ }),+}));++const page: DbTablePage = {+ result: {+ statement: "select * from users",+ columns: [+ { name: "id", typeName: "UInt64" },+ { name: "name", typeName: "String" },+ ],+ rows: [["1", "Ann"]],+ affected: null,+ hasMore: false,+ elapsedMs: 1,+ executionMs: 1,+ },+ details: {+ columns: [+ { name: "id", dataType: "UInt64", primaryKey: true, nullable: false, default: null },+ { name: "name", dataType: "String", primaryKey: false, nullable: false, default: null },+ ],+ indexes: [],+ foreignKeys: [],+ triggers: [],+ },+ offset: 0,+};++beforeEach(() => {+ backend.driver = "clickhouse";+ backend.page.mockResolvedValue({ status: "ok", data: page });+ backend.applyEdits.mockClear();+});++describe("table editor capabilities", () => {+ it("keeps ClickHouse rows read-only even when metadata marks a primary key", async () => {+ await act(async () => {+ render(<TableEditor input={tableInput("source", "default", "users")} />);+ });+ const cell = await screen.findByRole("gridcell", { name: "Ann" });+ fireEvent.doubleClick(cell);+ expect(screen.queryByRole("textbox", { name: "Edit name" })).toBeNull();+ expect(screen.queryByRole("button", { name: "Add Row" })).toBeNull();+ expect(screen.queryByRole("button", { name: "Submit" })).toBeNull();+ expect(screen.getByText("Use the query console to change ClickHouse data.")).toBeTruthy();+ fireEvent.mouseDown(cell, { button: 0 });+ fireEvent.paste(screen.getByRole("grid"), { clipboardData: { getData: () => "Changed" } });+ expect(screen.getByRole("gridcell", { name: "Ann" })).toBeTruthy();+ expect(backend.applyEdits).not.toHaveBeenCalled();+ });++ it("keeps keyed PostgreSQL rows editable", async () => {+ backend.driver = "postgres";+ await act(async () => {+ render(<TableEditor input={tableInput("source", "public", "users")} />);+ });+ fireEvent.doubleClick(await screen.findByRole("gridcell", { name: "Ann" }));+ expect(screen.getByRole("textbox", { name: "Edit name" })).toBeTruthy();+ expect(screen.getByRole("button", { name: "Add Row" })).toBeTruthy();+ expect(screen.getByRole("button", { name: "Submit" })).toBeTruthy();+ });+});diff --git a/src/features/database/treeActions.ts b/src/features/database/treeActions.tsindex 629b392cb..5a902278b 100644--- a/src/features/database/treeActions.ts+++ b/src/features/database/treeActions.ts@@ -8,7 +8,7 @@ import { registerActions, type Action } from "@/platform/actions";import { editorService, notifications, showServiceView, toolWindowService } from "@/workbench/contributions";import { splitTarget } from "./model";import { nodeTarget, objectOf, schemaObjectOf, tableFolder, tableOf, type DbNode } from "./nodes";-import { canDrop, canRename, reference, scriptSql, type ScriptKind } from "./objects";+import { canDrop, canModifyTable, canRename, reference, scriptSql, type ScriptKind } from "./objects";import {DB_TOOL_WINDOW,OUTPUT_TAB,@@ -134,7 +134,15 @@ export async function insertScript(n: DbNode, kind: ScriptKind) {if (useDatabase.getState().details[key]?.status !== "ok") await loadDetails(t.id, t.schema, t.table);const d = useDatabase.getState().details[key];const columns = d?.status === "ok" ? d.value.columns : [];- await openConsoleWith(t.id, scriptSql(driverOf(t.id), kind, t.schema, t.table, columns));+ try {+ await openConsoleWith(t.id, scriptSql(driverOf(t.id), kind, t.schema, t.table, columns));+ } catch (e) {+ notifications().notify({+ level: "error",+ title: "Cannot generate the SQL script",+ body: e instanceof Error ? e.message : String(e),+ });+ }}/** SQL Scripts › Run SQL Script…: picks a `.sql` file and runs all its statements. */@@ -319,7 +327,7 @@ export function registerDatabaseTreeActions(): () => void {run: ({ arg }) => {const n = nodeFrom(arg);const t = n && tableOf(n);- if (!t || t.view) return;+ if (!t || t.view || !canModifyTable(driverOf(t.id))) return;openDialog({kind: "modifyTable",id: t.id,@@ -351,7 +359,7 @@ export function registerDatabaseTreeActions(): () => void {run: ({ arg }) => {const n = nodeFrom(arg);const t = n && tableOf(n);- if (t && !t.view)+ if (t && !t.view && canModifyTable(driverOf(t.id)))openDialog({ kind: "modifyTable", id: t.id, schema: t.schema, table: t.table, addColumn: true });},}),@@ -362,7 +370,7 @@ export function registerDatabaseTreeActions(): () => void {keywords: ["csv", "tsv", "load data"],run: ({ arg }) => {const n = nodeFrom(arg);- if (n?.kind === "table" && n.table.kind === "table")+ if (n?.kind === "table" && n.table.kind === "table" && driverOf(n.id) !== "clickhouse")openDialog({ kind: "import", id: n.id, schema: n.schema, table: n.table.name });},}),diff --git a/src/features/database/treeMenu.ts b/src/features/database/treeMenu.tsindex c28e8bf85..ce7e7a0e2 100644--- a/src/features/database/treeMenu.ts+++ b/src/features/database/treeMenu.ts@@ -4,7 +4,7 @@ import { notifications } from "@/workbench/contributions";import { fileSourceName, parseSourceUrl } from "./model";import { VENDORS, vendorPreset } from "./vendors";import { nodeTarget, objectOf, tableOf, type DbNode } from "./nodes";-import { SCRIPT_LABELS, canDrop, canRename, type ScriptKind } from "./objects";+import { SCRIPT_LABELS, canDrop, canModifyTable, canRename, type ScriptKind } from "./objects";import { connectedTargets, openDialog, openSourceDialog, sourceById, useDatabase } from "./store";const act = (@@ -150,9 +150,17 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {{label: "New",icon: "plus",- submenu: [newConsole, sep, act("db.newColumn", n, { disabled: view }), act("db.newTable", n)],+ submenu: [+ newConsole,+ sep,+ act("db.newColumn", n, { disabled: view || !canModifyTable(driver) }),+ act("db.newTable", n),+ ],},- act("db.modifyTable", n, { label: column ? "Modify Column…" : "Modify Table…", disabled: view }),+ act("db.modifyTable", n, {+ label: column ? "Modify Column…" : "Modify Table…",+ disabled: view || !canModifyTable(driver),+ }),{ label: "Copy/Paste", submenu: [copyRef] },act("db.editData", n),refresh,@@ -165,7 +173,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {sqlScripts(n, true),...(n.kind === "table" && !view? [- { label: "Import/Export", submenu: [act("db.importData", n)] },+ { label: "Import/Export", submenu: [act("db.importData", n, { disabled: driver === "clickhouse" })] },{ label: "Object Actions", submenu: [act("db.truncate", n)] },]: []),@@ -203,7 +211,7 @@ export function nodeMenu(n: DbNode | null): MenuItem[] {case "key":return [...(n.kind === "group" && n.group === "columns"- ? [{ label: "New", icon: "plus", submenu: [act("db.newColumn", n)] }]+ ? [{ label: "New", icon: "plus", submenu: [act("db.newColumn", n, { disabled: !canModifyTable(driver) })] }]: []),refresh,sep,diff --git a/src/features/database/vendors.ts b/src/features/database/vendors.tsindex a5cd56afd..b92ac83f7 100644--- a/src/features/database/vendors.ts+++ b/src/features/database/vendors.ts@@ -28,6 +28,14 @@ export const VENDORS: readonly DbVendor[] = [scheme: "redshift",ssl: "require",},+ {+ id: "clickhouse",+ label: "ClickHouse",+ driver: "clickhouse",+ port: 8123,+ icon: "db-clickhouse",+ scheme: "clickhouse",+ },{id: "cockroachdb",label: "CockroachDB",@@ -101,11 +109,19 @@ export const vendorById = (id: string): DbVendor | undefined => BY_ID.get(id);export function vendorPreset(v: DbVendor): Partial<DataSource> {const preset: Partial<DataSource> = { driver: v.driver, vendor: v.id === v.driver ? "" : v.id, port: v.port };if (v.ssl) preset.ssl = v.ssl;+ if (v.driver === "clickhouse") {+ preset.user = "default";+ preset.database = "default";+ preset.ssl = "disable";+ }return preset;}/** URL schemes (besides the JDBC ones) that name a type. */const SCHEMES: Record<string, string> = {+ clickhouse: "clickhouse",+ http: "clickhouse",+ https: "clickhouse",postgres: "postgres",postgresql: "postgres",pgsql: "postgres",@@ -136,5 +152,9 @@ export function sourceUrl(s: DataSource): string {const host = bracketed(s.host?.trim() || "localhost");const port = s.port ?? v.port;const db = s.database ? `/${encodeURIComponent(s.database)}` : "";+ if (v.driver === "clickhouse") {+ const secure = s.ssl != null && s.ssl !== "disable" && s.ssl !== "prefer";+ return `${secure ? "https" : "http"}://${host}:${s.port ?? (secure ? 8443 : 8123)}${db}`;+ }return `jdbc:${v.scheme}://${host}${port ? `:${port}` : ""}${db}`;}diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex 3aeb866a2..dcd8bf04e 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -343,6 +343,7 @@"Cannot export data": "无法导出数据","Cannot find usages of '{name}'": "无法查找 '{name}' 的用法","Cannot generate the DDL": "无法生成 DDL",+ "Cannot generate the SQL script": "无法生成 SQL 脚本","Cannot get the DDL of {name}": "无法获取 {name} 的 DDL","Cannot open file": "无法打开文件","Cannot open library class": "无法打开库类",@@ -4603,6 +4604,7 @@"The Database tree shows only the checked names and patterns (* and ?); the connected database always shows.": "数据库树只显示选中的名称和模式(* 和 ?);已连接的数据库始终显示。","Save the data source to pick from the server's names; patterns (* and ?) work any time.": "保存数据源后可从服务器上的名称中选取;模式(* 和 ?)随时可用。","Read-only data source.": "只读数据源。",+ "Use the query console to change ClickHouse data.": "请使用查询控制台修改 ClickHouse 数据。","Read-only: the table has no primary key to identify rows.": "只读:该表没有可用于标识行的主键。","The session has finished.": "会话已结束。","Variables are available while suspended.": "变量仅在挂起时可用。",@@ -4941,6 +4943,7 @@"Add New Interpreter…": "添加新的解释器…","Interpreter Settings…": "解释器设置…","Connection settings for SQL Server.": "SQL Server 的连接设置。",+ "ClickHouse settings sent with each HTTP request. connect_timeout is in seconds.": "每个 HTTP 请求附带的 ClickHouse 设置。connect_timeout 的单位为秒。","Microsoft SQL Server": "微软 SQL Server","Add to .gitignore": "添加到 .gitignore","Add to .git/info/exclude": "添加到 .git/info/exclude",diff --git a/src/platform/locales/textCatalog.test.ts b/src/platform/locales/textCatalog.test.tsindex b35f033d8..985778500 100644--- a/src/platform/locales/textCatalog.test.ts+++ b/src/platform/locales/textCatalog.test.ts@@ -118,6 +118,7 @@ const UNTRANSLATED = new Set<string>(["basedpyright","Cargo Check","Clippy",+ "ClickHouse","CockroachDB","CodeLLDB","CodeLLDB (Rust, C, C++)",diff --git a/src/ui/icons.tsx b/src/ui/icons.tsxindex 77b04b775..6ba2137c6 100644--- a/src/ui/icons.tsx+++ b/src/ui/icons.tsx@@ -303,6 +303,7 @@ const ICONS = {"db-disconnect": "openidea/database/disconnect","db-sqlite": "openidea/database/sqlite","db-postgres": "openidea/database/postgres",+ "db-clickhouse": "openidea/database/clickhouse","db-mysql": "openidea/database/mysql","db-sqlserver": "openidea/database/sqlserver","db-mariadb": "openidea/database/mariadb",diff --git a/src/ui/openidea/database/clickhouse.svg b/src/ui/openidea/database/clickhouse.svgnew file mode 100644index 000000000..f0a7e8c40--- /dev/null+++ b/src/ui/openidea/database/clickhouse.svg@@ -0,0 +1 @@+<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 512 512"><rect width="512" height="512" rx="8" fill="#161616"/><g fill="#FCFF74"><rect x="83" y="83" width="38" height="346" rx="3"/><rect x="160" y="83" width="38" height="346" rx="3"/><rect x="237" y="83" width="38" height="346" rx="3"/><rect x="314" y="83" width="38" height="346" rx="3"/><rect x="391" y="218" width="38" height="76" rx="3"/></g></svg>