Struct PostgresBackend 

pub struct PostgresBackend { /* private fields */ }

SQLx-backed PostgreSQL backend.

Implementations

impl PostgresBackend

pub fn new(pool: PgPool) -> Self

Create a backend from an existing SQLx pool.

pub async fn connect(database_url: &str) -> Result<Self, Error>

Connect to PostgreSQL using database_url.

pub fn pool(&self) -> &PgPool

Borrow the underlying pool.

pub async fn initialize_schema(&self) -> Result<(), Error>

Create the required tables if they do not already exist.

Trait Implementations

impl Clone for PostgresBackend

fn clone(&self) -> PostgresBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PostgresBackend

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

Formats the value using the given formatter.

impl RemoteStoreBackend for PostgresBackend

type Error = Error

Backend error type.

async fn get_node(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error>

Read one content-addressed node by CID bytes.

async fn put_node(&self, key: &[u8], value: &[u8]) -> Result<(), Self::Error>

Store one content-addressed node by CID bytes.

async fn delete_node(&self, key: &[u8]) -> Result<(), Self::Error>

Delete one content-addressed node by CID bytes.

async fn batch_nodes( &self, ops: &[RemoteBatchOp<'_>], ) -> Result<(), Self::Error>

Apply node writes/deletes. Implementations should make this atomic when the provider supports it.

async fn batch_get_nodes_ordered( &self, keys: &[&[u8]], ) -> Result<Vec<Option<Vec<u8>>>, Self::Error>

Read unique node keys in request order.

async fn batch_put_nodes( &self, entries: &[(&[u8], &[u8])], ) -> Result<(), Self::Error>

Store multiple content-addressed nodes.

async fn list_node_cids(&self) -> Result<Vec<Vec<u8>>, Self::Error>

List all content-addressed node CIDs.

fn prefers_batch_reads(&self) -> bool

Whether this backend has native or efficiently coalesced batch reads.

fn supports_hints(&self) -> bool

Whether this backend persists optional performance hints.

async fn get_hint( &self, namespace: &[u8], key: &[u8], ) -> Result<Option<Vec<u8>>, Self::Error>

Read an optional performance hint.

async fn put_hint( &self, namespace: &[u8], key: &[u8], value: &[u8], ) -> Result<(), Self::Error>

Write an optional performance hint.

async fn batch_put_nodes_with_hint( &self, entries: &[(&[u8], &[u8])], namespace: &[u8], key: &[u8], value: &[u8], ) -> Result<(), Self::Error>

Store content-addressed nodes and one hint atomically when supported.

async fn get_root_manifest( &self, name: &[u8], ) -> Result<Option<Vec<u8>>, Self::Error>

Read a serialized root manifest.

async fn put_root_manifest( &self, name: &[u8], manifest: &[u8], ) -> Result<(), Self::Error>

Write a serialized root manifest unconditionally.

async fn delete_root_manifest(&self, name: &[u8]) -> Result<(), Self::Error>

Delete a root manifest.

async fn compare_and_swap_root_manifest( &self, name: &[u8], expected: Option<&[u8]>, new: Option<&[u8]>, ) -> Result<RemoteManifestUpdate, Self::Error>

Compare-and-swap a serialized root manifest.

async fn list_root_manifests(&self) -> Result<Vec<RemoteNamedRoot>, Self::Error>

List serialized root manifests sorted by raw name bytes.

fn supports_transactions(&self) -> bool

Whether this backend can atomically validate root conditions and commit staged node/root writes.

async fn commit_transaction( &self, node_writes: &[RemoteBatchOp<'_>], root_conditions: &[RemoteRootCondition], root_writes: &[RemoteRootWrite], ) -> Result<RemoteTransactionUpdate, Self::Error>

Atomically validate serialized root conditions, write nodes, and apply serialized root writes. Implementations should return RemoteTransactionUpdate::Conflict without applying any writes when a condition fails.

fn read_parallelism(&self) -> usize

Maximum in-flight reads for default async traversal paths.