Struct KeyValueStorageBackend 

pub struct KeyValueStorageBackend { /* private fields */ }

Persistent storage factory implemented over KeyValueStore.

Implementations

impl KeyValueStorageBackend

pub fn new(store: Arc<dyn KeyValueStore>) -> Self

pub fn store(&self) -> Arc<dyn KeyValueStore>

Trait Implementations

impl Clone for KeyValueStorageBackend

fn clone(&self) -> KeyValueStorageBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl PersistentStorageBackend for KeyValueStorageBackend

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 document_store(&self, table: &str) -> Box<dyn DocumentStore>

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 inverted_index( &self, table: &str, analyzer: Analyzer, ) -> Box<dyn InvertedIndex>

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.

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 replace_btree_index( &self, table: &str, field: &ValueIndexKey, values: &[(DocId, Value)], ) -> StorageBackendResult<()>

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 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 pinned transaction. An independent monitor can also be unsafe for a reader when a pending writer is waiting for that reader’s lock.

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 auxiliary_encryption_key(&self) -> Option<StorageEncryptionKey>

Return the encryption credential for database-owned auxiliary files, including engines constructed directly from this backend.

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 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 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 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.