Struct SqlxBackend 

pub struct SqlxBackend { /* private fields */ }

SQL-based backend implementing BackendImpl using sqlx.

This backend supports both SQLite and PostgreSQL through sqlx’s AnyPool.

Thread Safety

SqlxBackend is Send + Sync as required by BackendImpl. The underlying sqlx pool handles connection pooling and thread safety.

Test Isolation

For PostgreSQL, each backend instance can use its own schema for test isolation. Use connect_postgres_isolated() to create an isolated backend for testing.

Implementations

impl SqlxBackend

pub fn pool(&self) -> &AnyPool

Get a reference to the underlying pool.

pub fn kind(&self) -> DbKind

Get the database kind.

pub fn is_sqlite(&self) -> bool

Check if this backend is using SQLite.

pub fn is_postgres(&self) -> bool

Check if this backend is using PostgreSQL.

impl SqlxBackend

pub async fn open_sqlite<P: AsRef<Path>>(path: P) -> Result<Self>

Open a SQLite database at the given path.

Creates the database file and schema if they don’t exist.

Arguments

• path - Path to the SQLite database file

Example

use eidetica::backend::database::sql::SqlxBackend;

#[tokio::main]
async fn main() {
    let backend = SqlxBackend::open_sqlite("my_database.db").await.unwrap();
}

pub async fn connect_sqlite(url: &str) -> Result<Self>

Connect to a SQLite database using a connection URL.

Arguments

• url - SQLite connection URL (e.g., “sqlite:./my.db”)

pub async fn sqlite_in_memory() -> Result<Self>

Create an in-memory SQLite database (async).

The database exists only for the lifetime of this backend instance. Useful for testing.

Example

use eidetica::backend::database::sql::SqlxBackend;

#[tokio::main]
async fn main() {
    let backend = SqlxBackend::sqlite_in_memory().await.unwrap();
}

impl SqlxBackend

pub async fn connect_postgres(url: &str) -> Result<Self>

Connect to a PostgreSQL database using a connection URL.

This connects to the default (public) schema. For test isolation, use connect_postgres_isolated() instead.

Arguments

• url - PostgreSQL connection URL (e.g., “postgres://user:pass@localhost/dbname”)

Example

use eidetica::backend::database::sql::SqlxBackend;

let backend = SqlxBackend::connect_postgres("postgres://localhost/eidetica").await.unwrap();

pub async fn connect_postgres_isolated(url: &str) -> Result<Self>

Connect to a PostgreSQL database with test isolation.

Creates a unique schema for this backend instance, ensuring tests don’t interfere with each other when run in parallel.

Arguments

• url - PostgreSQL connection URL (e.g., “postgres://user:pass@localhost/dbname”)

Example

use eidetica::backend::database::sql::SqlxBackend;

let backend = SqlxBackend::connect_postgres_isolated("postgres://localhost/eidetica").await.unwrap();
// This backend uses its own isolated schema

Trait Implementations

impl BackendImpl for SqlxBackend

fn get<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Entry>> + Send + 'async_trait>>

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

Retrieves an entry by its unique content-addressable ID.

fn get_verification_status<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<VerificationStatus>> + Send + 'async_trait>>

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

Gets the verification status of an entry.

fn put<'life0, 'async_trait>( &'life0 self, verification_status: VerificationStatus, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Stores an entry in the database with the specified verification status.

fn update_verification_status<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 ID, verification_status: VerificationStatus, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Updates the verification status of an existing entry.

fn get_entries_by_verification_status<'life0, 'async_trait>( &'life0 self, status: VerificationStatus, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

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

Gets all entries with a specific verification status.

fn get_tips<'life0, 'life1, 'async_trait>( &'life0 self, tree: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

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

Retrieves the IDs of the tip entries for a given tree.

fn get_store_tips<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves the IDs of the tip entries for a specific store within a given tree.

fn get_store_tips_up_to_entries<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, main_entries: &'life3 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Gets the store tips that exist up to a specific set of main tree entries.

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

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

Retrieves the IDs of all top-level root entries stored in the backend.

fn find_merge_base<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, entry_ids: &'life3 [ID], ) -> Pin<Box<dyn Future<Output = Result<ID>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Finds the merge base (common dominator) of the given entry IDs within a store.

fn collect_root_to_target<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, target_entry: &'life3 ID, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Collects all entries from the tree root down to the target entry within a store.

fn as_any(&self) -> &dyn Any

Returns a reference to the backend instance as a dynamic Any type.

fn get_tree<'life0, 'life1, 'async_trait>( &'life0 self, tree: &'life1 ID, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

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

Retrieves all entries belonging to a specific tree, sorted topologically.

fn get_store<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves all entries belonging to a specific store within a tree, sorted topologically.

fn get_tree_from_tips<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, tree: &'life1 ID, tips: &'life2 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves all entries belonging to a specific tree up to the given tips, sorted topologically.

fn get_store_from_tips<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree: &'life1 ID, store: &'life2 str, tips: &'life3 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<Entry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Retrieves all entries belonging to a specific store within a tree up to the given tips, sorted topologically.

fn get_cached_crdt_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, entry_id: &'life1 ID, store: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get cached CRDT state for a store at a specific entry.

fn cache_crdt_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, entry_id: &'life1 ID, store: &'life2 str, state: String, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Cache CRDT state for a store at a specific entry.

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

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

Clear all cached CRDT states.

fn get_sorted_store_parents<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tree_id: &'life1 ID, entry_id: &'life2 ID, store: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get the store parent IDs for a specific entry and store, sorted by height then ID.

fn get_path_from_to<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, tree_id: &'life1 ID, store: &'life2 str, from_id: &'life3 ID, to_ids: &'life4 [ID], ) -> Pin<Box<dyn Future<Output = Result<Vec<ID>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Gets all entries between one entry and multiple target entries (exclusive of start, inclusive of targets).

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

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

Get the instance metadata.

fn set_instance_metadata<'life0, 'life1, 'async_trait>( &'life0 self, metadata: &'life1 InstanceMetadata, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Set the instance metadata.

fn put_verified<'life0, 'async_trait>( &'life0 self, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Stores an entry with verified status (convenience method for local entries).

fn put_unverified<'life0, 'async_trait>( &'life0 self, entry: Entry, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Stores an entry with failed verification status (convenience method for sync scenarios).