Struct StorageManager 

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

Implementations

impl<C> StorageManager<C>

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

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

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

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

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

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

impl<C> StorageManager<C>

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

pub fn settings(&self) -> &StorageSettings

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

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

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

pub fn cursor_accepted(&self) -> StorageCursor

pub fn cursor_saved(&self) -> StorageCursor

pub fn status(&self) -> StorageMetrics

impl<C> StorageManager<C>

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

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

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

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

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

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

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

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

pub fn retry_transient_persistence(&self) -> bool

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

pub fn write_receipt_capacity(&self) -> usize

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

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

impl<C> StorageManager<C>

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

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

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

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

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

impl<C> StorageManager<C>

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

impl<C: ObjectCatalog> StorageManager<C>

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

pub fn with_execution( backends: StorageBackends, settings: StorageSettings, execution: Execution, ) -> Result<Self>

impl<C> StorageManager<C>

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

impl<C: ObjectCatalog> StorageManager<C>

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

where C: Contains<T>,

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

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

where C: Contains<T>,

impl<C> StorageManager<C>

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

impl<C: ObjectCatalog> StorageManager<C>

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

where C: Contains<T>,

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

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

impl<C> StorageManager<C>

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

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

impl<C> StorageManager<C>

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

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

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

impl<C> StorageManager<C>

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

impl<C> StorageManager<C>

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

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

impl<C> StorageManager<C>

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

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

pub async fn settle_transition(&self)

impl<C> StorageManager<C>

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

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.