Struct BatchWriter 

pub struct BatchWriter { /* private fields */ }

Batch writer with configurable settings.

BatchWriter provides a configurable interface for applying batch mutations to Prolly trees. It wraps the batch operation logic and applies the configured optimizations.

Example

use prolly::{BatchWriter, BatchWriterConfig, Prolly, MemStore, Config, Mutation};

let store = MemStore::new();
let prolly = Prolly::new(store, Config::default());
let tree = prolly.create();

// Create a batch writer with custom configuration
let config = BatchWriterConfig::new()
    .with_optimized_merge(true);

let writer = BatchWriter::with_config(config);

// Apply mutations using the configured writer
let mutations = vec![
    Mutation::Upsert { key: b"a".to_vec(), val: b"1".to_vec() },
    Mutation::Upsert { key: b"b".to_vec(), val: b"2".to_vec() },
];

let new_tree = writer.apply_batch(&prolly, &tree, mutations).unwrap();

Implementations

impl BatchWriter

pub fn new() -> Self

Create a new batch writer with default configuration.

Returns

A new BatchWriter with default settings.

Example

use prolly::BatchWriter;

let writer = BatchWriter::new();

pub fn with_config(config: BatchWriterConfig) -> Self

Create a new batch writer with custom configuration.

Arguments

• config - The configuration to use

Returns

A new BatchWriter with the specified configuration.

Example

use prolly::{BatchWriter, BatchWriterConfig};

let config = BatchWriterConfig::new()
    .with_prefetch_parallelism(32);

let writer = BatchWriter::with_config(config);

pub fn config(&self) -> &BatchWriterConfig

Get a reference to the current configuration.

Returns

A reference to the BatchWriterConfig.

Example

use prolly::{BatchWriter, BatchWriterConfig};

let writer = BatchWriter::new();
let config = writer.config();
assert_eq!(config.prefetch_parallelism, 16);

pub fn apply_batch<S: Store>( &self, prolly: &Prolly<S>, tree: &Tree, mutations: Vec<Mutation>, ) -> Result<Tree, Error>

Apply batch mutations using the configured settings.

This method applies mutations to a tree using the optimizations specified in the configuration:

• Stores that prefer batched reads hydrate mutation paths in ordered batches
• If use_optimized_merge is true, uses O(n+m) two-pointer merge
• Otherwise, uses O(m log n) binary search approach
• If use_bottom_up_rebuild is true, uses bottom-up rebuild strategy for parent reconstruction (ensures each node is written exactly once)

Arguments

• prolly - Reference to the Prolly tree manager
• tree - The tree to modify
• mutations - Vector of mutations to apply

Returns

• Ok(Tree) - New tree with all mutations applied
• Err(Error) - On storage or processing errors

Example

use prolly::{BatchWriter, Prolly, MemStore, Config, Mutation};

let store = MemStore::new();
let prolly = Prolly::new(store, Config::default());
let tree = prolly.create();

let writer = BatchWriter::new();
let mutations = vec![
    Mutation::Upsert { key: b"key".to_vec(), val: b"value".to_vec() },
];

let new_tree = writer.apply_batch(&prolly, &tree, mutations).unwrap();

pub fn apply_batch_with_stats<S: Store>( &self, prolly: &Prolly<S>, tree: &Tree, mutations: Vec<Mutation>, ) -> Result<BatchApplyResult, Error>

Apply batch mutations and return store-neutral execution stats.

This is useful for tuning workload shape across storage backends. The returned stats report tree-level work such as affected leaves and unique prolly nodes/bytes written, independent of backend compaction or object layout.

Trait Implementations

impl Default for BatchWriter

fn default() -> Self

Returns the “default value” for a type.