Apache DataFusion SQL Query Engine
perf(pwmj):settle never-matching streamed rows against the buffered extreme… (#25840)
Subham Singhalaaf5df1db1f9
diff --git a/datafusion/core/tests/fuzz_cases/join_fuzz.rs b/datafusion/core/tests/fuzz_cases/join_fuzz.rsindex 7df8dcbe3f..296136fd7b 100644--- a/datafusion/core/tests/fuzz_cases/join_fuzz.rs+++ b/datafusion/core/tests/fuzz_cases/join_fuzz.rs@@ -1487,7 +1487,7 @@ fn make_staggered_batches_binary(//// What only randomization reaches: `LeftSemi`/`LeftAnti` record matches in a shared// `AtomicUsize` watermark and emit once, from whichever streamed partition finishes last. The-// streamed side below is spread round-robin over several partitions as one-row batches, so+// streamed side below is spread round-robin over several partitions in small batches, so// batches arrive in an order no static test pins down, and the counter that gates the final// pass is seeded from a partition count that deliberately disagrees with the `num_partitions`// argument. `RightSemi`/`RightAnti` take the mirror path -- every partition emits its own@@ -1575,25 +1575,39 @@ fn pwmj_single_exec<K: PwmjFuzzKey>(.unwrap()}-/// Rows spread round-robin across `nparts` partitions, one row per batch, with any partition-/// that draws no row left holding a single empty batch. Used for the streamed side throughout,-/// and for the buffered side of the right existence joins, which place no single-partition-/// requirement on it.+/// Rows spread round-robin across `nparts` partitions, with any partition that draws no row+/// left holding a single empty batch. With `stagger_seed`, each partition's rows are cut into+/// random-size batches, empty ones included, by [`stagger_batch_with_seed`]; without it, one+/// row per batch. Used for the streamed side throughout, and for the buffered side of the+/// right existence joins, which place no single-partition requirement on it.fn pwmj_parts_exec<K: PwmjFuzzKey>(ids: &[i32],keys: &[Option<K>],nparts: usize,+ stagger_seed: Option<u64>,) -> Arc<dyn ExecutionPlan> {let nparts = nparts.max(1);- let mut partitions: Vec<Vec<RecordBatch>> = vec![Vec::new(); nparts];+ let mut part_rows: Vec<(Vec<i32>, Vec<Option<K>>)> = vec![Default::default(); nparts];for (row, (&id, key)) in ids.iter().zip(keys.iter()).enumerate() {- partitions[row % nparts].push(pwmj_kv_batch(&[id], &[*key]));- }- for p in partitions.iter_mut() {- if p.is_empty() {- p.push(pwmj_kv_batch::<K>(&[], &[]));- }- }+ part_rows[row % nparts].0.push(id);+ part_rows[row % nparts].1.push(*key);+ }+ let partitions: Vec<Vec<RecordBatch>> = part_rows+ .iter()+ .enumerate()+ .map(|(part, (ids, keys))| match stagger_seed {+ // `stagger_batch_with_seed` panics on a batch with no rows.+ _ if ids.is_empty() => vec![pwmj_kv_batch::<K>(&[], &[])],+ Some(seed) => {+ stagger_batch_with_seed(pwmj_kv_batch(ids, keys), seed + part as u64)+ }+ None => ids+ .iter()+ .zip(keys)+ .map(|(&id, key)| pwmj_kv_batch(&[id], &[*key]))+ .collect(),+ })+ .collect();MemorySourceConfig::try_new_exec(&partitions, pwmj_kv_schema::<K>(), None).unwrap()}@@ -1820,6 +1834,9 @@ async fn run_pwmj_fuzz<K: PwmjFuzzKey + std::fmt::Debug>(task_ctx: &Arc<TaskContlet left_keys = gen_keys(left_len, &mut rng);let right_ids: Vec<i32> = (0..right_len as i32).collect();let right_keys = gen_keys(right_len, &mut rng);+ // Staggered streamed batches mix rows that can and cannot match, so the classic joins+ // set some aside before the sort and map the rest back to their rows.+ let stagger_seed = Some(seed);for op in ops {for join_type in join_types {@@ -1828,7 +1845,7 @@ async fn run_pwmj_fuzz<K: PwmjFuzzKey + std::fmt::Debug>(task_ctx: &Arc<TaskCont// single-partition shape below never reaches.let buffered = match join_type {JoinType::RightSemi | JoinType::RightAnti | JoinType::RightMark => {- pwmj_parts_exec(&left_ids, &left_keys, buffered_nparts)+ pwmj_parts_exec(&left_ids, &left_keys, buffered_nparts, None)}_ => pwmj_single_exec(&left_ids, &left_keys),};@@ -1840,7 +1857,12 @@ async fn run_pwmj_fuzz<K: PwmjFuzzKey + std::fmt::Debug>(task_ctx: &Arc<TaskContlet got = pwmj_collect_mark_pairs(pwmj_plan(buffered,- pwmj_parts_exec(&right_ids, &right_keys, nparts),+ pwmj_parts_exec(+ &right_ids,+ &right_keys,+ nparts,+ stagger_seed,+ ),op,join_type,),@@ -1872,7 +1894,7 @@ async fn run_pwmj_fuzz<K: PwmjFuzzKey + std::fmt::Debug>(task_ctx: &Arc<TaskContlet got = pwmj_collect_id_pairs(pwmj_plan(buffered,- pwmj_parts_exec(&right_ids, &right_keys, nparts),+ pwmj_parts_exec(&right_ids, &right_keys, nparts, stagger_seed),op,join_type,),@@ -2000,7 +2022,12 @@ async fn pwmj_watermark_nulls_duplicates_multi_partition() {let got = pwmj_collect_id_pairs(pwmj_plan(pwmj_single_exec(&left_ids, &left_keys),- pwmj_parts_exec(&case.streamed_ids, &case.streamed_keys, nparts),+ pwmj_parts_exec(+ &case.streamed_ids,+ &case.streamed_keys,+ nparts,+ None,+ ),Operator::Lt,join_type,),diff --git a/datafusion/physical-plan/src/joins/piecewise_merge_join/classic_join.rs b/datafusion/physical-plan/src/joins/piecewise_merge_join/classic_join.rsindex 63885aa652..25e7d6a833 100644--- a/datafusion/physical-plan/src/joins/piecewise_merge_join/classic_join.rs+++ b/datafusion/physical-plan/src/joins/piecewise_merge_join/classic_join.rs@@ -17,28 +17,31 @@//! Stream Implementation for PiecewiseMergeJoin's Classic Join (Left, Right, Full, Inner)-use arrow::array::{PrimitiveBuilder, new_null_array};-use arrow::compute::{BatchCoalescer, take};-use arrow::datatypes::UInt32Type;+use arrow::array::{Array, AsArray, new_null_array};+use arrow::buffer::BooleanBuffer;+use arrow::compute::{BatchCoalescer, filter, not, prep_null_mask_filter, take};use arrow::{- array::{ArrayRef, RecordBatch, UInt32Array},- compute::{SortColumn, lexsort_to_indices, take_record_batch},+ array::{ArrayRef, BooleanArray, RecordBatch, UInt32Array},+ compute::{SortColumn, filter_record_batch, lexsort_to_indices, take_record_batch},};-use arrow_schema::{Schema, SchemaRef, SortOptions};+use arrow_schema::{DataType, Schema, SchemaRef, SortOptions};use datafusion_common::NullEquality;-use datafusion_common::{Result, internal_err};+use datafusion_common::utils::normalize_float_zero;+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_execution::{RecordBatchStream, SendableRecordBatchStream};-use datafusion_expr::{JoinType, Operator};+use datafusion_expr::{ColumnarValue, JoinType, Operator};use datafusion_physical_expr::PhysicalExprRef;+use datafusion_physical_expr_common::datum::apply_cmp;use futures::{Stream, StreamExt};use std::sync::atomic::Ordering as AtomicOrdering;-use std::{cmp::Ordering, task::ready};+use std::task::ready;use std::{sync::Arc, task::Poll};use crate::handle_state;use crate::joins::piecewise_merge_join::exec::{BufferedSide, BufferedSideReadyState};use crate::joins::piecewise_merge_join::utils::{- need_produce_result_in_final, non_null_range, unmatched_buffered_batch,+ first_match, is_match, matches_on_equal, need_produce_result_in_final,+ non_null_range, unmatched_buffered_batch,};use crate::joins::utils::JoinKeyComparator;use crate::joins::utils::{BuildProbeJoinMetrics, StatefulStreamResult};@@ -114,6 +117,10 @@ pub(super) struct ClassicPWMJStream {join_metrics: BuildProbeJoinMetrics,// Tracking incremental state for emitting record batchesbatch_process_state: BatchProcessState,+ // The last buffered key, which every match set contains (see `matchable_rows`), or+ // `None` when no buffered key is non-null and nothing can match. Set once the buffered+ // side is ready.+ buffered_extreme: Option<ColumnarValue>,}impl RecordBatchStream for ClassicPWMJStream {@@ -160,6 +167,7 @@ impl ClassicPWMJStream {sort_option,join_metrics,batch_process_state: BatchProcessState::new(schema, batch_size),+ buffered_extreme: None,}}@@ -200,6 +208,9 @@ impl ClassicPWMJStream {)?;build_timer.done();+ self.buffered_extreme =+ buffered_extreme(buffered_data.values(), self.sort_option)?;+// We will start fetching stream batches for classic joinsself.state = PiecewiseMergeJoinStreamState::FetchStreamBatch;@@ -245,19 +256,53 @@ impl ClassicPWMJStream {self.join_metrics.input_batches.add(1);self.join_metrics.input_rows.add(batch.num_rows());- // Sort stream values and change the streamed record batch accordingly- let indices = lexsort_to_indices(+ // Rows that can match no buffered row are settled before the sort (see+ // `split_off_never_matching`); only the rest are sorted and scanned.+ let buffered_values =+ self.buffered_side.try_as_ready()?.buffered_data.values();+ let matchable = matchable_rows(+ &stream_values,+ buffered_values,+ self.buffered_extreme.as_ref(),+ self.operator,+ self.sort_option,+ )?;+ let candidates = split_off_never_matching(+ &matchable,+ self.join_type,+ &self.schema,+ &batch,+ &stream_values,+ &mut self.batch_process_state.output_batches,+ )?;++ // Sort the candidates' keys, and gather the batch once: when rows were split+ // off, the sort indices are mapped back to positions in `batch` first.+ let (keys, positions) = match candidates {+ None => (stream_values, None),+ Some((positions, keys)) => (keys, Some(positions)),+ };+ let sorted = lexsort_to_indices(&[SortColumn {- values: Arc::clone(&stream_values),+ values: Arc::clone(&keys),options: Some(self.sort_option),}],None,)?;- let stream_batch = take_record_batch(&batch, &indices)?;- let stream_values = take(stream_values.as_ref(), &indices, None)?;-- // Reset BatchProcessState before processing a new stream batch+ let stream_batch = match positions {+ None => take_record_batch(&batch, &sorted)?,+ Some(positions) => take_record_batch(+ &batch,+ take(&positions, &sorted, None)?.as_ref(),+ )?,+ };+ let stream_values = take(keys.as_ref(), &sorted, None)?;++ // Reset BatchProcessState before processing a new stream batch. NULL keys+ // never match, so the scan starts past any buffered ones at the front.self.batch_process_state.reset();+ self.batch_process_state.start_buffer_idx =+ non_null_range(buffered_values.as_ref(), self.sort_option).0;self.state = PiecewiseMergeJoinStreamState::ProcessStreamBatch(SortedStreamBatch::new(stream_batch, vec![stream_values]),);@@ -369,20 +414,14 @@ impl ClassicPWMJStream {struct BatchProcessState {// Used to pick up from the last index on the stream sideoutput_batches: Box<BatchCoalescer>,- // Used to store the unmatched stream indices for `JoinType::Right` and `JoinType::Full`- unmatched_indices: PrimitiveBuilder<UInt32Type>,// Used to store the start index on the buffered side; used to resume processing on the correct// rowstart_buffer_idx: usize,// Used to store the start index on the stream side; used to resume processing on the correct// rowstart_stream_idx: usize,- // Signals if we found a match for the current stream row- found: bool,// Signals to continue processing the current stream batchcontinue_process: bool,- // Skip nulls- processed_null_count: bool,// Smallest buffered index marked while scanning the current stream batch, or// `usize::MAX` if nothing has been marked yet. Because `buffer_idx` only moves forward// within a batch, this lets all but the batch's first match skip the shared atomic.@@ -393,23 +432,17 @@ impl BatchProcessState {pub(crate) fn new(schema: Arc<Schema>, batch_size: usize) -> Self {Self {output_batches: Box::new(BatchCoalescer::new(schema, batch_size)),- unmatched_indices: PrimitiveBuilder::new(),start_buffer_idx: 0,start_stream_idx: 0,- found: false,continue_process: true,- processed_null_count: false,batch_min_marked: usize::MAX,}}pub(crate) fn reset(&mut self) {- self.unmatched_indices = PrimitiveBuilder::new();self.start_buffer_idx = 0;self.start_stream_idx = 0;- self.found = false;self.continue_process = true;- self.processed_null_count = false;self.batch_min_marked = usize::MAX;}@@ -443,7 +476,9 @@ fn resolve_classic_join(join_type: JoinType,batch_process_state: &mut BatchProcessState,) -> Result<RecordBatch> {- let (buffered_start, buffered_len) =+ // Buffered NULL keys sort to one end and never match, so the scan stops before any+ // trailing ones; `start_buffer_idx` already starts it past any leading ones.+ let (_, buffered_len) =non_null_range(buffered_side.buffered_data.values().as_ref(), sort_options);let stream_values = stream_batch.compare_key_values();@@ -456,128 +491,55 @@ fn resolve_classic_join()?;let mut buffer_idx = batch_process_state.start_buffer_idx;- let mut stream_idx = batch_process_state.start_stream_idx;-- if !batch_process_state.processed_null_count {- let (stream_start, stream_end) =- non_null_range(stream_values[0].as_ref(), sort_options);- buffer_idx = buffered_start;- stream_idx = stream_start;- batch_process_state.processed_null_count = true;-- // NULL keys never match, but outer joins must emit them on either end.- if matches!(join_type, JoinType::Right | JoinType::Full) {- for row_idx in- (0..stream_start).chain(stream_end..stream_batch.batch.num_rows())- {- batch_process_state- .unmatched_indices- .append_value(row_idx as u32);- }- }+ let stream_idx = batch_process_state.start_stream_idx;++ // Streamed NULL keys are settled before the sort (see `split_off_never_matching`). One+ // that got here would sort before every buffered key and match all of them. Logical, as a+ // run-end encoded NULL has no physical null buffer.+ if stream_values[0].logical_null_count() > 0 {+ return internal_err!(+ "PiecewiseMergeJoin: streamed NULL keys must be settled before the scan"+ );}- // Our buffer_idx variable allows us to start probing on the buffered side where we last matched- // in the previous stream row.- let (_, stream_end) = non_null_range(stream_values[0].as_ref(), sort_options);- for row_idx in stream_idx..stream_end {- while buffer_idx < buffered_len {- let compare = cmp.compare(row_idx, buffer_idx);-- // If we find a match we append all indices and move to the next stream row index- match operator {- Operator::Gt | Operator::Lt => {- if compare == Ordering::Less {- batch_process_state.found = true;- let count = buffered_len - buffer_idx;-- let batch = build_matched_indices_and_mark_buffered(- (buffer_idx, count),- (row_idx, count),- buffered_side,- stream_batch,- join_type,- join_schema,- &mut batch_process_state.batch_min_marked,- )?;-- batch_process_state.output_batches.push_batch(batch)?;-- // Flush batch and update pointers if we have a completed batch- if let Some(batch) =- batch_process_state.output_batches.next_completed_batch()- {- batch_process_state.found = false;- batch_process_state.start_buffer_idx = buffer_idx;- batch_process_state.start_stream_idx = row_idx + 1;- return Ok(batch);- }-- break;- }- }- Operator::GtEq | Operator::LtEq => {- if matches!(compare, Ordering::Equal | Ordering::Less) {- batch_process_state.found = true;- let count = buffered_len - buffer_idx;- let batch = build_matched_indices_and_mark_buffered(- (buffer_idx, count),- (row_idx, count),- buffered_side,- stream_batch,- join_type,- join_schema,- &mut batch_process_state.batch_min_marked,- )?;-- // Flush batch and update pointers if we have a completed batch- batch_process_state.output_batches.push_batch(batch)?;- if let Some(batch) =- batch_process_state.output_batches.next_completed_batch()- {- batch_process_state.found = false;- batch_process_state.start_buffer_idx = buffer_idx;- batch_process_state.start_stream_idx = row_idx + 1;- return Ok(batch);- }-- break;- }- }- _ => {- return internal_err!(- "PiecewiseMergeJoin should not contain operator, {}",- operator- );- }- }+ let match_on_equal = matches_on_equal(operator)?;- // Increment buffer_idx after every row- buffer_idx += 1;- }-- // If a match was not found for the current stream row index the stream indice is appended- // to the unmatched indices to be flushed later.- if matches!(join_type, JoinType::Right | JoinType::Full)- && !batch_process_state.found- {- batch_process_state- .unmatched_indices- .append_value(row_idx as u32);+ // `buffer_idx` resumes where the previous stream row's first match was: rows are sorted+ // so that each one's first match is at or after the previous one's, which bounds the+ // search below to `[buffer_idx, buffered_len)`.+ //+ // Every row here matches the last buffered row, as `matchable_rows` kept only those.+ for row_idx in stream_idx..stream_batch.batch.num_rows() {+ buffer_idx = first_match(buffer_idx, buffered_len, |idx| {+ is_match(cmp.compare(row_idx, idx), match_on_equal)+ });+ // A row with no match would emit nothing here, and for `Right`/`Full` would never+ // be emitted as unmatched either.+ if buffer_idx >= buffered_len {+ return internal_err!(+ "PiecewiseMergeJoin: streamed row {row_idx} reached the scan without a match"+ );}+ let count = buffered_len - buffer_idx;- batch_process_state.found = false;- }-- // Flushed all unmatched indices on the streamed side- if matches!(join_type, JoinType::Right | JoinType::Full) {- let batch = create_unmatched_batch(- &mut batch_process_state.unmatched_indices,+ let batch = build_matched_indices_and_mark_buffered(+ (buffer_idx, count),+ (row_idx, count),+ buffered_side,stream_batch,+ join_type,join_schema,+ &mut batch_process_state.batch_min_marked,)?;batch_process_state.output_batches.push_batch(batch)?;++ // Flush batch and update pointers if we have a completed batch+ if let Some(batch) = batch_process_state.output_batches.next_completed_batch() {+ batch_process_state.start_buffer_idx = buffer_idx;+ batch_process_state.start_stream_idx = row_idx + 1;+ return Ok(batch);+ }}batch_process_state.continue_process = false;@@ -633,18 +595,127 @@ fn build_matched_indices_and_mark_buffered()?)}-// Creates a record batch from the unmatched indices on the streamed side-fn create_unmatched_batch(- streamed_indices: &mut PrimitiveBuilder<UInt32Type>,- stream_batch: &SortedStreamBatch,+// The last non-null key of the sorted buffered side, or `None` when it is empty or every key+// is NULL. NULLs sort last for `<`/`<=`, so this is not simply the last key. Logical, as a+// run-end encoded or `Null`-typed NULL has no physical null buffer.+fn buffered_extreme(+ values: &ArrayRef,+ sort_options: SortOptions,+) -> Result<Option<ColumnarValue>> {+ let (start, end) = non_null_range(values.as_ref(), sort_options);+ if start == end {+ return Ok(None);+ }+ let last = values.slice(end - 1, 1);+ // `apply_cmp` normalizes `-0.0` only in flat float scalars, not inside a+ // `ScalarValue::Dictionary`, so normalize the key before taking it.+ let extreme = normalize_float_zero(&last);+ Ok(Some(ColumnarValue::Scalar(ScalarValue::try_from_array(+ &extreme, 0,+ )?)))+}++// Which rows of `stream_values` can match at least one buffered row.+//+// Every match set is a suffix `[k, non_null_end)` of the sorted buffered side's non-null keys,+// so a streamed row matches anything at all iff it matches the last of them, `buffered_extreme`+// (`None` when no buffered key is non-null, so nothing can match). A NULL on either side+// compares to NULL, which is no match.+//+// This must agree exactly with the scan's `JoinKeyComparator`, or it would change which rows+// match. One vectorized `apply_cmp` does, nested keys included: it normalizes `-0.0` to+// `+0.0` as the comparator does, and orders NULL elements inside a nested key the same way.+fn matchable_rows(+ stream_values: &ArrayRef,+ buffered_values: &ArrayRef,+ buffered_extreme: Option<&ColumnarValue>,+ operator: Operator,+ sort_options: SortOptions,+) -> Result<BooleanArray> {+ let num_rows = stream_values.len();+ let Some(extreme) = buffered_extreme else {+ return Ok(BooleanArray::new(BooleanBuffer::new_unset(num_rows), None));+ };++ // Run-end encoded keys are decided with the scan's own comparator: arrow's run-end+ // comparison kernel overflows on an empty batch sliced past its first run, which the+ // scan never reaches.+ if matches!(stream_values.data_type(), DataType::RunEndEncoded(_, _)) {+ let match_on_equal = matches_on_equal(operator)?;+ let cmp = JoinKeyComparator::new(+ &[Arc::clone(stream_values)],+ &[Arc::clone(buffered_values)],+ &[sort_options],+ NullEquality::NullEqualsNothing,+ )?;+ let last = non_null_range(buffered_values.as_ref(), sort_options).1 - 1;+ // Logical NULLs: a run-end encoded NULL has no physical null buffer.+ let nulls = stream_values.logical_nulls();+ let matchable = BooleanBuffer::collect_bool(num_rows, |row| {+ nulls.as_ref().is_none_or(|nulls| nulls.is_valid(row))+ && is_match(cmp.compare(row, last), match_on_equal)+ });+ return Ok(BooleanArray::new(matchable, None));+ }++ // The predicate is oriented `buffered OP streamed`.+ let result = apply_cmp(+ operator,+ extreme,+ &ColumnarValue::Array(Arc::clone(stream_values)),+ )?+ .into_array(num_rows)?;+ let result = result.as_boolean();+ let matchable = if result.null_count() > 0 {+ prep_null_mask_filter(result)+ } else {+ result.clone()+ };+ // The nested `apply_cmp` masks only physical NULLs, so a dictionary key pointing at a+ // NULL nested value would pass.+ Ok(match stream_values.logical_nulls() {+ Some(nulls) => BooleanArray::new(matchable.values() & nulls.inner(), None),+ None => matchable,+ })+}++// Settles the rows of `batch` that `matchable` rules out: pushed to `output_batches` as+// unmatched rows for `Right`/`Full`, dropped for `Inner`/`Left`, as they produce nothing and+// mark nothing. Returns `None` when every row is a candidate, otherwise the candidates'+// positions in `batch` and their compare keys.+fn split_off_never_matching(+ matchable: &BooleanArray,+ join_type: JoinType,+ join_schema: &SchemaRef,+ batch: &RecordBatch,+ stream_values: &ArrayRef,+ output_batches: &mut BatchCoalescer,+) -> Result<Option<(UInt32Array, ArrayRef)>> {+ if matchable.true_count() == batch.num_rows() {+ return Ok(None);+ }++ if matches!(join_type, JoinType::Right | JoinType::Full) {+ let unmatched = filter_record_batch(batch, ¬(matchable)?)?;+ output_batches+ .push_batch(null_padded_streamed_batch(&unmatched, join_schema)?)?;+ }++ let positions =+ UInt32Array::from_iter_values(matchable.values().set_indices().map(|i| i as u32));+ let keys = filter(stream_values.as_ref(), matchable)?;+ Ok(Some((positions, keys)))+}++// Joins streamed rows with NULLs for every buffered column.+fn null_padded_streamed_batch(+ streamed_batch: &RecordBatch,join_schema: &SchemaRef,) -> Result<RecordBatch> {- let streamed_indices = streamed_indices.finish();- let new_stream_batch = take_record_batch(&stream_batch.batch, &streamed_indices)?;- let streamed_columns = new_stream_batch.columns().to_vec();+ let streamed_columns = streamed_batch.columns().to_vec();let buffered_cols_len = join_schema.fields().len() - streamed_columns.len();- let num_rows = new_stream_batch.num_rows();+ let num_rows = streamed_batch.num_rows();let mut buffered_columns: Vec<ArrayRef> = join_schema.fields().iter()@@ -671,7 +742,7 @@ mod tests {test::{TestMemoryExec, assert_join_metrics, build_table_i32},};use arrow::array::{Date32Array, Date64Array};- use arrow_schema::{DataType, Field};+ use arrow_schema::Field;use datafusion_common::instant::Instant;use datafusion_common::test_util::batches_to_string;use datafusion_common::tree_node::TreeNodeRecursion;@@ -1021,8 +1092,8 @@ mod tests {+----+----+-----+----+----+-----+| a1 | b1 | c1 | a2 | b1 | c2 |+----+----+-----+----+----+-----+- | 2 | 2 | 200 | 20 | 2 | 400 || | | | 10 | 3 | 300 |+ | 2 | 2 | 200 | 20 | 2 | 400 || 1 | 1 | 100 | | | |+----+----+-----+----+----+-----+");@@ -1124,10 +1195,10 @@ mod tests {+----+----+----+----+----+----+| a1 | b1 | c1 | a2 | b1 | c2 |+----+----+----+----+----+----++ | | | | 10 | 5 | 70 || 2 | 3 | 8 | 30 | 2 | 90 || 3 | 4 | 9 | 30 | 2 | 90 || 3 | 4 | 9 | 20 | 3 | 80 |- | | | | 10 | 5 | 70 |+----+----+----+----+----+----+");@@ -1187,6 +1258,532 @@ mod tests {Ok(())}+ /// An empty streamed batch of run-end encoded keys, sliced past the first run, must not+ /// reach arrow's run-end comparison kernel, which overflows on it. The streamed NULL key+ /// (`a2 = 0`) is a logical NULL with no physical null buffer, and must come out unmatched+ /// rather than join every buffered row.+ #[tokio::test]+ async fn join_right_run_end_encoded_keys_empty_sliced_batch() -> Result<()> {+ use arrow::array::{Int32Array, RunArray};+ use arrow::datatypes::Int32Type;++ let ree_exec = |ids: &str,+ keys: &str,+ run_ends: Vec<i32>,+ values: Vec<Option<i32>>,+ slices: &[(usize, usize)]|+ -> Result<Arc<dyn ExecutionPlan>> {+ let keys_array = RunArray::<Int32Type>::try_new(+ &Int32Array::from(run_ends),+ &Int32Array::from(values),+ )?;+ let schema = Arc::new(Schema::new(vec![+ Field::new(ids, DataType::Int32, false),+ Field::new(keys, keys_array.data_type().clone(), true),+ ]));+ let len = keys_array.len() as i32;+ let batch = RecordBatch::try_new(+ Arc::clone(&schema),+ vec![+ Arc::new(Int32Array::from((0..len).collect::<Vec<_>>())),+ Arc::new(keys_array),+ ],+ )?;+ let batches = slices+ .iter()+ .map(|&(offset, len)| batch.slice(offset, len))+ .collect::<Vec<_>>();+ Ok(TestMemoryExec::try_new_exec(&[batches], schema, None)?)+ };+ // Buffered keys sorted for `<` (descending, NULLs last): {5, 5, 1, 1, NULL}.+ let left = ree_exec(+ "a1",+ "b1",+ vec![2, 4, 5],+ vec![Some(5), Some(1), None],+ &[(0, 5)],+ )?;+ // Streamed keys {NULL, 2, 2, 0, 6}, as batches of 3, 0 and 2 rows. The empty one+ // starts at offset 3, past the end of the first run.+ let right = ree_exec(+ "a2",+ "b2",+ vec![1, 3, 4, 5],+ vec![None, Some(2), Some(0), Some(6)],+ &[(0, 3), (3, 0), (3, 2)],+ )?;+ let on = (+ Arc::new(Column::new_with_schema("b1", &left.schema())?) as _,+ Arc::new(Column::new_with_schema("b2", &right.schema())?) as _,+ );++ let (_, batches, _) =+ join_collect(left, right, on, Operator::Lt, JoinType::Right).await?;+ assert_snapshot!(batches_to_string(&batches), @r"+ +----+----+----+----++ | a1 | b1 | a2 | b2 |+ +----+----+----+----++ | | | 0 | |+ | 2 | 1 | 1 | 2 |+ | 3 | 1 | 1 | 2 |+ | 2 | 1 | 2 | 2 |+ | 3 | 1 | 2 | 2 |+ | | | 3 | 0 |+ | 0 | 5 | 4 | 6 |+ | 1 | 5 | 4 | 6 |+ | 2 | 1 | 4 | 6 |+ | 3 | 1 | 4 | 6 |+ +----+----+----+----++ ");+ Ok(())+ }++ /// `buffered_extreme` is `None` when the last buffered key is logically NULL, including+ /// run-end encoded, `Null`-typed and dictionary keys, which have no physical NULL there.+ #[test]+ fn buffered_extreme_is_none_for_logically_null_keys() -> Result<()> {+ use arrow::array::{DictionaryArray, Int32Array, ListArray, NullArray, RunArray};+ use arrow::datatypes::Int32Type;++ let null_keys: Vec<(&str, ArrayRef)> = vec![+ ("null", Arc::new(NullArray::new(3))),+ (+ "run_end_encoded",+ Arc::new(RunArray::<Int32Type>::try_new(+ &Int32Array::from(vec![3]),+ &Int32Array::from(vec![None::<i32>]),+ )?),+ ),+ (+ "dictionary_null_value",+ Arc::new(DictionaryArray::<Int32Type>::try_new(+ Int32Array::from(vec![0, 0]),+ Arc::new(Int32Array::from(vec![None::<i32>])),+ )?),+ ),+ (+ // `matchable_rows` relies on this: the nested `apply_cmp` would not mask it.+ "dictionary_list_null_value",+ Arc::new(DictionaryArray::<Int32Type>::try_new(+ Int32Array::from(vec![0, 0]),+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ None::<Vec<Option<i32>>>,+ ])),+ )?),+ ),+ ];+ // NULLs sort first for `>`/`>=` and last for `<`/`<=`.+ let nulls_first = SortOptions::new(false, true);+ let nulls_last = SortOptions::new(true, false);+ for (name, values) in null_keys {+ for sort_options in [nulls_first, nulls_last] {+ assert!(buffered_extreme(&values, sort_options)?.is_none(), "{name}");+ }+ }++ // The last non-null key, wherever the NULLs sort.+ for (values, sort_options) in [+ (vec![None, Some(1), Some(3)], nulls_first),+ (vec![Some(5), Some(3), None], nulls_last),+ ] {+ let values: ArrayRef = Arc::new(Int32Array::from(values));+ assert!(matches!(+ buffered_extreme(&values, sort_options)?,+ Some(ColumnarValue::Scalar(ScalarValue::Int32(Some(3))))+ ));+ }+ Ok(())+ }++ /// `matchable_rows` against the scan's own definition of a match -- some non-NULL+ /// buffered row `idx` with `is_match(cmp.compare(row, idx))` under the scan's+ /// `JoinKeyComparator` -- for every operator and every kind of key it dispatches on:+ /// keys through `apply_cmp` (incl. signed zeros, NaN, strings, dictionaries, and list,+ /// list-of-list and struct keys with NULL elements) and run-end encoded keys through+ /// the comparator. Each is also checked against+ /// an all-NULL and an empty buffered side.+ #[test]+ fn matchable_rows_agrees_with_scan() -> Result<()> {+ use arrow::array::{+ BinaryArray, BooleanArray, Decimal128Array, DictionaryArray, Float64Array,+ Int32Array, Int32Builder, ListArray, ListBuilder, StringArray,+ StringViewArray, StructArray, TimestampMicrosecondArray,+ };+ use arrow::buffer::NullBuffer;+ use arrow::datatypes::{Fields, Int32Type};++ let strings =+ |v: &[Option<&str>]| Arc::new(StringArray::from(v.to_vec())) as ArrayRef;+ type ListOfLists = Vec<Option<Vec<Option<Vec<Option<i32>>>>>>;+ let list_of_lists = |v: ListOfLists| {+ let mut builder = ListBuilder::new(ListBuilder::new(Int32Builder::new()));+ for outer in v {+ match outer {+ None => builder.append(false),+ Some(inner) => {+ for list in inner {+ builder.values().append_option(list);+ }+ builder.append(true);+ }+ }+ }+ Arc::new(builder.finish()) as ArrayRef+ };+ // A struct of two nullable Int32 fields, with its own validity.+ let structs =+ |a: Vec<Option<i32>>, b: Vec<Option<i32>>, valid: Option<Vec<bool>>| {+ let fields = Fields::from(vec![+ Field::new("a", DataType::Int32, true),+ Field::new("b", DataType::Int32, true),+ ]);+ Arc::new(StructArray::new(+ fields,+ vec![+ Arc::new(Int32Array::from(a)) as ArrayRef,+ Arc::new(Int32Array::from(b)) as ArrayRef,+ ],+ valid.map(NullBuffer::from),+ )) as ArrayRef+ };+ let cases: Vec<(&str, ArrayRef, ArrayRef)> = vec![+ (+ "int32",+ Arc::new(Int32Array::from(vec![+ Some(5),+ None,+ Some(1),+ Some(9),+ Some(3),+ ])),+ Arc::new(Int32Array::from(vec![+ Some(0),+ Some(1),+ Some(2),+ Some(3),+ Some(5),+ Some(9),+ Some(10),+ None,+ ])),+ ),+ (+ "float64",+ Arc::new(Float64Array::from(vec![+ Some(0.0),+ Some(-0.0),+ Some(1.5),+ Some(f64::NAN),+ None,+ ])),+ Arc::new(Float64Array::from(vec![+ Some(-0.0),+ Some(0.0),+ Some(1.5),+ Some(f64::NAN),+ Some(-1.0),+ Some(2.0),+ Some(f64::INFINITY),+ Some(f64::NEG_INFINITY),+ None,+ ])),+ ),+ (+ "utf8",+ strings(&[Some("b"), Some(""), Some("d"), None]),+ strings(&[+ Some(""),+ Some("a"),+ Some("b"),+ Some("c"),+ Some("d"),+ Some("e"),+ None,+ ]),+ ),+ (+ "utf8_view",+ Arc::new(StringViewArray::from(vec![+ Some("b"),+ Some(""),+ Some("d"),+ None,+ ])),+ Arc::new(StringViewArray::from(vec![+ Some(""),+ Some("a"),+ Some("b"),+ Some("d"),+ Some("e"),+ None,+ ])),+ ),+ (+ "binary",+ Arc::new(BinaryArray::from(vec![Some(&b"b"[..]), Some(b""), None])),+ Arc::new(BinaryArray::from(vec![+ Some(&b""[..]),+ Some(b"a"),+ Some(b"b"),+ Some(b"c"),+ None,+ ])),+ ),+ (+ "dictionary",+ Arc::new(+ vec![Some("b"), None, Some("d"), Some("b")]+ .into_iter()+ .collect::<DictionaryArray<Int32Type>>(),+ ),+ Arc::new(+ vec![Some("a"), Some("b"), Some("c"), Some("d"), Some("e"), None]+ .into_iter()+ .collect::<DictionaryArray<Int32Type>>(),+ ),+ ),+ (+ // `-0.0` as the buffered extreme inside a dictionary: the smallest+ // key for `<`/`<=`, the largest for `>`/`>=`.+ "dictionary_float64_neg_zero_min",+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1]),+ Arc::new(Float64Array::from(vec![-0.0, 0.5])),+ )),+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1, 2]),+ Arc::new(Float64Array::from(vec![0.0, -0.0, 0.25])),+ )),+ ),+ (+ "dictionary_float64_neg_zero_max",+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1]),+ Arc::new(Float64Array::from(vec![-1.0, -0.0])),+ )),+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1, 2]),+ Arc::new(Float64Array::from(vec![0.0, -0.0, -0.5])),+ )),+ ),+ (+ // NULL *values* behind valid dictionary keys, on both sides.+ "dictionary_null_values",+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1, 2]),+ Arc::new(StringArray::from(vec![Some("b"), None, Some("d")])),+ )),+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1, 2, 3, 1]),+ Arc::new(StringArray::from(vec![+ Some("a"),+ None,+ Some("c"),+ Some("e"),+ ])),+ )),+ ),+ (+ "decimal128",+ Arc::new(+ Decimal128Array::from(vec![Some(150), None, Some(-25)])+ .with_precision_and_scale(10, 2)?,+ ),+ Arc::new(+ Decimal128Array::from(vec![+ Some(-26),+ Some(-25),+ Some(0),+ Some(150),+ Some(151),+ None,+ ])+ .with_precision_and_scale(10, 2)?,+ ),+ ),+ (+ "date32",+ Arc::new(Date32Array::from(vec![Some(10), None, Some(20)])),+ Arc::new(Date32Array::from(vec![+ Some(9),+ Some(10),+ Some(15),+ Some(20),+ Some(21),+ None,+ ])),+ ),+ (+ "timestamp_us",+ Arc::new(TimestampMicrosecondArray::from(vec![+ Some(-5),+ Some(7),+ None,+ ])),+ Arc::new(TimestampMicrosecondArray::from(vec![+ Some(-6),+ Some(-5),+ Some(7),+ Some(8),+ None,+ ])),+ ),+ (+ "boolean",+ Arc::new(BooleanArray::from(vec![Some(true), None])),+ Arc::new(BooleanArray::from(vec![Some(false), Some(true), None])),+ ),+ (+ "list_with_null_elements",+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ Some(vec![Some(5)]),+ Some(vec![None]),+ Some(vec![Some(1), Some(2)]),+ Some(vec![]),+ None,+ ])),+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ Some(vec![None]),+ Some(vec![Some(7)]),+ Some(vec![Some(1)]),+ Some(vec![Some(5)]),+ Some(vec![]),+ Some(vec![None, Some(1)]),+ Some(vec![Some(5), None]),+ None,+ ])),+ ),+ (+ // No empty list, so the extreme key has a first element to compare+ // against the streamed NULL elements.+ "list_null_elements_vs_extreme",+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ Some(vec![Some(5)]),+ Some(vec![Some(3)]),+ None,+ ])),+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ Some(vec![None]),+ Some(vec![Some(3), None]),+ Some(vec![Some(4)]),+ Some(vec![Some(7)]),+ Some(vec![Some(1)]),+ None,+ ])),+ ),+ (+ "list_of_list_null_elements",+ list_of_lists(vec![+ Some(vec![Some(vec![Some(5)]), None]),+ Some(vec![Some(vec![Some(3), None])]),+ None,+ ]),+ list_of_lists(vec![+ Some(vec![None]),+ Some(vec![Some(vec![None])]),+ Some(vec![Some(vec![Some(3)])]),+ Some(vec![Some(vec![Some(3), None])]),+ Some(vec![Some(vec![Some(5)]), Some(vec![Some(1)])]),+ Some(vec![Some(vec![Some(7)])]),+ None,+ ]),+ ),+ (+ "struct_null_fields",+ structs(+ vec![Some(5), Some(3), None, Some(3)],+ vec![Some(1), None, Some(2), Some(2)],+ Some(vec![true, true, true, false]),+ ),+ structs(+ vec![None, Some(3), Some(3), Some(4), Some(5), Some(7), None],+ vec![Some(1), None, Some(0), None, Some(2), Some(1), None],+ Some(vec![true, true, true, true, true, true, false]),+ ),+ ),+ (+ // A valid key pointing at a NULL list: logically NULL, physically valid.+ "dictionary_list_null_values",+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![0, 1, 2]),+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ Some(vec![Some(5)]),+ None,+ Some(vec![Some(1)]),+ ])),+ )),+ Arc::new(DictionaryArray::<Int32Type>::new(+ Int32Array::from(vec![Some(0), Some(1), Some(2), Some(3), None]),+ Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![+ Some(vec![Some(2)]),+ None,+ Some(vec![Some(6)]),+ Some(vec![Some(0)]),+ ])),+ )),+ ),+ ];++ for (name, buffered, streamed) in cases {+ let all_null = new_null_array(buffered.data_type(), 3);+ let empty = buffered.slice(0, 0);+ for (side, buffered) in+ [("full", buffered), ("all_null", all_null), ("empty", empty)]+ {+ for operator in+ [Operator::Lt, Operator::LtEq, Operator::Gt, Operator::GtEq]+ {+ // As `PiecewiseMergeJoinExec::try_new` sorts both sides.+ let sort_options = match operator {+ Operator::Lt | Operator::LtEq => SortOptions::new(true, false),+ _ => SortOptions::new(false, true),+ };+ let indices = lexsort_to_indices(+ &[SortColumn {+ values: Arc::clone(&buffered),+ options: Some(sort_options),+ }],+ None,+ )?;+ let sorted = take(buffered.as_ref(), &indices, None)?;+ let extreme = buffered_extreme(&sorted, sort_options)?;++ let actual = matchable_rows(+ &streamed,+ &sorted,+ extreme.as_ref(),+ operator,+ sort_options,+ )?;++ let match_on_equal = matches_on_equal(operator)?;+ let cmp = JoinKeyComparator::new(+ &[Arc::clone(&streamed)],+ &[Arc::clone(&sorted)],+ &[sort_options],+ NullEquality::NullEqualsNothing,+ )?;+ // Logical NULLs, so a dictionary key whose *value* is NULL counts as one.+ let nulls = streamed.logical_nulls();+ let buffered_nulls = sorted.logical_nulls();+ for row in 0..streamed.len() {+ let expected = nulls.as_ref().is_none_or(|n| n.is_valid(row))+ && (0..sorted.len()).any(|idx| {+ buffered_nulls.as_ref().is_none_or(|n| n.is_valid(idx))+ && is_match(cmp.compare(row, idx), match_on_equal)+ });+ assert_eq!(+ actual.value(row),+ expected,+ "{name}/{side} {operator}: streamed row {row}"+ );+ }+ }+ }+ }+ Ok(())+ }+#[tokio::test]async fn join_inner_less_than_equal_with_dups() -> Result<()> {// +----+----+----+@@ -1594,8 +2191,8 @@ mod tests {+-------------------------+---------------------+-------------------------+-------------------------+---------------------+-------------------------+| a1 | b1 | c1 | a2 | b1 | c2 |+-------------------------+---------------------+-------------------------+-------------------------+---------------------+-------------------------+- | 1970-01-01T00:00:00.002 | 2022-04-23T08:44:01 | 1970-01-01T00:00:00.008 | 1970-01-01T00:00:00.020 | 2022-04-25T16:17:21 | 1970-01-01T00:00:00.090 || | | | 1970-01-01T00:00:00.010 | 2022-04-23T08:44:01 | 1970-01-01T00:00:00.080 |+ | 1970-01-01T00:00:00.002 | 2022-04-23T08:44:01 | 1970-01-01T00:00:00.008 | 1970-01-01T00:00:00.020 | 2022-04-25T16:17:21 | 1970-01-01T00:00:00.090 |+-------------------------+---------------------+-------------------------+-------------------------+---------------------+-------------------------+");diff --git a/datafusion/physical-plan/src/joins/piecewise_merge_join/exec.rs b/datafusion/physical-plan/src/joins/piecewise_merge_join/exec.rsindex fb878b7747..e1bf6b8711 100644--- a/datafusion/physical-plan/src/joins/piecewise_merge_join/exec.rs+++ b/datafusion/physical-plan/src/joins/piecewise_merge_join/exec.rs@@ -97,15 +97,23 @@ use crate::{/// in `requires_input_order`, which allows the optimizer to automatically insert a `SortExec` on that side if needed./// By the time this operator runs, the buffered side is guaranteed to be in the proper order.///+/// Every match set is a suffix of the sorted buffered side's non-null keys, so a streamed row matches+/// anything at all exactly when it matches the last of them. Each streamed batch is first checked against that+/// key with one vectorized comparison: rows that fail it (including NULL keys) are emitted as+/// unmatched for `Right`/`Full` and dropped otherwise, before the sort. Only the rest are sorted,+/// and each one's first match is found by a binary search that starts at the previous row's.+////// The pseudocode for the algorithm looks like this:////// ```text-/// for stream_row in stream_batch:-/// for buffer_row in buffer_batch:-/// if compare(stream_row, probe_row):-/// output stream_row X buffer_batch[buffer_row:]-/// else:-/// continue+/// extreme = buffer_batch[last non-null]+/// candidates = [row for row in stream_batch if compare(row, extreme)]+/// emit the other rows as unmatched (Right/Full) or drop them (Inner/Left)+///+/// start = 0+/// for stream_row in sort(candidates):+/// start = binary_search(buffer_batch[start:], first row matching stream_row)+/// output stream_row X buffer_batch[start:]/// ```////// The algorithm uses the streamed side (larger) to drive the loop. This is due to every row on the stream side iterating@@ -115,7 +123,7 @@ use crate::{/// Here is an example:////// We perform a `JoinType::Left` with these two batches and the operator being `Operator::Lt`(<). For each-/// row on the streamed side we move a pointer on the buffered until it matches the condition. Once we reach+/// row on the streamed side we search the buffered side for the first row that matches the condition. Once we reach/// the row which matches (in this case with row 1 on streamed will have its first match on row 2 on/// buffered; 100 < 200 is true), we can emit all rows after that match. We can emit the rows like this because/// if the batch is sorted in ascending order, every subsequent row will also satisfy the condition as they willdiff --git a/datafusion/physical-plan/src/joins/piecewise_merge_join/existence_join.rs b/datafusion/physical-plan/src/joins/piecewise_merge_join/existence_join.rsindex 274577b4ed..267fc3ba8b 100644--- a/datafusion/physical-plan/src/joins/piecewise_merge_join/existence_join.rs+++ b/datafusion/physical-plan/src/joins/piecewise_merge_join/existence_join.rs@@ -108,6 +108,9 @@ use futures::{Stream, StreamExt};use super::utils::{non_null_range, unmatched_buffered_batch};use crate::handle_state;use crate::joins::piecewise_merge_join::exec::{BufferedSide, BufferedSideReadyState};+use crate::joins::piecewise_merge_join::utils::{+ first_match, is_match, matches_on_equal,+};use crate::joins::utils::{BuildProbeJoinMetrics, JoinKeyComparator, StatefulStreamResult,};@@ -326,18 +329,8 @@ impl ExistencePWMJStream {// is 0 for a real key and 1 for an all-null batch, which skips the scan.let row_idx = stream_values.null_count();- // `<=`/`>=` also match on equality; validated once here rather than inside- // the search below.- let match_on_equal = match operator {- Operator::Gt | Operator::Lt => false,- Operator::GtEq | Operator::LtEq => true,- _ => {- return internal_err!(- "PiecewiseMergeJoin should not contain operator, {}",- operator- );- }- };+ // Validated once here rather than inside the search below.+ let match_on_equal = matches_on_equal(operator)?;if row_idx < stream_values.len() && first_non_null_buffered < scan_limit {let cmp = JoinKeyComparator::new(@@ -346,31 +339,16 @@ impl ExistencePWMJStream {&[sort_option],NullEquality::NullEqualsNothing,)?;- let is_match = |buffer_idx: usize| {- let compare = cmp.compare(row_idx, buffer_idx);- compare == Ordering::Less- || (match_on_equal && compare == Ordering::Equal)+ let matches = |buffer_idx: usize| {+ is_match(cmp.compare(row_idx, buffer_idx), match_on_equal)};- // Because the buffered side is sorted, `is_match` is monotone over it:+ // Because the buffered side is sorted, `matches` is monotone over it:// false while the buffered key has not yet passed the streamed key, true- // from there on. So the first match is a partition point and can be found- // by binary search instead of a walk -- `O(log buffered)` per batch rather- // than `O(buffered)`.- let mut lo = first_non_null_buffered;- let mut hi = scan_limit;- while lo < hi {- let mid = lo + (hi - lo) / 2;- if is_match(mid) {- hi = mid;- } else {- lo = mid + 1;- }- }-- // `lo` is now the first matching buffered index, or `scan_limit` if this- // batch matches nothing new.- let buffer_idx = lo;+ // from there on. `buffer_idx` is the first matching buffered index, or+ // `scan_limit` if this batch matches nothing new.+ let buffer_idx =+ first_match(first_non_null_buffered, scan_limit, matches);if buffer_idx < scan_limit {// Everything from `buffer_idx` on matches, so lowering the// watermark to it records the match: the marked set is exactlydiff --git a/datafusion/physical-plan/src/joins/piecewise_merge_join/utils.rs b/datafusion/physical-plan/src/joins/piecewise_merge_join/utils.rsindex 2c0417aada..008e36a273 100644--- a/datafusion/physical-plan/src/joins/piecewise_merge_join/utils.rs+++ b/datafusion/physical-plan/src/joins/piecewise_merge_join/utils.rs@@ -15,11 +15,13 @@// specific language governing permissions and limitations// under the License.+use std::cmp::Ordering;+use arrow::array::{Array, RecordBatch};use arrow::compute::concat_batches;use arrow_schema::SortOptions;-use datafusion_common::Result;-use datafusion_expr::JoinType;+use datafusion_common::{Result, internal_err};+use datafusion_expr::{JoinType, Operator};/// Bounds of the non-null keys in an array sorted with `options`.pub(super) fn non_null_range(values: &dyn Array, options: SortOptions) -> (usize, usize) {@@ -63,3 +65,86 @@ pub(super) fn is_right_existence_join(join_type: JoinType) -> bool {pub(super) fn need_produce_result_in_final(join_type: JoinType) -> bool {matches!(join_type, JoinType::Full | JoinType::Left)}++// Whether `operator` also holds when the two keys are equal: `<=` and `>=` do, `<` and `>`+// do not.+pub(super) fn matches_on_equal(operator: Operator) -> Result<bool> {+ match operator {+ Operator::Lt | Operator::Gt => Ok(false),+ Operator::LtEq | Operator::GtEq => Ok(true),+ _ => internal_err!("PiecewiseMergeJoin should not contain operator, {operator}"),+ }+}++// Whether the predicate holds for a streamed key that compares `ordering` to a buffered key+// under the join's sort options. Those are chosen so that `Less` means the predicate holds+// for every operator; `Equal` does too for `<=`/`>=`.+pub(super) fn is_match(ordering: Ordering, match_on_equal: bool) -> bool {+ match ordering {+ Ordering::Less => true,+ Ordering::Equal => match_on_equal,+ Ordering::Greater => false,+ }+}++// Returns the first index in `[lo, hi)` for which `matches` holds, or `hi` if none does.+//+// `matches` must be monotone over that range -- false up to some index, true from there on.+// Both PiecewiseMergeJoin streams search a sorted buffered side, where every match set is a+// suffix, so the first match is a partition point: `O(log(hi - lo))` comparisons instead of a+// walk.+pub(super) fn first_match(+ lo: usize,+ hi: usize,+ matches: impl Fn(usize) -> bool,+) -> usize {+ let (mut first, mut above) = (lo, hi);+ while first < above {+ let mid = first + (above - first) / 2;+ if matches(mid) {+ above = mid;+ } else {+ first = mid + 1;+ }+ }+ first+}++#[cfg(test)]+mod tests {+ use super::first_match;++ /// `first_match` against a linear scan for every range, answer and start up to 40, also+ /// bounding its comparisons by `ceil(log2(hi - lo + 1))`.+ #[test]+ fn first_match_agrees_with_linear_scan() {+ for hi in 0..=40usize {+ for boundary in 0..=hi {+ for lo in 0..=hi {+ let probes = std::cell::Cell::new(0usize);+ let matches = |idx: usize| {+ assert!(+ idx >= lo && idx < hi,+ "probed {idx} outside [{lo}, {hi})"+ );+ probes.set(probes.get() + 1);+ idx >= boundary+ };+ let expected = (lo..hi).find(|&idx| idx >= boundary).unwrap_or(hi);+ assert_eq!(+ first_match(lo, hi, matches),+ expected,+ "hi={hi} boundary={boundary} lo={lo}"+ );++ let bound = (usize::BITS - (hi - lo).leading_zeros()) as usize;+ assert!(+ probes.get() <= bound,+ "hi={hi} boundary={boundary} lo={lo}: {} probes > {bound}",+ probes.get()+ );+ }+ }+ }+ }+}diff --git a/datafusion/sqllogictest/test_files/piecewise_merge_join_matrix.slt b/datafusion/sqllogictest/test_files/piecewise_merge_join_matrix.sltindex 6714f3d2a6..401e56b41c 100644--- a/datafusion/sqllogictest/test_files/piecewise_merge_join_matrix.slt+++ b/datafusion/sqllogictest/test_files/piecewise_merge_join_matrix.slt@@ -164,6 +164,444 @@ SELECT l.lid, l.lv, r.rid, r.rv FROM cj_dup_l l JOIN cj_dup_r r ON l.lv < r.rv;2 1 1 22 1 2 2+# Float key with negative zero on an outer side: -0.0 and +0.0 compare equal in+# SQL, so `-0.0 < 0.0` is false and `-0.0 <= 0.0` is true. Streamed rows that+# match no buffered row are set aside before the sort, and that check must agree+# with the scan's comparator, which normalizes the sign of zero.+statement ok+CREATE TABLE cj_fl(lid INT, lv DOUBLE);++statement ok+INSERT INTO cj_fl VALUES (1, -0.0);++statement ok+CREATE TABLE cj_fr(rid INT, rv DOUBLE);++statement ok+INSERT INTO cj_fr VALUES (1, 0.0), (2, -1.0);++query IRIR rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_fl l RIGHT JOIN cj_fr r ON l.lv < r.rv;+----+NULL NULL 1 0+NULL NULL 2 -1++query IRIR rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_fl l RIGHT JOIN cj_fr r ON l.lv <= r.rv;+----+1 0 1 0+NULL NULL 2 -1++query IRIR rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_fl l FULL JOIN cj_fr r ON l.lv < r.rv;+----+1 0 NULL NULL+NULL NULL 1 0+NULL NULL 2 -1++# The same signed-zero agreement with dictionary-encoded float keys, whose+# values are normalized one level down. -0.0 is the smallest buffered key for+# `<` and the largest for `>=`.+statement ok+CREATE TABLE cj_dfl(lid INT, lv DOUBLE);++statement ok+INSERT INTO cj_dfl VALUES (1, -0.0), (2, 0.5);++statement ok+CREATE TABLE cj_dfr(rid INT, rv DOUBLE);++statement ok+INSERT INTO cj_dfr VALUES (1, 0.0), (2, 0.25);++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv+FROM (SELECT lid, arrow_cast(lv, 'Dictionary(Int32, Float64)') AS lv FROM cj_dfl) l+JOIN (SELECT rid, arrow_cast(rv, 'Dictionary(Int32, Float64)') AS rv FROM cj_dfr) r+ ON l.lv < r.rv;+----+1 0 2 0.25++statement ok+CREATE TABLE cj_dfl2(lid INT, lv DOUBLE);++statement ok+INSERT INTO cj_dfl2 VALUES (1, -1.0), (2, -0.0);++statement ok+CREATE TABLE cj_dfr2(rid INT, rv DOUBLE);++statement ok+INSERT INTO cj_dfr2 VALUES (1, 0.0);++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv+FROM (SELECT lid, arrow_cast(lv, 'Dictionary(Int32, Float64)') AS lv FROM cj_dfl2) l+RIGHT JOIN (SELECT rid, arrow_cast(rv, 'Dictionary(Int32, Float64)') AS rv FROM cj_dfr2) r+ ON l.lv >= r.rv;+----+2 0 1 0++# One unsorted streamed batch mixing matching, non-matching and NULL keys. The+# non-matching and NULL rows are set aside before the sort, and the rest are+# sorted and mapped back to their rows in the batch. Against cj_l.lv = {1,3,5,+# NULL} with `<`: rv=4 matches lv 1 and 3, rv=6 matches 1, 3 and 5, rv=2+# matches 1; rv=0, rv=1 and the NULLs match nothing.+statement ok+CREATE TABLE cj_mix_r(rid INT, rv INT);++statement ok+INSERT INTO cj_mix_r VALUES (1, 4), (2, NULL), (3, 0), (4, 6), (5, 2), (6, NULL), (7, 1);++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_l l JOIN cj_mix_r r ON l.lv < r.rv;+----+1 1 1 4+1 1 4 6+1 1 5 2+2 3 1 4+2 3 4 6+3 5 4 6++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_l l RIGHT JOIN cj_mix_r r ON l.lv < r.rv;+----+1 1 1 4+1 1 4 6+1 1 5 2+2 3 1 4+2 3 4 6+3 5 4 6+NULL NULL 2 NULL+NULL NULL 3 0+NULL NULL 6 NULL+NULL NULL 7 1++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_l l FULL JOIN cj_mix_r r ON l.lv < r.rv;+----+1 1 1 4+1 1 4 6+1 1 5 2+2 3 1 4+2 3 4 6+3 5 4 6+4 NULL NULL NULL+NULL NULL 2 NULL+NULL NULL 3 0+NULL NULL 6 NULL+NULL NULL 7 1++# The streamed side arrives in several batches, and the first one has no+# matchable row: it is settled whole, and the scan sees an empty batch.+statement ok+CREATE TABLE cj_mb_r(rid INT, rv INT);++statement ok+INSERT INTO cj_mb_r VALUES (1, 0), (2, 1);++statement ok+INSERT INTO cj_mb_r VALUES (3, 4), (4, NULL), (5, 6);++statement ok+INSERT INTO cj_mb_r VALUES (6, NULL);++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_l l JOIN cj_mb_r r ON l.lv < r.rv;+----+1 1 3 4+1 1 5 6+2 3 3 4+2 3 5 6+3 5 5 6++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_l l FULL JOIN cj_mb_r r ON l.lv < r.rv;+----+1 1 3 4+1 1 5 6+2 3 3 4+2 3 5 6+3 5 5 6+4 NULL NULL NULL+NULL NULL 1 0+NULL NULL 2 1+NULL NULL 4 NULL+NULL NULL 6 NULL++# A buffered side whose keys are all NULL has no key to match against, so every+# streamed row is settled as unmatched.+statement ok+CREATE TABLE cj_alln(lid INT, lv INT);++statement ok+INSERT INTO cj_alln VALUES (1, NULL), (2, NULL);++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_alln l JOIN cj_r r ON l.lv < r.rv;+----++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_alln l RIGHT JOIN cj_r r ON l.lv < r.rv;+----+NULL NULL 1 3+NULL NULL 2 5+NULL NULL 3 NULL++query IIII rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_alln l FULL JOIN cj_r r ON l.lv >= r.rv;+----+1 NULL NULL NULL+2 NULL NULL NULL+NULL NULL 1 3+NULL NULL 2 5+NULL NULL 3 NULL++# Keys of type Null (columns built only from NULL literals) match nothing.+statement ok+CREATE TABLE cj_nl AS SELECT * FROM (VALUES (1, NULL), (2, NULL)) AS t(lid, lv);++statement ok+CREATE TABLE cj_nr AS SELECT * FROM (VALUES (10, NULL), (20, NULL)) AS t(rid, rv);++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_nl l JOIN cj_nr r ON l.lv < r.rv;+----++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_nl l LEFT JOIN cj_nr r ON l.lv <= r.rv;+----+1 NULL NULL NULL+2 NULL NULL NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_nl l RIGHT JOIN cj_nr r ON l.lv > r.rv;+----+NULL NULL 10 NULL+NULL NULL 20 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_nl l FULL JOIN cj_nr r ON l.lv >= r.rv;+----+1 NULL NULL NULL+2 NULL NULL NULL+NULL NULL 10 NULL+NULL NULL 20 NULL++# List keys, checked against the buffered extreme with the same vectorized+# comparison as flat keys. A NULL list on the streamed side must still come out+# unmatched.+statement ok+CREATE TABLE cj_ll AS SELECT * FROM (VALUES (1, make_array(1, 2)), (2, make_array(3)), (3, NULL)) AS t(lid, lv);++statement ok+CREATE TABLE cj_lr AS SELECT * FROM (VALUES (1, make_array(2)), (2, make_array(1, 2)), (3, make_array(0)), (4, NULL)) AS t(rid, rv);++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_ll l RIGHT JOIN cj_lr r ON l.lv < r.rv;+----+1 [1, 2] 1 [2]+NULL NULL 2 [1, 2]+NULL NULL 3 [0]+NULL NULL 4 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_ll l FULL JOIN cj_lr r ON l.lv <= r.rv;+----+1 [1, 2] 1 [2]+1 [1, 2] 2 [1, 2]+2 [3] NULL NULL+3 NULL NULL NULL+NULL NULL 3 [0]+NULL NULL 4 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_ll l RIGHT JOIN cj_lr r ON l.lv >= r.rv;+----+1 [1, 2] 2 [1, 2]+1 [1, 2] 3 [0]+2 [3] 1 [2]+2 [3] 2 [1, 2]+2 [3] 3 [0]+NULL NULL 4 NULL++# Struct keys, also checked against the buffered extreme with the vectorized+# comparison. Structs compare field by field, so where `x` ties the NULLable `y`+# decides. cj_sl.lv = {{1,2}, {3,1}, {3,NULL}, NULL}; cj_sr.rv mixes keys that+# tie a buffered key on `x` or on both fields, fall below or above every+# buffered key, have a NULL `y`, or are NULL themselves.+statement ok+CREATE TABLE cj_sl AS SELECT * FROM (VALUES+ (1, named_struct('x', 1, 'y', CAST(2 AS BIGINT))),+ (2, named_struct('x', 3, 'y', CAST(1 AS BIGINT))),+ (3, named_struct('x', 3, 'y', CAST(NULL AS BIGINT))),+ (4, NULL)+) AS t(lid, lv);++statement ok+CREATE TABLE cj_sr AS SELECT * FROM (VALUES+ (1, named_struct('x', 3, 'y', CAST(0 AS BIGINT))),+ (2, named_struct('x', 3, 'y', CAST(2 AS BIGINT))),+ (3, named_struct('x', 1, 'y', CAST(NULL AS BIGINT))),+ (4, named_struct('x', 5, 'y', CAST(0 AS BIGINT))),+ (5, named_struct('x', 0, 'y', CAST(9 AS BIGINT))),+ (6, NULL),+ (7, named_struct('x', 3, 'y', CAST(1 AS BIGINT)))+) AS t(rid, rv);++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_sl l RIGHT JOIN cj_sr r ON l.lv < r.rv;+----+1 {x: 1, y: 2} 1 {x: 3, y: 0}+1 {x: 1, y: 2} 2 {x: 3, y: 2}+1 {x: 1, y: 2} 4 {x: 5, y: 0}+1 {x: 1, y: 2} 7 {x: 3, y: 1}+2 {x: 3, y: 1} 2 {x: 3, y: 2}+2 {x: 3, y: 1} 4 {x: 5, y: 0}+3 {x: 3, y: NULL} 1 {x: 3, y: 0}+3 {x: 3, y: NULL} 2 {x: 3, y: 2}+3 {x: 3, y: NULL} 4 {x: 5, y: 0}+3 {x: 3, y: NULL} 7 {x: 3, y: 1}+NULL NULL 3 {x: 1, y: NULL}+NULL NULL 5 {x: 0, y: 9}+NULL NULL 6 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_sl l FULL JOIN cj_sr r ON l.lv <= r.rv;+----+1 {x: 1, y: 2} 1 {x: 3, y: 0}+1 {x: 1, y: 2} 2 {x: 3, y: 2}+1 {x: 1, y: 2} 4 {x: 5, y: 0}+1 {x: 1, y: 2} 7 {x: 3, y: 1}+2 {x: 3, y: 1} 2 {x: 3, y: 2}+2 {x: 3, y: 1} 4 {x: 5, y: 0}+2 {x: 3, y: 1} 7 {x: 3, y: 1}+3 {x: 3, y: NULL} 1 {x: 3, y: 0}+3 {x: 3, y: NULL} 2 {x: 3, y: 2}+3 {x: 3, y: NULL} 4 {x: 5, y: 0}+3 {x: 3, y: NULL} 7 {x: 3, y: 1}+4 NULL NULL NULL+NULL NULL 3 {x: 1, y: NULL}+NULL NULL 5 {x: 0, y: 9}+NULL NULL 6 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_sl l RIGHT JOIN cj_sr r ON l.lv > r.rv;+----+1 {x: 1, y: 2} 3 {x: 1, y: NULL}+1 {x: 1, y: 2} 5 {x: 0, y: 9}+2 {x: 3, y: 1} 1 {x: 3, y: 0}+2 {x: 3, y: 1} 3 {x: 1, y: NULL}+2 {x: 3, y: 1} 5 {x: 0, y: 9}+3 {x: 3, y: NULL} 3 {x: 1, y: NULL}+3 {x: 3, y: NULL} 5 {x: 0, y: 9}+NULL NULL 2 {x: 3, y: 2}+NULL NULL 4 {x: 5, y: 0}+NULL NULL 6 NULL+NULL NULL 7 {x: 3, y: 1}++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_sl l FULL JOIN cj_sr r ON l.lv >= r.rv;+----+1 {x: 1, y: 2} 3 {x: 1, y: NULL}+1 {x: 1, y: 2} 5 {x: 0, y: 9}+2 {x: 3, y: 1} 1 {x: 3, y: 0}+2 {x: 3, y: 1} 3 {x: 1, y: NULL}+2 {x: 3, y: 1} 5 {x: 0, y: 9}+2 {x: 3, y: 1} 7 {x: 3, y: 1}+3 {x: 3, y: NULL} 3 {x: 1, y: NULL}+3 {x: 3, y: NULL} 5 {x: 0, y: 9}+4 NULL NULL NULL+NULL NULL 2 {x: 3, y: 2}+NULL NULL 4 {x: 5, y: 0}+NULL NULL 6 NULL++# Lists of structs: the struct ordering, NULL fields included, one level down.+# No empty list or NULL element on the buffered side, so its smallest key,+# [{3,NULL}], ends in a NULL field that decides the streamed rows against it.+statement ok+CREATE TABLE cj_lsl AS SELECT * FROM (VALUES+ (1, make_array(named_struct('x', 5, 'y', CAST(1 AS BIGINT)))),+ (2, make_array(named_struct('x', 3, 'y', CAST(NULL AS BIGINT)), named_struct('x', 1, 'y', CAST(1 AS BIGINT)))),+ (3, make_array(named_struct('x', 3, 'y', CAST(NULL AS BIGINT)))),+ (4, NULL)+) AS t(lid, lv);++statement ok+CREATE TABLE cj_lsr AS SELECT * FROM (VALUES+ (1, make_array(named_struct('x', 3, 'y', CAST(0 AS BIGINT)))),+ (2, make_array(named_struct('x', 3, 'y', CAST(NULL AS BIGINT)))),+ (3, make_array(named_struct('x', 3, 'y', CAST(NULL AS BIGINT)), named_struct('x', 1, 'y', CAST(2 AS BIGINT)))),+ (4, make_array(named_struct('x', 2, 'y', CAST(9 AS BIGINT)))),+ (5, make_array(named_struct('x', 7, 'y', CAST(NULL AS BIGINT)))),+ (6, NULL),+ (7, make_array(named_struct('x', 5, 'y', CAST(1 AS BIGINT))))+) AS t(rid, rv);++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_lsl l RIGHT JOIN cj_lsr r ON l.lv < r.rv;+----+1 [{x: 5, y: 1}] 5 [{x: 7, y: NULL}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 1 [{x: 3, y: 0}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 3 [{x: 3, y: NULL}, {x: 1, y: 2}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 5 [{x: 7, y: NULL}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 7 [{x: 5, y: 1}]+3 [{x: 3, y: NULL}] 1 [{x: 3, y: 0}]+3 [{x: 3, y: NULL}] 3 [{x: 3, y: NULL}, {x: 1, y: 2}]+3 [{x: 3, y: NULL}] 5 [{x: 7, y: NULL}]+3 [{x: 3, y: NULL}] 7 [{x: 5, y: 1}]+NULL NULL 2 [{x: 3, y: NULL}]+NULL NULL 4 [{x: 2, y: 9}]+NULL NULL 6 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_lsl l FULL JOIN cj_lsr r ON l.lv <= r.rv;+----+1 [{x: 5, y: 1}] 5 [{x: 7, y: NULL}]+1 [{x: 5, y: 1}] 7 [{x: 5, y: 1}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 1 [{x: 3, y: 0}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 3 [{x: 3, y: NULL}, {x: 1, y: 2}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 5 [{x: 7, y: NULL}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 7 [{x: 5, y: 1}]+3 [{x: 3, y: NULL}] 1 [{x: 3, y: 0}]+3 [{x: 3, y: NULL}] 2 [{x: 3, y: NULL}]+3 [{x: 3, y: NULL}] 3 [{x: 3, y: NULL}, {x: 1, y: 2}]+3 [{x: 3, y: NULL}] 5 [{x: 7, y: NULL}]+3 [{x: 3, y: NULL}] 7 [{x: 5, y: 1}]+4 NULL NULL NULL+NULL NULL 4 [{x: 2, y: 9}]+NULL NULL 6 NULL++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_lsl l RIGHT JOIN cj_lsr r ON l.lv > r.rv;+----+1 [{x: 5, y: 1}] 1 [{x: 3, y: 0}]+1 [{x: 5, y: 1}] 2 [{x: 3, y: NULL}]+1 [{x: 5, y: 1}] 3 [{x: 3, y: NULL}, {x: 1, y: 2}]+1 [{x: 5, y: 1}] 4 [{x: 2, y: 9}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 2 [{x: 3, y: NULL}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 4 [{x: 2, y: 9}]+3 [{x: 3, y: NULL}] 4 [{x: 2, y: 9}]+NULL NULL 5 [{x: 7, y: NULL}]+NULL NULL 6 NULL+NULL NULL 7 [{x: 5, y: 1}]++query I?I? rowsort+SELECT l.lid, l.lv, r.rid, r.rv FROM cj_lsl l FULL JOIN cj_lsr r ON l.lv >= r.rv;+----+1 [{x: 5, y: 1}] 1 [{x: 3, y: 0}]+1 [{x: 5, y: 1}] 2 [{x: 3, y: NULL}]+1 [{x: 5, y: 1}] 3 [{x: 3, y: NULL}, {x: 1, y: 2}]+1 [{x: 5, y: 1}] 4 [{x: 2, y: 9}]+1 [{x: 5, y: 1}] 7 [{x: 5, y: 1}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 2 [{x: 3, y: NULL}]+2 [{x: 3, y: NULL}, {x: 1, y: 1}] 4 [{x: 2, y: 9}]+3 [{x: 3, y: NULL}] 2 [{x: 3, y: NULL}]+3 [{x: 3, y: NULL}] 4 [{x: 2, y: 9}]+4 NULL NULL NULL+NULL NULL 5 [{x: 7, y: NULL}]+NULL NULL 6 NULL+# ==================================================================# Part 2: Existence joins (LeftSemi / LeftAnti; Right/Mark fall back to NLJ)# ==================================================================