Struct SqliteStore 

pub struct SqliteStore { /* private fields */ }

SQLite-backed persistence store using sqlx connection pool.

Implementations

impl SqliteStore

pub async fn open(path: impl AsRef<Path>) -> KanbanResult<Self>

pub fn pool(&self) -> &Pool<Sqlite>

pub async fn checkpoint(&self) -> KanbanResult<()>

Trait Implementations

impl DataStore for SqliteStore

fn get_board(&self, id: Uuid) -> KanbanResult<Option<Board>>

fn list_boards(&self) -> KanbanResult<Vec<Board>>

fn upsert_board(&self, board: Board) -> KanbanResult<()>

fn delete_board(&self, id: Uuid) -> KanbanResult<()>

fn get_column(&self, id: Uuid) -> KanbanResult<Option<Column>>

fn list_columns_by_board(&self, board_id: Uuid) -> KanbanResult<Vec<Column>>

fn list_all_columns(&self) -> KanbanResult<Vec<Column>>

fn upsert_column(&self, column: Column) -> KanbanResult<()>

fn delete_column(&self, id: Uuid) -> KanbanResult<()>

fn delete_columns_by_board(&self, board_id: Uuid) -> KanbanResult<()>

fn get_card(&self, id: Uuid) -> KanbanResult<Option<Card>>

fn list_all_cards(&self) -> KanbanResult<Vec<Card>>

fn list_cards_by_column(&self, column_id: Uuid) -> KanbanResult<Vec<Card>>

fn list_cards_by_columns(&self, column_ids: &[Uuid]) -> KanbanResult<Vec<Card>>

Return all cards across the given columns in one call.

fn list_cards_by_sprint(&self, sprint_id: Uuid) -> KanbanResult<Vec<Card>>

fn count_cards_in_column(&self, column_id: Uuid) -> KanbanResult<usize>

fn count_cards_in_column_excluding( &self, column_id: Uuid, exclude: &[Uuid], ) -> KanbanResult<usize>

fn upsert_card(&self, card: Card) -> KanbanResult<()>

fn delete_card(&self, id: Uuid) -> KanbanResult<()>

fn delete_cards_by_columns(&self, column_ids: &[Uuid]) -> KanbanResult<()>

fn clear_sprint_from_cards( &self, sprint_id: Uuid, timestamp: DateTime<Utc>, ) -> KanbanResult<()>

fn get_archived_card(&self, card_id: Uuid) -> KanbanResult<Option<ArchivedCard>>

fn list_archived_cards(&self) -> KanbanResult<Vec<ArchivedCard>>

fn insert_archived_card(&self, ac: ArchivedCard) -> KanbanResult<()>

fn delete_archived_card(&self, card_id: Uuid) -> KanbanResult<()>

fn list_archived_cards_by_columns( &self, column_ids: &[Uuid], ) -> KanbanResult<Vec<ArchivedCard>>

fn clear_sprint_from_archived_cards( &self, sprint_id: Uuid, timestamp: DateTime<Utc>, ) -> KanbanResult<()>

fn get_sprint(&self, id: Uuid) -> KanbanResult<Option<Sprint>>

fn list_sprints_by_board(&self, board_id: Uuid) -> KanbanResult<Vec<Sprint>>

fn list_all_sprints(&self) -> KanbanResult<Vec<Sprint>>

fn upsert_sprint(&self, sprint: Sprint) -> KanbanResult<()>

fn delete_sprint(&self, id: Uuid) -> KanbanResult<()>

fn delete_sprints_by_board(&self, board_id: Uuid) -> KanbanResult<()>

fn get_graph(&self) -> KanbanResult<DependencyGraph>

fn set_graph(&self, graph: DependencyGraph) -> KanbanResult<()>

fn modify_graph(&self, f: GraphMutFn) -> KanbanResult<()>

Atomically read-modify-write the dependency graph.

fn snapshot(&self) -> KanbanResult<Snapshot>

fn apply_snapshot(&self, snapshot: Snapshot) -> KanbanResult<()>

impl PersistenceStore for SqliteStore

fn save<'life0, 'async_trait>( &'life0 self, snapshot: StoreSnapshot, ) -> Pin<Box<dyn Future<Output = PersistenceResult<PersistenceMetadata>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save a snapshot to the store

fn load<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = PersistenceResult<(StoreSnapshot, PersistenceMetadata)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load the current snapshot from the store

fn exists<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Check if the store file exists

fn path(&self) -> &Path

Get the path to the store file

fn instance_id(&self) -> Uuid

Get the unique instance ID for this store

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Drain any open connections / file handles before the backing file is unlinked. Required on Windows: the OS refuses to delete files that still have live handles, and async resources (e.g. an sqlx pool) outlive synchronous Drop because the runtime needs time to close each connection.

fn load_sync( &self, ) -> Result<Option<(StoreSnapshot, PersistenceMetadata)>, PersistenceError>

Load the store synchronously (no async runtime required). Returns Ok(None) when the backing file does not exist.