Struct PgLoroStore 

pub struct PgLoroStore { /* private fields */ }

PG analogue of LoroStore. Lives on the Postgres-backed runtime; holds the per-row LoroDoc cache (mutated only behind the inner per-row Mutex) and persists snapshots to the PG sidecar table.

Implementations

impl PgLoroStore

pub fn new() -> Self

impl PgLoroStore

pub fn apply_patch<C: PgConn>( &self, conn: &mut C, entity: &str, row_id: &str, fields: &[CrdtField], patch: &Value, ) -> Result<Value, LoroStoreError>

Apply a JSON patch, persist the new snapshot, return the projected JSON. Caller is responsible for materializing the projected JSON into the entity row — typically done in the same with_transaction_raw so both writes share BEGIN/COMMIT.

Multi-replica safe: hydrates with SELECT ... FOR UPDATE, which serializes concurrent updates to the same row across processes. Bypasses the in-memory cache on the write path — the cache only updates after commit (see cache_after_commit), so a stale cache from a different process can’t shadow the row-locked snapshot we just read.

pub fn apply_remote_update<C: PgConn>( &self, conn: &mut C, entity: &str, row_id: &str, fields: &[CrdtField], update: &[u8], ) -> Result<Value, LoroStoreError>

Apply a binary update from a peer. Returns the projected JSON for re-materialization on the entity row. Same locking shape as apply_patch.

pub fn snapshot<C: PgConn>( &self, conn: &mut C, entity: &str, row_id: &str, ) -> Result<Vec<u8>, LoroStoreError>

Full snapshot for the row. Returns the encoded LoroDoc bytes (empty doc if the row hasn’t been written yet — same shape as the SQLite path). Read-only, no FOR UPDATE.

pub fn update_since<C: PgConn>( &self, conn: &mut C, entity: &str, row_id: &str, since: &VersionVector, ) -> Result<Vec<u8>, LoroStoreError>

Incremental update since since for catch-up. Same shape as the SQLite path’s update_since.

pub fn read_snapshot_via_conn<C: PgConn>( conn: &mut C, entity: &str, row_id: &str, ) -> Result<Vec<u8>, LoroStoreError>

Read the snapshot bytes directly through the supplied connection, bypassing the in-memory cache. Used by the crdt_apply_update path: the cache may hold stale bytes from a prior read (snapshot() populates it), and we need the bytes that just committed to land in the broadcast.

pub fn cache_after_commit<C: PgConn>( &self, conn: &mut C, entity: &str, row_id: &str, )

Refresh the in-memory cache entry for a row from the just-committed sidecar bytes. Called by the runtime layer after with_transaction_raw commits the CRDT write — this way the cache only ever reflects what’s on disk, and a rolled-back tx leaves no cache poison.

On any read error we evict instead of caching stale state.

pub fn evict(&self, entity: &str, row_id: &str)

Drop a row’s cached doc. Next access re-hydrates from the PG sidecar.

pub fn cached_rows(&self) -> usize

Diagnostic — number of rows cached in memory.

Trait Implementations

impl Default for PgLoroStore

fn default() -> PgLoroStore

Returns the “default value” for a type.