Struct StorageManager 

pub struct StorageManager<C = ()> { /* private fields */ }

Implementations

impl<C: ObjectCatalog> StorageManager<C>

pub fn new(backends: StorageBackends, settings: StorageSettings) -> Result<Self>

impl<C> StorageManager<C>

pub async fn close(&self) -> Result<()>

pub async fn start<A: Application>(&self, runtime: &Runtime<A>) -> Result<()>

Methods from Deref<Target = StorageManager<C>>

pub async fn write_schema_once( &self, mutation: &MutationId, key: &SchemaKey, schema: &Schema, ) -> Result<StorageCursor, Error>

pub async fn write_records_once( &self, mutation: &MutationId, records: &[RecordWrite<'_>], ) -> Result<StorageCursor, Error>

pub async fn write_stream_once( &self, mutation: &MutationId, rows: &[StreamWrite<'_>], ) -> Result<StorageCursor, Error>

pub async fn delete_file_once( &self, mutation: &MutationId, file: &StagedFile, ) -> Result<StagedFile, Error>

pub async fn follow_file( &self, file: &StagedFile, offset: u64, ) -> Result<FileFollower, Error>

pub async fn file_progress( &self, file: &StagedFile, ) -> Result<FileProgress, Error>

pub async fn read_file(&self, request: ReadFile) -> Result<FileReader, Error>

pub async fn follow<T>( &self, after: Option<&StorageCursor>, selection: <T as Entry>::Selection, ) -> Result<Follower<T>, Error>

where T: Entry,

pub async fn page<T>( &self, selection: &<T as Entry>::Selection, after: u64, limits: ReadLimits, ) -> Result<FollowPage<T>, Error>

where T: Entry,

pub async fn lookup_schema( &self, key: &SchemaKey, ) -> Result<(StorageSchema, RetainedMemory), Error>

pub async fn admit_arrow_records( &self, scope: Option<&Identifier>, batch: &DecodedBatch, ) -> Result<StorageCursor, Error>

pub async fn admit_arrow_streams( &self, scope: Option<&Identifier>, batch: &DecodedBatch, ) -> Result<StorageCursor, Error>

pub async fn admit_arrow_objects( &self, _scope: Option<&Identifier>, batch: &DecodedBatch, ) -> Result<StorageCursor, Error>

pub async fn start_with( &self, owner: Arc<()>, spawn: impl FnOnce(Worker) -> Result<Box<dyn WorkerOwner>, Error>, ) -> Result<(), Error>

pub fn settings(&self) -> &StorageSettings

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

pub fn same_instance<D>(&self, other: &StorageManager<D>) -> bool

pub fn claim_owner(&self, owner: Arc<()>) -> Result<(), Error>

pub fn cursor_accepted(&self) -> StorageCursor

pub fn cursor_saved(&self) -> StorageCursor

pub fn status(&self) -> StorageMetrics

pub async fn write_recovery( &self, payloads: &[&[u8]], ) -> Result<RecoveryPosition, Error>

pub async fn write_snapshot( &self, snapshot: &RecoverySnapshot, ) -> Result<(), Error>

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

pub async fn flush_until( &self, through: &StorageCursor, ) -> Result<StorageCursor, Error>

pub async fn flush_prepared( &self, through: &StorageCursor, files: &Option<FileSave>, ) -> Result<StorageCursor, Error>

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

pub async fn read_recovery( &self, after: &RecoveryPosition, through: &RecoveryPosition, limits: ReadLimits, ) -> Result<RecoveryPage, Error>

pub async fn read_snapshot( &self, max_bytes: NonZero<usize>, ) -> Result<Option<RecoverySnapshot>, Error>

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

pub fn check_state_dependency( &self, required: &StorageCursor, ) -> Result<(), Error>

pub fn retry_transient_persistence(&self) -> bool

pub fn reserve_arrow_memory( &self, bytes: usize, ) -> Result<RetainedMemory, Error>

pub fn write_receipt_capacity(&self) -> usize

pub async fn await_durable(&self, cursor: &StorageCursor) -> Result<(), Error>

pub async fn release_object_history( &self, schema: &SchemaKey, item: &ObjectKey, through: &StorageCursor, ) -> Result<(), Error>

pub async fn write_schema( &self, key: &SchemaKey, schema: &Schema, ) -> Result<StorageCursor, Error>

pub fn record_batch_len( &self, records: &[RecordWrite<'_>], ) -> Result<usize, Error>

pub fn stream_batch_len(&self, rows: &[StreamWrite<'_>]) -> Result<usize, Error>

pub async fn write_records( &self, records: &[RecordWrite<'_>], ) -> Result<StorageCursor, Error>

pub async fn write_stream( &self, rows: &[StreamWrite<'_>], ) -> Result<StorageCursor, Error>

pub fn erased(&self) -> StorageManager<ErasedCatalog>

pub async fn write_objects_once( &self, mutation: &MutationId, objects: &[ObjectValue], ) -> Result<Vec<ObjectReceipt>, Error>

pub async fn write_object<T>(&self, value: &T) -> Result<ObjectReceipt, Error>

where T: StoredObject, C: Contains<T>,

pub async fn write_object_group( &self, max_bytes: NonZero<usize>, count: NonZero<usize>, build: impl FnOnce(&mut ObjectGroup<'_, C>) -> Result<(), Error> + Send, ) -> Result<Vec<ObjectReceipt>, Error>

pub async fn read_object<T>( &self, key: &<T as StoredObject>::Key, version: ObjectVersion, ) -> Result<Option<ObjectRevision<T>>, Error>

where T: StoredObject, C: Contains<T>,

pub async fn query(&self, query: Query) -> Result<QueryReader, Error>

pub async fn read_objects<T>( &self, read: ObjectRead<'_, T>, ) -> Result<ObjectReader<T>, Error>

where T: StoredObject, C: Contains<T>,

pub async fn read_records<T>( &self, read: RecordRead, ) -> Result<RecordReader<T>, Error>

where T: Message,

pub fn info(&self) -> Result<StorageInfo, Error>

pub fn mutation_window(&self) -> Result<MutationWindow, Error>

pub fn capture_files( &self, through: Option<&StorageCursor>, ) -> Result<Option<FileSave>, Error>

pub async fn persist_files(&self, save: &Option<FileSave>) -> Result<(), Error>

pub async fn create_file( &self, metadata: FileMetadata, ) -> Result<StorageFile, Error>

pub async fn write_file( &self, metadata: FileMetadata, bytes: &[u8], ) -> Result<FileReference, Error>

pub async fn append_file_once( &self, mutation: &MutationId, token: &FileSession, offset: u64, bytes: &[u8], ) -> Result<FileProducer, Error>

pub async fn create_file_once( &self, mutation: &MutationId, metadata: &FileMetadata, ) -> Result<FileProducer, Error>

pub async fn finish_file_once( &self, mutation: &MutationId, token: &FileSession, ) -> Result<FileReference, Error>

pub async fn abandon_file_once( &self, mutation: &MutationId, token: &FileSession, ) -> Result<FileProgress, Error>

pub async fn resume_file_once( &self, mutation: &MutationId, token: &FileSession, ) -> Result<FileProducer, Error>

pub async fn produce_file( &self, metadata: FileMetadata, ) -> Result<StorageFile, Error>

pub async fn resume_file( &self, token: &FileSession, ) -> Result<StorageFile, Error>

pub async fn reserve_transition( &self, payload_bytes: usize, records: Option<ReadLimits>, ) -> Result<Permit, Error>

pub async fn reserve_snapshot( &self, payload_bytes: usize, ) -> Result<Permit, Error>

pub async fn settle_transition(&self)

pub async fn recovery_reader( &self, limits: ReadLimits, snapshot_bytes: Option<NonZero<usize>>, ) -> Result<RecoveryReader<'_, C>, Error>

Trait Implementations

impl<C> Clone for StorageManager<C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Deref for StorageManager<C>

type Target = StorageManager<C>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.