Struct Literals 

struct Literals<Tr: TraceReader<Batch: Navigable>> {
    literals: <BatchCursor<Tr> as Cursor>::KeyContainer,
    range: Range<usize>,
    position: LiteralPosition,
}

Helper to handle literals in peeks

Fields

literals: <BatchCursor<Tr> as Cursor>::KeyContainer

The literals in a container, sorted by Ord.

range: Range<usize>

The range of the literals that are still available.

position: LiteralPosition

Where the cursor sits relative to the literal list.

Implementations

impl<Tr> Literals<Tr>

where Tr: TraceReader<Batch: Navigable>, BatchCursor<Tr>: Cursor<KeyContainer: BatchContainer<Owned: Ord>>,

fn new( literals: &mut [<<BatchCursor<Tr> as Cursor>::KeyContainer as BatchContainer>::Owned], ) -> Self

Construct a new Literals from a mutable slice of literals. Sorts contents.

The literals must be distinct. A repeated literal seeks to the same key twice and returns its rows twice, since seek_key seeks forward only. MirRelationExpr literal constraints are deduplicated by the optimizer (mz_transform::literal_constraints).

Does not seek the trace cursor. The initial seek runs on the first fueled step instead, so its cost is charged to a budget instead of paid before any budget exists.

fn peek(&self) -> Option<BatchKey<'_, Tr>>

Returns the current literal, if the cursor sits on one.

Returns None while a seek is outstanding and once the literals are exhausted. In neither case does the cursor point at a row that belongs to a literal.

fn seek_pending(&self) -> bool

Returns true if a seek has to run before the cursor sits on a matching literal.

fn is_exhausted(&self) -> bool

Returns true if there are no more literals to process.

fn seek_next_literal_key( &mut self, cursor: &mut CursorList<BatchCursor<Tr>>, storage: &Vec<<Tr as TraceReader>::Batch>, fuel: &mut usize, ) -> SeekOutcome

Seeks the cursor to the next key of a matching literal, if any, charging one unit of fuel per seek_key call.

Returns SeekOutcome::OutOfFuel if literals remain untried when the fuel runs out. The walk resumes from that literal on the next call, so a caller must not treat a suspended seek as an end of scan.

A literal list whose entries are mostly absent from the trace costs one seek per absent literal, so the walk is fueled instead of run to completion.