Skip to content

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.

feat(database): add ClickHouse data sources (#865)

kkmihaie04e5dd57d8e
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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 = true
serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["raw_value"] }
specta.workspace = true
toml.workspace = true
tokio.workspace = true
@@ -21,6 +21,10 @@ bb8.workspace = true
tokio-util = { workspace = true, features = ["compat"] }
dirs.workspace = true
ide-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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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", "azur
pub 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.rs
new file mode 100644
index 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.rs
index 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() -> IdeResu
db.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.rs
index 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.ts
new file mode 100644
index 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.ts
index 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.tsx
index 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 />
<Checkbox
diff --git a/src/features/database/SourceDialog.tsx b/src/features/database/SourceDialog.tsx
index 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({
<Select
aria-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 }
+ : {}),
+ });
+ }}
/>
<FileField
id="db-ssl-ca"
diff --git a/src/features/database/TableEditor.tsx b/src/features/database/TableEditor.tsx
index 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.tsx
index 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 && (
<>
<IconButton
icon="commit"
diff --git a/src/features/database/database.test.ts b/src/features/database/database.test.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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): string
if (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): st
return `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.ts
index 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: Lexe
blocks.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.ts
index 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 }: Comple
else {
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 }: Comple
if (!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.ts
index 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.ts
index 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.ts
index 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): SqlPar
const 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.ts
index 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.ts
index 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.ts
index 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.tsx
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.json
index 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.ts
index 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.tsx
index 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.svg
new file mode 100644
index 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>