Coverage Report

Created: 2026-03-12 02:33

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exec/common/join_utils.h
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#pragma once
19
20
#include <variant>
21
22
#include "exec/common/hash_table/hash_key_type.h"
23
#include "exec/common/hash_table/hash_map_context.h"
24
#include "exec/common/hash_table/join_hash_table.h"
25
26
namespace doris {
27
using JoinOpVariants =
28
        std::variant<std::integral_constant<TJoinOp::type, TJoinOp::INNER_JOIN>,
29
                     std::integral_constant<TJoinOp::type, TJoinOp::LEFT_SEMI_JOIN>,
30
                     std::integral_constant<TJoinOp::type, TJoinOp::LEFT_ANTI_JOIN>,
31
                     std::integral_constant<TJoinOp::type, TJoinOp::LEFT_OUTER_JOIN>,
32
                     std::integral_constant<TJoinOp::type, TJoinOp::FULL_OUTER_JOIN>,
33
                     std::integral_constant<TJoinOp::type, TJoinOp::RIGHT_OUTER_JOIN>,
34
                     std::integral_constant<TJoinOp::type, TJoinOp::CROSS_JOIN>,
35
                     std::integral_constant<TJoinOp::type, TJoinOp::RIGHT_SEMI_JOIN>,
36
                     std::integral_constant<TJoinOp::type, TJoinOp::RIGHT_ANTI_JOIN>,
37
                     std::integral_constant<TJoinOp::type, TJoinOp::NULL_AWARE_LEFT_ANTI_JOIN>,
38
                     std::integral_constant<TJoinOp::type, TJoinOp::NULL_AWARE_LEFT_SEMI_JOIN>>;
39
40
template <class T>
41
using PrimaryTypeHashTableContext = MethodOneNumber<T, JoinHashMap<T, HashCRC32<T>, false>>;
42
43
template <class T>
44
using DirectPrimaryTypeHashTableContext =
45
        MethodOneNumberDirect<T, JoinHashMap<T, HashCRC32<T>, true>>;
46
47
template <class Key>
48
using FixedKeyHashTableContext = MethodKeysFixed<JoinHashMap<Key, HashCRC32<Key>, false>>;
49
50
using SerializedHashTableContext =
51
        MethodSerialized<JoinHashMap<StringRef, DefaultHash<StringRef>, false>>;
52
using MethodOneString = MethodStringNoCache<JoinHashMap<StringRef, DefaultHash<StringRef>, false>>;
53
54
using HashTableVariants = std::variant<
55
        std::monostate, SerializedHashTableContext, PrimaryTypeHashTableContext<UInt8>,
56
        PrimaryTypeHashTableContext<UInt16>, PrimaryTypeHashTableContext<UInt32>,
57
        PrimaryTypeHashTableContext<UInt64>, PrimaryTypeHashTableContext<UInt128>,
58
        PrimaryTypeHashTableContext<UInt256>, DirectPrimaryTypeHashTableContext<UInt8>,
59
        DirectPrimaryTypeHashTableContext<UInt16>, DirectPrimaryTypeHashTableContext<UInt32>,
60
        DirectPrimaryTypeHashTableContext<UInt64>, DirectPrimaryTypeHashTableContext<UInt128>,
61
        FixedKeyHashTableContext<UInt64>, FixedKeyHashTableContext<UInt72>,
62
        FixedKeyHashTableContext<UInt96>, FixedKeyHashTableContext<UInt104>,
63
        FixedKeyHashTableContext<UInt128>, FixedKeyHashTableContext<UInt136>,
64
        FixedKeyHashTableContext<UInt256>, MethodOneString>;
65
66
struct JoinDataVariants {
67
    HashTableVariants method_variant;
68
69
48.0k
    void init(const std::vector<DataTypePtr>& data_types, HashKeyType type) {
70
48.0k
        switch (type) {
71
14.1k
        case HashKeyType::serialized:
72
14.1k
            method_variant.emplace<SerializedHashTableContext>();
73
14.1k
            break;
74
160
        case HashKeyType::int8_key:
75
160
            method_variant.emplace<PrimaryTypeHashTableContext<UInt8>>();
76
160
            break;
77
80
        case HashKeyType::int16_key:
78
80
            method_variant.emplace<PrimaryTypeHashTableContext<UInt16>>();
79
80
            break;
80
322
        case HashKeyType::int32_key:
81
322
            method_variant.emplace<PrimaryTypeHashTableContext<UInt32>>();
82
322
            break;
83
800
        case HashKeyType::int64_key:
84
800
            method_variant.emplace<PrimaryTypeHashTableContext<UInt64>>();
85
800
            break;
86
240
        case HashKeyType::int128_key:
87
240
            method_variant.emplace<PrimaryTypeHashTableContext<UInt128>>();
88
240
            break;
89
0
        case HashKeyType::int256_key:
90
0
            method_variant.emplace<PrimaryTypeHashTableContext<UInt256>>();
91
0
            break;
92
324
        case HashKeyType::string_key:
93
324
            method_variant.emplace<MethodOneString>();
94
324
            break;
95
3.92k
        case HashKeyType::fixed64:
96
3.92k
            method_variant.emplace<FixedKeyHashTableContext<UInt64>>(get_key_sizes(data_types));
97
3.92k
            break;
98
3.20k
        case HashKeyType::fixed72:
99
3.20k
            method_variant.emplace<FixedKeyHashTableContext<UInt72>>(get_key_sizes(data_types));
100
3.20k
            break;
101
8.00k
        case HashKeyType::fixed96:
102
8.00k
            method_variant.emplace<FixedKeyHashTableContext<UInt96>>(get_key_sizes(data_types));
103
8.00k
            break;
104
0
        case HashKeyType::fixed104:
105
0
            method_variant.emplace<FixedKeyHashTableContext<UInt104>>(get_key_sizes(data_types));
106
0
            break;
107
8.00k
        case HashKeyType::fixed128:
108
8.00k
            method_variant.emplace<FixedKeyHashTableContext<UInt128>>(get_key_sizes(data_types));
109
8.00k
            break;
110
960
        case HashKeyType::fixed136:
111
960
            method_variant.emplace<FixedKeyHashTableContext<UInt136>>(get_key_sizes(data_types));
112
960
            break;
113
7.92k
        case HashKeyType::fixed256:
114
7.92k
            method_variant.emplace<FixedKeyHashTableContext<UInt256>>(get_key_sizes(data_types));
115
7.92k
            break;
116
0
        default:
117
0
            throw Exception(ErrorCode::INTERNAL_ERROR,
118
0
                            "JoinDataVariants meet invalid key type, type={}", type);
119
48.0k
        }
120
48.0k
    }
121
};
122
123
template <typename Method>
124
void primary_to_direct_mapping(Method* context, const ColumnRawPtrs& key_columns,
125
1.60k
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
126
1.60k
    using FieldType = typename Method::Base::Key;
127
1.60k
    FieldType max_key = std::numeric_limits<FieldType>::min();
128
1.60k
    FieldType min_key = std::numeric_limits<FieldType>::max();
129
130
1.60k
    size_t num_rows = key_columns[0]->size();
131
1.60k
    if (key_columns[0]->is_nullable()) {
132
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
133
0
                                              ->get_nested_column_ptr()
134
0
                                              ->get_raw_data()
135
0
                                              .data;
136
0
        const NullMap& null_map =
137
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
138
        // skip first mocked row
139
0
        for (size_t i = 1; i < num_rows; i++) {
140
0
            if (null_map[i]) {
141
0
                continue;
142
0
            }
143
0
            max_key = std::max(max_key, input_keys[i]);
144
0
            min_key = std::min(min_key, input_keys[i]);
145
0
        }
146
1.60k
    } else {
147
1.60k
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
148
        // skip first mocked row
149
4.82k
        for (size_t i = 1; i < num_rows; i++) {
150
3.22k
            max_key = std::max(max_key, input_keys[i]);
151
3.22k
            min_key = std::min(min_key, input_keys[i]);
152
3.22k
        }
153
1.60k
    }
154
155
1.60k
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
156
1.60k
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
157
1.60k
    if (allow_direct_mapping) {
158
1.60k
        for (const auto& variant_ptr : variant_ptrs) {
159
1.60k
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
160
1.60k
                    max_key, min_key);
161
1.60k
        }
162
1.60k
    }
163
1.60k
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberIhNS_13JoinHashTableIh9HashCRC32IhELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
125
160
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
126
160
    using FieldType = typename Method::Base::Key;
127
160
    FieldType max_key = std::numeric_limits<FieldType>::min();
128
160
    FieldType min_key = std::numeric_limits<FieldType>::max();
129
130
160
    size_t num_rows = key_columns[0]->size();
131
160
    if (key_columns[0]->is_nullable()) {
132
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
133
0
                                              ->get_nested_column_ptr()
134
0
                                              ->get_raw_data()
135
0
                                              .data;
136
0
        const NullMap& null_map =
137
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
138
        // skip first mocked row
139
0
        for (size_t i = 1; i < num_rows; i++) {
140
0
            if (null_map[i]) {
141
0
                continue;
142
0
            }
143
0
            max_key = std::max(max_key, input_keys[i]);
144
0
            min_key = std::min(min_key, input_keys[i]);
145
0
        }
146
160
    } else {
147
160
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
148
        // skip first mocked row
149
480
        for (size_t i = 1; i < num_rows; i++) {
150
320
            max_key = std::max(max_key, input_keys[i]);
151
320
            min_key = std::min(min_key, input_keys[i]);
152
320
        }
153
160
    }
154
155
160
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
156
160
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
157
160
    if (allow_direct_mapping) {
158
160
        for (const auto& variant_ptr : variant_ptrs) {
159
160
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
160
160
                    max_key, min_key);
161
160
        }
162
160
    }
163
160
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberItNS_13JoinHashTableIt9HashCRC32ItELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
125
80
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
126
80
    using FieldType = typename Method::Base::Key;
127
80
    FieldType max_key = std::numeric_limits<FieldType>::min();
128
80
    FieldType min_key = std::numeric_limits<FieldType>::max();
129
130
80
    size_t num_rows = key_columns[0]->size();
131
80
    if (key_columns[0]->is_nullable()) {
132
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
133
0
                                              ->get_nested_column_ptr()
134
0
                                              ->get_raw_data()
135
0
                                              .data;
136
0
        const NullMap& null_map =
137
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
138
        // skip first mocked row
139
0
        for (size_t i = 1; i < num_rows; i++) {
140
0
            if (null_map[i]) {
141
0
                continue;
142
0
            }
143
0
            max_key = std::max(max_key, input_keys[i]);
144
0
            min_key = std::min(min_key, input_keys[i]);
145
0
        }
146
80
    } else {
147
80
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
148
        // skip first mocked row
149
240
        for (size_t i = 1; i < num_rows; i++) {
150
160
            max_key = std::max(max_key, input_keys[i]);
151
160
            min_key = std::min(min_key, input_keys[i]);
152
160
        }
153
80
    }
154
155
80
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
156
80
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
157
80
    if (allow_direct_mapping) {
158
80
        for (const auto& variant_ptr : variant_ptrs) {
159
80
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
160
80
                    max_key, min_key);
161
80
        }
162
80
    }
163
80
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberIjNS_13JoinHashTableIj9HashCRC32IjELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
125
322
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
126
322
    using FieldType = typename Method::Base::Key;
127
322
    FieldType max_key = std::numeric_limits<FieldType>::min();
128
322
    FieldType min_key = std::numeric_limits<FieldType>::max();
129
130
322
    size_t num_rows = key_columns[0]->size();
131
322
    if (key_columns[0]->is_nullable()) {
132
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
133
0
                                              ->get_nested_column_ptr()
134
0
                                              ->get_raw_data()
135
0
                                              .data;
136
0
        const NullMap& null_map =
137
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
138
        // skip first mocked row
139
0
        for (size_t i = 1; i < num_rows; i++) {
140
0
            if (null_map[i]) {
141
0
                continue;
142
0
            }
143
0
            max_key = std::max(max_key, input_keys[i]);
144
0
            min_key = std::min(min_key, input_keys[i]);
145
0
        }
146
322
    } else {
147
322
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
148
        // skip first mocked row
149
988
        for (size_t i = 1; i < num_rows; i++) {
150
666
            max_key = std::max(max_key, input_keys[i]);
151
666
            min_key = std::min(min_key, input_keys[i]);
152
666
        }
153
322
    }
154
155
322
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
156
322
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
157
322
    if (allow_direct_mapping) {
158
322
        for (const auto& variant_ptr : variant_ptrs) {
159
322
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
160
322
                    max_key, min_key);
161
322
        }
162
322
    }
163
322
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberImNS_13JoinHashTableIm9HashCRC32ImELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
125
800
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
126
800
    using FieldType = typename Method::Base::Key;
127
800
    FieldType max_key = std::numeric_limits<FieldType>::min();
128
800
    FieldType min_key = std::numeric_limits<FieldType>::max();
129
130
800
    size_t num_rows = key_columns[0]->size();
131
800
    if (key_columns[0]->is_nullable()) {
132
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
133
0
                                              ->get_nested_column_ptr()
134
0
                                              ->get_raw_data()
135
0
                                              .data;
136
0
        const NullMap& null_map =
137
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
138
        // skip first mocked row
139
0
        for (size_t i = 1; i < num_rows; i++) {
140
0
            if (null_map[i]) {
141
0
                continue;
142
0
            }
143
0
            max_key = std::max(max_key, input_keys[i]);
144
0
            min_key = std::min(min_key, input_keys[i]);
145
0
        }
146
800
    } else {
147
800
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
148
        // skip first mocked row
149
2.40k
        for (size_t i = 1; i < num_rows; i++) {
150
1.60k
            max_key = std::max(max_key, input_keys[i]);
151
1.60k
            min_key = std::min(min_key, input_keys[i]);
152
1.60k
        }
153
800
    }
154
155
800
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
156
800
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
157
800
    if (allow_direct_mapping) {
158
800
        for (const auto& variant_ptr : variant_ptrs) {
159
800
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
160
800
                    max_key, min_key);
161
800
        }
162
800
    }
163
800
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberIN4wide7integerILm128EjEENS_13JoinHashTableIS4_9HashCRC32IS4_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
125
240
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
126
240
    using FieldType = typename Method::Base::Key;
127
240
    FieldType max_key = std::numeric_limits<FieldType>::min();
128
240
    FieldType min_key = std::numeric_limits<FieldType>::max();
129
130
240
    size_t num_rows = key_columns[0]->size();
131
240
    if (key_columns[0]->is_nullable()) {
132
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
133
0
                                              ->get_nested_column_ptr()
134
0
                                              ->get_raw_data()
135
0
                                              .data;
136
0
        const NullMap& null_map =
137
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
138
        // skip first mocked row
139
0
        for (size_t i = 1; i < num_rows; i++) {
140
0
            if (null_map[i]) {
141
0
                continue;
142
0
            }
143
0
            max_key = std::max(max_key, input_keys[i]);
144
0
            min_key = std::min(min_key, input_keys[i]);
145
0
        }
146
240
    } else {
147
240
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
148
        // skip first mocked row
149
720
        for (size_t i = 1; i < num_rows; i++) {
150
480
            max_key = std::max(max_key, input_keys[i]);
151
480
            min_key = std::min(min_key, input_keys[i]);
152
480
        }
153
240
    }
154
155
240
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
156
240
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
157
240
    if (allow_direct_mapping) {
158
240
        for (const auto& variant_ptr : variant_ptrs) {
159
240
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
160
240
                    max_key, min_key);
161
240
        }
162
240
    }
163
240
}
164
165
template <typename Method>
166
void try_convert_to_direct_mapping(
167
        Method* method, const ColumnRawPtrs& key_columns,
168
46.4k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingISt9monostateEEvPT_RKSt6vectorIPKNS_7IColumnESaIS7_EERKS4_ISt10shared_ptrINS_16JoinDataVariantsEESaISE_EE
_ZN5doris29try_convert_to_direct_mappingINS_16MethodSerializedINS_13JoinHashTableINS_9StringRefE11DefaultHashIS3_vELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
168
14.1k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_15MethodOneNumberIN4wide7integerILm256EjEENS_13JoinHashTableIS4_9HashCRC32IS4_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectIhNS_13JoinHashTableIh9HashCRC32IhELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectItNS_13JoinHashTableIt9HashCRC32ItELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectIjNS_13JoinHashTableIj9HashCRC32IjELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectImNS_13JoinHashTableIm9HashCRC32ImELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectIN4wide7integerILm128EjEENS_13JoinHashTableIS4_9HashCRC32IS4_ELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableIm9HashCRC32ImELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
168
3.92k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_6UInt72E9HashCRC32IS3_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
168
3.20k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_6UInt96E9HashCRC32IS3_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
168
8.00k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_7UInt104E9HashCRC32IS3_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableIN4wide7integerILm128EjEE9HashCRC32IS5_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
168
8.00k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_7UInt136E9HashCRC32IS3_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
168
960
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableIN4wide7integerILm256EjEE9HashCRC32IS5_ELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
168
7.92k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_19MethodStringNoCacheINS_13JoinHashTableINS_9StringRefE11DefaultHashIS3_vELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
168
324
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
169
170
inline void try_convert_to_direct_mapping(
171
        PrimaryTypeHashTableContext<UInt8>* context, const ColumnRawPtrs& key_columns,
172
160
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
173
160
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
174
160
}
175
176
inline void try_convert_to_direct_mapping(
177
        PrimaryTypeHashTableContext<UInt16>* context, const ColumnRawPtrs& key_columns,
178
80
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
179
80
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
180
80
}
181
182
inline void try_convert_to_direct_mapping(
183
        PrimaryTypeHashTableContext<UInt32>* context, const ColumnRawPtrs& key_columns,
184
322
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
185
322
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
186
322
}
187
188
inline void try_convert_to_direct_mapping(
189
        PrimaryTypeHashTableContext<UInt64>* context, const ColumnRawPtrs& key_columns,
190
800
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
191
800
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
192
800
}
193
194
inline void try_convert_to_direct_mapping(
195
        PrimaryTypeHashTableContext<UInt128>* context, const ColumnRawPtrs& key_columns,
196
240
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
197
240
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
198
240
}
199
200
} // namespace doris