[Refactor] Refactor build_hash_map and build_set to remove duplicated codes

[LiShuMing]

What type of PR is this：

• BugFix
• Feature
• Enhancement
• Refactor
• UT
• Doc
• Tool

Which issues of this PR fixes ：

Fixes #13880

• Use template to refactor build_hash_map and build_set to remove duplicated codes;
• Add build_hash_map_allocate_and_with_selection method to be used in StreamMV later.

// When meets not found group keys, mark the first pos into `_streaming_selection` and insert into the hashmap
// so the following group keys(same as the first not found group keys) are not marked as non-founded.
// This can be used for stream mv so no need to find multi times for the same non-found group keys.

Problem Summary(Required) ：

Checklist:

• I have added test cases for my bug fix or my new feature
• This pr will affect users' behaviors
• This pr needs user documentation (for new or modified features or behaviors)
  • I have added documentation for my new feature or new function

Bugfix cherry-pick branch check:

• I have checked the version labels which the pr will be auto backported to target branch
  • 2.5
  • 2.4
  • 2.3
  • 2.2

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[stdpain]

            if constexpr (allocate_and_compute_state && compute_not_founds) {
                auto iter = this->hash_map.lazy_emplace_with_hash(key, hash_values[i], [&](const auto& ctor) {
                    (*not_founds)[i] = 1;
                    AggDataPtr pv = allocate_func(key);
                    ctor(key, pv);
                });
                (*agg_states)[i] = iter->second;
            } else if constexpr (compute_not_founds) {
                DCHECK(not_founds);
                if (auto iter = this->hash_map.find(key); iter != this->hash_map.end()) {
                    (*agg_states)[i] = iter->second;
                } else {
                    (*not_founds)[i] = 1;
                }

compute_not_founds and allocate_and_compute_state && compute_not_founds should be simpty to

if constexpr (allocate_and_compute_state) {
    auto iter = this->hash_map.lazy_emplace_with_hash(key, hash_values[i], [&](const auto& ctor) {
       if constexpr (xxx) {
           (*not_founds)[i] = true;
       }
        AggDataPtr pv = allocate_func(key);
        ctor(key, pv);
     });

    (*agg_states)[i] = iter->second;
}

[satanson]

This function is single-purpose in the past, why now need to be multiple-purpose?
if we add another two single-purpose functions to support 1.allocate_and_compute_state && compute_not_founds and 2. compute_not_founds, is it be better?

[LiShuMing]

This function is single-purpose in the past, why now need to be multiple-purpose?

• there are many duplicated codes for computing allocate_and_compute_state and compute_not_founds seperately;
• add this template parameter doesn't add any affects with old implements;

if we add another two single-purpose functions to support 1.allocate_and_compute_state && compute_not_founds and 2. compute_not_founds, is it be better?

• as above, we can use one function to express the purpose. use one function is better?

[satanson]

as above, explicitly, three different purposes split into single function would make the code more clear and succinct.

[LiShuMing]

            if constexpr (allocate_and_compute_state && compute_not_founds) {
                auto iter = this->hash_map.lazy_emplace_with_hash(key, hash_values[i], [&](const auto& ctor) {
                    (*not_founds)[i] = 1;
                    AggDataPtr pv = allocate_func(key);
                    ctor(key, pv);
                });
                (*agg_states)[i] = iter->second;
            } else if constexpr (compute_not_founds) {
                DCHECK(not_founds);
                if (auto iter = this->hash_map.find(key); iter != this->hash_map.end()) {
                    (*agg_states)[i] = iter->second;
                } else {
                    (*not_founds)[i] = 1;
                }

compute_not_founds and allocate_and_compute_state && compute_not_founds should be simpty to

if constexpr (allocate_and_compute_state) {
    auto iter = this->hash_map.lazy_emplace_with_hash(key, hash_values[i], [&](const auto& ctor) {
       if constexpr (xxx) {
           (*not_founds)[i] = true;
       }
        AggDataPtr pv = allocate_func(key);
        ctor(key, pv);
     });

    (*agg_states)[i] = iter->second;
}

Good~ fixed.

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[wanpengfei-git]

run starrocks_admit_test

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[stdpain]

It's unnecessary to add this macros.
we can add this to AggHashMapWithKey

[LiShuMing]

Good advise~

[LiShuMing]

run starrocks_be_unittest

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[wanpengfei-git]

run starrocks_admit_test

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[LiShuMing]

run starrocks_admit_test

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[LiShuMing]

run starrocks_admit_test

[LiShuMing]

run starrocks_admit_test

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[wanpengfei-git]

run starrocks_admit_test

[github-actions]

clang-tidy review says "All clean, LGTM! 👍"

[sonarcloud]

SonarCloud Quality Gate failed.   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
0 Code Smells

No Coverage information
10.7% Duplication