It is recommended to optimize the encode_document and encode_array functions.

[danclive]

In our implementation of the function that encodes the Document and Array as bytes, we need to allocate a Vec and encode the elements in it to calculate the length. This causes excess memory allocation.

bson-rust/src/encoder/mod.rs

Lines 96 to 117 in aa4fe08

	pub fn encode_document<
	'a,
	S: AsRef<str> + 'a,
	W: Write + ?Sized,
	D: IntoIterator<Item = (&'a S, &'a Bson)>,
	>(
	writer: &mut W,
	doc: D,
	) -> EncoderResult<()> {
	let mut buf = Vec::new();
	for (key, val) in doc.into_iter() {
	encode_bson(&mut buf, key.as_ref(), val)?;
	}
	write_i32(
	writer,
	(buf.len() + mem::size_of::<i32>() + mem::size_of::<u8>()) as i32,
	)?;
	writer.write_all(&buf)?;
	writer.write_u8(0)?;
	Ok(())
	}

I looked at RawBson idea, but RawBson is immutable, and we often need to change documents, so it's not particularly useful in practice.

That's why I recommend whether you can maintain a length message when you're building a Document and an Array, just like that:

pub struct Document {
    map: IndexMap<String, Bson>,
    len: usize
}

pub struct Array {
    vec: Vec<Bson>,
    len: usize
}

This allows you to use this length directly when encode, without having to encode to vec first.

[koshkin-kna]

Encoding and decoding of embedded objects and arrays, in principle, work very slowly.
A flat document is processed on the order of ~ 0.002 seconds, while its counterpart with nesting is ~ 0.030 seconds

[jcdyer]

Length of a Bson object can be calculated without encoding it. See the doc_size_bytes and size_bytes functions in https://github.com/mongodb/mongo-rust-driver/blob/master/src/bson_util.rs