Struct SqliteFlowStore 

pub struct SqliteFlowStore { /* private fields */ }

SQLite-backed Flow store.

Implementations

impl SqliteFlowStore

pub fn open( path: impl AsRef<Path>, site_id: impl Into<String>, ) -> Result<Self, VcsBackendError>

Open or create a store at path using site_id for locally emitted atoms.

pub fn in_memory(site_id: impl Into<String>) -> Result<Self, VcsBackendError>

Create an in-memory store for tests and ephemeral callers.

pub fn site_id(&self) -> &str

pub fn emit_atoms( &self, atoms: &[Atom], ) -> Result<Vec<AtomRef>, VcsBackendError>

Persist multiple locally emitted atoms in one transaction.

pub fn emit_preverified_atoms( &self, atoms: &[Atom], ) -> Result<Vec<AtomRef>, VcsBackendError>

Persist new atoms that the caller has already verified.

This is intended for sync and benchmark hot paths that validate a batch once at the boundary, then measure storage throughput independently from signature verification cost. The caller must guarantee these atoms are not already present in the store.

pub fn insert_remote_atom( &self, atom: &Atom, site_id: &str, clock: u64, ) -> Result<AtomRef, VcsBackendError>

Persist a remote atom at its original site clock.

pub fn get_atom(&self, atom_id: AtomId) -> Result<Atom, VcsBackendError>

Load one atom by id.

pub fn atom_by_content_hash( &self, content_hash: AtomId, ) -> Result<Option<Atom>, VcsBackendError>

Find an atom by its content hash. For Flow atoms the content hash is the atom id, so this uses the primary-key index directly.

pub fn atoms_for_principal_persona( &self, principal: &str, persona: &str, ) -> Result<Vec<Atom>, VcsBackendError>

Load atoms for a principal/persona ordered by timestamp and atom id.

pub fn atom_count_for_principal_persona( &self, principal: &str, persona: &str, ) -> Result<u64, VcsBackendError>

Count atoms for a principal/persona using the timestamp index.

pub fn atoms_with_parent( &self, parent: AtomId, ) -> Result<Vec<Atom>, VcsBackendError>

Load all child atoms that list parent as a parent edge.

pub fn state_vector( &self, principal: &str, persona: &str, ) -> Result<StateVector, VcsBackendError>

Current state vector for one principal/persona stream.

pub fn causal_delta( &self, principal: &str, persona: &str, remote: &StateVector, ) -> Result<Vec<AtomDelta>, VcsBackendError>

Return atoms this store has that are newer than remote.

pub fn put_intent(&self, intent: &Intent) -> Result<(), VcsBackendError>

Persist an intent record and its atom edges.

pub fn get_intent(&self, intent_id: IntentId) -> Result<Intent, VcsBackendError>

pub fn put_derived_slice( &self, slice: &DerivedSlice, ) -> Result<(), VcsBackendError>

Persist a derived Flow slice record.

pub fn put_shipped_derived_slice( &self, slice: &DerivedSlice, ) -> Result<(), VcsBackendError>

Persist a derived Flow slice as shipped.

This writes the immutable shipped record directly; callers should not persist an unshipped row first and later mutate it.

pub fn get_derived_slice( &self, slice_id: SliceId, ) -> Result<DerivedSlice, VcsBackendError>

pub fn shipped_derived_slices_since( &self, since: Option<OffsetDateTime>, ) -> Result<Vec<StoredDerivedSlice>, VcsBackendError>

List shipped derived slices, optionally filtering by store creation timestamp.

Trait Implementations

impl Debug for SqliteFlowStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl VcsBackend for SqliteFlowStore

fn emit_atom(&self, atom: &Atom) -> Result<AtomRef, VcsBackendError>

Persist one atom and return its backend location.

fn derive_slice(&self, atoms: &[AtomId]) -> Result<FlowSlice, VcsBackendError>

Derive a shippable slice from an ordered atom set.

fn ship_slice(&self, slice: &FlowSlice) -> Result<ShipReceipt, VcsBackendError>

Publish a slice in the backend’s native shipping surface.

fn list_atoms(&self) -> Result<Vec<AtomRef>, VcsBackendError>

List persisted atoms.

fn replay_slice(&self, slice: &FlowSlice) -> Result<Vec<Atom>, VcsBackendError>

Load atoms in the order recorded by a slice.

fn export_git( &self, _slice: &FlowSlice, _ref_name: &str, ) -> Result<GitExportReceipt, VcsBackendError>

Export a slice into a git ref.

fn import_git(&self, _ref_name: &str) -> Result<FlowSlice, VcsBackendError>

Import a git ref containing ShadowGit atom commits as a Flow slice.