Merge origin/main into cli-reorg

Integrates #266 (query --dialect + SDK 0.14.0) with the reorg:
- Dropped main's old flag-based `search` handler and top-level `Query`/`Queries`
  arms in favor of the reorg's `commands::search::dispatch` and re-parented
  surface; kept #266's `dialect` field/threading.
- Added `--dialect` to both `query` (shortcut) and `databases query` (canonical),
  threaded through `query::execute`; search always passes `hotsql`.
- Adopted SDK 0.14.0 (embedding-provider config map) via the auto-merged
  `parse_config_map` from #266.
- Docs: kept reorg command spellings, kept #266's dialect notes.

Author: eddietejeda

Cargo.lock

@@ -16,7 +16,7 @@ path = "src/main.rs"
 # behind a shared multi-thread tokio runtime. The `arrow` feature backs result
 # decode; `upload_file` runs the presigned direct-to-storage upload flow
 # (see src/sdk.rs::Api::upload).
-hotdata = { version = "0.13.0", features = ["arrow"] }
+hotdata = { version = "0.14.0", features = ["arrow"] }
 # Shared multi-thread runtime for the sync wrapper; block_on is called
 # concurrently from rayon worker threads (see src/indexes.rs). The presigned
 # upload (src/sdk.rs::Api::upload) drives the SDK's async `upload_file` on this

Cargo.toml

@@ -177,9 +177,19 @@ hotdata databases load --catalog demo --table listings --file ./listings.parquet
 ```sh
 hotdata databases tables list                # every queryable table, as connection.schema.table
 hotdata databases tables show <table>        # column names and types for one table
-hotdata query "<sql>" [-o table|json|csv]    # PostgreSQL dialect
+hotdata query "<sql>" [-o table|json|csv]    # HotSQL (PostgreSQL dialect)
 ```
 
+Write your SQL in another dialect and have the server transpile it to HotSQL
+before it runs — use idioms like Snowflake `IFF(...)` or DuckDB `len(...)`:
+
+```sh
+hotdata query "SELECT IFF(n > 0, 'pos', 'neg') FROM t" --dialect snowflake
+```
+
+`--dialect` accepts `hotsql` (default, no transpilation), `duckdb`, `postgres`,
+or `snowflake`. Only read-only queries are accepted for a non-`hotsql` dialect.
+
 Long-running queries fall back to async and print a `query_run_id` — poll with
 `hotdata query status <id>` (exit codes: `0` done, `1` failed, `2` running).
 Every result gets a `result-id`; re-fetch past results with

README.md

@@ -17,11 +17,12 @@ version: 0.26.0
 ## Execute SQL
 
 ```bash
-hotdata query "<sql>" [--workspace-id <workspace_id>] [--database <database>] [--output table|json|csv]
+hotdata query "<sql>" [--workspace-id <workspace_id>] [--database <database>] [--dialect hotsql|duckdb|postgres|snowflake] [--output table|json|csv]
 hotdata query status <query_run_id>
 ```
 
 - **PostgreSQL dialect.** Quote mixed-case identifiers: `"CustomerName"`.
+- **`--dialect`** (default `hotsql`): write SQL in `duckdb`/`postgres`/`snowflake` and the server transpiles it to HotSQL before running (e.g. Snowflake `IFF(...)`, DuckDB `len(...)`). Read-only queries only for a non-`hotsql` dialect.
 - Use **`hotdata databases tables list`** for schema discovery — not `information_schema` via `query`.
 - Fully qualified names: `<catalog>.<schema>.<table>`, `<database>.<schema>.<table>`.
 - **Query scope:** every query runs inside one managed database (active or `--database`); it sees that database's own catalog plus **attached** catalogs only. To query an attached catalog's table, or **join a managed table against an attached catalog's table**, attach the catalog first: `hotdata databases attach <catalog>` — see **`hotdata`** skill → [Querying across catalogs](../../SKILL.md#querying-across-catalogs-attach). No managed database set → *"a database is required."*

skills/hotdata/subskills/analytics/SKILL.md

@@ -52,6 +52,11 @@ pub enum Commands {
         #[arg(long, short = 'd')]
         database: Option<String>,
 
+        /// SQL dialect the query is written in — a non-`hotsql` dialect is
+        /// transpiled to HotSQL server-side before it runs (read-only only)
+        #[arg(long, default_value = "hotsql", value_parser = ["hotsql", "duckdb", "postgres", "snowflake"])]
+        dialect: String,
+
         /// Output format
         #[arg(long = "output", short = 'o', default_value = "table", value_parser = ["table", "json", "csv"])]
         output: String,

src/cli.rs

@@ -209,6 +209,11 @@ pub enum DatabasesCommands {
         #[arg(long, short = 'd')]
         database: Option<String>,
 
+        /// SQL dialect the query is written in — a non-`hotsql` dialect is
+        /// transpiled to HotSQL server-side before it runs (read-only only)
+        #[arg(long, default_value = "hotsql", value_parser = ["hotsql", "duckdb", "postgres", "snowflake"])]
+        dialect: String,
+
         /// Output format
         #[arg(long = "output", short = 'o', default_value = "table", value_parser = ["table", "json", "csv"])]
         output: String,

src/commands/databases.rs

@@ -171,6 +171,25 @@ fn parse_config(raw: Option<&str>) -> Option<serde_json::Value> {
     })
 }
 
+/// Parse `--config` into the object map the create request expects. Exits on
+/// invalid JSON (via [`parse_config`]) or a JSON value that isn't an object.
+fn parse_config_map(
+    raw: Option<&str>,
+) -> Option<std::collections::HashMap<String, serde_json::Value>> {
+    use crossterm::style::Stylize;
+    match parse_config(raw)? {
+        serde_json::Value::Object(map) => Some(map.into_iter().collect()),
+        _ => {
+            eprintln!(
+                "{}",
+                "--config must be a JSON object, e.g. '{\"model\": \"text-embedding-3-small\"}'"
+                    .red()
+            );
+            std::process::exit(1);
+        }
+    }
+}
+
 pub fn list(workspace_id: &str, format: &str) {
     let api = Api::new(Some(workspace_id));
     let providers: Vec<Provider> = crate::client::sdk::block_with_wakeup(
@@ -255,8 +274,8 @@ pub fn create(
 
     let api = Api::new(Some(workspace_id));
     let mut req = CreateEmbeddingProviderRequest::new(name.to_string(), provider_type.to_string());
-    if let Some(cfg) = parse_config(config) {
-        req.config = Some(Some(cfg));
+    if let Some(cfg) = parse_config_map(config) {
+        req.config = Some(cfg);
     }
     if let Some(k) = api_key {
         req.api_key = Some(Some(k.to_string()));

src/commands/embedding_providers.rs

@@ -440,7 +440,7 @@ fn fail_run(error_msg: &str) -> ! {
     std::process::exit(1);
 }
 
-pub fn execute(sql: &str, workspace_id: &str, database: Option<&str>, format: &str) {
+pub fn execute(sql: &str, workspace_id: &str, database: Option<&str>, format: &str, dialect: &str) {
     // Scope to the explicit --database flag, else the active database resolved
     // at construction (HOTDATA_DATABASE / current database). The scoped `Api`
     // carries the database into submit_query's `X-Database-Id` header and into
@@ -451,6 +451,11 @@ pub fn execute(sql: &str, workspace_id: &str, database: Option<&str>, format: &s
     let mut request = hotdata::models::QueryRequest::new(sql.to_string());
     request.r#async = Some(true);
     request.async_after_ms = Some(Some(1000));
+    // `hotsql` is the server default and planned as-is; only send `dialect` for a
+    // non-default dialect so ordinary queries keep their existing request shape.
+    if dialect != "hotsql" {
+        request.dialect = Some(Some(dialect.to_string()));
+    }
 
     let outcome = crate::client::sdk::block_with_wakeup(
         &api,

src/commands/query.rs

@@ -393,7 +393,8 @@ pub fn run(
         select,
         limit,
     );
-    query::execute(&sql, workspace_id, Some(&loc.database_id), output);
+    // Search generates HotSQL directly — never a foreign dialect.
+    query::execute(&sql, workspace_id, Some(&loc.database_id), output, "hotsql");
 }
 
 fn remove(workspace_id: &str, database: Option<&str>, name: &str) {

src/commands/search.rs

@@ -192,6 +192,7 @@ fn main() {
                 sql,
                 workspace_id,
                 database,
+                dialect,
                 output,
                 command,
             } => {
@@ -201,9 +202,13 @@ fn main() {
                         query::poll(&id, &workspace_id, database.as_deref(), &output)
                     }
                     None => match sql {
-                        Some(sql) => {
-                            query::execute(&sql, &workspace_id, database.as_deref(), &output)
-                        }
+                        Some(sql) => query::execute(
+                            &sql,
+                            &workspace_id,
+                            database.as_deref(),
+                            &output,
+                            &dialect,
+                        ),
                         None => {
                             use clap::CommandFactory;
                             let mut cmd = Cli::command();
@@ -441,6 +446,7 @@ fn main() {
                         Some(DatabasesCommands::Query {
                             sql,
                             database,
+                            dialect,
                             output,
                             command,
                         }) => match command {
@@ -453,6 +459,7 @@ fn main() {
                                     &workspace_id,
                                     database.as_deref(),
                                     &output,
+                                    &dialect,
                                 ),
                                 None => {
                                     use clap::CommandFactory;