fix: prefer active database connection when resolving catalog name

Author: eddietejeda

src/api.rs

@@ -182,6 +182,10 @@ impl ApiClient {
     }
 
     /// Test-only client (no config load). Used with a local mock HTTP server.
+    pub fn workspace_id(&self) -> Option<&str> {
+        self.workspace_id.as_deref()
+    }
+
     /// The refresher returns `None`, so 401s are not retried — matching the
     /// behavior of tests that don't exercise the refresh path.
     #[cfg(test)]

src/connections.rs

@@ -172,6 +172,20 @@ pub fn resolve_connection_id(api: &ApiClient, name_or_id: &str) -> String {
         }
     }
 
+    // Before listing connections, check if the active database's catalog or name
+    // matches — prefer it over any stale connection entry with the same name.
+    if let Some(ws) = api.workspace_id() {
+        if let Some(active_id) = crate::config::load_current_database("default", ws) {
+            if let Some(active_db) = api.get_none_if_not_found::<crate::databases::Database>(&format!("/databases/{active_id}")) {
+                if active_db.default_catalog.as_deref() == Some(name_or_id)
+                    || active_db.name.as_deref() == Some(name_or_id)
+                {
+                    return active_db.default_connection_id;
+                }
+            }
+        }
+    }
+
     let body: ListResponse = api.get("/connections");
     if let Some(conn) = body
         .connections

src/databases.rs

@@ -111,37 +111,39 @@ pub fn try_resolve_database(api: &ApiClient, id_or_name: &str) -> Result<Databas
         return Ok(db);
     }
 
-    // Fall back to listing and matching by name or catalog alias.
+    // Fall back to listing — prefer catalog alias match, then name.
     let body: ListDatabasesResponse = api.get("/databases");
-    let name_matches: Vec<&DatabaseSummary> = body
+
+    let catalog_matches: Vec<&DatabaseSummary> = body
         .databases
         .iter()
-        .filter(|d| d.name.as_deref() == Some(id_or_name))
+        .filter(|d| d.default_catalog.as_deref() == Some(id_or_name))
         .collect();
 
-    if !name_matches.is_empty() {
-        return match name_matches.len() {
-            1 => Ok(fetch_database(api, &name_matches[0].id)),
+    if !catalog_matches.is_empty() {
+        return match catalog_matches.len() {
+            1 => Ok(fetch_database(api, &catalog_matches[0].id)),
             _ => Err(format!(
-                "multiple databases have name '{}' — use the database id instead",
+                "multiple databases have catalog '{}' — use the database id instead",
                 id_or_name
             )),
         };
     }
 
-    let catalog_matches: Vec<&DatabaseSummary> = body
+
+    let name_matches: Vec<&DatabaseSummary> = body
         .databases
         .iter()
-        .filter(|d| d.default_catalog.as_deref() == Some(id_or_name))
+        .filter(|d| d.name.as_deref() == Some(id_or_name))
         .collect();
 
-    match catalog_matches.len() {
+    match name_matches.len() {
         0 => Err(format!(
-            "no database with id, name, or catalog '{id_or_name}'"
+            "no database with id, catalog, or name '{id_or_name}'"
         )),
-        1 => Ok(fetch_database(api, &catalog_matches[0].id)),
+        1 => Ok(fetch_database(api, &name_matches[0].id)),
         _ => Err(format!(
-            "multiple databases have catalog '{}' — use the database id instead",
+            "multiple databases have name '{}' — use the database id instead",
             id_or_name
         )),
     }
@@ -777,7 +779,26 @@ pub fn tables_load(
 
     let database = resolve_current_database(database, workspace_id);
     let api = ApiClient::new(Some(workspace_id));
-    let db = resolve_database(&api, &database);
+    // Prefer the active database when its catalog or name matches the lookup key,
+    // avoiding ambiguity when multiple databases share the same catalog name.
+    let active_id = crate::config::load_current_database("default", workspace_id);
+    let lookup_key = match active_id.as_deref() {
+        Some(id) => {
+            if let Some(active) = api.get_none_if_not_found::<Database>(&format!("/databases/{id}")) {
+                if active.default_catalog.as_deref() == Some(database.as_str())
+                    || active.name.as_deref() == Some(database.as_str())
+                {
+                    id.to_string()
+                } else {
+                    database.clone()
+                }
+            } else {
+                database.clone()
+            }
+        }
+        None => database.clone(),
+    };
+    let db = resolve_database(&api, &lookup_key);
     let schema = schema_name(schema);
 
     // clap enforces mutual exclusion; only one of these is ever Some.
@@ -1036,7 +1057,7 @@ mod tests {
 
         let api = ApiClient::test_new(&server.url(), "k", None);
         let err = try_resolve_database(&api, "missing").unwrap_err();
-        assert!(err.contains("no database with id or name"));
+        assert!(err.contains("no database with id"));
     }
 
     #[test]

src/indexes.rs

@@ -219,18 +219,8 @@ pub fn infer_for_search(
 
     let api = ApiClient::new(Some(workspace_id));
 
-    // Resolve connection name → ID
-    let conn_map = connection_lookup(&api);
-    let connection_id = match conn_map.get(connection_name) {
-        Some(id) => id.clone(),
-        None => {
-            eprintln!(
-                "{}",
-                format!("Connection '{}' not found.", connection_name).red()
-            );
-            std::process::exit(1);
-        }
-    };
+    // Resolve connection name → ID (falls back to managed database catalog lookup)
+    let connection_id = crate::connections::resolve_connection_id(&api, connection_name);
 
     // Fetch indexes for this table
     let indexes = list_one_table(&api, &connection_id, schema, table);