feat: target build optimization for merge into

src/common/hashtable/src/lib.rs

@@ -23,18 +23,18 @@
 extern crate core;
 
 mod container;
+mod dictionary_string_hashtable;
+
 mod hashjoin_hashtable;
 mod hashjoin_string_hashtable;
 mod hashtable;
 mod keys_ref;
 mod lookup_hashtable;
-mod stack_hashtable;
-mod table0;
-
-mod dictionary_string_hashtable;
 mod partitioned_hashtable;
 mod short_string_hashtable;
+mod stack_hashtable;
 mod string_hashtable;
+mod table0;
 #[allow(dead_code)]
 mod table1;
 mod table_empty;
@@ -113,3 +113,5 @@ pub use partitioned_hashtable::hash2bucket;
 pub type HashJoinHashMap<K> = hashjoin_hashtable::HashJoinHashTable<K>;
 pub type BinaryHashJoinHashMap = hashjoin_string_hashtable::HashJoinStringHashTable;
 pub use traits::HashJoinHashtableLike;
+pub use utils::BlockInfoIndex;
+pub use utils::Interval;

src/common/hashtable/src/traits.rs

@@ -25,6 +25,7 @@ use ethnum::i256;
 use ethnum::U256;
 use ordered_float::OrderedFloat;
 
+use crate::utils::Interval;
 use crate::RowPtr;
 
 /// # Safety
@@ -508,21 +509,42 @@ pub trait HashJoinHashtableLike {
     type Key: ?Sized;
 
     // Using hashes to probe hash table and converting them in-place to pointers for memory reuse.
+    // same with `early_filtering_probe`, but we don't use early_filter
     fn probe(&self, hashes: &mut [u64], bitmap: Option<Bitmap>) -> usize;
 
     // Using hashes to probe hash table and converting them in-place to pointers for memory reuse.
+    // 1. same with `early_filtering_probe_with_selection`, but we don't use selection to preserve the
+    // unfiltered indexes, we just set the filtered hashes as zero.
+    // 2. return the unfiltered counts.
     fn early_filtering_probe(&self, hashes: &mut [u64], bitmap: Option<Bitmap>) -> usize;
 
     // Using hashes to probe hash table and converting them in-place to pointers for memory reuse.
+    // we use `early_filtering_probe_with_selection` to do the first round probe.
+    // 1. `hashes` is the hash value of probe block's rows. we will use this one to
+    // do early filtering. if we can't early filter one row(at idx), we will assign pointer in
+    // the bucket to hashes[idx] to reuse the memory.
+    // 2. `selection` is used to preserved the indexes which can't be early_filtered.
+    // 3. return the count of preserved the indexes in `selection`
     fn early_filtering_probe_with_selection(
         &self,
         hashes: &mut [u64],
         valids: Option<Bitmap>,
         selection: &mut [u32],
     ) -> usize;
 
+    // we use `next_contains` to see whether we can find a matched row in the link.
+    // the ptr is the link header.
     fn next_contains(&self, key: &Self::Key, ptr: u64) -> bool;
 
+    /// 1. `key` is the serialize build key from one row
+    /// 2. `ptr` pointers to the *RawEntry for of the bucket correlated to key.So before this method,
+    /// we will do a round probe firstly. If the ptr is zero, it means there is no correlated bucket
+    /// for key
+    /// 3. `vec_ptr` is RowPtr Array, we use this one to record the matched row in chunks
+    /// 4. `occupied` is the length for vec_ptr
+    /// 5. `capacity` is the capacity of vec_ptr
+    /// 6. return macthed rows count and next ptr which need to test in the future.
+    /// if the capacity is enough, the next ptr is zero, otherwise next ptr is valid.
     fn next_probe(
         &self,
         key: &Self::Key,