Struct LateralJoin 

pub struct LateralJoin<'a> { /* private fields */ }

Streaming physical implementation of a SQL LATERAL join.

The left child is pulled in batches. The correlated right relation is evaluated once per left row, and produced rows are drained in bounded output batches instead of materialising the complete join result.

Implementations

impl<'a> LateralJoin<'a>

pub fn new( left: Box<dyn PhysicalOperator + 'a>, source: Box<dyn LateralSource + 'a>, kind: JoinKind, left_nulls: ResultRow, right_nulls: ResultRow, ) -> Self

pub fn new_with_right_schema( left: Box<dyn PhysicalOperator + 'a>, source: Box<dyn LateralSource + 'a>, kind: JoinKind, left_nulls: ResultRow, right_nulls: ResultRow, right_schema: RowSchema, ) -> Self

Trait Implementations

impl PhysicalOperator for LateralJoin<'_>

fn row_schema(&self) -> &RowSchema

Complete logical-to-physical row layout emitted by this operator. Every Batch returned by Self::next must carry this exact schema; operators must reject a child that violates that invariant.

fn open(&mut self) -> ExecResult<()>

fn next(&mut self) -> ExecResult<Option<Batch>>

fn close(&mut self) -> ExecResult<()>

fn schema(&self) -> &[String]

Schema column names in logical output order.

fn estimated_cardinality(&self) -> Option<u64>

Planner/runtime cardinality estimate for choosing physical strategies. None means the operator cannot provide a useful estimate. The value is advisory rather than a correctness bound.

fn output_ordering(&self) -> &[PhysicalOrder]

Leading output ordering known to be preserved by this operator.

fn consume_into_aggregate( &mut self, _executor: &mut dyn AggregateExecutor, ) -> ExecResult<bool>

Let a leaf consume its native projected rows directly into an aggregate executor. Returning false promises that no input was consumed, so the caller can fall back to ordinary Batch pulls.