Release 1.0.2

Cargo.toml

@@ -1,15 +1,16 @@
 [package]
 name = "clickhouse-query-ext"
-version = "1.0.1"
+version = "1.0.2"
 edition = "2024"
 authors = ["Querya Community"]
 description = "High-performance ClickHouse driver for Querya Desktop"
 
 [dependencies]
 # Async runtime & I/O
 tokio = { version = "1", features = ["rt-multi-thread", "io-std", "sync", "macros", "time", "net"] }
-tokio-util = { version = "0.7", features = ["codec"] }
+tokio-util = { version = "0.7", features = ["codec", "io"] }
 futures = "0.3"
+bytes = "1"
 
 # HTTP & TLS for ClickHouse API
 reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
@@ -32,6 +33,9 @@ regex = "1"
 thiserror = "2.0"
 anyhow = "1.0"
 
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
 [profile.release]
 lto = true
 strip = true

README.md

@@ -33,8 +33,8 @@ cargo build --release
 | Файл | Назначение |
 |------|------------|
 | `target/release/clickhouse-query-ext` | Бинарник драйвера |
-| `dist/clickhouse-query-ext-1.0.1.qext` | Пакет для установки в Querya Desktop |
-| `dist/clickhouse-query-ext-1.0.1.qext.sha256` | Контрольная сумма |
+| `dist/clickhouse-query-ext-1.0.2.qext` | Пакет для установки в Querya Desktop |
+| `dist/clickhouse-query-ext-1.0.2.qext.sha256` | Контрольная сумма |
 
 Установка: **Querya Desktop → Extensions → Install from file** → выбрать `.qext`.
 

manifest.json

@@ -1,14 +1,14 @@
 {
   "id": "queryahub.clickhouse-driver",
   "name": "ClickHouse Database Driver (Analyst Edition)",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "publisher": "Querya Community",
   "description": "Изолированный нативный Rust-драйвер для аналитической СУБД ClickHouse с полной поддержкой MergeTree, словарей, партиций и SDUI-интроспекции.",
   "type": "database_driver",
   "main": "bin/clickhouse_rpc_server",
   "icon": "assets/icon.svg",
   "engines": {
-    "querya_desktop": "^2.0.0"
+    "querya_desktop": ">=0.4.0 <3.0.0"
   },
   "capabilities": {
     "databaseDriver": true,
@@ -41,6 +41,28 @@
         "defaultPort": 8123,
         "connectionFormSchema": "assets/connection_form.json"
       }
+    ],
+    "commands": [
+      {
+        "id": "clickhouse.optimizeFinal",
+        "title": "ClickHouse: Optimize Table (FINAL)",
+        "category": "ClickHouse"
+      },
+      {
+        "id": "clickhouse.deduplicate",
+        "title": "ClickHouse: Deduplicate Table",
+        "category": "ClickHouse"
+      },
+      {
+        "id": "clickhouse.serverStats",
+        "title": "ClickHouse: Show Server Statistics",
+        "category": "ClickHouse"
+      },
+      {
+        "id": "clickhouse.dropPartition",
+        "title": "ClickHouse: Drop Selected Partition",
+        "category": "ClickHouse"
+      }
     ]
   }
 }

scripts/package_qext.sh

@@ -64,11 +64,29 @@ mkdir -p "${STAGING_DIR}/bin" "${STAGING_DIR}/assets"
 cp manifest.json "${STAGING_DIR}/"
 cp -r assets/* "${STAGING_DIR}/assets/"
 
+# For Windows targets, adjust manifest.json main entry point to include .exe extension
+if [[ "$TARGET" == *"windows"* ]] || [[ "$DEST_BIN_NAME" == *".exe" ]]; then
+  python3 -c "
+import json, sys
+manifest_path = sys.argv[1]
+dest_bin = sys.argv[2]
+with open(manifest_path, 'r', encoding='utf-8') as f:
+    manifest = json.load(f)
+manifest['main'] = f'bin/{dest_bin}'
+with open(manifest_path, 'w', encoding='utf-8') as f:
+    json.dump(manifest, f, indent=2, ensure_ascii=False)
+" "${STAGING_DIR}/manifest.json" "${DEST_BIN_NAME}"
+fi
+
 # 2. Copy binary into bin/ under both the manifest main entry and original name
 cp "${BIN_PATH}" "${STAGING_DIR}/bin/${DEST_BIN_NAME}"
 if [ "${DEST_BIN_NAME}" != "${BIN_NAME}" ] && [ ! -f "${STAGING_DIR}/bin/${BIN_NAME}" ]; then
   cp "${BIN_PATH}" "${STAGING_DIR}/bin/${BIN_NAME}"
 fi
+# On Windows packages, also provide the extensionless binary name for backward compatibility
+if [[ "$DEST_BIN_NAME" == *".exe" ]] && [ ! -f "${STAGING_DIR}/bin/clickhouse_rpc_server" ]; then
+  cp "${BIN_PATH}" "${STAGING_DIR}/bin/clickhouse_rpc_server" 2>/dev/null || true
+fi
 chmod +x "${STAGING_DIR}/bin/${DEST_BIN_NAME}"
 if [ -f "${STAGING_DIR}/bin/${BIN_NAME}" ]; then
   chmod +x "${STAGING_DIR}/bin/${BIN_NAME}"

src/driver/client.rs

@@ -14,10 +14,13 @@ pub struct ConnectParams {
     pub connection_string: Option<String>,
     pub host: Option<String>,
     pub port: Option<u16>,
+    #[serde(alias = "username")]
     pub user: Option<String>,
     pub database: Option<String>,
     #[serde(alias = "safe_mode", alias = "safeMode")]
     pub readonly: Option<bool>,
+    #[serde(alias = "sslMode")]
+    pub ssl_mode: Option<String>,
 }
 
 #[derive(Debug)]
@@ -44,8 +47,17 @@ impl ClickHouseClient {
             } else {
                 let parsed = Url::parse(&cs)?;
                 let host = parsed.host_str().unwrap_or("localhost");
-                let port = parsed.port().unwrap_or(8123);
                 let scheme = parsed.scheme();
+                let port_str = match parsed.port() {
+                    Some(p) => format!(":{}", p),
+                    None => {
+                        if scheme == "http" {
+                            ":8123".to_string()
+                        } else {
+                            String::new()
+                        }
+                    }
+                };
                 let user = if !parsed.username().is_empty() {
                     parsed.username().to_string()
                 } else {
@@ -58,17 +70,24 @@ impl ClickHouseClient {
                     params.database.unwrap_or_else(|| "default".to_string())
                 };
                 let readonly = params.readonly.unwrap_or(false);
-                let base = format!("{}://{}:{}", scheme, host, port);
+                let base = format!("{}://{}{}", scheme, host, port_str);
                 (base, user, database, readonly)
             }
         } else {
             let host = params.host.unwrap_or_else(|| "localhost".to_string());
-            let port = params.port.unwrap_or(8123);
+            let scheme = match params.ssl_mode.as_deref() {
+                Some("prefer") | Some("require") => "https",
+                _ => "http",
+            };
+            let mut port = params.port.unwrap_or(8123);
+            if scheme == "https" && port == 8123 {
+                port = 8443;
+            }
             let user = params.user.unwrap_or_else(|| "default".to_string());
             let database = params.database.unwrap_or_else(|| "default".to_string());
             let readonly = params.readonly.unwrap_or(false);
             (
-                format!("http://{}:{}", host, port),
+                format!("{}://{}:{}", scheme, host, port),
                 user,
                 database,
                 readonly,
@@ -146,14 +165,15 @@ impl ClickHouseClient {
         req
     }
 
+    async fn error_from_response(resp: reqwest::Response) -> DriverError {
+        let status = resp.status();
+        let text = resp.text().await.unwrap_or_default();
+        DriverError::Client(format!("ClickHouse HTTP error {}: {}", status, text))
+    }
+
     async fn read_response(resp: reqwest::Response) -> Result<String, DriverError> {
         if !resp.status().is_success() {
-            let status = resp.status();
-            let text = resp.text().await.unwrap_or_default();
-            return Err(DriverError::Client(format!(
-                "ClickHouse HTTP error {}: {}",
-                status, text
-            )));
+            return Err(Self::error_from_response(resp).await);
         }
         Ok(resp.text().await?)
     }
@@ -229,6 +249,41 @@ impl ClickHouseClient {
         }
     }
 
+    /// Like `post_sql`, but on success returns the raw streaming `reqwest::Response`
+    /// instead of buffering the whole body into a `String`, so a large analytical
+    /// result set can be parsed incrementally as it arrives over the network via
+    /// `crate::driver::streaming::stream_compact_output` (issue #49). Callers must
+    /// gate on mock/test connections themselves, same as before calling `post_sql`.
+    pub async fn post_sql_response(
+        &self,
+        sql: &str,
+        mut extra_params: impl FnMut(&mut Url),
+    ) -> Result<reqwest::Response, DriverError> {
+        let sql = sql.to_string();
+        let mut omit = self.omit_readonly_setting();
+        loop {
+            let mut url = Url::parse(&self.base_url)?;
+            url.query_pairs_mut()
+                .append_pair("database", &self.database);
+            extra_params(&mut url);
+            self.append_safe_mode_settings_with(&mut url, omit);
+            let req = self
+                .apply_auth(self.http_client.post(url))
+                .body(sql.clone());
+            let resp = req.send().await?;
+            if resp.status().is_success() {
+                return Ok(resp);
+            }
+            let err = Self::error_from_response(resp).await;
+            if self.readonly && !omit && Self::is_readonly_setting_conflict(&err) {
+                self.mark_server_readonly_enforced();
+                omit = true;
+                continue;
+            }
+            return Err(err);
+        }
+    }
+
     /// Check connection health by executing `SELECT version()` against ClickHouse.
     pub async fn ping_connection(&self) -> Result<String, DriverError> {
         let version = self.get_with_query("SELECT version()").await?;

src/driver/mod.rs

@@ -1,3 +1,4 @@
 //! ClickHouse HTTP client and session management.
 pub mod client;
 pub mod pool;
+pub mod streaming;