fix(databases): declare --schema beside a dot-qualified --table too

An empty `--table` list was not the only way the chosen schema went
undeclared. `--table raw.orders` names its own schema, so with every entry
dot-qualified the group list never contained `--schema` either, and
`databases create --table raw.orders` left `public` undeclared exactly as a
tables-less create used to. A later bare-name declaration into it then fails
with "Schema 'public' is not declared" — the same failure, reached a
different way, and the doc comment claimed otherwise.

Seeding the group list with the chosen schema covers all three cases in one
path instead of special-casing the empty one, and a group that collected no
tables is emitted without `tables` rather than with an empty array.

Found in review of #259.

Author: anoop-narang

src/commands/databases.rs

@@ -561,7 +561,8 @@ fn schema_name(schema: Option<&str>) -> &str {
 /// Build the request body for `POST /v1/databases`.
 ///
 /// The `schema` argument (the `--schema` flag, defaulting to `public`) is always
-/// declared, with or without `--table`.
+/// declared: with no `--table`, with bare ones, and alongside any schema a
+/// dot-qualified `--table` names for itself.
 pub fn create_database_request(
     name: Option<&str>,
     catalog: Option<&str>,
@@ -582,39 +583,47 @@ pub fn create_database_request(
         );
     }
 
-    // `schemas` always goes out, even with no `--table`: the engine only
-    // auto-declares `main`, so a schemas-less create leaves `--schema` (default
-    // `public`) undeclared and every later table declaration into it fails with
-    // "Schema 'public' is not declared". `tables` is optional on a schema
-    // declaration, so an empty schema is a first-class request.
-    let schemas_json: Vec<serde_json::Value> = if tables.is_empty() {
-        vec![serde_json::json!({ "name": schema })]
-    } else {
-        // Group tables by schema, preserving insertion order.
-        // Dot-notation entries (e.g. "raw.raw_orders") use the named schema;
-        // bare names fall back to the `schema` argument.
-        let mut schema_tables: Vec<(String, Vec<String>)> = Vec::new();
-        for t in tables {
-            let (s, table_name) = match t.split_once('.') {
-                Some((s, tbl)) => (s.to_string(), tbl.to_string()),
-                None => (schema.to_string(), t.to_string()),
-            };
-            if let Some(entry) = schema_tables.iter_mut().find(|(n, _)| n == &s) {
-                entry.1.push(table_name);
-            } else {
-                schema_tables.push((s, vec![table_name]));
-            }
+    // `schemas` always goes out, and always carries `schema`: the engine only
+    // auto-declares `main`, so leaving `--schema` (default `public`) undeclared
+    // makes every later table declaration into it fail with "Schema 'public' is
+    // not declared". `tables` is optional on a schema declaration, so a schema
+    // with nothing in it yet is a first-class request.
+    //
+    // Seeded rather than special-cased on `tables.is_empty()`, because an empty
+    // `--table` list is not the only way the chosen schema goes undeclared:
+    // `--table raw.orders` names its own schema, so with every entry
+    // dot-qualified the group list would never contain `schema` either.
+    let mut schema_tables: Vec<(String, Vec<String>)> = vec![(schema.to_string(), Vec::new())];
+    // Dot-notation entries (e.g. "raw.raw_orders") use the named schema; bare
+    // names fall back to the `schema` argument. Insertion order is preserved,
+    // and `schema` leads because it is already seeded.
+    for t in tables {
+        let (s, table_name) = match t.split_once('.') {
+            Some((s, tbl)) => (s.to_string(), tbl.to_string()),
+            None => (schema.to_string(), t.to_string()),
+        };
+        if let Some(entry) = schema_tables.iter_mut().find(|(n, _)| n == &s) {
+            entry.1.push(table_name);
+        } else {
+            schema_tables.push((s, vec![table_name]));
         }
-        schema_tables
-            .into_iter()
-            .map(|(s, tbls)| {
+    }
+    let schemas_json: Vec<serde_json::Value> = schema_tables
+        .into_iter()
+        .map(|(s, tbls)| {
+            // `tables` omitted rather than sent empty: the seeded schema may
+            // have collected nothing, and the field is optional precisely so a
+            // schema can be declared on its own.
+            if tbls.is_empty() {
+                serde_json::json!({ "name": s })
+            } else {
                 serde_json::json!({
                     "name": s,
                     "tables": tbls.iter().map(|t| serde_json::json!({ "name": t })).collect::<Vec<_>>()
                 })
-            })
-            .collect()
-    };
+            }
+        })
+        .collect();
     req.insert(
         "schemas".to_string(),
         serde_json::Value::Array(schemas_json),
@@ -2282,6 +2291,38 @@ mod tests {
         assert_eq!(req["schemas"][0]["name"], "analytics");
     }
 
+    #[test]
+    fn create_database_request_declares_the_chosen_schema_beside_a_dotted_one() {
+        // Every --table dot-qualified elsewhere: --schema still has to be
+        // declared, or a later bare-name declaration into it fails the same way
+        // an empty --table list used to.
+        let req = create_database_request(None, None, "public", &["raw.orders".to_string()], None);
+        assert_eq!(req["schemas"][0]["name"], "public");
+        assert!(
+            req["schemas"][0].get("tables").is_none(),
+            "the chosen schema collected no tables, so it is declared on its own"
+        );
+        assert_eq!(req["schemas"][1]["name"], "raw");
+        assert_eq!(req["schemas"][1]["tables"][0]["name"], "orders");
+    }
+
+    #[test]
+    fn create_database_request_does_not_declare_the_chosen_schema_twice() {
+        // A bare name and a dot-qualified one naming the SAME schema are one
+        // group, and the seed must not become a second, empty copy of it.
+        let req = create_database_request(
+            None,
+            None,
+            "public",
+            &["orders".to_string(), "public.customers".to_string()],
+            None,
+        );
+        assert_eq!(req["schemas"].as_array().unwrap().len(), 1);
+        assert_eq!(req["schemas"][0]["name"], "public");
+        assert_eq!(req["schemas"][0]["tables"][0]["name"], "orders");
+        assert_eq!(req["schemas"][0]["tables"][1]["name"], "customers");
+    }
+
     #[test]
     fn create_database_request_includes_expires_at_when_provided() {
         let req = create_database_request(None, None, "public", &[], Some("24h"));