Struct Reservation 

pub struct Reservation { /* private fields */ }

Memory one operator is holding, given back when this is dropped.

It starts at whatever Memory::reserve was asked for and grows from there, which is the shape a buffering operator wants: it does not know how much it will hold until it has read its input, and it wants to be told as soon as the answer is too much rather than after the last row.

Implementations

impl Reservation

pub fn bytes(&self) -> u64

How much this reservation is holding.

pub fn grow(&mut self, bytes: u64) -> Result<()>

Takes another bytes out of the same budget.

Errors

crate::ErrorCode::OutOfMemory when the limit is set and this would pass it. The reservation is unchanged in that case and still releases what it already held.

pub fn shrink(&mut self, bytes: u64)

Gives bytes of it back, or everything if that is more than this is holding.

For an operator that charged several things against one reservation and has dropped one of them. The aggregate charges its hash table, its accumulators and its distinct sets together, and then hands the keys out of the table into the rows it is building, at which point the table is gone and the accumulators are not. Waiting for the whole reservation would charge a table that no longer exists for the whole of the conversion, which is exactly the moment the operator is holding the most.

pub fn release(&mut self)

Gives everything back now rather than at the end of the scope.

For an operator that has finished with its buffer and is about to hand out what it built from it, where waiting for the drop would hold two copies against the limit at once.

Trait Implementations

impl Debug for Reservation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Reservation

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.