Struct StreamingJoinRequest 

pub struct StreamingJoinRequest<'a> {
    pub build_rows: CompactArc<Vec<Row>>,
    pub build_columns: &'a [String],
    pub probe_source: Box<dyn Operator>,
    pub probe_columns: Vec<String>,
    pub condition: Option<&'a Expression>,
    pub join_type: &'a str,
    pub build_is_left: bool,
    pub limit: Option<u64>,
    pub ctx: &'a ExecutionContext,
    pub pre_built_hash_state: Option<JoinHashState>,
    pub projection: Option<&'a JoinProjectionIndices>,
}

Request to execute a streaming hash join.

Unlike JoinRequest, this takes a streaming operator for the probe side, enabling true streaming without full materialization. This is optimal for LIMIT queries where early termination can stop the probe scan early.

Memory Model

• Build side: Fully materialized (required for hash table construction)
• Probe side: Streams row-by-row from the operator (O(1) memory)

When to Use

Use StreamingJoinRequest when:

• Query has LIMIT (early termination benefit)
• Probe side is large (avoid full materialization)
• Join algorithm is Hash Join

Fields

build_rows: CompactArc<Vec<Row>>

Build side rows (Arc for zero-copy sharing with CTE results).

build_columns: &'a [String]

Build side column names.

probe_source: Box<dyn Operator>

Probe side as streaming operator (NOT materialized).

probe_columns: Vec<String>

Probe side column names.

condition: Option<&'a Expression>

Join condition (if any).

join_type: &'a str

Join type string (INNER, LEFT, RIGHT, FULL, CROSS).

build_is_left: bool

Whether build side is left (false = build is right).

limit: Option<u64>

LIMIT for early termination.

ctx: &'a ExecutionContext

Execution context for expression evaluation.

pre_built_hash_state: Option<JoinHashState>

Pre-built hash table (if available). When provided, skips the hash table build phase in HashJoinOperator, avoiding double iteration of build_rows.

projection: Option<&'a JoinProjectionIndices>

Optional fused projection for the final joined row.

This is applied inside HashJoinOperator only when the join condition has no residual predicates that need the full logical left+right row.