feat(query): add --dialect to transpile DuckDB/Postgres/Snowflake SQL

The runtime's POST /v1/query gained an optional `dialect` field
(hotdata-dev/runtimedb#1096, #1097): a non-`hotsql` dialect is transpiled to
HotSQL server-side before planning, so callers can use Snowflake `IFF(...)`,
Postgres `MOD(a, b)`, DuckDB `len(...)`, etc. Read-only queries only.

- `hotdata query "<sql>" --dialect hotsql|duckdb|postgres|snowflake` (default
  `hotsql`). Only a non-default dialect is put on the wire, so ordinary queries
  keep their existing request shape.
- Generated search SQL stays `hotsql`.
- Docs: README query section + analytics skill.

Bumps the hotdata SDK to 0.14.0, which carries the `dialect` field and also
tightened CreateEmbeddingProviderRequest.config to a String->Value map; adapt
`embedding_providers::add` accordingly (the update path still takes the old
optional value).

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 tables list                          # every queryable table, as connection.schema.table
 hotdata tables list --connection-id <id>     # with column names and types
-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 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

@@ -35,6 +35,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

@@ -126,6 +126,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(
@@ -210,8 +229,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

@@ -439,7 +439,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
@@ -450,6 +450,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

@@ -190,6 +190,7 @@ fn main() {
                 sql,
                 workspace_id,
                 database,
+                dialect,
                 output,
                 command,
             } => {
@@ -199,9 +200,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();
@@ -775,7 +780,8 @@ fn main() {
                     ),
                     _ => unreachable!(),
                 };
-                query::execute(&sql, &workspace_id, None, &output)
+                // Search generates HotSQL directly — never a foreign dialect.
+                query::execute(&sql, &workspace_id, None, &output, "hotsql")
             }
             Commands::Queries {
                 id,