Struct opendal::Deleter

pub struct Deleter { /* private fields */ }

Deleter is designed to continuously remove content from storage.

It leverages batch deletion capabilities provided by storage services for efficient removal.

Usage

Deleter provides several ways to delete files:

Direct Deletion

Use the delete method to remove a single file:

use opendal::Operator;
use opendal::Result;

async fn example(op: Operator) -> Result<()> {
    let mut d = op.deleter().await?;
    d.delete("path/to/file").await?;
    d.close().await?;
    Ok(())
}

Delete multiple files via a stream:

use opendal::Operator;
use opendal::Result;
use futures::stream;

async fn example(op: Operator) -> Result<()> {
    let mut d = op.deleter().await?;
    d.delete_stream(stream::iter(vec!["path/to/file"])).await?;
    d.close().await?;
    Ok(())
}

Using as a Sink

Deleter can be used as a Sink for file deletion:

use opendal::Operator;
use opendal::Result;
use futures::{stream, Sink};
use futures::SinkExt;

async fn example(op: Operator) -> Result<()> {
    let mut sink = op.deleter().await?.into_sink();
    sink.send("path/to/file").await?;
    sink.close().await?;
    Ok(())
}

Implementations

impl Deleter

pub async fn delete(&mut self, input: impl IntoDeleteInput) -> Result<()>

Delete a path.

pub async fn delete_iter<I, D>(&mut self, iter: I) -> Result<()>

where I: IntoIterator<Item = D>, D: IntoDeleteInput,

Delete an infallible iterator of paths.

Also see:

• Deleter::delete_try_iter: delete an fallible iterator of paths.
• Deleter::delete_stream: delete an infallible stream of paths.
• Deleter::delete_try_stream: delete an fallible stream of paths.

pub async fn delete_try_iter<I, D>(&mut self, try_iter: I) -> Result<()>

where I: IntoIterator<Item = Result<D>>, D: IntoDeleteInput,

Delete an fallible iterator of paths.

Also see:

• Deleter::delete_iter: delete an infallible iterator of paths.
• Deleter::delete_stream: delete an infallible stream of paths.
• Deleter::delete_try_stream: delete an fallible stream of paths.

pub async fn delete_stream<S, D>(&mut self, stream: S) -> Result<()>

where S: Stream<Item = D>, D: IntoDeleteInput,

Delete an infallible stream of paths.

Also see:

• Deleter::delete_iter: delete an infallible iterator of paths.
• Deleter::delete_try_iter: delete an fallible iterator of paths.
• Deleter::delete_try_stream: delete an fallible stream of paths.

pub async fn delete_try_stream<S, D>(&mut self, try_stream: S) -> Result<()>

where S: Stream<Item = Result<D>>, D: IntoDeleteInput,

Delete an fallible stream of paths.

Also see:

• Deleter::delete_iter: delete an infallible iterator of paths.
• Deleter::delete_try_iter: delete an fallible iterator of paths.
• Deleter::delete_stream: delete an infallible stream of paths.

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

Flush the deleter, returns the number of deleted paths.

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

Close the deleter, this will flush the deleter and wait until all paths are deleted.

pub fn into_sink<T: IntoDeleteInput>(self) -> FuturesDeleteSink<T>

Convert the deleter into a sink.