Struct ObjectStorageAdapter 

pub struct ObjectStorageAdapter { /* private fields */ }

The one storage implementation: every backend is an object_store::ObjectStore, so the semantics (atomic-visibility puts, conditional creates, path-delimited listing) are upstream-maintained and identical across backends by construction. The per-backend residue is confined to [UriCodec] (URI ↔ object path mapping) and the supports_conditional_update capability flag (false only for the local filesystem, where upstream PutMode::Update is unimplemented).

Implementations

impl ObjectStorageAdapter

pub fn local() -> Self

Local-filesystem backend rooted at /. URIs are plain paths or file:// URIs; relative paths are lexically absolutized against the current working directory.

pub fn s3_from_root_uri(root_uri: &str) -> Result<Self>

S3 backend scoped to the bucket named in root_uri. Credentials and endpoint come from the standard AWS_* environment variables (the same ones Lance reads for its dataset stores).

pub fn in_memory() -> Self

In-memory backend for tests and embedded experiments. Implements the FULL contract including true conditional updates (unlike the local filesystem), so contract tests exercise the strong-CAS path without a bucket. State lives only as long as the adapter.

Trait Implementations

impl Debug for ObjectStorageAdapter

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

Formats the value using the given formatter.

impl StorageAdapter for ObjectStorageAdapter

fn read_text<'life0, 'life1, 'async_trait>( &'life0 self, uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn write_text<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, uri: &'life1 str, contents: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn write_text_if_absent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, uri: &'life1 str, contents: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Write a text object only if no object exists at uri.

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn rename_text<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from_uri: &'life1 str, to_uri: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Move a file from from_uri to to_uri, replacing any existing file at to_uri. Atomic on local POSIX; on S3 implemented as copy + delete (NOT atomic — callers that depend on atomicity for crash recovery must tolerate “both source and destination exist after a crash”).

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a file. Returns Ok(()) if the file does not exist.

fn list_dir<'life0, 'life1, 'async_trait>( &'life0 self, dir_uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all files (non-recursively, files only) directly under dir_uri. Returns full URIs (same scheme as dir_uri). The result is unordered. Returns Ok(empty) if the directory does not exist or is empty. Consumers must tolerate non-payload residue appearing in storage (backend staging files are filtered by the backend, but crash residue of any future producer may not be) — filter by suffix, never assume every entry is yours.

fn read_text_versioned<'life0, 'life1, 'async_trait>( &'life0 self, uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(String, String)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a text object together with its backend version token (stores with conditional-update support: the object’s ETag; local: sha256 of the content). The token is opaque — valid only for write_text_if_match against the same adapter.

fn write_text_if_match<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, uri: &'life1 str, contents: &'life2 str, expected_version: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Replace the object at uri only if its current version still matches expected_version (obtained from a prior versioned read/write on this adapter). Returns Ok(Some(new_version)) on success and Ok(None) when the precondition failed (a concurrent writer won — the CAS-lost case callers must surface, never swallow). Stores with conditional updates (S3, in-memory) use a true conditional put (If-Match); the local filesystem has no such primitive (PutMode::Update is unimplemented upstream), so local compares content then replaces via an atomic staged write — the same single-machine semantics the callers had before this trait, safe under the callers’ own lock protocol but not a cross-process barrier by itself (see the Known Gaps entry in docs/dev/invariants.md).

fn delete_prefix<'life0, 'life1, 'async_trait>( &'life0 self, prefix_uri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Recursively delete every object under prefix_uri. Returns Ok(()) when nothing exists there (idempotent). Local: remove_dir_all (directories are a local-FS concept; list+delete would leave empty directory skeletons that local existence probes report as present); object stores: list + delete (NOT atomic — callers must tolerate partial prefixes on crash, which the cluster delete protocol does by retry).