diff --git a/core/crates/storage/migrations/20261108000000_favourites.sql b/core/crates/storage/migrations/20261108000000_favourites.sql new file mode 100644 index 0000000000..c9336027e0 --- /dev/null +++ b/core/crates/storage/migrations/20261108000000_favourites.sql @@ -0,0 +1,46 @@ +-- Folders and keywords on saved queries, and the tables and databases a +-- user marks as favourites (core ADR 0017). + +CREATE TABLE saved_query_folders ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + connection_id TEXT NOT NULL, + name TEXT NOT NULL, + -- A deleted folder takes the folders inside it. + parent_id INTEGER REFERENCES saved_query_folders (id) ON DELETE CASCADE, + sort_order INTEGER NOT NULL DEFAULT 0, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL +); + +-- No two siblings share a name in any case. A top-level folder has no +-- parent, which a unique index would treat as always different. +CREATE UNIQUE INDEX saved_query_folders_name_idx + ON saved_query_folders (connection_id, COALESCE(parent_id, 0), name COLLATE NOCASE); + +ALTER TABLE saved_queries ADD COLUMN keyword TEXT; +-- A deleted folder leaves its queries at the top. +ALTER TABLE saved_queries ADD COLUMN folder_id INTEGER REFERENCES saved_query_folders (id) ON DELETE SET NULL; +ALTER TABLE saved_queries ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0; + +CREATE UNIQUE INDEX saved_queries_keyword_idx + ON saved_queries (connection_id, keyword COLLATE NOCASE) WHERE keyword IS NOT NULL; + +-- A table is named by its database and schema where the engine has them, +-- and by the empty string where it does not, so the key is never NULL. +CREATE TABLE favourite_tables ( + connection_id TEXT NOT NULL, + database TEXT NOT NULL DEFAULT '', + schema TEXT NOT NULL DEFAULT '', + name TEXT NOT NULL, + created_at INTEGER NOT NULL, + PRIMARY KEY (connection_id, database, schema, name) +); + +CREATE TABLE favourite_databases ( + connection_id TEXT NOT NULL, + database TEXT NOT NULL, + environment TEXT NOT NULL DEFAULT 'unassigned' + CHECK (environment IN ('development', 'testing', 'production', 'unassigned')), + created_at INTEGER NOT NULL, + PRIMARY KEY (connection_id, database) +); diff --git a/core/crates/storage/migrations/20261109000000_favourites_order.sql b/core/crates/storage/migrations/20261109000000_favourites_order.sql new file mode 100644 index 0000000000..8c2c1e3b3a --- /dev/null +++ b/core/crates/storage/migrations/20261109000000_favourites_order.sql @@ -0,0 +1,23 @@ +WITH positions AS ( + SELECT id, ROW_NUMBER() OVER ( + PARTITION BY connection_id, folder_id + ORDER BY sort_order, name COLLATE NOCASE, id + ) - 1 AS position + FROM saved_queries +) +UPDATE saved_queries SET sort_order = positions.position +FROM positions WHERE saved_queries.id = positions.id; + +WITH positions AS ( + SELECT id, ROW_NUMBER() OVER ( + PARTITION BY connection_id, parent_id + ORDER BY sort_order, name COLLATE NOCASE, id + ) - 1 AS position + FROM saved_query_folders +) +UPDATE saved_query_folders SET sort_order = positions.position +FROM positions WHERE saved_query_folders.id = positions.id; + +CREATE INDEX saved_queries_folder_order_idx ON saved_queries (connection_id, folder_id, sort_order, id); +CREATE INDEX saved_query_folders_parent_idx ON saved_query_folders (parent_id); +CREATE INDEX saved_query_folders_order_idx ON saved_query_folders (connection_id, parent_id, sort_order, id); diff --git a/core/crates/storage/src/error.rs b/core/crates/storage/src/error.rs index 1326c363c7..e76a03eb55 100644 --- a/core/crates/storage/src/error.rs +++ b/core/crates/storage/src/error.rs @@ -50,6 +50,21 @@ pub enum StorageError { #[error("another tag has that name")] TagNameTaken, + #[error("another saved query of the connection has that keyword")] + KeywordTaken, + + #[error("a keyword is one word of at most {max} characters, with no spaces")] + KeywordInvalid { max: usize }, + + #[error("the folder name contains a control character")] + FolderNameInvalid, + + #[error("another folder in the same place has that name")] + FolderNameTaken, + + #[error("the folder {id} cannot move inside itself")] + FolderCycle { id: i64 }, + #[error("export encoding failed: {0}")] Encode(#[from] tablepro_core::export::RenderError), @@ -104,6 +119,11 @@ impl StorageError { Self::EmptyName => "storage.empty_name", Self::NameTaken => "storage.name_taken", Self::TagNameTaken => "storage.tag_name_taken", + Self::KeywordTaken => "storage.keyword_taken", + Self::KeywordInvalid { .. } => "storage.keyword_invalid", + Self::FolderNameInvalid => "storage.folder_name_invalid", + Self::FolderNameTaken => "storage.folder_name_taken", + Self::FolderCycle { .. } => "storage.folder_cycle", Self::Encode(..) => "storage.encode", Self::HistoryNewerThanApp { .. } => "storage.history_newer_than_app", Self::HistoryMigration(..) => "storage.history_migration", diff --git a/core/crates/storage/src/favourites.rs b/core/crates/storage/src/favourites.rs new file mode 100644 index 0000000000..bba38b38c9 --- /dev/null +++ b/core/crates/storage/src/favourites.rs @@ -0,0 +1,492 @@ +use std::path::PathBuf; +use std::sync::Arc; +use std::time::SystemTime; + +use sqlx::{AssertSqlSafe, Connection, Row, SqlitePool}; +use tokio::sync::watch; +use uuid::Uuid; + +use crate::error::StorageError; +use crate::unix_time::to_unix; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DatabaseEnvironment { + Development, + Testing, + Production, + Unassigned, +} + +impl DatabaseEnvironment { + pub fn as_str(self) -> &'static str { + match self { + Self::Development => "development", + Self::Testing => "testing", + Self::Production => "production", + Self::Unassigned => "unassigned", + } + } + + pub fn parse(text: &str) -> Option { + [Self::Development, Self::Testing, Self::Production, Self::Unassigned] + .into_iter() + .find(|environment| environment.as_str() == text) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FavouriteTable { + pub connection_id: Uuid, + pub database: Option, + pub schema: Option, + pub name: String, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FavouriteDatabase { + pub connection_id: Uuid, + pub database: String, + pub environment: DatabaseEnvironment, +} + +#[derive(Debug, Clone)] +pub struct Favourites { + pool: SqlitePool, + path: PathBuf, + changes: Arc>, +} + +impl Favourites { + pub(crate) fn new(pool: SqlitePool, path: PathBuf, changes: Arc>) -> Self { + Self { pool, path, changes } + } + + pub fn changes(&self) -> watch::Receiver { + self.changes.subscribe() + } + + fn changed(&self) { + self.changes + .send_modify(|revision| *revision = revision.wrapping_add(1)); + } + + pub async fn add_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { + if table.name.is_empty() { + return Err(StorageError::EmptyName); + } + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let affected = sqlx::query( + "INSERT INTO favourite_tables (connection_id, database, schema, name, created_at) \ + VALUES (?, ?, ?, ?, ?) ON CONFLICT (connection_id, database, schema, name) DO NOTHING", + ) + .bind(table.connection_id.to_string()) + .bind(table.database.as_deref().unwrap_or_default()) + .bind(table.schema.as_deref().unwrap_or_default()) + .bind(&table.name) + .bind(to_unix(SystemTime::now())) + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } + Ok(()) + } + + pub async fn remove_table(&self, table: &FavouriteTable) -> Result<(), StorageError> { + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + crate::query_history::trim_upgrade_copies( + &self.path, + &[crate::query_history::CopyDelete { + table: "favourite_tables", + sql: "DELETE FROM main.favourite_tables \ + WHERE connection_id = ? AND database = ? AND schema = ? AND name = ?" + .to_owned(), + binds: vec![ + crate::query_history::Bind::Text(table.connection_id.to_string()), + crate::query_history::Bind::Text(table.database.clone().unwrap_or_default()), + crate::query_history::Bind::Text(table.schema.clone().unwrap_or_default()), + crate::query_history::Bind::Text(table.name.clone()), + ], + }], + ) + .await?; + let affected = sqlx::query( + "DELETE FROM favourite_tables WHERE connection_id = ? AND database = ? AND schema = ? AND name = ?", + ) + .bind(table.connection_id.to_string()) + .bind(table.database.as_deref().unwrap_or_default()) + .bind(table.schema.as_deref().unwrap_or_default()) + .bind(&table.name) + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } + Ok(()) + } + + pub async fn tables(&self, connection: Uuid) -> Result, StorageError> { + let rows = sqlx::query( + "SELECT database, schema, name FROM favourite_tables WHERE connection_id = ? \ + ORDER BY database COLLATE NOCASE, schema COLLATE NOCASE, name COLLATE NOCASE", + ) + .bind(connection.to_string()) + .fetch_all(&self.pool) + .await?; + rows.into_iter() + .map(|row| { + let (database, schema): (String, String) = (row.try_get("database")?, row.try_get("schema")?); + Ok(FavouriteTable { + connection_id: connection, + database: Some(database).filter(|text| !text.is_empty()), + schema: Some(schema).filter(|text| !text.is_empty()), + name: row.try_get("name")?, + }) + }) + .collect() + } + + pub async fn set_database( + &self, + connection: Uuid, + database: &str, + environment: DatabaseEnvironment, + ) -> Result<(), StorageError> { + if database.is_empty() { + return Err(StorageError::EmptyName); + } + let mut held = self.pool.acquire().await?; + let mut transaction = held.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let affected = sqlx::query( + "INSERT INTO favourite_databases (connection_id, database, environment, created_at) \ + VALUES (?, ?, ?, ?) \ + ON CONFLICT (connection_id, database) DO UPDATE SET environment = excluded.environment \ + WHERE favourite_databases.environment <> excluded.environment", + ) + .bind(connection.to_string()) + .bind(database) + .bind(environment.as_str()) + .bind(to_unix(SystemTime::now())) + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } + Ok(()) + } + + pub async fn remove_database(&self, connection: Uuid, database: &str) -> Result<(), StorageError> { + let mut held = self.pool.acquire().await?; + let mut transaction = held.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + crate::query_history::trim_upgrade_copies( + &self.path, + &[crate::query_history::CopyDelete { + table: "favourite_databases", + sql: "DELETE FROM main.favourite_databases WHERE connection_id = ? AND database = ?".to_owned(), + binds: vec![ + crate::query_history::Bind::Text(connection.to_string()), + crate::query_history::Bind::Text(database.to_owned()), + ], + }], + ) + .await?; + let affected = sqlx::query("DELETE FROM favourite_databases WHERE connection_id = ? AND database = ?") + .bind(connection.to_string()) + .bind(database) + .execute(&mut *transaction) + .await? + .rows_affected(); + transaction.commit().await?; + if affected > 0 { + self.changed(); + } + Ok(()) + } + + pub async fn databases(&self, connection: Uuid) -> Result, StorageError> { + let rows = sqlx::query( + "SELECT database, environment FROM favourite_databases WHERE connection_id = ? \ + ORDER BY database COLLATE NOCASE", + ) + .bind(connection.to_string()) + .fetch_all(&self.pool) + .await?; + rows.into_iter() + .map(|row| { + let environment: String = row.try_get("environment")?; + Ok(FavouriteDatabase { + connection_id: connection, + database: row.try_get("database")?, + environment: DatabaseEnvironment::parse(&environment) + .ok_or_else(|| StorageError::Schema(format!("unknown database environment: {environment}")))?, + }) + }) + .collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn an_environment_round_trips_through_its_word() { + for environment in [ + DatabaseEnvironment::Development, + DatabaseEnvironment::Testing, + DatabaseEnvironment::Production, + DatabaseEnvironment::Unassigned, + ] { + assert_eq!(DatabaseEnvironment::parse(environment.as_str()), Some(environment)); + } + assert_eq!(DatabaseEnvironment::parse("staging"), None); + } + + async fn history(root: &tempfile::TempDir) -> crate::QueryHistory { + crate::QueryHistory::open(&crate::StoragePaths::under( + root.path(), + "tablepro", + "app.tablepro.TablePro", + )) + .await + .expect("open history") + } + + fn table(connection_id: Uuid, database: Option<&str>, schema: Option<&str>, name: &str) -> FavouriteTable { + FavouriteTable { + connection_id, + database: database.map(str::to_owned), + schema: schema.map(str::to_owned), + name: name.to_owned(), + } + } + + #[tokio::test] + async fn catalog_names_keep_case_spaces_and_connection_database_and_schema_identity() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + let tables = [ + table(connection, Some(" shop "), Some("public"), "Orders"), + table(connection, Some("shop"), Some("public"), "Orders"), + table(connection, Some("shop"), Some("Public"), "Orders"), + table(connection, Some("shop"), Some("public"), "orders"), + table(connection, Some(" "), Some(" "), " "), + table(other, Some("shop"), Some("public"), "Orders"), + ]; + for table in &tables { + favourites.add_table(table).await.expect("add table"); + } + let found = favourites.tables(connection).await.expect("tables"); + assert_eq!(found.len(), tables.len() - 1); + assert!(tables[..5].iter().all(|table| found.contains(table))); + assert_eq!( + favourites.tables(other).await.expect("other tables"), + vec![tables[5].clone()] + ); + + favourites.remove_table(&tables[1]).await.expect("remove exact table"); + let found = favourites.tables(connection).await.expect("tables"); + assert_eq!(found.len(), 4); + assert!(!found.contains(&tables[1])); + assert!(found.contains(&tables[0])); + assert!(found.contains(&tables[2])); + assert!(found.contains(&tables[3])); + assert!(found.contains(&tables[4])); + + for name in [" ", "shop", "Shop", " shop "] { + favourites + .set_database(connection, name, DatabaseEnvironment::Testing) + .await + .expect("mark database"); + } + favourites + .set_database(other, "shop", DatabaseEnvironment::Production) + .await + .expect("other database"); + favourites + .remove_database(connection, "shop") + .await + .expect("remove database"); + let found = favourites.databases(connection).await.expect("databases"); + assert_eq!(found.len(), 3); + assert!( + [" ", "Shop", " shop "] + .iter() + .all(|name| found.iter().any(|db| db.database == *name)) + ); + assert_eq!(favourites.databases(other).await.expect("other databases").len(), 1); + } + + #[tokio::test] + async fn table_changes_notify_every_surface_only_when_committed_data_changes() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let mut changed = favourites.changes(); + let mut queries_changed = history.saved_queries().changes(); + let connection = Uuid::new_v4(); + let entry = table(connection, None, None, "orders"); + + favourites.add_table(&entry).await.expect("add"); + assert!(changed.has_changed().expect("revision")); + assert!(queries_changed.has_changed().expect("shared revision")); + assert_eq!( + favourites.tables(connection).await.expect("committed rows"), + vec![entry.clone()] + ); + changed.borrow_and_update(); + queries_changed.borrow_and_update(); + + favourites.add_table(&entry).await.expect("add again"); + favourites + .add_table(&table(connection, Some(""), Some(""), "orders")) + .await + .expect("empty namespace is absent namespace"); + assert!(!changed.has_changed().expect("no revision")); + assert!(!queries_changed.has_changed().expect("no shared revision")); + assert_eq!(favourites.tables(connection).await.expect("rows").len(), 1); + + favourites.remove_table(&entry).await.expect("remove"); + assert!(changed.has_changed().expect("revision")); + assert!(queries_changed.has_changed().expect("shared revision")); + assert!( + favourites + .tables(connection) + .await + .expect("committed removal") + .is_empty() + ); + changed.borrow_and_update(); + queries_changed.borrow_and_update(); + favourites.remove_table(&entry).await.expect("remove again"); + assert!(!changed.has_changed().expect("no revision")); + assert!(!queries_changed.has_changed().expect("no shared revision")); + } + + #[tokio::test] + async fn database_environment_changes_notify_but_repeated_assignments_do_not() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let mut changed = favourites.changes(); + let connection = Uuid::new_v4(); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Testing) + .await + .expect("mark database"); + assert!(changed.has_changed().expect("revision")); + changed.borrow_and_update(); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Testing) + .await + .expect("same environment"); + assert!(!changed.has_changed().expect("no revision")); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Production) + .await + .expect("change environment"); + assert!(changed.has_changed().expect("revision")); + assert_eq!( + favourites.databases(connection).await.expect("committed database"), + vec![FavouriteDatabase { + connection_id: connection, + database: "shop".to_owned(), + environment: DatabaseEnvironment::Production, + }] + ); + changed.borrow_and_update(); + favourites.remove_database(connection, "shop").await.expect("remove"); + assert!(changed.has_changed().expect("revision")); + changed.borrow_and_update(); + favourites + .remove_database(connection, "shop") + .await + .expect("remove again"); + assert!(!changed.has_changed().expect("no revision")); + } + + #[tokio::test] + async fn failed_writes_keep_data_and_publish_no_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let entry = table(connection, None, None, "orders"); + favourites.add_table(&entry).await.expect("add"); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Testing) + .await + .expect("mark database"); + sqlx::query("CREATE TRIGGER reject_table_delete BEFORE DELETE ON favourite_tables BEGIN SELECT RAISE(ABORT, 'denied'); END") + .execute(&favourites.pool) + .await + .expect("install failure"); + sqlx::query("CREATE TRIGGER reject_database_change BEFORE UPDATE ON favourite_databases BEGIN SELECT RAISE(ABORT, 'denied'); END") + .execute(&favourites.pool) + .await + .expect("install failure"); + let changed = favourites.changes(); + assert!(favourites.remove_table(&entry).await.is_err()); + assert!( + favourites + .set_database(connection, "shop", DatabaseEnvironment::Production) + .await + .is_err() + ); + assert!(matches!( + favourites.add_table(&table(connection, None, None, "")).await, + Err(StorageError::EmptyName) + )); + assert!(matches!( + favourites + .set_database(connection, "", DatabaseEnvironment::Testing) + .await, + Err(StorageError::EmptyName) + )); + assert!(!changed.has_changed().expect("no revision")); + assert_eq!( + favourites.tables(connection).await.expect("unchanged table"), + vec![entry] + ); + assert_eq!( + favourites.databases(connection).await.expect("unchanged database")[0].environment, + DatabaseEnvironment::Testing + ); + } + + #[tokio::test] + async fn corrupt_environment_is_an_error_instead_of_an_unassigned_database() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + sqlx::query("PRAGMA ignore_check_constraints = ON") + .execute(&favourites.pool) + .await + .expect("allow corrupt fixture"); + sqlx::query("INSERT INTO favourite_databases (connection_id, database, environment, created_at) VALUES (?, 'shop', 'unknown', 0)") + .bind(connection.to_string()) + .execute(&favourites.pool) + .await + .expect("corrupt fixture"); + sqlx::query("PRAGMA ignore_check_constraints = OFF") + .execute(&favourites.pool) + .await + .expect("restore constraints"); + assert!(matches!( + favourites.databases(connection).await, + Err(StorageError::Schema(_)) + )); + } +} diff --git a/core/crates/storage/src/lib.rs b/core/crates/storage/src/lib.rs index c0404bb9ac..b0658e19fc 100644 --- a/core/crates/storage/src/lib.rs +++ b/core/crates/storage/src/lib.rs @@ -11,6 +11,7 @@ pub mod document; mod document_problem; pub mod drafts; mod error; +pub mod favourites; pub mod fs; mod group_icon; mod group_name_error; @@ -40,10 +41,11 @@ pub use credentials::{ pub use document_problem::{DocumentProblem, DocumentProblemKind}; pub use drafts::{DraftId, DraftScope, DraftStore}; pub use error::StorageError; +pub use favourites::{DatabaseEnvironment, FavouriteDatabase, FavouriteTable, Favourites}; pub use group_icon::{GroupIcon, SymbolName}; pub use group_name_error::GroupNameError; pub use group_tree::GroupTree; pub use paths::StoragePaths; pub use query_history::QueryHistory; -pub use saved_queries::SavedQueries; +pub use saved_queries::{SavedQueries, SavedQueriesSnapshot, SavedQueryFolder, SavedQueryFolders}; pub use tag_name_error::TagNameError; diff --git a/core/crates/storage/src/query_history/backup_folders.rs b/core/crates/storage/src/query_history/backup_folders.rs new file mode 100644 index 0000000000..fcb834fd25 --- /dev/null +++ b/core/crates/storage/src/query_history/backup_folders.rs @@ -0,0 +1,337 @@ +use sqlx::SqliteConnection; + +use crate::StorageError; + +pub(super) async fn reconcile(database: &mut SqliteConnection) -> Result { + let present: i64 = sqlx::query_scalar( + "SELECT (SELECT COUNT(*) FROM main.sqlite_master WHERE type = 'table' AND name = 'saved_query_folders') \ + * (SELECT COUNT(*) FROM live.sqlite_master WHERE type = 'table' AND name = 'saved_query_folders')", + ) + .fetch_one(&mut *database) + .await?; + if present == 0 { + return Ok(false); + } + + // A stale parent can otherwise delete a folder that moved out, or retain one that moved in. + // Replacing the graph also avoids transient sibling-name collisions and deep FK cascades. + sqlx::query( + "CREATE TEMP TABLE recovery_folders AS \ + WITH RECURSIVE kept(id) AS ( \ + SELECT old.id FROM main.saved_query_folders old \ + JOIN live.saved_query_folders live_folder ON live_folder.id = old.id \ + UNION \ + SELECT live_folder.parent_id FROM live.saved_query_folders live_folder \ + JOIN kept ON live_folder.id = kept.id WHERE live_folder.parent_id IS NOT NULL \ + ) \ + SELECT live_folder.* FROM live.saved_query_folders live_folder JOIN kept ON kept.id = live_folder.id", + ) + .execute(&mut *database) + .await?; + sqlx::query("DELETE FROM main.saved_query_folders") + .execute(&mut *database) + .await?; + sqlx::query( + "INSERT INTO main.saved_query_folders (id, connection_id, name, parent_id, sort_order, created_at, updated_at) \ + SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at FROM temp.recovery_folders", + ) + .execute(&mut *database) + .await?; + sqlx::query("DROP TABLE temp.recovery_folders") + .execute(&mut *database) + .await?; + Ok(true) +} + +pub(super) async fn repair_queries(database: &mut SqliteConnection) -> Result<(), StorageError> { + // Deleted folders leave recoverable query text after the existing root queries. + sqlx::query( + "WITH promoted AS MATERIALIZED ( \ + SELECT item.id, \ + COALESCE((SELECT MAX(root.sort_order) + 1 FROM main.saved_queries root \ + WHERE root.connection_id = item.connection_id AND root.folder_id IS NULL), 0) \ + + ROW_NUMBER() OVER (PARTITION BY item.connection_id ORDER BY item.folder_id, item.sort_order, item.id) - 1 \ + AS position \ + FROM main.saved_queries item \ + WHERE item.folder_id IS NOT NULL \ + AND NOT EXISTS (SELECT 1 FROM main.saved_query_folders folder WHERE folder.id = item.folder_id) \ + ) \ + UPDATE main.saved_queries SET folder_id = NULL, sort_order = (SELECT position FROM promoted WHERE id = saved_queries.id) \ + WHERE id IN (SELECT id FROM promoted)", + ) + .execute(&mut *database) + .await?; + sqlx::query( + "WITH positions AS MATERIALIZED ( \ + SELECT id, ROW_NUMBER() OVER (PARTITION BY connection_id, folder_id ORDER BY sort_order, name COLLATE NOCASE, id) - 1 AS position \ + FROM main.saved_queries \ + ) \ + UPDATE main.saved_queries SET sort_order = (SELECT position FROM positions WHERE id = saved_queries.id)", + ) + .execute(&mut *database) + .await?; + sqlx::query( + "WITH positions AS MATERIALIZED ( \ + SELECT id, ROW_NUMBER() OVER (PARTITION BY connection_id, parent_id ORDER BY sort_order, name COLLATE NOCASE, id) - 1 AS position \ + FROM main.saved_query_folders \ + ) \ + UPDATE main.saved_query_folders SET sort_order = (SELECT position FROM positions WHERE id = saved_query_folders.id)", + ) + .execute(&mut *database) + .await?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use std::path::Path; + + use sqlx::sqlite::SqliteConnectOptions; + use sqlx::{AssertSqlSafe, ConnectOptions, Connection, SqliteConnection}; + use uuid::Uuid; + + use crate::paths::StoragePaths; + use crate::query_history::{QueryHistory, trim_copy}; + use crate::saved_queries::NewSavedQuery; + + async fn history(root: &tempfile::TempDir) -> QueryHistory { + QueryHistory::open(&StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro")) + .await + .expect("open history") + } + + async fn copy_database(path: &Path) -> SqliteConnection { + SqliteConnectOptions::new() + .filename(path) + .read_only(true) + .connect() + .await + .expect("open copy") + } + + async fn save(history: &QueryHistory, name: &str, folder: Option) -> i64 { + let store = history.saved_queries(); + let id = store + .save(NewSavedQuery { + name: name.to_owned(), + query: format!("SELECT '{name}'"), + connection_id: Uuid::nil(), + connection_name: "local".to_owned(), + }) + .await + .expect("save query") + .id; + if folder.is_some() { + store.move_to_folder(id, folder, None).await.expect("file query"); + } + id + } + + #[tokio::test] + async fn a_copy_deletes_the_live_subtree_and_keeps_folders_that_moved_out() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let reports = folders.create(Uuid::nil(), "Reports", None).await.expect("root folder"); + let parent = folders.create(Uuid::nil(), "P", None).await.expect("parent"); + let moved_out = folders + .create(Uuid::nil(), "Reports", Some(parent)) + .await + .expect("nested folder with the same name"); + let moved_in = folders.create(Uuid::nil(), "Into", None).await.expect("moving folder"); + let root_query = save(&history, "root", None).await; + let kept_query = save(&history, "kept", Some(moved_out)).await; + let promoted_query = save(&history, "promoted", Some(moved_in)).await; + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("keep copy"); + + let archive = folders + .create(Uuid::nil(), "Archive", None) + .await + .expect("new ancestor"); + folders.move_to(moved_out, Some(archive)).await.expect("move out"); + folders.move_to(moved_in, Some(parent)).await.expect("move in"); + folders.delete(parent).await.expect("delete the live subtree"); + + let mut database = copy_database(©).await; + let stored: Vec<(i64, String, Option)> = + sqlx::query_as("SELECT id, name, parent_id FROM saved_query_folders ORDER BY id") + .fetch_all(&mut database) + .await + .expect("folders in copy"); + assert_eq!( + stored, + vec![ + (reports, "Reports".to_owned(), None), + (moved_out, "Reports".to_owned(), Some(archive)), + (archive, "Archive".to_owned(), None), + ] + ); + let queries: Vec<(i64, String, Option, i64)> = + sqlx::query_as("SELECT id, query, folder_id, sort_order FROM saved_queries ORDER BY id") + .fetch_all(&mut database) + .await + .expect("queries in copy"); + assert_eq!( + queries, + vec![ + (root_query, "SELECT 'root'".to_owned(), None, 0), + (kept_query, "SELECT 'kept'".to_owned(), Some(moved_out), 0), + (promoted_query, "SELECT 'promoted'".to_owned(), None, 1), + ] + ); + assert!( + sqlx::query("PRAGMA foreign_key_check") + .fetch_optional(&mut database) + .await + .expect("foreign keys") + .is_none() + ); + database.close().await.expect("close copy"); + } + + #[tokio::test] + async fn a_generic_sweep_keeps_a_moved_child_and_uses_its_current_name() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let root_folder = folders.create(Uuid::nil(), "Reports", None).await.expect("root folder"); + let parent = folders.create(Uuid::nil(), "P", None).await.expect("parent"); + let child = folders + .create(Uuid::nil(), "Reports", Some(parent)) + .await + .expect("child"); + let query = save(&history, "kept", Some(child)).await; + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("keep copy"); + folders.rename(root_folder, "Renamed").await.expect("rename root"); + folders.move_to(child, None).await.expect("reuse the former root name"); + sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") + .bind(parent) + .execute(&history.pool) + .await + .expect("simulate a prior committed deletion"); + + let mut live = history.pool.acquire().await.expect("live connection"); + let transaction = live + .begin_with(AssertSqlSafe("BEGIN IMMEDIATE")) + .await + .expect("hold the live graph"); + trim_copy(©, history.path.to_str().expect("UTF-8 path"), &[]) + .await + .expect("trim copy"); + transaction.commit().await.expect("release live graph"); + + let mut database = copy_database(©).await; + let stored: Vec<(i64, String, Option)> = + sqlx::query_as("SELECT id, name, parent_id FROM saved_query_folders ORDER BY id") + .fetch_all(&mut database) + .await + .expect("folders"); + assert_eq!( + stored, + vec![ + (root_folder, "Renamed".to_owned(), None), + (child, "Reports".to_owned(), None) + ] + ); + let held: Option = sqlx::query_scalar("SELECT folder_id FROM saved_queries WHERE id = ?") + .bind(query) + .fetch_one(&mut database) + .await + .expect("query folder"); + assert_eq!(held, Some(child)); + database.close().await.expect("close copy"); + } + + #[tokio::test] + async fn a_copy_can_remove_more_folders_than_the_sqlite_cascade_limit() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let mut transaction = history.pool.begin().await.expect("begin fixture"); + let mut parent = None; + let mut first = None; + for _ in 0..1_100 { + let id = sqlx::query( + "INSERT INTO saved_query_folders (connection_id, name, parent_id, sort_order, created_at, updated_at) \ + VALUES (?, 'Nested', ?, 0, 1, 1)", + ) + .bind(Uuid::nil().to_string()) + .bind(parent) + .execute(&mut *transaction) + .await + .expect("insert folder") + .last_insert_rowid(); + first.get_or_insert(id); + parent = Some(id); + } + transaction.commit().await.expect("commit fixture"); + let query = save(&history, "deep", parent).await; + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("keep copy"); + history + .saved_query_folders() + .delete(first.expect("first folder")) + .await + .expect("delete deep subtree"); + + let mut database = copy_database(©).await; + let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM saved_query_folders") + .fetch_one(&mut database) + .await + .expect("folder count"); + assert_eq!(count, 0); + let stored: (String, Option, i64) = + sqlx::query_as("SELECT query, folder_id, sort_order FROM saved_queries WHERE id = ?") + .bind(query) + .fetch_one(&mut database) + .await + .expect("recoverable query"); + assert_eq!(stored, ("SELECT 'deep'".to_owned(), None, 0)); + database.close().await.expect("close copy"); + } + + #[tokio::test] + async fn a_copy_from_before_folders_still_trims_saved_queries() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let kept = save(&history, "kept", None).await; + let copy = root.path().join("legacy.sqlite3"); + let mut database = SqliteConnectOptions::new() + .filename(©) + .create_if_missing(true) + .connect() + .await + .expect("create legacy copy"); + sqlx::raw_sql(include_str!("../../migrations/20260914000000_create_history.sql")) + .execute(&mut database) + .await + .expect("legacy schema"); + for (id, name) in [(kept, "kept"), (kept + 1, "deleted")] { + sqlx::query( + "INSERT INTO saved_queries (id, name, query, connection_id, connection_name, created_at, updated_at) \ + VALUES (?, ?, 'SELECT 1', ?, 'local', 1, 1)", + ) + .bind(id) + .bind(name) + .bind(Uuid::nil().to_string()) + .execute(&mut database) + .await + .expect("legacy query"); + } + database.close().await.expect("close fixture"); + trim_copy(©, history.path.to_str().expect("UTF-8 path"), &[]) + .await + .expect("trim legacy copy"); + let mut database = copy_database(©).await; + let names: Vec = sqlx::query_scalar("SELECT name FROM saved_queries") + .fetch_all(&mut database) + .await + .expect("remaining queries"); + assert_eq!(names, ["kept"]); + database.close().await.expect("close copy"); + } +} diff --git a/core/crates/storage/src/query_history/favourites_migration_tests.rs b/core/crates/storage/src/query_history/favourites_migration_tests.rs new file mode 100644 index 0000000000..84d62ffd09 --- /dev/null +++ b/core/crates/storage/src/query_history/favourites_migration_tests.rs @@ -0,0 +1,185 @@ +use super::*; +use crate::unix_time::from_unix; + +async fn old_database(root: &tempfile::TempDir, migrations: usize) -> (StoragePaths, SqlitePool) { + let paths = StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro"); + crate::fs::create_private_file_if_missing(&paths.history_database()).expect("file"); + let pool = SqlitePoolOptions::new() + .max_connections(1) + .connect_with( + SqliteConnectOptions::new() + .filename(paths.history_database()) + .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal), + ) + .await + .expect("pool"); + sqlx::migrate::Migrator::with_migrations(schema::MIGRATOR.iter().take(migrations).cloned().collect()) + .run(&pool) + .await + .expect("old migrations"); + (paths, pool) +} + +async fn insert_queries(pool: &SqlitePool, connection: Uuid, other: Uuid) { + for (id, owner, name) in [(42, connection, "z"), (9, connection, "A"), (51, other, "other")] { + sqlx::query( + "INSERT INTO saved_queries (id, name, query, connection_id, connection_name, created_at, updated_at) \ + VALUES (?, ?, 'SELECT 42', ?, 'Original connection', 11, 12)", + ) + .bind(id) + .bind(name) + .bind(owner.to_string()) + .execute(pool) + .await + .expect("saved query fixture"); + } +} + +async fn assert_copy_kept(paths: &StoragePaths, migrations: i64) -> sqlx::SqliteConnection { + let copies = crate::upgrade_copies::copies_blocking(&paths.history_database()).expect("copies"); + assert_eq!(copies.len(), 1); + let mut copy = SqliteConnectOptions::new() + .filename(&copies[0].path) + .read_only(true) + .connect() + .await + .expect("open copy"); + let applied: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM _sqlx_migrations") + .fetch_one(&mut copy) + .await + .expect("copy migration count"); + assert_eq!(applied, migrations); + let ids: Vec = sqlx::query_scalar("SELECT id FROM saved_queries ORDER BY id") + .fetch_all(&mut copy) + .await + .expect("copy queries"); + assert_eq!(ids, [9, 42, 51]); + copy +} + +#[tokio::test] +async fn original_schema_upgrade_preserves_queries_and_assigns_connection_scoped_order() { + let root = tempfile::tempdir().expect("tempdir"); + let (paths, pool) = old_database(&root, 1).await; + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + insert_queries(&pool, connection, other).await; + pool.close().await; + + let history = QueryHistory::open(&paths).await.expect("upgrade"); + let queries = history.saved_queries().list(Some(connection)).await.expect("queries"); + assert_eq!( + queries.iter().map(|query| (query.id, query.order)).collect::>(), + [(9, 0), (42, 1)] + ); + for query in &queries { + assert_eq!(query.query, "SELECT 42"); + assert_eq!(query.connection_name, "Original connection"); + assert_eq!(query.created_at, from_unix(11)); + assert_eq!(query.updated_at, from_unix(12)); + assert_eq!(query.keyword, None); + assert_eq!(query.folder_id, None); + } + let other = history + .saved_queries() + .list(Some(other)) + .await + .expect("other connection"); + assert_eq!(other.len(), 1); + assert_eq!((other[0].id, other[0].order), (51, 0)); + assert_copy_kept(&paths, 1).await.close().await.expect("close copy"); +} + +async fn insert_favorites(pool: &SqlitePool, connection: Uuid, other: Uuid) { + for (id, owner, name, parent, order) in [ + (1, connection, "Reports", None, 8), + (2, connection, "Archive", None, 2), + (3, connection, "Monthly", Some(1), 8), + (4, other, "Other", None, 8), + ] { + sqlx::query( + "INSERT INTO saved_query_folders (id, connection_id, name, parent_id, sort_order, created_at, updated_at) \ + VALUES (?, ?, ?, ?, ?, 21, 22)", + ) + .bind(id) + .bind(owner.to_string()) + .bind(name) + .bind(parent) + .bind(order) + .execute(pool) + .await + .expect("folder fixture"); + } + sqlx::query("UPDATE saved_queries SET folder_id = 3, keyword = 'daily', sort_order = 9 WHERE id = 42") + .execute(pool) + .await + .expect("file query"); + sqlx::query("UPDATE saved_queries SET sort_order = 4 WHERE id <> 42") + .execute(pool) + .await + .expect("root query orders"); + sqlx::query("INSERT INTO favourite_tables (connection_id, database, schema, name, created_at) VALUES (?, 'shop', 'public', 'orders', 31)") + .bind(connection.to_string()).execute(pool).await.expect("table fixture"); + sqlx::query("INSERT INTO favourite_databases (connection_id, database, environment, created_at) VALUES (?, 'shop', 'production', 32)") + .bind(connection.to_string()).execute(pool).await.expect("database fixture"); +} + +#[tokio::test] +async fn favorites_schema_upgrade_preserves_filing_and_metadata_and_normalizes_positions() { + let root = tempfile::tempdir().expect("tempdir"); + let (paths, pool) = old_database(&root, 2).await; + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + insert_queries(&pool, connection, other).await; + insert_favorites(&pool, connection, other).await; + pool.close().await; + + let history = QueryHistory::open(&paths).await.expect("upgrade"); + let snapshot = history.saved_queries().snapshot(connection).await.expect("snapshot"); + let filed = snapshot + .queries + .iter() + .find(|query| query.id == 42) + .expect("filed query"); + assert_eq!( + (filed.folder_id, filed.keyword.as_deref(), filed.order), + (Some(3), Some("daily"), 0) + ); + assert_eq!(filed.query, "SELECT 42"); + assert_eq!(filed.connection_name, "Original connection"); + assert_eq!(filed.created_at, from_unix(11)); + assert_eq!(filed.updated_at, from_unix(12)); + let root_query = snapshot.queries.iter().find(|query| query.id == 9).expect("root query"); + assert_eq!((root_query.folder_id, root_query.order), (None, 0)); + for (id, parent, order) in [(1, None, 1), (2, None, 0), (3, Some(1), 0)] { + let folder = snapshot.folders.iter().find(|folder| folder.id == id).expect("folder"); + assert_eq!((folder.parent_id, folder.order), (parent, order)); + assert_eq!(folder.created_at, from_unix(21)); + assert_eq!(folder.updated_at, from_unix(22)); + } + let other = history.saved_queries().snapshot(other).await.expect("other connection"); + assert_eq!((other.queries[0].id, other.queries[0].order), (51, 0)); + assert_eq!((other.folders[0].id, other.folders[0].order), (4, 0)); + assert_eq!( + history.favourites().tables(connection).await.expect("tables")[0].name, + "orders" + ); + assert_eq!( + history.favourites().databases(connection).await.expect("databases")[0].environment, + crate::DatabaseEnvironment::Production + ); + + let mut copy = assert_copy_kept(&paths, 2).await; + let original: (Option, Option, i64) = + sqlx::query_as("SELECT folder_id, keyword, sort_order FROM saved_queries WHERE id = 42") + .fetch_one(&mut copy) + .await + .expect("original query metadata"); + assert_eq!(original, (Some(3), Some("daily".to_owned()), 9)); + let original_order: i64 = sqlx::query_scalar("SELECT sort_order FROM saved_query_folders WHERE id = 1") + .fetch_one(&mut copy) + .await + .expect("original folder order"); + assert_eq!(original_order, 8); + copy.close().await.expect("close copy"); +} diff --git a/core/crates/storage/src/query_history/mod.rs b/core/crates/storage/src/query_history/mod.rs index b03f8f2c9d..352e127204 100644 --- a/core/crates/storage/src/query_history/mod.rs +++ b/core/crates/storage/src/query_history/mod.rs @@ -1,5 +1,8 @@ +mod backup_folders; mod entry; mod export; +#[cfg(test)] +mod favourites_migration_tests; mod history_connection; mod history_cursor; mod history_page; @@ -106,6 +109,16 @@ impl QueryHistory { crate::saved_queries::SavedQueries::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) } + /// The folders saved queries are filed in, in the same database. + pub fn saved_query_folders(&self) -> crate::saved_queries::SavedQueryFolders { + crate::saved_queries::SavedQueryFolders::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) + } + + /// The favourite tables and databases, in the same database. + pub fn favourites(&self) -> crate::favourites::Favourites { + crate::favourites::Favourites::new(self.pool.clone(), self.path.clone(), self.saved_changes.clone()) + } + pub async fn record(&self, entry: NewEntry) -> Result { if entry.query.len() > MAX_QUERY_BYTES { return Err(StorageError::TooLarge { @@ -263,8 +276,9 @@ impl QueryHistory { binds: chunk.iter().map(|id| Bind::Integer(*id)).collect(), }) .collect(); + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies(&self.path, &from_copies).await?; - let mut transaction = self.pool.begin().await?; let mut deleted = Vec::with_capacity(ids.len()); for chunk in ids.chunks(IDS_PER_STATEMENT) { let placeholders = vec!["?"; chunk.len()].join(","); @@ -318,6 +332,8 @@ impl QueryHistory { } pub async fn clear_all(&self) -> Result { + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies( &self.path, &[CopyDelete { @@ -328,15 +344,16 @@ impl QueryHistory { ) .await?; let affected = sqlx::query("DELETE FROM history") - .execute(&self.pool) + .execute(&mut *transaction) .await? .rows_affected(); // The delete triggers leave the queries' words in the index until it is optimized. if affected > 0 { sqlx::query("INSERT INTO history_search(history_search) VALUES('optimize')") - .execute(&self.pool) + .execute(&mut *transaction) .await?; } + transaction.commit().await?; Ok(affected as usize) } @@ -376,7 +393,10 @@ impl QueryHistory { .await?; } // Rows expired here, or unpinned since a copy was made, leave the copies too. + let mut database = self.pool.acquire().await?; + let transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies(&self.path, &[]).await?; + transaction.commit().await?; Ok(report) } @@ -392,6 +412,8 @@ impl QueryHistory { /// Drop every query run on a connection, pinned ones included, for a /// connection the user deleted along with its history. pub async fn delete_for_connection(&self, connection: Uuid) -> Result { + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; trim_upgrade_copies( &self.path, &[CopyDelete { @@ -403,16 +425,17 @@ impl QueryHistory { .await?; let removed = sqlx::query("DELETE FROM history WHERE connection_id = ?") .bind(connection.to_string()) - .execute(&self.pool) + .execute(&mut *transaction) .await? .rows_affected(); // As after a prune: the delete triggers leave tombstones in the // index until it is optimized. if removed > 0 { sqlx::query("INSERT INTO history_search(history_search) VALUES('optimize')") - .execute(&self.pool) + .execute(&mut *transaction) .await?; } + transaction.commit().await?; Ok(removed) } @@ -478,6 +501,7 @@ pub(crate) struct CopyDelete { pub(crate) binds: Vec, } +// Callers hold the live SQLite write lock until their deletion commits, so copy reconciliation cannot restore a pending deletion. pub(crate) async fn trim_upgrade_copies(path: &Path, first: &[CopyDelete]) -> Result<(), StorageError> { crate::upgrade_copies::remove_leftovers_blocking(path)?; let copies = crate::upgrade_copies::copies_blocking(path)?; @@ -516,6 +540,7 @@ fn is_busy(error: &StorageError) -> bool { async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), StorageError> { let mut database = SqliteConnectOptions::new() .filename(copy) + .foreign_keys(false) .journal_mode(sqlx::sqlite::SqliteJournalMode::Delete) .pragma("secure_delete", "ON") .disable_statement_logging() @@ -526,6 +551,7 @@ async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), .execute(&mut database) .await?; let mut transaction = database.begin().await?; + let has_folders = backup_folders::reconcile(&mut transaction).await?; for delete in first { let present: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM main.sqlite_master WHERE type = 'table' AND name = ?") @@ -543,7 +569,7 @@ async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), statement.execute(&mut *transaction).await?; } } - for table in ["history", "saved_queries"] { + for table in ["history", "saved_queries", "saved_query_folders"] { let present: i64 = sqlx::query_scalar( "SELECT (SELECT COUNT(*) FROM main.sqlite_master WHERE type = 'table' AND name = ?1) \ * (SELECT COUNT(*) FROM live.sqlite_master WHERE type = 'table' AND name = ?1)", @@ -559,9 +585,19 @@ async fn trim_copy(copy: &Path, live: &str, first: &[CopyDelete]) -> Result<(), .await?; } } - // Every time, which costs little on an index already merged. + if has_folders { + backup_folders::repair_queries(&mut transaction).await?; + } + if sqlx::query("PRAGMA main.foreign_key_check") + .fetch_optional(&mut *transaction) + .await? + .is_some() + { + return Err(StorageError::Schema("invalid references in an upgrade copy".to_owned())); + } optimize_full_text_indexes(&mut transaction).await?; transaction.commit().await?; + sqlx::query("PRAGMA foreign_keys = ON").execute(&mut database).await?; sqlx::query("DETACH DATABASE live").execute(&mut database).await?; database.close().await?; Ok(()) @@ -714,7 +750,56 @@ mod tests { .fetch_one(&history.pool) .await .expect("count migrations"); - assert_eq!(applied, 1); + assert_eq!(applied, 3); + } + + /// A database an earlier build wrote, with its saved queries, is kept + /// as a copy before the favourites' migration and then reads as it did, + /// with no keyword and no folder. + #[tokio::test] + async fn a_database_from_before_the_favourites_keeps_its_saved_queries() { + let root = tempfile::tempdir().expect("tempdir"); + let paths = paths(&root); + let path = paths.history_database(); + crate::fs::create_private_file_if_missing(&path).expect("the file"); + let pool = SqlitePoolOptions::new() + .max_connections(1) + .connect_with( + SqliteConnectOptions::new() + .filename(&path) + .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal), + ) + .await + .expect("a pool"); + sqlx::migrate::Migrator::with_migrations(schema::MIGRATOR.iter().take(1).cloned().collect()) + .run(&pool) + .await + .expect("the first migration"); + let connection = Uuid::new_v4(); + sqlx::query( + "INSERT INTO saved_queries (name, query, connection_id, connection_name, created_at, updated_at) \ + VALUES ('daily', 'SELECT 1', ?, 'local', 1, 1)", + ) + .bind(connection.to_string()) + .execute(&pool) + .await + .expect("a saved query"); + pool.close().await; + + let history = QueryHistory::open(&paths).await.expect("open"); + + let saved = history.saved_queries().list(Some(connection)).await.expect("list"); + assert_eq!(saved.len(), 1); + assert_eq!( + (saved[0].keyword.as_deref(), saved[0].folder_id, saved[0].order), + (None, None, 0) + ); + assert!( + !crate::upgrade_copies::copies_blocking(&path) + .expect("copies") + .is_empty(), + "no copy was kept before the migration" + ); } #[tokio::test] @@ -859,7 +944,7 @@ mod tests { /// means a change went into a file that has already run somewhere. #[test] fn migrator_embeds_every_migration() { - assert_eq!(schema::MIGRATOR.iter().count(), 1); + assert_eq!(schema::MIGRATOR.iter().count(), 3); } #[tokio::test] @@ -1406,6 +1491,65 @@ mod tests { assert!(indexed(©, "qqq").await); } + /// A copy made after the favourites existed holds no folder, table or + /// database the user then deleted. + #[tokio::test] + async fn deleted_folders_and_favourites_leave_the_copies_too() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let connection = Uuid::new_v4(); + let folders = history.saved_query_folders(); + let favourites = history.favourites(); + let folder = folders.create(connection, "Reports", None).await.expect("a folder"); + folders + .create(connection, "Monthly", Some(folder)) + .await + .expect("a subfolder"); + let table = crate::favourites::FavouriteTable { + connection_id: connection, + database: None, + schema: None, + name: "orders".to_owned(), + }; + favourites.add_table(&table).await.expect("a table"); + favourites + .set_database(connection, "shop", crate::favourites::DatabaseEnvironment::Testing) + .await + .expect("a database"); + let copy = crate::upgrade_copies::keep_database(&history.pool, &history.path, 1) + .await + .expect("a copy"); + async fn kept(copy: &Path) -> Vec { + let mut database = SqliteConnectOptions::new() + .filename(copy) + .read_only(true) + .connect() + .await + .expect("open the copy"); + let mut counts = Vec::new(); + for table in ["saved_query_folders", "favourite_tables", "favourite_databases"] { + counts.push( + sqlx::query_scalar(AssertSqlSafe(format!("SELECT COUNT(*) FROM {table}"))) + .fetch_one(&mut database) + .await + .expect("count"), + ); + } + database.close().await.expect("close"); + counts + } + assert_eq!(kept(©).await, [2, 1, 1]); + + folders.delete(folder).await.expect("delete the folder"); + favourites.remove_table(&table).await.expect("remove the table"); + favourites + .remove_database(connection, "shop") + .await + .expect("remove the database"); + + assert_eq!(kept(©).await, [0, 0, 0], "a deleted favourite stayed in the copy"); + } + #[tokio::test] async fn a_copy_that_cannot_be_trimmed_is_removed() { let root = tempfile::tempdir().expect("tempdir"); diff --git a/core/crates/storage/src/saved_queries/deletion.rs b/core/crates/storage/src/saved_queries/deletion.rs new file mode 100644 index 0000000000..14c3b68e83 --- /dev/null +++ b/core/crates/storage/src/saved_queries/deletion.rs @@ -0,0 +1,160 @@ +use std::collections::{HashMap, HashSet}; +use std::path::Path; +use std::time::SystemTime; + +use sqlx::{AssertSqlSafe, Connection, Row, SqliteConnection, SqlitePool}; +use uuid::Uuid; + +use crate::StorageError; +use crate::query_history::{Bind, CopyDelete, trim_upgrade_copies}; +use crate::unix_time::to_unix; + +use super::ordering; + +pub(super) async fn delete_folder(pool: &SqlitePool, path: &Path, id: i64) -> Result<(), StorageError> { + let mut connection = pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, parent_id FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + let owner: String = row.try_get("connection_id")?; + let parent: Option = row.try_get("parent_id")?; + let ids: Vec = sqlx::query_scalar( + "WITH RECURSIVE subtree(id) AS (SELECT id FROM saved_query_folders WHERE id = ? \ + UNION SELECT f.id FROM saved_query_folders f JOIN subtree s ON f.parent_id = s.id) \ + SELECT id FROM subtree", + ) + .bind(id) + .fetch_all(&mut *transaction) + .await?; + let doomed: HashSet = ids.iter().copied().collect(); + trim_upgrade_copies(path, &folder_deletes(&ids)).await?; + let rows = sqlx::query( + "SELECT id, folder_id FROM saved_queries WHERE connection_id = ? AND folder_id IS NOT NULL \ + ORDER BY folder_id, sort_order, name COLLATE NOCASE, id", + ) + .bind(&owner) + .fetch_all(&mut *transaction) + .await?; + let mut position: i64 = sqlx::query_scalar( + "SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_queries WHERE connection_id = ? AND folder_id IS NULL", + ) + .bind(&owner) + .fetch_one(&mut *transaction) + .await?; + for row in rows { + if !doomed.contains(&row.try_get::("folder_id")?) { + continue; + } + sqlx::query("UPDATE saved_queries SET folder_id = NULL, sort_order = ?, updated_at = ? WHERE id = ?") + .bind(position) + .bind(to_unix(SystemTime::now())) + .bind(row.try_get::("id")?) + .execute(&mut *transaction) + .await?; + position += 1; + } + delete_folder_rows(&mut transaction, &doomed).await?; + ordering::compact_folders(&mut transaction, &owner, parent).await?; + transaction.commit().await?; + Ok(()) +} + +pub(super) async fn delete_connection( + pool: &SqlitePool, + path: &Path, + connection: Uuid, +) -> Result<(usize, bool), StorageError> { + let mut database = pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let owner = connection.to_string(); + let copies = [ + "saved_queries", + "saved_query_folders", + "favourite_tables", + "favourite_databases", + ] + .map(|table| CopyDelete { + table, + sql: format!("DELETE FROM main.{table} WHERE connection_id = ?"), + binds: vec![Bind::Text(owner.clone())], + }); + trim_upgrade_copies(path, &copies).await?; + let queries = sqlx::query("DELETE FROM saved_queries WHERE connection_id = ?") + .bind(&owner) + .execute(&mut *transaction) + .await? + .rows_affected(); + let folders: Vec = sqlx::query_scalar("SELECT id FROM saved_query_folders WHERE connection_id = ?") + .bind(&owner) + .fetch_all(&mut *transaction) + .await?; + let mut changed = queries > 0 || !folders.is_empty(); + delete_folder_rows(&mut transaction, &folders.into_iter().collect()).await?; + for statement in [ + "DELETE FROM favourite_tables WHERE connection_id = ?", + "DELETE FROM favourite_databases WHERE connection_id = ?", + ] { + changed |= sqlx::query(statement) + .bind(&owner) + .execute(&mut *transaction) + .await? + .rows_affected() + > 0; + } + transaction.commit().await?; + Ok((queries as usize, changed)) +} + +fn folder_deletes(ids: &[i64]) -> Vec { + ids.chunks(500) + .map(|chunk| CopyDelete { + table: "saved_query_folders", + sql: format!( + "DELETE FROM main.saved_query_folders WHERE id IN ({})", + vec!["?"; chunk.len()].join(",") + ), + binds: chunk.iter().map(|id| Bind::Integer(*id)).collect(), + }) + .collect() +} + +async fn delete_folder_rows(database: &mut SqliteConnection, ids: &HashSet) -> Result<(), StorageError> { + // Deleting leaves first avoids SQLite's cascade depth limit without moving names into occupied sibling lists. + let rows: Vec<(i64, Option)> = sqlx::query_as("SELECT id, parent_id FROM saved_query_folders") + .fetch_all(&mut *database) + .await?; + let parents: HashMap> = rows.into_iter().filter(|(id, _)| ids.contains(id)).collect(); + let mut children: HashMap = parents.keys().map(|id| (*id, 0)).collect(); + for parent in parents.values().flatten() { + if let Some(count) = children.get_mut(parent) { + *count += 1; + } + } + let mut leaves: Vec = children + .iter() + .filter_map(|(id, count)| (*count == 0).then_some(*id)) + .collect(); + let mut removed = 0; + while let Some(id) = leaves.pop() { + sqlx::query("DELETE FROM saved_query_folders WHERE id = ?") + .bind(id) + .execute(&mut *database) + .await?; + removed += 1; + if let Some(Some(parent)) = parents.get(&id) + && let Some(count) = children.get_mut(parent) + { + *count -= 1; + if *count == 0 { + leaves.push(*parent); + } + } + } + if removed != parents.len() { + return Err(StorageError::Schema("saved query folder cycle".to_owned())); + } + Ok(()) +} diff --git a/core/crates/storage/src/saved_queries/folders.rs b/core/crates/storage/src/saved_queries/folders.rs new file mode 100644 index 0000000000..c682502a62 --- /dev/null +++ b/core/crates/storage/src/saved_queries/folders.rs @@ -0,0 +1,244 @@ +use std::collections::HashSet; +use std::path::PathBuf; +use std::sync::Arc; +use std::time::SystemTime; + +use sqlx::{AssertSqlSafe, Connection, Row, SqliteConnection, SqlitePool}; +use tokio::sync::watch; +use uuid::Uuid; + +use crate::error::StorageError; +use crate::name_rules::{self, NameFault}; +use crate::unix_time::{from_unix, to_unix}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SavedQueryFolder { + pub id: i64, + pub connection_id: Uuid, + pub name: String, + pub parent_id: Option, + pub order: i64, + pub created_at: SystemTime, + pub updated_at: SystemTime, +} + +const MAX_NAME_CHARS: usize = 200; + +#[derive(Debug, Clone)] +pub struct SavedQueryFolders { + pool: SqlitePool, + path: PathBuf, + changes: Arc>, +} + +impl SavedQueryFolders { + pub(crate) fn new(pool: SqlitePool, path: PathBuf, changes: Arc>) -> Self { + Self { pool, path, changes } + } + + pub fn changes(&self) -> watch::Receiver { + self.changes.subscribe() + } + + fn changed(&self) { + self.changes + .send_modify(|revision| *revision = revision.wrapping_add(1)); + } + + pub async fn create(&self, connection: Uuid, name: &str, parent: Option) -> Result { + let name = checked_name(name)?; + let owner = connection.to_string(); + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + check_parent(&mut transaction, &owner, parent, None).await?; + check_name(&mut transaction, &owner, parent, &name, None).await?; + let now = to_unix(SystemTime::now()); + let id = sqlx::query( + "INSERT INTO saved_query_folders (connection_id, name, parent_id, sort_order, created_at, updated_at) \ + VALUES (?1, ?2, ?3, \ + (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_query_folders \ + WHERE connection_id = ?1 AND parent_id IS ?3), ?4, ?4) \ + RETURNING id", + ) + .bind(owner) + .bind(name) + .bind(parent) + .bind(now) + .fetch_one(&mut *transaction) + .await + .map_err(name_taken)? + .try_get("id")?; + transaction.commit().await?; + self.changed(); + Ok(id) + } + + pub async fn rename(&self, id: i64, name: &str) -> Result<(), StorageError> { + let name = checked_name(name)?; + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let (owner, parent, previous): (String, Option, String) = + sqlx::query_as("SELECT connection_id, parent_id, name FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + if previous == name { + transaction.commit().await?; + return Ok(()); + } + check_name(&mut transaction, &owner, parent, &name, Some(id)).await?; + sqlx::query("UPDATE saved_query_folders SET name = ?, updated_at = ? WHERE id = ?") + .bind(name) + .bind(to_unix(SystemTime::now())) + .bind(id) + .execute(&mut *transaction) + .await + .map_err(name_taken)?; + transaction.commit().await?; + self.changed(); + Ok(()) + } + + pub async fn move_to(&self, id: i64, parent: Option) -> Result<(), StorageError> { + let mut database = self.pool.acquire().await?; + let mut transaction = database.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let (owner, previous, name): (String, Option, String) = + sqlx::query_as("SELECT connection_id, parent_id, name FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + check_parent(&mut transaction, &owner, parent, Some(id)).await?; + if previous == parent { + transaction.commit().await?; + return Ok(()); + } + check_name(&mut transaction, &owner, parent, &name, Some(id)).await?; + sqlx::query( + "UPDATE saved_query_folders SET parent_id = ?1, updated_at = ?2, \ + sort_order = (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_query_folders \ + WHERE connection_id = ?3 AND parent_id IS ?1) \ + WHERE id = ?4", + ) + .bind(parent) + .bind(to_unix(SystemTime::now())) + .bind(&owner) + .bind(id) + .execute(&mut *transaction) + .await + .map_err(name_taken)?; + super::ordering::compact_folders(&mut transaction, &owner, previous).await?; + transaction.commit().await?; + self.changed(); + Ok(()) + } + + pub async fn delete(&self, id: i64) -> Result<(), StorageError> { + super::deletion::delete_folder(&self.pool, &self.path, id).await?; + self.changed(); + Ok(()) + } + + pub async fn list(&self, connection: Uuid) -> Result, StorageError> { + let rows = sqlx::query( + "SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at \ + FROM saved_query_folders WHERE connection_id = ? \ + ORDER BY COALESCE(parent_id, 0), sort_order, name COLLATE NOCASE, id", + ) + .bind(connection.to_string()) + .fetch_all(&self.pool) + .await?; + rows.into_iter().map(row_to_folder).collect() + } +} + +async fn check_parent( + database: &mut SqliteConnection, + connection: &str, + parent: Option, + moving: Option, +) -> Result<(), StorageError> { + let mut above = parent; + let mut visited = HashSet::new(); + while let Some(id) = above { + if Some(id) == moving || !visited.insert(id) { + return Err(StorageError::FolderCycle { + id: moving.unwrap_or(id), + }); + } + let (owner, next): (String, Option) = + sqlx::query_as("SELECT connection_id, parent_id FROM saved_query_folders WHERE id = ?") + .bind(id) + .fetch_optional(&mut *database) + .await? + .ok_or(StorageError::NotFound)?; + if owner != connection { + return Err(StorageError::NotFound); + } + above = next; + } + Ok(()) +} + +async fn check_name( + database: &mut SqliteConnection, + connection: &str, + parent: Option, + name: &str, + own_id: Option, +) -> Result<(), StorageError> { + let siblings: Vec<(i64, String)> = + sqlx::query_as("SELECT id, name FROM saved_query_folders WHERE connection_id = ? AND parent_id IS ?") + .bind(connection) + .bind(parent) + .fetch_all(database) + .await?; + let key = name_rules::shown(name).to_lowercase(); + if siblings + .into_iter() + .any(|(id, sibling)| Some(id) != own_id && name_rules::shown(&sibling).to_lowercase() == key) + { + return Err(StorageError::FolderNameTaken); + } + Ok(()) +} + +pub(super) fn row_to_folder(row: sqlx::sqlite::SqliteRow) -> Result { + let owner: String = row.try_get("connection_id")?; + let connection_id = Uuid::parse_str(&owner).map_err(|error| StorageError::Schema(error.to_string()))?; + Ok(SavedQueryFolder { + id: row.try_get("id")?, + connection_id, + name: row.try_get("name")?, + parent_id: row.try_get("parent_id")?, + order: row.try_get("sort_order")?, + created_at: from_unix(row.try_get::("created_at")?), + updated_at: from_unix(row.try_get::("updated_at")?), + }) +} + +fn checked_name(name: &str) -> Result { + let name = name_rules::checked(name).map_err(|error| match error { + NameFault::Empty => StorageError::EmptyName, + NameFault::ControlCharacter => StorageError::FolderNameInvalid, + })?; + if name.chars().count() > MAX_NAME_CHARS { + return Err(StorageError::TooLarge { + got: name.chars().count(), + limit: MAX_NAME_CHARS, + }); + } + Ok(name) +} + +fn name_taken(error: sqlx::Error) -> StorageError { + match &error { + sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::FolderNameTaken, + _ => StorageError::Database(error), + } +} + +#[cfg(test)] +#[path = "folders_tests.rs"] +mod tests; diff --git a/core/crates/storage/src/saved_queries/folders_tests.rs b/core/crates/storage/src/saved_queries/folders_tests.rs new file mode 100644 index 0000000000..71c91f6af7 --- /dev/null +++ b/core/crates/storage/src/saved_queries/folders_tests.rs @@ -0,0 +1,273 @@ +use super::*; +use crate::paths::StoragePaths; +use crate::query_history::QueryHistory; + +async fn history(root: &tempfile::TempDir) -> QueryHistory { + let paths = StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro"); + QueryHistory::open(&paths).await.expect("open history") +} + +fn places(folders: &[SavedQueryFolder], parent: Option) -> Vec<(i64, i64)> { + folders + .iter() + .filter(|folder| folder.parent_id == parent) + .map(|folder| (folder.id, folder.order)) + .collect() +} + +#[tokio::test] +async fn folder_names_are_visible_normalized_and_unique_within_their_parent() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let reports = folders + .create(connection, " E\u{301}tat\u{200b} ", None) + .await + .expect("normalized folder"); + assert_eq!(folders.list(connection).await.expect("list")[0].name, "État"); + assert!(matches!( + folders.create(connection, "état", None).await, + Err(StorageError::FolderNameTaken) + )); + folders + .create(connection, "état", Some(reports)) + .await + .expect("same name in another parent"); + folders + .create(Uuid::new_v4(), "état", None) + .await + .expect("same name on another connection"); + for name in ["", " \t ", "\u{200b}"] { + assert!(matches!( + folders.create(connection, name, None).await, + Err(StorageError::EmptyName) + )); + } + assert!(matches!( + folders.create(connection, "bad\nname", None).await, + Err(StorageError::FolderNameInvalid) + )); + assert!(matches!( + folders.create(connection, &"é".repeat(201), None).await, + Err(StorageError::TooLarge { got: 201, limit: 200 }) + )); + folders + .create(connection, &"e\u{301}".repeat(200), None) + .await + .expect("length applies to the normalized name"); +} + +#[tokio::test] +async fn independent_handles_cannot_create_unicode_name_duplicates() { + let root = tempfile::tempdir().expect("tempdir"); + let first_history = history(&root).await; + let second_history = history(&root).await; + let first = first_history.saved_query_folders(); + let second = second_history.saved_query_folders(); + let connection = Uuid::new_v4(); + let results = tokio::join!( + first.create(connection, "État", None), + second.create(connection, "e\u{301}tat", None) + ); + assert!(matches!( + results, + (Ok(_), Err(StorageError::FolderNameTaken)) | (Err(StorageError::FolderNameTaken), Ok(_)) + )); + let saved = first.list(connection).await.expect("list"); + assert_eq!(saved.len(), 1); + assert_eq!(saved[0].order, 0); +} + +#[tokio::test] +async fn independent_renames_cannot_claim_the_same_unicode_name() { + let root = tempfile::tempdir().expect("tempdir"); + let first_history = history(&root).await; + let second_history = history(&root).await; + let first = first_history.saved_query_folders(); + let second = second_history.saved_query_folders(); + let connection = Uuid::new_v4(); + let a = first.create(connection, "A", None).await.expect("A"); + let b = first.create(connection, "B", None).await.expect("B"); + let results = tokio::join!(first.rename(a, "État"), second.rename(b, "état")); + assert!(matches!( + results, + (Ok(()), Err(StorageError::FolderNameTaken)) | (Err(StorageError::FolderNameTaken), Ok(())) + )); + assert_eq!(first.list(connection).await.expect("list").len(), 2); +} + +#[tokio::test] +async fn moving_a_folder_compacts_its_source_and_appends_to_its_destination() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let source = folders.create(connection, "Source", None).await.expect("source"); + let target = folders.create(connection, "Target", None).await.expect("target"); + let a = folders.create(connection, "A", Some(source)).await.expect("A"); + let b = folders.create(connection, "B", Some(source)).await.expect("B"); + let c = folders.create(connection, "C", Some(source)).await.expect("C"); + let x = folders.create(connection, "X", Some(target)).await.expect("X"); + let other = Uuid::new_v4(); + folders.create(other, "Other", None).await.expect("other"); + let elsewhere = folders.list(other).await.expect("other folders"); + + folders.move_to(b, Some(target)).await.expect("move"); + let saved = folders.list(connection).await.expect("list"); + assert_eq!(places(&saved, Some(source)), vec![(a, 0), (c, 1)]); + assert_eq!(places(&saved, Some(target)), vec![(x, 0), (b, 1)]); + assert_eq!(folders.list(other).await.expect("other folders"), elsewhere); + folders.move_to(a, None).await.expect("move to root"); + let saved = folders.list(connection).await.expect("list"); + assert_eq!(places(&saved, None), vec![(source, 0), (target, 1), (a, 2)]); + assert_eq!(places(&saved, Some(source)), vec![(c, 0)]); +} + +#[tokio::test] +async fn invalid_moves_leave_names_hierarchy_and_positions_unchanged() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let parent = folders.create(connection, "Parent", None).await.expect("parent"); + let child = folders.create(connection, "État", Some(parent)).await.expect("child"); + folders + .create(connection, "état", None) + .await + .expect("same name at root"); + let foreign = folders.create(Uuid::new_v4(), "Foreign", None).await.expect("foreign"); + let before = folders.list(connection).await.expect("before"); + + assert!(matches!( + folders.move_to(child, None).await, + Err(StorageError::FolderNameTaken) + )); + assert!(matches!( + folders.move_to(child, Some(foreign)).await, + Err(StorageError::NotFound) + )); + assert!( + matches!(folders.move_to(parent, Some(child)).await, Err(StorageError::FolderCycle { id }) if id == parent) + ); + assert!( + matches!(folders.move_to(parent, Some(parent)).await, Err(StorageError::FolderCycle { id }) if id == parent) + ); + assert!(matches!( + folders.move_to(parent, Some(i64::MAX)).await, + Err(StorageError::NotFound) + )); + assert!(matches!( + folders.move_to(i64::MAX, None).await, + Err(StorageError::NotFound) + )); + assert_eq!(folders.list(connection).await.expect("after"), before); +} + +#[tokio::test] +async fn a_corrupt_ancestor_cycle_is_rejected_instead_of_walked_forever() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let connection = Uuid::new_v4(); + let a = folders.create(connection, "A", None).await.expect("A"); + let b = folders.create(connection, "B", Some(a)).await.expect("B"); + let c = folders.create(connection, "C", None).await.expect("C"); + sqlx::query("UPDATE saved_query_folders SET parent_id = ? WHERE id = ?") + .bind(b) + .bind(a) + .execute(&folders.pool) + .await + .expect("corrupt cycle"); + + assert!(matches!(folders.move_to(c, Some(a)).await, Err(StorageError::FolderCycle { id }) if id == c)); + assert!(matches!( + folders.create(connection, "D", Some(a)).await, + Err(StorageError::FolderCycle { .. }) + )); +} + +#[tokio::test] +async fn folder_notifications_follow_committed_changes_only() { + let root = tempfile::tempdir().expect("tempdir"); + let first_history = history(&root).await; + let second_history = history(&root).await; + let folders = first_history.saved_query_folders(); + let queries = first_history.saved_queries(); + let mut changes = queries.changes(); + let mut folder_changes = folders.changes(); + let connection = Uuid::new_v4(); + let a = folders.create(connection, "A", None).await.expect("A"); + assert_eq!(*changes.borrow_and_update(), 1); + assert_eq!(*folder_changes.borrow_and_update(), 1); + assert_eq!( + second_history + .saved_query_folders() + .list(connection) + .await + .expect("committed")[0] + .id, + a + ); + + folders.rename(a, "B").await.expect("rename"); + assert_eq!(*changes.borrow_and_update(), 2); + assert_eq!( + second_history + .saved_query_folders() + .list(connection) + .await + .expect("committed")[0] + .name, + "B" + ); + folders.rename(a, " B ").await.expect("same normalized name"); + folders.move_to(a, None).await.expect("same parent"); + assert!(!changes.has_changed().expect("open sender")); + assert!(matches!(folders.rename(a, "").await, Err(StorageError::EmptyName))); + assert!(matches!( + folders.rename(i64::MAX, "C").await, + Err(StorageError::NotFound) + )); + assert!(!changes.has_changed().expect("open sender")); + + let parent = folders.create(connection, "Parent", None).await.expect("parent"); + changes.borrow_and_update(); + folders.move_to(a, Some(parent)).await.expect("move"); + assert_eq!(*changes.borrow_and_update(), 4); + assert_eq!( + second_history + .saved_query_folders() + .list(connection) + .await + .expect("committed") + .iter() + .find(|folder| folder.id == a) + .expect("A") + .parent_id, + Some(parent) + ); +} + +#[tokio::test] +async fn a_failed_database_write_emits_no_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = history(&root).await; + let folders = history.saved_query_folders(); + let changes = folders.changes(); + let connection = Uuid::new_v4(); + sqlx::query( + "CREATE TRIGGER reject_folder BEFORE INSERT ON saved_query_folders \ + BEGIN SELECT RAISE(ABORT, 'test failure'); END", + ) + .execute(&folders.pool) + .await + .expect("failure trigger"); + + assert!(matches!( + folders.create(connection, "A", None).await, + Err(StorageError::Database(_)) + )); + assert!(!changes.has_changed().expect("open sender")); + assert!(folders.list(connection).await.expect("list").is_empty()); +} diff --git a/core/crates/storage/src/saved_queries/mod.rs b/core/crates/storage/src/saved_queries/mod.rs index 88dedfd222..d329bcc0ef 100644 --- a/core/crates/storage/src/saved_queries/mod.rs +++ b/core/crates/storage/src/saved_queries/mod.rs @@ -1,4 +1,9 @@ +mod deletion; +mod folders; mod new_saved_query; +mod ordering; +#[cfg(test)] +mod ordering_tests; mod saved_query; use std::sync::Arc; @@ -6,28 +11,41 @@ use std::time::SystemTime; use sqlx::{AssertSqlSafe, Connection, Row, SqlitePool}; use tokio::sync::watch; +use unicode_normalization::UnicodeNormalization; use uuid::Uuid; use crate::error::StorageError; use crate::unix_time::{from_unix, to_unix}; +pub use folders::{SavedQueryFolder, SavedQueryFolders}; pub use new_saved_query::NewSavedQuery; pub use saved_query::SavedQuery; +macro_rules! columns { + () => { + "id, name, query, connection_id, connection_name, keyword, folder_id, sort_order, created_at, updated_at" + }; +} + +const MAX_KEYWORD_CHARS: usize = 64; +const MAX_QUERY_BYTES: usize = 1024 * 1024; +const MAX_NAME_CHARS: usize = 200; + #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SaveOutcome { pub id: i64, pub replaced: bool, } -const MAX_QUERY_BYTES: usize = 1024 * 1024; - -const MAX_NAME_CHARS: usize = 200; +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SavedQueriesSnapshot { + pub queries: Vec, + pub folders: Vec, +} #[derive(Debug, Clone)] pub struct SavedQueries { pool: SqlitePool, - // The database's file, whose upgrade copies a delete reaches too. path: std::path::PathBuf, changes: Arc>, } @@ -47,23 +65,7 @@ impl SavedQueries { } pub async fn save(&self, query: NewSavedQuery) -> Result { - let name = query.name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); - } - if name.chars().count() > MAX_NAME_CHARS { - return Err(StorageError::TooLarge { - got: name.chars().count(), - limit: MAX_NAME_CHARS, - }); - } - if query.query.len() > MAX_QUERY_BYTES { - return Err(StorageError::TooLarge { - got: query.query.len(), - limit: MAX_QUERY_BYTES, - }); - } - let now = to_unix(SystemTime::now()); + let name = checked_query(&query)?; // Hold the write lock across both statements, so concurrent saves agree on which inserted. let mut connection = self.pool.acquire().await?; let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; @@ -74,91 +76,60 @@ impl SavedQueries { .fetch_one(&mut *transaction) .await? > 0; - let id = sqlx::query( - r#" - INSERT INTO saved_queries (name, query, connection_id, connection_name, created_at, updated_at) - VALUES (?, ?, ?, ?, ?, ?) - ON CONFLICT (connection_id, name) DO UPDATE SET - query = excluded.query, - connection_name = excluded.connection_name, - updated_at = excluded.updated_at - RETURNING id - "#, + let now = to_unix(SystemTime::now()); + let id = sqlx::query_scalar( + "INSERT INTO saved_queries (name, query, connection_id, connection_name, sort_order, created_at, updated_at) \ + VALUES (?1, ?2, ?3, ?4, \ + (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_queries WHERE connection_id = ?3 AND folder_id IS NULL), ?5, ?5) \ + ON CONFLICT (connection_id, name) DO UPDATE SET query = excluded.query, \ + connection_name = excluded.connection_name, updated_at = excluded.updated_at RETURNING id", ) - .bind(name) - .bind(&query.query) - .bind(query.connection_id.to_string()) - .bind(&query.connection_name) - .bind(now) - .bind(now) - .fetch_one(&mut *transaction) - .await? - .try_get("id")?; + .bind(name).bind(&query.query).bind(query.connection_id.to_string()) + .bind(&query.connection_name).bind(now) + .fetch_one(&mut *transaction).await?; transaction.commit().await?; self.changed(); Ok(SaveOutcome { id, replaced }) } - // An import never overwrites what the user saved, even when another window saves the same - // name between the import's look and its write. `None` when the name is taken. pub async fn save_if_new(&self, query: NewSavedQuery) -> Result, StorageError> { - let name = query.name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); - } - if name.chars().count() > MAX_NAME_CHARS { - return Err(StorageError::TooLarge { - got: name.chars().count(), - limit: MAX_NAME_CHARS, - }); - } - if query.query.len() > MAX_QUERY_BYTES { - return Err(StorageError::TooLarge { - got: query.query.len(), - limit: MAX_QUERY_BYTES, - }); - } - let now = to_unix(SystemTime::now()); - let inserted = sqlx::query( - r#" - INSERT INTO saved_queries (name, query, connection_id, connection_name, created_at, updated_at) - VALUES (?, ?, ?, ?, ?, ?) - ON CONFLICT (connection_id, name) DO NOTHING - RETURNING id - "#, + let name = checked_query(&query)?; + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let id = sqlx::query_scalar( + "INSERT INTO saved_queries (name, query, connection_id, connection_name, sort_order, created_at, updated_at) \ + VALUES (?1, ?2, ?3, ?4, \ + (SELECT COALESCE(MAX(sort_order) + 1, 0) FROM saved_queries WHERE connection_id = ?3 AND folder_id IS NULL), ?5, ?5) \ + ON CONFLICT (connection_id, name) DO NOTHING RETURNING id", ) - .bind(name) - .bind(&query.query) - .bind(query.connection_id.to_string()) - .bind(&query.connection_name) - .bind(now) - .bind(now) - .fetch_optional(&self.pool) - .await?; - let Some(row) = inserted else { - return Ok(None); - }; - let id = row.try_get("id")?; - self.changed(); - Ok(Some(id)) + .bind(name).bind(&query.query).bind(query.connection_id.to_string()) + .bind(&query.connection_name).bind(to_unix(SystemTime::now())) + .fetch_optional(&mut *transaction).await?; + transaction.commit().await?; + if id.is_some() { + self.changed(); + } + Ok(id) } pub async fn list(&self, connection: Option) -> Result, StorageError> { let rows = match connection { Some(id) => { - sqlx::query( - "SELECT id, name, query, connection_id, connection_name, created_at, updated_at \ - FROM saved_queries WHERE connection_id = ? ORDER BY name COLLATE NOCASE, id", - ) + sqlx::query(concat!( + "SELECT ", + columns!(), + " FROM saved_queries WHERE connection_id = ? ORDER BY name COLLATE NOCASE, id" + )) .bind(id.to_string()) .fetch_all(&self.pool) .await? } None => { - sqlx::query( - "SELECT id, name, query, connection_id, connection_name, created_at, updated_at \ - FROM saved_queries ORDER BY connection_name COLLATE NOCASE, name COLLATE NOCASE, id", - ) + sqlx::query(concat!( + "SELECT ", + columns!(), + " FROM saved_queries ORDER BY connection_name COLLATE NOCASE, name COLLATE NOCASE, id" + )) .fetch_all(&self.pool) .await? } @@ -166,47 +137,213 @@ impl SavedQueries { rows.into_iter().map(row_to_saved_query).collect() } - pub async fn get(&self, id: i64) -> Result, StorageError> { - let row = sqlx::query( - "SELECT id, name, query, connection_id, connection_name, created_at, updated_at \ - FROM saved_queries WHERE id = ?", + pub async fn snapshot(&self, connection: Uuid) -> Result { + let mut transaction = self.pool.begin().await?; + let queries = sqlx::query(concat!( + "SELECT ", + columns!(), + " FROM saved_queries WHERE connection_id = ? ORDER BY sort_order, name COLLATE NOCASE, id" + )) + .bind(connection.to_string()) + .fetch_all(&mut *transaction) + .await? + .into_iter() + .map(row_to_saved_query) + .collect::, _>>()?; + let folders = sqlx::query( + "SELECT id, connection_id, name, parent_id, sort_order, created_at, updated_at \ + FROM saved_query_folders WHERE connection_id = ? ORDER BY sort_order, name COLLATE NOCASE, id", ) - .bind(id) - .fetch_optional(&self.pool) - .await?; - row.map(row_to_saved_query).transpose() + .bind(connection.to_string()) + .fetch_all(&mut *transaction) + .await? + .into_iter() + .map(folders::row_to_folder) + .collect::, _>>()?; + transaction.commit().await?; + Ok(SavedQueriesSnapshot { queries, folders }) + } + + pub async fn get(&self, id: i64) -> Result, StorageError> { + sqlx::query(concat!("SELECT ", columns!(), " FROM saved_queries WHERE id = ?")) + .bind(id) + .fetch_optional(&self.pool) + .await? + .map(row_to_saved_query) + .transpose() } pub async fn rename(&self, id: i64, name: &str) -> Result<(), StorageError> { - let name = name.trim(); - if name.is_empty() { - return Err(StorageError::EmptyName); - } - if name.chars().count() > MAX_NAME_CHARS { - return Err(StorageError::TooLarge { - got: name.chars().count(), - limit: MAX_NAME_CHARS, - }); + let name = checked_name(name)?; + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let previous: Option = sqlx::query_scalar("SELECT name FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await?; + let previous = previous.ok_or(StorageError::NotFound)?; + if previous == name { + return Ok(()); } - let affected = sqlx::query("UPDATE saved_queries SET name = ?, updated_at = ? WHERE id = ?") + sqlx::query("UPDATE saved_queries SET name = ?, updated_at = ? WHERE id = ?") .bind(name) .bind(to_unix(SystemTime::now())) .bind(id) - .execute(&self.pool) + .execute(&mut *transaction) .await .map_err(|error| match &error { sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::NameTaken, _ => StorageError::Database(error), - })? - .rows_affected(); - if affected == 0 { - return Err(StorageError::NotFound); + })?; + transaction.commit().await?; + self.changed(); + Ok(()) + } + + pub async fn set_keyword(&self, id: i64, keyword: Option<&str>) -> Result<(), StorageError> { + let keyword: Option = keyword + .map(str::trim) + .filter(|word| !word.is_empty()) + .map(|word| word.nfc().collect()); + if let Some(word) = &keyword + && (word.chars().count() > MAX_KEYWORD_CHARS + || word.chars().any(|c| { + c.is_whitespace() || c.is_control() || tablepro_core::unicode_blank::is_default_ignorable(c) + })) + { + return Err(StorageError::KeywordInvalid { max: MAX_KEYWORD_CHARS }); + } + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, keyword FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + let owner: String = row.try_get("connection_id")?; + if row.try_get::, _>("keyword")? == keyword { + return Ok(()); + } + if let Some(word) = &keyword { + let held: Vec = sqlx::query_scalar( + "SELECT keyword FROM saved_queries WHERE connection_id = ? AND id <> ? AND keyword IS NOT NULL", + ) + .bind(owner) + .bind(id) + .fetch_all(&mut *transaction) + .await?; + let key = word.to_lowercase(); + if held + .iter() + .any(|held| held.nfc().collect::().to_lowercase() == key) + { + return Err(StorageError::KeywordTaken); + } + } + sqlx::query("UPDATE saved_queries SET keyword = ?, updated_at = ? WHERE id = ?") + .bind(keyword) + .bind(to_unix(SystemTime::now())) + .bind(id) + .execute(&mut *transaction) + .await + .map_err(|error| match &error { + sqlx::Error::Database(database) if database.is_unique_violation() => StorageError::KeywordTaken, + _ => StorageError::Database(error), + })?; + transaction.commit().await?; + self.changed(); + Ok(()) + } + + pub async fn set_folder(&self, id: i64, folder: Option) -> Result<(), StorageError> { + self.move_query(id, folder, None, true).await + } + + pub async fn move_to_folder(&self, id: i64, folder: Option, before: Option) -> Result<(), StorageError> { + self.move_query(id, folder, before, false).await + } + + async fn move_query( + &self, + id: i64, + folder: Option, + before: Option, + keep_position: bool, + ) -> Result<(), StorageError> { + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, folder_id FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; + let owner: String = row.try_get("connection_id")?; + let old_folder: Option = row.try_get("folder_id")?; + if let Some(folder) = folder { + let target: Option = + sqlx::query_scalar("SELECT connection_id FROM saved_query_folders WHERE id = ?") + .bind(folder) + .fetch_optional(&mut *transaction) + .await?; + if target.as_deref() != Some(owner.as_str()) { + return Err(StorageError::NotFound); + } + } + if keep_position && old_folder == folder { + transaction.commit().await?; + return Ok(()); + } + if before == Some(id) { + return if old_folder == folder { + Ok(()) + } else { + Err(StorageError::NotFound) + }; + } + let mut place: Vec = sqlx::query_scalar( + "SELECT id FROM saved_queries WHERE connection_id = ? AND folder_id IS ? \ + ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(&owner) + .bind(folder) + .fetch_all(&mut *transaction) + .await?; + let original = place.clone(); + place.retain(|held| *held != id); + let at = match before { + Some(before) => place + .iter() + .position(|held| *held == before) + .ok_or(StorageError::NotFound)?, + None => place.len(), + }; + place.insert(at, id); + if old_folder == folder && place == original { + return Ok(()); + } + sqlx::query("UPDATE saved_queries SET folder_id = ?, updated_at = ? WHERE id = ?") + .bind(folder) + .bind(to_unix(SystemTime::now())) + .bind(id) + .execute(&mut *transaction) + .await?; + ordering::set_query_order(&mut transaction, &place).await?; + if old_folder != folder { + ordering::compact_queries(&mut transaction, &owner, old_folder).await?; } + transaction.commit().await?; self.changed(); Ok(()) } pub async fn delete(&self, id: i64) -> Result<(), StorageError> { + let mut connection = self.pool.acquire().await?; + let mut transaction = connection.begin_with(AssertSqlSafe("BEGIN IMMEDIATE")).await?; + let row = sqlx::query("SELECT connection_id, folder_id FROM saved_queries WHERE id = ?") + .bind(id) + .fetch_optional(&mut *transaction) + .await? + .ok_or(StorageError::NotFound)?; crate::query_history::trim_upgrade_copies( &self.path, &[crate::query_history::CopyDelete { @@ -216,48 +353,66 @@ impl SavedQueries { }], ) .await?; - let affected = sqlx::query("DELETE FROM saved_queries WHERE id = ?") + sqlx::query("DELETE FROM saved_queries WHERE id = ?") .bind(id) - .execute(&self.pool) - .await? - .rows_affected(); - if affected == 0 { - return Err(StorageError::NotFound); - } + .execute(&mut *transaction) + .await?; + ordering::compact_queries( + &mut transaction, + &row.try_get::("connection_id")?, + row.try_get("folder_id")?, + ) + .await?; + transaction.commit().await?; self.changed(); Ok(()) } pub async fn delete_for_connection(&self, connection: Uuid) -> Result { - crate::query_history::trim_upgrade_copies( - &self.path, - &[crate::query_history::CopyDelete { - table: "saved_queries", - sql: "DELETE FROM main.saved_queries WHERE connection_id = ?".to_owned(), - binds: vec![crate::query_history::Bind::Text(connection.to_string())], - }], - ) - .await?; - let affected = sqlx::query("DELETE FROM saved_queries WHERE connection_id = ?") - .bind(connection.to_string()) - .execute(&self.pool) - .await? - .rows_affected(); - if affected > 0 { + let (queries, changed) = deletion::delete_connection(&self.pool, &self.path, connection).await?; + if changed { self.changed(); } - Ok(affected as usize) + Ok(queries) } } +fn checked_name(name: &str) -> Result<&str, StorageError> { + let name = name.trim(); + if name.is_empty() { + return Err(StorageError::EmptyName); + } + if name.chars().count() > MAX_NAME_CHARS { + return Err(StorageError::TooLarge { + got: name.chars().count(), + limit: MAX_NAME_CHARS, + }); + } + Ok(name) +} + +fn checked_query(query: &NewSavedQuery) -> Result<&str, StorageError> { + let name = checked_name(&query.name)?; + if query.query.len() > MAX_QUERY_BYTES { + return Err(StorageError::TooLarge { + got: query.query.len(), + limit: MAX_QUERY_BYTES, + }); + } + Ok(name) +} + fn row_to_saved_query(row: sqlx::sqlite::SqliteRow) -> Result { let connection_id: String = row.try_get("connection_id")?; Ok(SavedQuery { id: row.try_get("id")?, name: row.try_get("name")?, query: row.try_get("query")?, - connection_id: Uuid::parse_str(&connection_id).unwrap_or_default(), + connection_id: Uuid::parse_str(&connection_id).map_err(|error| StorageError::Schema(error.to_string()))?, connection_name: row.try_get("connection_name")?, + keyword: row.try_get("keyword")?, + folder_id: row.try_get("folder_id")?, + order: row.try_get("sort_order")?, created_at: from_unix(row.try_get::("created_at")?), updated_at: from_unix(row.try_get::("updated_at")?), }) @@ -302,6 +457,172 @@ mod tests { assert_eq!(saved.connection_name, "local"); } + #[tokio::test] + async fn a_keyword_is_one_word_unique_to_the_connection_in_any_case() { + let root = tempfile::tempdir().expect("tempdir"); + let store = store(&root).await; + let connection = Uuid::new_v4(); + let first = store + .save(new_query("a", "SELECT 1", connection)) + .await + .expect("save") + .id; + let second = store + .save(new_query("b", "SELECT 2", connection)) + .await + .expect("save") + .id; + let elsewhere = store + .save(new_query("c", "SELECT 3", Uuid::new_v4())) + .await + .expect("save") + .id; + + store.set_keyword(first, Some(" Daily ")).await.expect("a keyword"); + assert_eq!( + store + .get(first) + .await + .expect("get") + .expect("the query") + .keyword + .as_deref(), + Some("Daily") + ); + assert!(matches!( + store.set_keyword(second, Some("daily")).await, + Err(StorageError::KeywordTaken) + )); + assert!(matches!( + store.set_keyword(second, Some("two words")).await, + Err(StorageError::KeywordInvalid { .. }) + )); + store + .set_keyword(elsewhere, Some("daily")) + .await + .expect("another connection may reuse it"); + + store + .set_keyword(first, Some(" ")) + .await + .expect("a blank keyword clears"); + assert_eq!(store.get(first).await.expect("get").expect("the query").keyword, None); + store + .set_keyword(second, Some("daily")) + .await + .expect("the keyword is free again"); + } + + #[tokio::test] + async fn queries_are_filed_in_folders_that_nest_and_go_with_their_parent() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro")) + .await + .expect("open"); + let (store, folders) = (history.saved_queries(), history.saved_query_folders()); + let connection = Uuid::new_v4(); + let reports = folders.create(connection, "Reports", None).await.expect("a folder"); + let monthly = folders + .create(connection, "Monthly", Some(reports)) + .await + .expect("a subfolder"); + let a = store + .save(new_query("a", "SELECT 1", connection)) + .await + .expect("save") + .id; + let b = store + .save(new_query("b", "SELECT 2", connection)) + .await + .expect("save") + .id; + + store.move_to_folder(a, Some(monthly), None).await.expect("file a"); + store + .move_to_folder(b, Some(monthly), Some(a)) + .await + .expect("file b before a"); + async fn placed(store: &SavedQueries, id: i64) -> (Option, i64) { + let query = store.get(id).await.expect("get").expect("the query"); + (query.folder_id, query.order) + } + assert_eq!(placed(&store, b).await, (Some(monthly), 0)); + assert_eq!(placed(&store, a).await, (Some(monthly), 1)); + + assert!(matches!( + folders.create(connection, "REPORTS", None).await, + Err(StorageError::FolderNameTaken) + )); + assert!(matches!( + folders.move_to(reports, Some(monthly)).await, + Err(StorageError::FolderCycle { .. }) + )); + let other = folders + .create(Uuid::new_v4(), "Elsewhere", None) + .await + .expect("another connection's"); + assert!(matches!( + store.move_to_folder(a, Some(other), None).await, + Err(StorageError::NotFound) + )); + + folders.delete(reports).await.expect("delete the folder"); + assert!( + folders.list(connection).await.expect("list").is_empty(), + "a subfolder outlived its parent" + ); + assert_eq!(placed(&store, a).await.0, None, "a query went with its folder"); + } + + #[tokio::test] + async fn favourite_tables_and_databases_are_kept_per_connection_and_go_with_it() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro")) + .await + .expect("open"); + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let orders = crate::favourites::FavouriteTable { + connection_id: connection, + database: None, + schema: Some("public".to_owned()), + name: "orders".to_owned(), + }; + + favourites.add_table(&orders).await.expect("mark a table"); + favourites + .add_table(&orders) + .await + .expect("marking it again changes nothing"); + favourites + .set_database(connection, "shop", crate::favourites::DatabaseEnvironment::Testing) + .await + .expect("mark a database"); + favourites + .set_database(connection, "shop", crate::favourites::DatabaseEnvironment::Production) + .await + .expect("change its environment"); + + assert_eq!( + favourites.tables(connection).await.expect("tables"), + std::slice::from_ref(&orders) + ); + let databases = favourites.databases(connection).await.expect("databases"); + assert_eq!(databases.len(), 1); + assert_eq!( + databases[0].environment, + crate::favourites::DatabaseEnvironment::Production + ); + + store(&root) + .await + .delete_for_connection(connection) + .await + .expect("remove the connection's data"); + assert!(favourites.tables(connection).await.expect("tables").is_empty()); + assert!(favourites.databases(connection).await.expect("databases").is_empty()); + } + #[tokio::test] async fn saving_if_new_leaves_a_held_name_alone() { let root = tempfile::tempdir().expect("tempdir"); diff --git a/core/crates/storage/src/saved_queries/ordering.rs b/core/crates/storage/src/saved_queries/ordering.rs new file mode 100644 index 0000000000..3f8c114dea --- /dev/null +++ b/core/crates/storage/src/saved_queries/ordering.rs @@ -0,0 +1,53 @@ +use sqlx::SqliteConnection; + +use crate::StorageError; + +pub(super) async fn set_query_order(database: &mut SqliteConnection, ids: &[i64]) -> Result<(), StorageError> { + for (order, id) in ids.iter().enumerate() { + sqlx::query("UPDATE saved_queries SET sort_order = ? WHERE id = ?") + .bind(order as i64) + .bind(id) + .execute(&mut *database) + .await?; + } + Ok(()) +} + +pub(super) async fn compact_queries( + database: &mut SqliteConnection, + connection: &str, + folder: Option, +) -> Result<(), StorageError> { + let ids = sqlx::query_scalar( + "SELECT id FROM saved_queries WHERE connection_id = ? AND folder_id IS ? \ + ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(connection) + .bind(folder) + .fetch_all(&mut *database) + .await?; + set_query_order(database, &ids).await +} + +pub(super) async fn compact_folders( + database: &mut SqliteConnection, + connection: &str, + parent: Option, +) -> Result<(), StorageError> { + let ids: Vec = sqlx::query_scalar( + "SELECT id FROM saved_query_folders WHERE connection_id = ? AND parent_id IS ? \ + ORDER BY sort_order, name COLLATE NOCASE, id", + ) + .bind(connection) + .bind(parent) + .fetch_all(&mut *database) + .await?; + for (order, id) in ids.into_iter().enumerate() { + sqlx::query("UPDATE saved_query_folders SET sort_order = ? WHERE id = ?") + .bind(order as i64) + .bind(id) + .execute(&mut *database) + .await?; + } + Ok(()) +} diff --git a/core/crates/storage/src/saved_queries/ordering_tests.rs b/core/crates/storage/src/saved_queries/ordering_tests.rs new file mode 100644 index 0000000000..460a733c5e --- /dev/null +++ b/core/crates/storage/src/saved_queries/ordering_tests.rs @@ -0,0 +1,321 @@ +use super::*; +use crate::{DatabaseEnvironment, FavouriteTable, QueryHistory, StoragePaths}; + +fn paths(root: &tempfile::TempDir) -> StoragePaths { + StoragePaths::under(root.path(), "tablepro", "app.tablepro.TablePro") +} + +fn query(connection: Uuid, name: &str) -> NewSavedQuery { + NewSavedQuery { + name: name.to_owned(), + query: format!("SELECT '{name}'"), + connection_id: connection, + connection_name: "local".to_owned(), + } +} + +async fn save(store: &SavedQueries, connection: Uuid, name: &str) -> i64 { + store.save(query(connection, name)).await.expect("save").id +} + +async fn order(store: &SavedQueries, connection: Uuid, folder: Option) -> Vec { + let mut rows = store.list(Some(connection)).await.expect("list"); + rows.retain(|row| row.folder_id == folder); + rows.sort_by_key(|row| row.order); + assert_eq!( + rows.iter().map(|row| row.order).collect::>(), + (0..i64::try_from(rows.len()).expect("row count")).collect::>() + ); + rows.into_iter().map(|row| row.id).collect() +} + +#[tokio::test] +async fn new_saves_append_and_replacement_keeps_identity_and_filing() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let z = save(&store, connection, "z").await; + let a = store + .save_if_new(query(connection, "a")) + .await + .expect("import") + .expect("inserted"); + let m = save(&store, connection, "m").await; + assert_eq!(order(&store, connection, None).await, [z, a, m]); + assert_eq!( + store.save_if_new(query(connection, "a")).await.expect("repeat import"), + None + ); + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + store.move_to_folder(a, Some(folder), None).await.expect("file"); + store.set_keyword(a, Some("daily")).await.expect("keyword"); + let before = store.get(a).await.expect("get").expect("query"); + let mut replacement = query(connection, "a"); + replacement.query = "SELECT 42".to_owned(); + replacement.connection_name = "renamed connection".to_owned(); + let replaced = store.save(replacement).await.expect("replace"); + assert_eq!(replaced, SaveOutcome { id: a, replaced: true }); + let after = store.get(a).await.expect("get").expect("query"); + assert_eq!( + (after.id, after.keyword, after.folder_id, after.order, after.created_at), + ( + before.id, + before.keyword, + before.folder_id, + before.order, + before.created_at + ) + ); + assert_eq!(after.query, "SELECT 42"); + assert_eq!(after.connection_name, "renamed connection"); + let b = save(&store, connection, "b").await; + assert_eq!(order(&store, connection, None).await, [z, m, b]); + assert_eq!(order(&store, connection, Some(folder)).await, [a]); +} + +#[tokio::test] +async fn moving_and_deleting_queries_compacts_only_their_connection_and_place() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let other = Uuid::new_v4(); + let other_z = save(&store, other, "z").await; + let other_a = save(&store, other, "a").await; + let a = save(&store, connection, "a").await; + let b = save(&store, connection, "b").await; + let c = save(&store, connection, "c").await; + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + store.move_to_folder(b, Some(folder), None).await.expect("file b"); + assert_eq!(order(&store, connection, None).await, [a, c]); + store + .move_to_folder(c, Some(folder), Some(b)) + .await + .expect("file c before b"); + assert_eq!(order(&store, connection, Some(folder)).await, [c, b]); + store.move_to_folder(c, None, Some(a)).await.expect("move c to root"); + assert_eq!(order(&store, connection, None).await, [c, a]); + assert_eq!(order(&store, connection, Some(folder)).await, [b]); + assert_eq!(order(&store, other, None).await, [other_z, other_a]); + store.delete(c).await.expect("delete c"); + assert_eq!(order(&store, connection, None).await, [a]); + assert_eq!(order(&store, other, None).await, [other_z, other_a]); +} + +#[tokio::test] +async fn invalid_destinations_and_self_before_leave_rows_and_revisions_alone() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let a = save(&store, connection, "a").await; + let b = save(&store, connection, "b").await; + let other = save(&store, Uuid::new_v4(), "other").await; + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + let before = store.snapshot(connection).await.expect("snapshot"); + let changes = store.changes(); + store.move_to_folder(a, None, Some(a)).await.expect("self-before no-op"); + store.move_to_folder(b, None, None).await.expect("already last"); + for (destination, before) in [(None, other), (Some(folder), a), (None, i64::MAX)] { + assert!(matches!( + store.move_to_folder(a, destination, Some(before)).await, + Err(StorageError::NotFound) + )); + } + assert!(!changes.has_changed().expect("no revision")); + assert_eq!(store.snapshot(connection).await.expect("snapshot"), before); +} + +#[tokio::test] +async fn unicode_keywords_share_one_key_even_when_separate_handles_write_together() { + let root = tempfile::tempdir().expect("tempdir"); + let first = QueryHistory::open(&paths(&root)).await.expect("first handle"); + let second = QueryHistory::open(&paths(&root)).await.expect("second handle"); + let first = first.saved_queries(); + let second = second.saved_queries(); + let connection = Uuid::new_v4(); + let a = save(&first, connection, "a").await; + let b = save(&first, connection, "b").await; + let (left, right) = tokio::join!( + first.set_keyword(a, Some("État")), + second.set_keyword(b, Some("e\u{301}tat")) + ); + assert!(matches!( + (&left, &right), + (Ok(()), Err(StorageError::KeywordTaken)) | (Err(StorageError::KeywordTaken), Ok(())) + )); + let held = first.list(Some(connection)).await.expect("list"); + assert_eq!(held.iter().filter(|row| row.keyword.is_some()).count(), 1); + first.set_keyword(a, None).await.expect("clear"); + second.set_keyword(b, None).await.expect("clear"); + first.set_keyword(a, Some("e\u{301}tat")).await.expect("canonicalize"); + assert_eq!( + first.get(a).await.expect("get").expect("query").keyword.as_deref(), + Some("état") + ); + assert!(matches!( + second.set_keyword(b, Some("ÉTAT")).await, + Err(StorageError::KeywordTaken) + )); + let other = save(&second, Uuid::new_v4(), "other").await; + second.set_keyword(other, Some("ÉTAT")).await.expect("other connection"); +} + +#[tokio::test] +async fn snapshots_never_return_a_query_whose_folder_was_read_from_another_generation() { + let root = tempfile::tempdir().expect("tempdir"); + let writer = QueryHistory::open(&paths(&root)).await.expect("writer"); + let reader = QueryHistory::open(&paths(&root)).await.expect("reader"); + let connection = Uuid::new_v4(); + let id = save(&writer.saved_queries(), connection, "report").await; + let change = async { + for index in 0..40 { + let folder = writer + .saved_query_folders() + .create(connection, &format!("Folder {index}"), None) + .await + .expect("create"); + writer + .saved_queries() + .move_to_folder(id, Some(folder), None) + .await + .expect("file"); + writer.saved_query_folders().delete(folder).await.expect("delete"); + } + }; + let read = async { + for _ in 0..160 { + let snapshot = reader.saved_queries().snapshot(connection).await.expect("snapshot"); + assert_eq!(snapshot.queries.len(), 1); + for query in snapshot.queries { + assert!( + query + .folder_id + .is_none_or(|id| snapshot.folders.iter().any(|folder| folder.id == id)) + ); + } + } + }; + tokio::join!(change, read); +} + +#[tokio::test] +async fn mutation_notifications_are_shared_and_follow_successful_changes() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let id = save(&store, connection, "report").await; + let mut changes = store.changes(); + let mut folders_changed = history.saved_query_folders().changes(); + let mut catalog_changed = history.favourites().changes(); + store.set_keyword(id, Some("daily")).await.expect("keyword"); + assert!(changes.has_changed().expect("revision")); + assert!(folders_changed.has_changed().expect("shared revision")); + assert!(catalog_changed.has_changed().expect("shared revision")); + changes.borrow_and_update(); + folders_changed.borrow_and_update(); + catalog_changed.borrow_and_update(); + store.set_keyword(id, Some("daily")).await.expect("same keyword"); + store.rename(id, "report").await.expect("same name"); + assert_eq!( + store + .save_if_new(query(connection, "report")) + .await + .expect("same import"), + None + ); + assert!(matches!( + store.set_keyword(id, Some("two words")).await, + Err(StorageError::KeywordInvalid { .. }) + )); + assert!(!changes.has_changed().expect("no revision")); + assert!(!folders_changed.has_changed().expect("no shared revision")); + assert!(!catalog_changed.has_changed().expect("no shared revision")); +} + +#[tokio::test] +async fn a_failed_connection_purge_preserves_every_kind_of_favorite_and_its_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let folders = history.saved_query_folders(); + let favourites = history.favourites(); + let connection = Uuid::new_v4(); + let id = save(&store, connection, "report").await; + let folder = folders.create(connection, "Reports", None).await.expect("folder"); + store.move_to_folder(id, Some(folder), None).await.expect("file"); + let table = FavouriteTable { + connection_id: connection, + database: None, + schema: None, + name: "orders".to_owned(), + }; + favourites.add_table(&table).await.expect("table"); + favourites + .set_database(connection, "shop", DatabaseEnvironment::Production) + .await + .expect("database"); + let before = store.snapshot(connection).await.expect("snapshot"); + sqlx::query( + "CREATE TRIGGER reject_purge BEFORE DELETE ON favourite_databases BEGIN SELECT RAISE(ABORT, 'denied'); END", + ) + .execute(&store.pool) + .await + .expect("install failure"); + let changes = store.changes(); + assert!(store.delete_for_connection(connection).await.is_err()); + assert_eq!(store.snapshot(connection).await.expect("snapshot"), before); + assert_eq!(favourites.tables(connection).await.expect("tables"), vec![table]); + assert_eq!(favourites.databases(connection).await.expect("databases").len(), 1); + assert!(!changes.has_changed().expect("no revision")); + sqlx::query("DROP TRIGGER reject_purge") + .execute(&store.pool) + .await + .expect("remove failure"); + assert_eq!(store.delete_for_connection(connection).await.expect("purge"), 1); + assert!(changes.has_changed().expect("revision")); + let after = store.snapshot(connection).await.expect("snapshot"); + assert!(after.queries.is_empty()); + assert!(after.folders.is_empty()); + assert!(favourites.tables(connection).await.expect("tables").is_empty()); + assert!(favourites.databases(connection).await.expect("databases").is_empty()); +} + +#[tokio::test] +async fn assigning_the_same_folder_preserves_position_and_revision() { + let root = tempfile::tempdir().expect("tempdir"); + let history = QueryHistory::open(&paths(&root)).await.expect("open"); + let store = history.saved_queries(); + let connection = Uuid::new_v4(); + let a = save(&store, connection, "a").await; + let b = save(&store, connection, "b").await; + let folder = history + .saved_query_folders() + .create(connection, "Reports", None) + .await + .expect("folder"); + store.set_folder(a, Some(folder)).await.expect("file a"); + store.set_folder(b, Some(folder)).await.expect("file b"); + let changes = store.changes(); + store.set_folder(a, Some(folder)).await.expect("same folder"); + assert_eq!(order(&store, connection, Some(folder)).await, [a, b]); + assert!(!changes.has_changed().expect("no revision")); + store.set_folder(a, None).await.expect("move to root"); + assert_eq!(order(&store, connection, None).await, [a]); + assert_eq!(order(&store, connection, Some(folder)).await, [b]); + assert!(changes.has_changed().expect("revision")); +} diff --git a/core/crates/storage/src/saved_queries/saved_query.rs b/core/crates/storage/src/saved_queries/saved_query.rs index 643175d098..32c6f34d7e 100644 --- a/core/crates/storage/src/saved_queries/saved_query.rs +++ b/core/crates/storage/src/saved_queries/saved_query.rs @@ -2,25 +2,21 @@ use std::time::SystemTime; use uuid::Uuid; -/// One query the user named and kept. #[derive(Debug, Clone, PartialEq, Eq)] pub struct SavedQuery { pub id: i64, pub name: String, pub query: String, - /// The connection it was saved against. A saved query is written - /// for one database's schema, so it is listed under that - /// connection rather than offered everywhere. pub connection_id: Uuid, - /// The connection's name as of the last save, which is what the - /// list shows when the connection itself is gone. pub connection_name: String, + pub keyword: Option, + pub folder_id: Option, + pub order: i64, pub created_at: SystemTime, pub updated_at: SystemTime, } impl SavedQuery { - /// The first non-empty line, for a list row's subtitle. pub fn summary(&self) -> &str { self.query .lines() @@ -41,6 +37,9 @@ mod tests { query: query.to_owned(), connection_id: Uuid::nil(), connection_name: "local".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, } diff --git a/core/docs/decisions/0017-favourites.md b/core/docs/decisions/0017-favourites.md new file mode 100644 index 0000000000..b771612102 --- /dev/null +++ b/core/docs/decisions/0017-favourites.md @@ -0,0 +1,37 @@ +# 0017: Favourites keep folders and keywords on saved queries, and the tables and databases a user marks + +- **Status**: Accepted +- **Date**: 2026-11-08 + +## Context + +The macOS sidebar has a Favorites scope next to Tables. It lists SQL favorites in folders, each with a name, a query and an optional keyword that expands in the editor, and the tables and databases the user marked, with each database filed under an environment (`SQLFavorite`, `SQLFavoriteFolder`, `FavoriteTablesStorage.FavoriteEntry`, `FavoriteDatabaseEntry`). The core keeps one half of this: `tablepro-storage` has saved queries, a name and a query per connection, in the query history's SQLite database. The Linux sidebar lists them, flat (linux PRs on the Favorites scope). Windows and the macOS app's move to the core ([0010](0010-macos-on-the-core.md)) need the rest, so it belongs in the core and not in one app. + +## Decision + +The folders, the keywords, the order and the marked tables and databases live in the history's database, introduced by `20261108000000_favourites.sql`, with positions initialized by `20261109000000_favourites_order.sql`, and reached through `QueryHistory::saved_queries`, `saved_query_folders` and `favourites`. + +## Rationale + +- **The same database.** Saved queries already live there, so a folder or a keyword is a column or a table beside them, in one transaction and one migration chain, and `delete_for_connection` removes all of a connection's favourites in one call. +- **Integer ids, not UUIDs.** A folder is a row of `saved_query_folders` with an `INTEGER` key, as a saved query has. macOS's UUID ids are not kept; a later importer maps them by name and place, as [0006](0006-connection-library.md) does for groups. +- **A folder is per connection**, with a parent id. New or renamed siblings cannot share a name after NFC normalization and Unicode lowercasing. Validation runs under the SQLite write lock, including across separately opened handles. Deleting a folder deletes the folders in it and leaves their queries at the top, as deleting a group does ([0006](0006-connection-library.md)). A folder never moves inside itself. +- **A keyword is one word**, at most 64 characters with no whitespace, unique among a connection's queries after NFC normalization and Unicode lowercasing, as macOS's unique index on keyword and connection. Folders nest without a depth limit, as on macOS. +- **Order is a number per place**, dense from 0 within each connection and parent. Inserts append, moves compact both places, and deletion compacts the old place. Replacing a saved query preserves its identity and metadata. `set_folder` preserves the position when the destination is unchanged; `move_to_folder` also permits an explicit reorder. Both decide under the write lock. +- **A favourite table is keyed by connection, database, schema and name**, the empty string standing for none so the key is never `NULL`. A favourite database carries one of four environments, the four macOS buckets, in a column with a check. +- **Errors are `StorageError` variants with stable codes**: `storage.keyword_taken`, `keyword_invalid`, `folder_name_taken`, `folder_name_invalid` and `folder_cycle`, with `not_found` and `empty_name` as before. + +## Consequences + +- A database an earlier build wrote is copied beside itself before the migration ([0012](0012-copies-before-a-format-upgrade.md)); a build before this one refuses it, as it refuses any newer one. A copy made from the older format holds none of the new tables, but one a later migration makes holds them, so deleting a folder, a favourite or a connection's data trims the copies as a saved query's delete does, and the copies' sweep covers folders by id. +- Writes acquire `BEGIN IMMEDIATE` before reading or validating. Queries, folders and catalog favorites share one revision feed from `QueryHistory`; only committed changes publish a revision. `SavedQueries::snapshot` reads queries and folders in one transaction. A connection purge commits all four tables together. +- Folder deletion removes the live subtree leaf first, without a nesting limit, and appends its queries after existing root queries. Upgrade copies remove those same folder IDs. Before trimming, a copy refreshes surviving folder names and placement from the live database, adding any missing ancestors. Query IDs and SQL remain unchanged. The dedicated copy connection disables foreign keys while replacing its folder graph, repairs query references, and validates them before committing. Every trim holds the live write lock so concurrent trims cannot restore a pending deletion. +- `SavedQuery` gains `keyword`, `folder_id` and `order`. `NewSavedQuery` is unchanged: a save keeps the keyword and the place of the query it replaces. +- Not here: the macOS team library, linked folders and per-file favourites, which stay outside the core, and the FFI surface, which a later change adds when Windows or macOS shows favourites. +- The Linux sidebar shows the folders, the keyword expansion and the marked tables and databases in later changes, each its own pull request. + +## Alternatives considered + +- **A JSON document, as the connection library.** Saved queries are in SQLite already, so folders in a file would split one list across two stores and two writers. +- **UUID ids to match macOS.** A second key beside the row id, and an id nothing here joins on. +- **A keyword unique across connections.** macOS scopes it to the connection, since a saved query is written for one database's schema. diff --git a/core/docs/decisions/README.md b/core/docs/decisions/README.md index 202c9f2576..cc8675ce3a 100644 --- a/core/docs/decisions/README.md +++ b/core/docs/decisions/README.md @@ -24,3 +24,4 @@ The format, the statuses and how a later ADR changes an earlier one follow [the | [0014](0014-tls-mode-of-a-new-connection.md) | A new connection starts on the TLS mode the engine's own client starts on | Accepted | `TlsMode::Prefer` for PostgreSQL and MySQL, Verify full for SQL Server, Disable for the engines that decide TLS by the port, with a DNS seed list and ClickHouse's HTTPS ports on Verify full; the core holds the rule, and every TLS failure a mode change fixes offers Change Encryption. | | [0015](0015-editing-a-query-result.md) | A query result edits when its statement reads one table and its driver traces the columns | Accepted | The parser accepts one row-preserving SELECT over one table; each driver sets `ResultColumn::origin` only for a direct column of a permanent base table, from the wire or a lookup on its own connection; the result maps to the catalog with its full primary key and saves through `plan_save`. | | [0016](0016-tablepro-accounts.md) | TablePro accounts live in the core, with features gated by the entitlement | Accepted | `tablepro-account` signs in through the browser with OAuth and a loopback redirect, registers the device, verifies the Ed25519 entitlement and gates features by its codes; each app passes its keyring, browser, machine ID and OAuth client in. | +| [0017](0017-favourites.md) | Favourites keep folders and keywords on saved queries, and the tables and databases a user marks | Accepted | One migration in the history's database adds per-connection folders that nest, a keyword and an order on saved queries, and favourite tables and databases with the four macOS environments; stable error codes, no UUID ids, and a database an older build wrote is copied first. | diff --git a/linux/changelog.d/4116.changed.md b/linux/changelog.d/4116.changed.md new file mode 100644 index 0000000000..8aa273b74a --- /dev/null +++ b/linux/changelog.d/4116.changed.md @@ -0,0 +1 @@ +Saved queries keep their folder, keyword, and order when replaced. diff --git a/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs b/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs index 05d48a4de6..806b6de367 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/saved_query_listing.rs @@ -83,6 +83,9 @@ mod tests { query: query.to_owned(), connection_id, connection_name: connection.to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, } diff --git a/linux/crates/app/src/ui/saved_queries_dialog/tests.rs b/linux/crates/app/src/ui/saved_queries_dialog/tests.rs index b883ce1e01..4813fa128e 100644 --- a/linux/crates/app/src/ui/saved_queries_dialog/tests.rs +++ b/linux/crates/app/src/ui/saved_queries_dialog/tests.rs @@ -304,6 +304,9 @@ fn a_row_shows_its_name_and_summary_as_written() { query: "\n SELECT 1 & 2\nFROM t".to_owned(), connection_id: Uuid::nil(), connection_name: "local".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, }; diff --git a/linux/crates/app/src/ui/workspace/mod.rs b/linux/crates/app/src/ui/workspace/mod.rs index 97905d18c9..1546b9b017 100644 --- a/linux/crates/app/src/ui/workspace/mod.rs +++ b/linux/crates/app/src/ui/workspace/mod.rs @@ -1330,10 +1330,6 @@ impl WorkspaceModel { } } - #[expect( - clippy::too_many_lines, - reason = "Each workspace input dispatches to its own handler" - )] fn update(&mut self, msg: WorkspaceInput) { match msg { WorkspaceInput::HealthChanged(health) => self.refresh_health_banner(&health), diff --git a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs index 6f7c41dbdf..261836a237 100644 --- a/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs +++ b/linux/crates/app/src/ui/workspace/sidebar/favorites_pane.rs @@ -228,6 +228,9 @@ mod tests { query: "SELECT 1".to_owned(), connection_id: Uuid::nil(), connection_name: "Database".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: SystemTime::UNIX_EPOCH, updated_at: SystemTime::UNIX_EPOCH, } diff --git a/linux/crates/app/src/ui/workspace/workspace_shell.rs b/linux/crates/app/src/ui/workspace/workspace_shell.rs index 0909c2ac0c..19305c1c3a 100644 --- a/linux/crates/app/src/ui/workspace/workspace_shell.rs +++ b/linux/crates/app/src/ui/workspace/workspace_shell.rs @@ -957,6 +957,9 @@ mod tests { query: "SELECT 1".to_owned(), connection_id: connection, connection_name: "Database".to_owned(), + keyword: None, + folder_id: None, + order: 0, created_at: std::time::SystemTime::UNIX_EPOCH, updated_at: std::time::SystemTime::UNIX_EPOCH, }; diff --git a/linux/docs/storage.md b/linux/docs/storage.md index 3c9ab1f113..5e3d780028 100644 --- a/linux/docs/storage.md +++ b/linux/docs/storage.md @@ -10,7 +10,7 @@ The app's data goes to the store its shape calls for. The core's `storage` crate | The account's device ID and last entitlement, or an imported offline file | JSON file | `tablepro-account` ([core ADR 0016](../../core/docs/decisions/0016-tablepro-accounts.md), [ADR 0038](decisions/0038-account-page-and-license-ask.md)) | | The usage data's anonymous ID and what it sent once | JSON file | `Telemetry` in the app crate ([ADR 0039](decisions/0039-usage-data.md)) | | Preferences and window geometry | `gio::Settings` | `AppSettings` | -| Query history and saved queries | SQLite, one database | `QueryHistory`, `SavedQueries` | +| Query history, saved queries with their folders and keywords, and favourite tables and databases | SQLite, one database ([core ADR 0017](../../core/docs/decisions/0017-favourites.md)) | `QueryHistory`, `SavedQueries`, `SavedQueryFolders`, `Favourites` | | Editor tab text | one file per tab | `DraftStore` | | Open tabs, open sessions, column layouts, filters | JSON files the app crate writes | `WorkspaceStore`, `OpenSessions`, `crates/app/src/persistence/` | @@ -192,7 +192,8 @@ at compile time with `sqlx::migrate!` and run by `QueryHistory::open`. `20260914000000_create_history.sql` creates the `history` table with `query_folded`, the trigram index `history_search` over it, `history_page_idx` on `(pinned DESC, executed_at DESC, id DESC)` for -paging, and the `saved_queries` table. +paging, and the `saved_queries` table. Favorites metadata, ordering, coherent reads +and mutation notifications follow [core ADR 0017](../../core/docs/decisions/0017-favourites.md). **An applied migration is never edited.** Each change is a new timestamped file with its own fixture test. Editing one in place changes its checksum,