feat(databases): explicit flags for load, unset command, and star in list

- Replace dot-notation positional <TARGET> on `databases load` with
  explicit --catalog, --schema, --table flags
- Add `databases unset` to clear the active database from config
- Show * marker on the active database in `databases list`
- Remove parse_db_target and its tests (no longer needed)

Author: eddietejeda

src/command.rs

@@ -600,17 +600,28 @@ pub enum DatabasesCommands {
         id: String,
     },
 
+    /// Clear the current database
+    Unset,
+
     /// Delete a managed database and its tables
     Delete {
         /// Database name or connection ID
         name_or_id: String,
     },
 
-    /// Load a parquet file into a table using dot notation: `database.table` or `database.schema.table`
+    /// Load a parquet file into a managed database table
     Load {
-        /// Table to load into: `database.table` or `database.schema.table`.
-        /// Schema defaults to `public` when omitted.
-        target: String,
+        /// SQL catalog alias of the target database (e.g. `--catalog airbnb`)
+        #[arg(long)]
+        catalog: String,
+
+        /// Schema to load into (default: public)
+        #[arg(long, default_value = "public")]
+        schema: String,
+
+        /// Table name to load into
+        #[arg(long)]
+        table: String,
 
         /// Path to a local parquet file to upload and load
         #[arg(long, conflicts_with_all = ["upload_id", "url"])]

src/databases.rs

@@ -398,17 +398,20 @@ pub fn list(workspace_id: &str, format: &str) {
                     "Create one with: hotdata databases create --catalog <alias>".dark_grey()
                 );
             } else {
+                let current = crate::config::load_current_database("default", workspace_id);
                 let rows: Vec<Vec<String>> = body
                     .databases
                     .iter()
                     .map(|d| {
+                        let marker = if current.as_deref() == Some(d.id.as_str()) { "*" } else { "" };
                         vec![
+                            marker.to_string(),
                             d.id.clone(),
                             d.name.as_deref().unwrap_or("-").to_string(),
                         ]
                     })
                     .collect();
-                crate::table::print(&["ID", "NAME"], &rows);
+                crate::table::print(&["", "ID", "NAME"], &rows);
             }
         }
         _ => unreachable!(),
@@ -644,6 +647,15 @@ pub fn create(
     }
 }
 
+pub fn unset(workspace_id: &str) {
+    use crossterm::style::Stylize;
+    if let Err(e) = crate::config::clear_current_database("default", workspace_id) {
+        eprintln!("{}", format!("error clearing current database: {e}").red());
+        std::process::exit(1);
+    }
+    println!("{}", "Current database cleared.".green());
+}
+
 pub fn set(workspace_id: &str, id: &str) {
     use crossterm::style::Stylize;
     let api = ApiClient::new(Some(workspace_id));

src/main.rs

@@ -449,26 +449,28 @@ fn main() {
                         Some(DatabasesCommands::Set { id }) => {
                             databases::set(&workspace_id, &id)
                         }
+                        Some(DatabasesCommands::Unset) => {
+                            databases::unset(&workspace_id)
+                        }
                         Some(DatabasesCommands::Delete { name_or_id }) => {
                             databases::delete(&workspace_id, &name_or_id)
                         }
                         Some(DatabasesCommands::Load {
-                            target,
+                            catalog,
+                            schema,
+                            table,
                             file,
                             url,
                             upload_id,
-                        }) => {
-                            let (database, schema, table) = parse_db_target(&target);
-                            databases::tables_load(
-                                &workspace_id,
-                                Some(database.as_str()),
-                                &table,
-                                Some(schema.as_str()),
-                                file.as_deref(),
-                                url.as_deref(),
-                                upload_id.as_deref(),
-                            )
-                        }
+                        }) => databases::tables_load(
+                            &workspace_id,
+                            Some(catalog.as_str()),
+                            &table,
+                            Some(schema.as_str()),
+                            file.as_deref(),
+                            url.as_deref(),
+                            upload_id.as_deref(),
+                        ),
                         Some(DatabasesCommands::Tables { database, command }) => match command {
                             Some(DatabaseTablesCommands::List {
                                 database: db_flag,
@@ -1059,21 +1061,6 @@ fn main() {
     update::maybe_print_update_notice(update_handle);
 }
 
-/// Parse a database target like `airbnb.listings` or `airbnb.public.listings`
-/// into `(database, schema, table)`. Schema defaults to `public`.
-fn parse_db_target(target: &str) -> (String, String, String) {
-    let parts: Vec<&str> = target.splitn(4, '.').collect();
-    match parts.as_slice() {
-        [db, tbl] => (db.to_string(), "public".to_string(), tbl.to_string()),
-        [db, schema, tbl] => (db.to_string(), schema.to_string(), tbl.to_string()),
-        _ => {
-            eprintln!(
-                "error: target must be 'database.table' or 'database.schema.table'"
-            );
-            std::process::exit(1);
-        }
-    }
-}
 
 /// Parse an index target like `airbnb.listings[col1,col2]` or
 /// `airbnb.public.listings[col1,col2]` into `(conn_name, schema, table, columns)`.
@@ -1124,24 +1111,6 @@ fn parse_index_target(target: &str) -> (String, String, String, Vec<String>) {
 mod tests {
     use super::*;
 
-    // --- parse_db_target ---
-
-    #[test]
-    fn db_target_two_parts_defaults_schema_to_public() {
-        let (db, schema, table) = parse_db_target("airbnb.listings");
-        assert_eq!(db, "airbnb");
-        assert_eq!(schema, "public");
-        assert_eq!(table, "listings");
-    }
-
-    #[test]
-    fn db_target_three_parts_uses_explicit_schema() {
-        let (db, schema, table) = parse_db_target("airbnb.staging.listings");
-        assert_eq!(db, "airbnb");
-        assert_eq!(schema, "staging");
-        assert_eq!(table, "listings");
-    }
-
     // --- parse_index_target ---
 
     #[test]