Struct SQLiteStorageBackend 

pub struct SQLiteStorageBackend { /* private fields */ }

Implementations

impl SQLiteStorageBackend

pub fn new(conn: ManagedConnection) -> Self

pub fn connection(&self) -> ManagedConnection

pub fn new_session(&self) -> Self

Create a backend whose stores use an independent transaction session over the same physical SQLite pool.

Trait Implementations

impl Clone for SQLiteStorageBackend

fn clone(&self) -> SQLiteStorageBackend

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PersistentStorageBackend for SQLiteStorageBackend

fn storage_identity( &self, ) -> StorageBackendResult<Option<PersistentStorageIdentity>>

Return the stable database identity for independently constructed engines over this backend. File identities also enable cross-process row-lock coordination.

fn open_session(&self) -> StorageBackendResult<PersistentStorageSession>

Open a transaction-isolated catalog/backend pair over the same durable database. Engines constructed from already-open backends retain this factory so a row-lock recheck can read the latest committed tuple while the caller’s statement snapshot remains pinned.

fn supports_concurrent_pinned_read_and_write(&self) -> bool

Whether an independently pinned read session can remain open while another session writes the same database. Backends that return false use a detached fixed snapshot for REPEATABLE READ and SERIALIZABLE transactions.

fn document_store(&self, table: &str) -> Box<dyn DocumentStore>

fn inverted_index( &self, table: &str, analyzer: Analyzer, ) -> Box<dyn InvertedIndex>

fn vector_index( &self, table: &str, field: &str, dimensions: u32, spec: VectorIndexSpec, mode: VectorIndexOpenMode, ) -> StorageBackendResult<Box<dyn VectorIndex>>

fn drop_vector_index_metadata( &self, table: &str, field: &str, ) -> StorageBackendResult<()>

fn persists_btree_indexes(&self) -> bool

Whether this backend maps logical btree indexes to durable postings.

fn load_btree_index( &self, table: &str, field: &ValueIndexKey, ) -> StorageBackendResult<Option<Vec<(DocId, Value)>>>

Some(entries) is a complete persisted index; None means it has not been built yet and the engine must backfill it from documents once.

fn btree_index_fields( &self, table: &str, ) -> StorageBackendResult<Vec<ValueIndexKey>>

fn btree_index_repairs( &self, ) -> StorageBackendResult<Vec<(String, ValueIndexKey)>>

Fields whose persisted posting support was found inconsistent during a schema migration. The engine repairs these at its explicit open-time write boundary and clears each durable retry marker only after success.

fn clear_btree_index_repair( &self, table: &str, field: &ValueIndexKey, ) -> StorageBackendResult<()>

fn replace_btree_index( &self, table: &str, field: &ValueIndexKey, values: &[(DocId, Value)], ) -> StorageBackendResult<()>

fn repair_btree_index( &self, table: &str, field: &ValueIndexKey, _complete: &[(DocId, Value)], stale_doc_ids: &[DocId], missing: &[(DocId, Value)], ) -> StorageBackendResult<()>

Repair sparse support differences without requiring capable backends to rewrite every already-valid posting. The complete replacement is supplied for the storage-neutral fallback.

fn replace_btree_indexes( &self, table: &str, indexes: &[(&ValueIndexKey, &[(DocId, Value)])], ) -> StorageBackendResult<()>

Replace several complete indexes for one table atomically. Backends may override this to share one transaction and prepared statements.

fn apply_btree_index_write( &self, table: &str, doc_id: DocId, values: Option<&BTreeMap<ValueIndexKey, Value>>, ) -> StorageBackendResult<()>

fn drop_btree_index( &self, table: &str, field: &ValueIndexKey, ) -> StorageBackendResult<()>

fn clear_btree_indexes(&self, table: &str) -> StorageBackendResult<()>

fn vacuum(&self) -> StorageBackendResult<()>

Reclaim backend-owned storage outside a transaction. Backends whose logical stores eagerly remove obsolete values may keep the no-op default; durable backends with file-level compaction should override it.

fn begin_transaction(&self) -> StorageBackendResult<()>

fn begin_read_transaction(&self) -> StorageBackendResult<()>

Begin a transaction whose first operation is expected to be a read. Backends with distinct lock modes may defer write-lock acquisition; the default preserves existing transaction semantics.

fn begin_upgradeable_transaction(&self) -> StorageBackendResult<()>

Begin an atomic transaction that may remain read-only or perform writes after its initial reads. Backends without read-to-write promotion acquire a writer transaction immediately.

fn in_transaction(&self) -> bool

Whether this session currently owns a pinned storage transaction.

fn transaction_has_written(&self) -> StorageBackendResult<bool>

Whether the current transaction has performed a physical write.

fn change_version(&self) -> StorageBackendResult<Option<u64>>

Backend commit generation visible to this session, when available. A changing value invalidates session-local catalog and index caches.

fn change_version_monitor_is_nonblocking(&self) -> StorageBackendResult<bool>

Whether reading Self::change_version can proceed while this session owns its write transaction.

fn pin_transaction_snapshot(&self) -> StorageBackendResult<()>

Pin the transaction’s read snapshot before cache restoration.

fn commit_transaction(&self) -> StorageBackendResult<()>

fn rollback_transaction(&self) -> StorageBackendResult<()>

fn savepoint(&self, id: StorageSavepointId) -> StorageBackendResult<()>

fn release_savepoint(&self, id: StorageSavepointId) -> StorageBackendResult<()>

fn rollback_to_savepoint( &self, id: StorageSavepointId, ) -> StorageBackendResult<()>

fn migrate_document_storage(&self) -> StorageBackendResult<()>

Upgrade backend-owned document records before table handles are restored. Implementations must make the rewrite atomic and idempotent.

fn migrate_inverted_index_storage(&self) -> StorageBackendResult<()>

Upgrade backend-owned inverted-index values before table handles are restored. Implementations must make the rewrite atomic and idempotent.