fix(databases): scope result load to the target database

`databases load --result` (and `tables load --result`) hit the
connection-scoped load endpoint, where the server scopes a result-sourced
load by the X-Database-Id header. That header carried the ambient active
database, which may be unset or differ from the --catalog/--database
target, so the load could be rejected (missing scope) or resolve against
the wrong database.

Re-scope the load client to the resolved target database via the new
Api::scoped_to_database, so the load request always carries X-Database-Id
for the addressed database.

Author: eddietejeda

src/client/sdk.rs

@@ -609,6 +609,19 @@ impl Api {
         self.database_id.as_deref()
     }
 
+    /// Return a clone of this handle scoped to `database_id`, so its requests
+    /// carry the `X-Database-Id` header regardless of the ambient active
+    /// database. Used by database-addressed flows (e.g. `databases load`) that
+    /// resolve the target database from a `--catalog` / `--database` argument:
+    /// the server scopes a result-sourced load by this header, so it must name
+    /// the load target, not whatever database happens to be active.
+    pub fn scoped_to_database(&self, database_id: &str) -> Api {
+        Api {
+            database_id: Some(database_id.to_string()),
+            ..self.clone()
+        }
+    }
+
     /// Best-effort probe of the scoped workspace's runtimedb scale state, via
     /// the control-plane `GET /v1/workspaces/{id}/runtime/status` endpoint.
     ///
@@ -1442,6 +1455,30 @@ mod tests {
         m.assert();
     }
 
+    #[test]
+    fn scoped_to_database_sends_x_database_id_without_ambient_scope() {
+        // `databases load --catalog X` builds an unscoped Api (no active
+        // database) and re-scopes it to the resolved target, so the load POST
+        // carries X-Database-Id even when nothing is set via `databases set`.
+        let mut server = mockito::Server::new();
+        let m = server
+            .mock("POST", "/v1/query")
+            .match_header("X-Database-Id", "db-target")
+            .with_status(200)
+            .with_header("content-type", "application/json")
+            .with_body(r#"{"ok":true}"#)
+            .create();
+
+        let api = Api::test_new(&server.url(), "test-jwt", Some("ws-1"));
+        assert_eq!(api.database_id(), None, "test_new starts unscoped");
+        let api = api.scoped_to_database("db-target");
+        let (status, _body) = api
+            .post_raw("/query", &serde_json::json!({"sql": "select 1"}))
+            .expect("post_raw should succeed");
+        assert_eq!(status, reqwest::StatusCode::OK);
+        m.assert();
+    }
+
     // --- presigned direct-to-storage upload ---------------------------------
 
     /// A deterministic ASCII payload of `len` bytes written to a temp parquet

src/commands/databases.rs

@@ -1404,6 +1404,11 @@ pub fn tables_load(
         None => database.clone(),
     };
     let db = resolve_database(&api, &lookup_key);
+    // Scope requests to the resolved target database. The load hits the
+    // connection-scoped endpoint, where the server scopes a result-sourced load
+    // by the X-Database-Id header; that must name the --catalog/--database
+    // target, not the ambient active database (which may be unset or different).
+    let api = api.scoped_to_database(&db.id);
     let schema = schema_name(schema);
 
     // clap enforces mutual exclusion; only one source is ever Some. A file/URL
@@ -2154,12 +2159,15 @@ mod tests {
             .with_body(full_detail("db_1", "sales", "conn_default"))
             .create();
         // A result load hits the same loads endpoint but with a result_id body
-        // and no upload step (no POST /v1/uploads mock is registered).
+        // and no upload step (no POST /v1/uploads mock is registered). The
+        // server scopes a result-sourced load by X-Database-Id, so the request
+        // must carry the resolved target database id.
         let load = server
             .mock(
                 "POST",
                 "/v1/connections/conn_default/schemas/public/tables/orders/loads",
             )
+            .match_header("X-Database-Id", "db_1")
             .match_body(mockito::Matcher::JsonString(
                 serde_json::to_string(&load_table_request_from_result("rslt_123")).unwrap(),
             ))
@@ -2177,6 +2185,9 @@ mod tests {
 
         let api = Api::test_new(&server.url(), "k", Some("ws1"));
         let db = resolve_database(&api, "db_1");
+        // Mirror tables_load: scope to the resolved target database so the load
+        // carries X-Database-Id.
+        let api = api.scoped_to_database(&db.id);
         let path = managed_table_load_path(&db.default_connection_id, "public", "orders");
         let body = load_table_request_from_result("rslt_123");
         let (status, resp_body) = api.post_raw(&path, &body).unwrap();