feat(linux-workspace): open another of a connection's databases beside it in the window

linux/changelog.d/3902.added.md

@@ -0,0 +1 @@
+Open Database… on a connection's row opens another of the server's databases beside it in the window, with its own tables and tabs.

linux/crates/app/src/application/mcp_bridge.rs

@@ -138,7 +138,9 @@ fn answer(app: &TableProApplication, request: McpRequest) {
                 .into_iter()
                 .filter_map(|(key, _)| match key {
                     SessionKey::Saved(id) => Some(id),
-                    SessionKey::File(_) => None,
+                    // Another database of an open connection is no other
+                    // connection.
+                    SessionKey::SavedIn { .. } | SessionKey::File(_) => None,
                 })
                 .collect();
             let _ = reply.send(open);

linux/crates/app/src/services/connection_deletion.rs

@@ -61,6 +61,9 @@ impl ConnectionDeletion {
         if let Err(error) = self.workspaces.purge(&SessionKey::Saved(id)).await {
             report.purge_failures.push(PurgeFailure::Workspace(error));
         }
+        if let Err(error) = self.workspaces.purge_databases_of(id).await {
+            report.purge_failures.push(PurgeFailure::Workspace(error));
+        }
         let Some(history) = self.history.clone() else {
             let unavailable = || "the query history did not open".to_owned();
             report.purge_failures.push(PurgeFailure::SavedQueries(unavailable()));
@@ -357,6 +360,62 @@ mod tests {
         }
     }
 
+    /// Another database opened beside the connection keeps its tabs and
+    /// drafts under a name of its own, which goes with the connection.
+    #[tokio::test]
+    async fn the_tabs_of_its_other_databases_go_with_the_connection() {
+        let fixture = fixture().await;
+        let (database, other_database) = (
+            SessionKey::SavedIn {
+                id: fixture.id,
+                database: "analytics".to_owned(),
+            },
+            SessionKey::SavedIn {
+                id: fixture.other,
+                database: "analytics".to_owned(),
+            },
+        );
+        let names = [&database, &other_database].map(WorkspaceFileName::for_key);
+        for (key, name) in [&database, &other_database].into_iter().zip(&names) {
+            let draft = DraftId::new();
+            fixture
+                .drafts
+                .write_blocking(&name.draft_scope(), draft, "SELECT 1")
+                .expect("a draft");
+            fixture
+                .workspaces
+                .schedule(
+                    key,
+                    WorkspaceRecord {
+                        active_tab: Some(0),
+                        tabs: vec![TabRecord::Editor {
+                            draft,
+                            file: None,
+                            database: None,
+                        }],
+                    },
+                )
+                .expect("scheduled");
+            fixture.workspaces.flush(key).await.expect("the saved tabs");
+        }
+        let workspaces_dir = fixture.paths.workspaces_dir();
+        let drafts_dir = |name: &WorkspaceFileName| fixture.drafts.root().join(name.draft_scope().as_str());
+
+        fixture
+            .deletion()
+            .run(fixture.id, DeletionOptions { delete_history: false })
+            .await
+            .expect("the delete");
+
+        assert!(!workspaces_dir.join(names[0].file_name()).exists(), "its tabs stayed");
+        assert!(!drafts_dir(&names[0]).exists(), "its drafts stayed");
+        assert!(
+            workspaces_dir.join(names[1].file_name()).exists(),
+            "another connection's went"
+        );
+        assert!(drafts_dir(&names[1]).exists());
+    }
+
     #[tokio::test]
     async fn secret_failure_keeps_entry_and_skips_purge() {
         let fixture = fixture().await;

linux/crates/app/src/services/file_resolution.rs

@@ -77,7 +77,7 @@ pub fn resolve_file_blocking(
                 Some(connection) => FileTarget::Saved(Box::new(connection)),
                 None => FileTarget::File(identity),
             },
-            SessionKey::File(_) => FileTarget::File(identity),
+            SessionKey::SavedIn { .. } | SessionKey::File(_) => FileTarget::File(identity),
         }
     });
     ResolvedFile { uri, target }

linux/crates/app/src/ui/session_target.rs

@@ -7,12 +7,15 @@ use tablepro_session::SessionKey;
 use uuid::Uuid;
 
 const SAVED: &str = "saved:";
+const SAVED_IN: &str = "saved-in:";
 const FILE: &str = "file:";
 
-/// `saved:<uuid>` or `file:<uri>`.
+/// `saved:<uuid>`, `saved-in:<uuid>/<database>` or `file:<uri>`. A uuid
+/// holds no `/`, so the database after it may hold any.
 pub(crate) fn to_variant(key: &SessionKey) -> glib::Variant {
     match key {
         SessionKey::Saved(id) => format!("{SAVED}{id}"),
+        SessionKey::SavedIn { id, database } => format!("{SAVED_IN}{id}/{database}"),
         SessionKey::File(uri) => format!("{FILE}{uri}"),
     }
     .to_variant()
@@ -24,6 +27,13 @@ pub(crate) fn from_variant(value: &glib::Variant) -> Option<SessionKey> {
     if let Some(id) = text.strip_prefix(SAVED) {
         return Uuid::parse_str(id).ok().map(SessionKey::Saved);
     }
+    if let Some(rest) = text.strip_prefix(SAVED_IN) {
+        let (id, database) = rest.split_once('/')?;
+        return Uuid::parse_str(id).ok().map(|id| SessionKey::SavedIn {
+            id,
+            database: database.to_owned(),
+        });
+    }
     text.strip_prefix(FILE)
         .filter(|uri| glib::Uri::peek_scheme(uri).is_some())
         .map(|uri| SessionKey::File(uri.to_owned()))
@@ -37,6 +47,10 @@ mod tests {
     fn a_key_round_trips() {
         let keys = [
             SessionKey::Saved(Uuid::new_v4()),
+            SessionKey::SavedIn {
+                id: Uuid::new_v4(),
+                database: "sales/2026".to_owned(),
+            },
             SessionKey::File("file:///home/u/R%26D/sales.db".to_owned()),
             SessionKey::File("file:///srv/caf%C3%A9.sqlite3".to_owned()),
         ];

linux/crates/app/src/ui/session_window/connections.rs

@@ -481,19 +481,27 @@ impl SessionWindow {
     /// connection opened again, so the window reconnects once the tabs
     /// may go; until then the saved level waits for the next connect.
     pub(super) fn on_set_safe_mode(&self, key: &SessionKey, level: SafeModeLevel) {
-        let Some(session) = self
-            .imp()
-            .sessions
-            .borrow()
-            .iter()
-            .find(|open| open.claim.key() == key)
-            .map(|open| open.session.clone())
-        else {
+        // The level is the connection's, which its other databases took
+        // when they opened (0030).
+        let key = match key {
+            SessionKey::SavedIn { id, .. } => SessionKey::Saved(*id),
+            SessionKey::Saved(_) | SessionKey::File(_) => key.clone(),
+        };
+        let Some(sessions) = self.find_open(|open| {
+            (open.claim.key() == &key).then(|| {
+                open.with_databases()
+                    .map(|open| (open.claim.key().clone(), open.session.clone()))
+                    .collect::<Vec<_>>()
+            })
+        }) else {
+            return;
+        };
+        let Some((_, session)) = sessions.first() else {
             return;
         };
-        let saved = match key {
+        let saved = match &key {
             SessionKey::Saved(id) => self.stored_connection(*id),
-            SessionKey::File(_) => None,
+            SessionKey::SavedIn { .. } | SessionKey::File(_) => None,
         };
         // The saved level can differ from the session's after a reconnect
         // was declined, and a level still being written can land after
@@ -504,7 +512,9 @@ impl SessionWindow {
         let differs =
             session.safe_mode() != level || writing || saved.as_ref().is_some_and(|saved| saved.safe_mode != level);
         if differs {
-            let applied = session.safe_mode() == level || session.set_safe_mode(level);
+            let applied = sessions
+                .iter()
+                .all(|(_, session)| session.safe_mode() == level || session.set_safe_mode(level));
             match (saved.map(|saved| saved.id), applied) {
                 (Some(id), _) => self.save_safe_mode(LevelSave {
                     id,
@@ -517,7 +527,9 @@ impl SessionWindow {
                 )),
             }
             if applied {
-                self.deliver_to(key, WorkspaceInput::SafeModeChanged);
+                for (key, _) in &sessions {
+                    self.deliver_to(key, WorkspaceInput::SafeModeChanged);
+                }
             }
         }
         self.show_safe_mode();
@@ -571,20 +583,20 @@ impl SessionWindow {
 
     /// Ask the tabs, as Disconnect does, then connect again.
     fn reopen_after_teardown(&self, id: Uuid) {
-        let Some(workspace) = self.session_workspace(&SessionKey::Saved(id)) else {
-            return;
-        };
-        let (Some(handle), Some(guards), Some(input)) = (workspace.prompt_handle(), self.close_guards(), self.input())
-        else {
+        let (Some(handles), Some(guards), Some(input)) = (
+            self.teardown_handles(&SessionKey::Saved(id)),
+            self.close_guards(),
+            self.input(),
+        ) else {
             return;
         };
         guards.begin_teardown();
-        if guards.may_tear_down(&handle) {
+        if guards.may_tear_down(&handles) {
             input.deliver(SessionWindowInput::ReopenApproved(id));
             return;
         }
         let window = self.downgrade();
-        guards.ask_tear_down(self.upcast_ref(), &handle, move |decision| match decision {
+        guards.ask_tear_down(self.upcast_ref(), &handles, move |decision| match decision {
             CloseDecision::Approved => input.deliver(SessionWindowInput::ReopenApproved(id)),
             _ => {
                 if let Some(window) = window.upgrade() {
@@ -595,17 +607,31 @@ impl SessionWindow {
     }
 
     /// Tear the session down and connect it again through the window's
-    /// one connect path, at the level just saved. The window's other
-    /// sessions and connects go on.
+    /// one connect path, at the level just saved, with the other
+    /// databases it had open. The window's other sessions and connects
+    /// go on.
     pub(super) fn on_reopen_approved(&self, id: Uuid) {
+        let key = SessionKey::Saved(id);
         let stored = self.stored_connection(id);
-        if !self.tear_down_session(&SessionKey::Saved(id)) {
+        let databases = self
+            .find_open(|open| (open.claim.key() == &key).then(|| open.databases.names()))
+            .unwrap_or_default();
+        if !self.tear_down_session(&key) {
             return;
         }
-        match stored {
-            Some(saved) => self.connect(ConnectSource::Saved(Box::new(saved)), CredentialDemand::default()),
-            None => self.show_toast(&crate::i18n::gettext("The connection was deleted.")),
+        let Some(saved) = stored else {
+            self.show_toast(&crate::i18n::gettext("The connection was deleted."));
+            return;
+        };
+        let source = ConnectSource::Saved(Box::new(saved));
+        let Some(claim) = self.claim_for(&key) else {
+            return;
+        };
+        if let Some(mut pending) = self.spawn_connect(claim, source, None, CredentialDemand::default()) {
+            pending.databases = databases;
+            self.imp().connects.borrow_mut().push(pending);
         }
+        self.connects_changed();
     }
 
     /// Tick the level of the session in front in the main menu.