refactor: remove semi/anti join support in favor of apply-based subqueries

Author: KKould

src/binder/select.rs

@@ -1253,14 +1253,12 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                 (JoinType::RightOuter, Some(constraint))
             }
             JoinOperator::FullOuter(constraint) => (JoinType::Full, Some(constraint)),
-            JoinOperator::Semi(constraint) | JoinOperator::LeftSemi(constraint) => {
-                (JoinType::LeftSemi, Some(constraint))
-            }
-            JoinOperator::Anti(constraint) | JoinOperator::LeftAnti(constraint) => {
-                (JoinType::LeftAnti, Some(constraint))
-            }
             JoinOperator::CrossJoin(constraint) => (JoinType::Cross, Some(constraint)),
-            JoinOperator::RightSemi(_)
+            JoinOperator::Semi(_)
+            | JoinOperator::LeftSemi(_)
+            | JoinOperator::Anti(_)
+            | JoinOperator::LeftAnti(_)
+            | JoinOperator::RightSemi(_)
             | JoinOperator::RightAnti(_)
             | JoinOperator::CrossApply
             | JoinOperator::OuterApply

src/execution/dql/join/hash/left_anti_join.rs

@@ -14,17 +14,13 @@
 
 pub(crate) mod full_join;
 pub(crate) mod inner_join;
-pub(crate) mod left_anti_join;
 pub(crate) mod left_join;
-pub(crate) mod left_semi_join;
 pub(crate) mod right_join;
 
 use crate::errors::DatabaseError;
 use crate::execution::dql::join::hash::full_join::FullJoinState;
 use crate::execution::dql::join::hash::inner_join::InnerJoinState;
-use crate::execution::dql::join::hash::left_anti_join::LeftAntiJoinState;
 use crate::execution::dql::join::hash::left_join::LeftJoinState;
-use crate::execution::dql::join::hash::left_semi_join::LeftSemiJoinState;
 use crate::execution::dql::join::hash::right_join::RightJoinState;
 use crate::execution::dql::join::hash_join::BuildState;
 use crate::execution::dql::sort::BumpVec;
@@ -80,8 +76,6 @@ pub(crate) enum JoinProbeStateImpl {
     Left(LeftJoinState),
     Right(RightJoinState),
     Full(FullJoinState),
-    LeftSemi(LeftSemiJoinState),
-    LeftAnti(LeftAntiJoinState),
 }
 
 impl JoinProbeState for JoinProbeStateImpl {
@@ -104,12 +98,6 @@ impl JoinProbeState for JoinProbeStateImpl {
             JoinProbeStateImpl::Full(state) => {
                 state.probe_next(probe_state, build_state, filter_args)
             }
-            JoinProbeStateImpl::LeftSemi(state) => {
-                state.probe_next(probe_state, build_state, filter_args)
-            }
-            JoinProbeStateImpl::LeftAnti(state) => {
-                state.probe_next(probe_state, build_state, filter_args)
-            }
         }
     }
 
@@ -123,12 +111,6 @@ impl JoinProbeState for JoinProbeStateImpl {
             JoinProbeStateImpl::Left(state) => state.left_drop_next(left_drop_state, filter_args),
             JoinProbeStateImpl::Right(state) => state.left_drop_next(left_drop_state, filter_args),
             JoinProbeStateImpl::Full(state) => state.left_drop_next(left_drop_state, filter_args),
-            JoinProbeStateImpl::LeftSemi(state) => {
-                state.left_drop_next(left_drop_state, filter_args)
-            }
-            JoinProbeStateImpl::LeftAnti(state) => {
-                state.left_drop_next(left_drop_state, filter_args)
-            }
         }
     }
 }

src/execution/dql/join/hash/left_semi_join.rs

@@ -16,9 +16,7 @@ use crate::catalog::ColumnRef;
 use crate::errors::DatabaseError;
 use crate::execution::dql::join::hash::full_join::FullJoinState;
 use crate::execution::dql::join::hash::inner_join::InnerJoinState;
-use crate::execution::dql::join::hash::left_anti_join::LeftAntiJoinState;
 use crate::execution::dql::join::hash::left_join::LeftJoinState;
-use crate::execution::dql::join::hash::left_semi_join::LeftSemiJoinState;
 use crate::execution::dql::join::hash::right_join::RightJoinState;
 use crate::execution::dql::join::hash::{
     FilterArgs, JoinProbeState, JoinProbeStateImpl, LeftDropState, ProbeState,
@@ -241,15 +239,6 @@ impl HashJoin {
                 right_schema_len,
                 bits: FixedBitSet::with_capacity(build_count),
             }),
-            JoinType::LeftSemi => JoinProbeStateImpl::LeftSemi(LeftSemiJoinState {
-                bits: FixedBitSet::with_capacity(build_count),
-            }),
-            JoinType::LeftAnti => JoinProbeStateImpl::LeftAnti(LeftAntiJoinState {
-                right_schema_len,
-                inner: LeftSemiJoinState {
-                    bits: FixedBitSet::with_capacity(build_count),
-                },
-            }),
             JoinType::RightOuter => JoinProbeStateImpl::Right(RightJoinState { left_schema_len }),
             JoinType::Full => JoinProbeStateImpl::Full(FullJoinState {
                 left_schema_len,
@@ -433,12 +422,10 @@ mod test {
     use crate::planner::operator::Operator;
     use crate::planner::{Childrens, LogicalPlan};
     use crate::storage::rocksdb::{RocksStorage, RocksTransaction};
-    use crate::storage::table_codec::BumpBytes;
     use crate::storage::Storage;
     use crate::types::value::DataValue;
     use crate::types::LogicalType;
     use crate::utils::lru::SharedLruCache;
-    use bumpalo::Bump;
     use std::hash::RandomState;
     use std::sync::Arc;
     use tempfile::TempDir;
@@ -649,47 +636,6 @@ mod test {
                 build_integers(vec![Some(3), Some(5), Some(7), None, None, None])
             );
         }
-        {
-            let mut executor = HashJoin::from((op.clone(), left.clone(), right.clone()));
-            executor.ty = JoinType::LeftSemi;
-            let mut tuples = try_collect(crate::execution::execute(
-                executor,
-                (&table_cache, &view_cache, &meta_cache),
-                &mut transaction,
-            ))?;
-
-            let arena = Bump::new();
-            assert_eq!(tuples.len(), 2);
-            tuples.sort_by_key(|tuple| {
-                let mut bytes = BumpBytes::new_in(&arena);
-                tuple.values[0].memcomparable_encode(&mut bytes).unwrap();
-                bytes
-            });
-
-            assert_eq!(
-                tuples[0].values,
-                build_integers(vec![Some(0), Some(2), Some(4)])
-            );
-            assert_eq!(
-                tuples[1].values,
-                build_integers(vec![Some(1), Some(3), Some(5)])
-            );
-        }
-        {
-            let mut executor = HashJoin::from((op, left, right));
-            executor.ty = JoinType::LeftAnti;
-            let tuples = try_collect(crate::execution::execute(
-                executor,
-                (&table_cache, &view_cache, &meta_cache),
-                &mut transaction,
-            ))?;
-
-            assert_eq!(tuples.len(), 1);
-            assert_eq!(
-                tuples[0].values,
-                build_integers(vec![Some(3), Some(5), Some(7)])
-            );
-        }
 
         Ok(())
     }

src/execution/dql/join/hash/mod.rs

@@ -21,7 +21,7 @@ pub(crate) mod nested_loop_join;
 pub fn joins_nullable(join_type: &JoinType) -> (bool, bool) {
     match join_type {
         JoinType::Inner => (false, false),
-        JoinType::LeftOuter | JoinType::LeftSemi | JoinType::LeftAnti => (false, true),
+        JoinType::LeftOuter => (false, true),
         JoinType::RightOuter => (true, false),
         JoinType::Full => (true, true),
         JoinType::Cross => (true, true),