Struct SpannerBackend 

pub struct SpannerBackend { /* private fields */ }

Google Cloud Spanner-backed backend.

Implementations

impl SpannerBackend

pub fn new(client: Client) -> Self

Create a backend from an existing Spanner client.

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

Connect to a Spanner database resource name using a caller-provided config.

pub fn client(&self) -> &Client

Borrow the underlying Spanner client.

pub fn with_read_parallelism(self, read_parallelism: usize) -> Self

Set the read parallelism advertised to async prolly traversals.

Trait Implementations

impl Clone for SpannerBackend

fn clone(&self) -> SpannerBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpannerBackend

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

Formats the value using the given formatter.

impl RemoteStoreBackend for SpannerBackend

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 read_parallelism(&self) -> usize

Maximum in-flight reads for default async traversal paths.

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 prefers_batch_reads(&self) -> bool

Whether this backend has native or efficiently coalesced batch reads.

fn prefers_rightmost_path_hints(&self) -> bool

Whether append-heavy writes should maintain rightmost-path hints.

async fn publish_nodes( &self, publication: NodePublication<'_>, ) -> Result<(), Self::Error>

Publish canonical immutable nodes with advisory logical context.