Struct BulkOperations

pub struct BulkOperations { /* private fields */ }

A collection of bulk operations.

A collection of bulk operations can perform operations against multiple different indices, specifying a different source document for each. When modelling source documents with different structs, it becomes difficult to construct a collection of bulk operations with such a setup. BulkOperations alleviates this difficulty by serializing bulk operations ahead of time of the bulk API call, into an internal byte buffer, using the buffered bytes as the body of the bulk API call.

Example

Using BulkOperations to construct a collection of bulk operations that use different structs to model source documents

#[derive(Serialize)]
struct IndexDoc<'a> {
    foo: &'a str,
}

#[derive(Serialize)]
struct CreateDoc<'a> {
    bar: &'a str,
}

#[derive(Serialize)]
struct UpdateDoc<'a> {
    baz: &'a str,
}

let mut ops = BulkOperations::new();
ops.push(BulkOperation::index(IndexDoc { foo: "index" })
    .id("1")
    .pipeline("pipeline")
    .index("index_doc")
    .routing("routing")
)?;
ops.push(BulkOperation::create("2", CreateDoc { bar: "create" }))?;
ops.push(BulkOperation::update("3", UpdateDoc { baz: "update" }))?;
ops.push(BulkOperation::<()>::delete("4"))?;

let bulk_response = client.bulk(BulkParts::Index("tweets"))
    .body(vec![ops])
    .send()
    .await?;

Implementations

impl BulkOperations

pub fn new() -> Self

Initializes a new instance of BulkOperations

pub fn with_bytes(buf: BytesMut) -> Self

Initializes a new instance of BulkOperations, using the passed bytes::BytesMut as the buffer to write operations to

pub fn push<O, B>(&mut self, op: O) -> Result<(), Error>

where O: Into<BulkOperation<B>>, B: Serialize,

Pushes a bulk operation into the collection of bulk operations.

The operation is serialized and written to the underlying byte buffer.

Trait Implementations

impl Body for BulkOperations

fn bytes(&self) -> Option<Bytes>

An existing immutable buffer that can be used to avoid having to write to another buffer that will then be written to the request stream.

fn write(&self, bytes: &mut BytesMut) -> Result<(), Error>

Write to a buffer that will be written to the request stream

impl Default for BulkOperations

fn default() -> Self

Returns the “default value” for a type.