Coverage Report

Created: 2026-08-27 08:14

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 <algorithm>
21
#include <variant>
22
23
#include "exec/common/hash_table/hash_crc32_return32.h"
24
#include "exec/common/hash_table/hash_key_type.h"
25
#include "exec/common/hash_table/hash_map_context.h"
26
#include "exec/common/hash_table/join_hash_table.h"
27
#include "exec/common/join_op_utils.h" // IWYU pragma: export (JoinOpVariants/AsofIndexGroup moved there)
28
29
namespace doris {
30
31
// Devirtualize compare_at for ASOF JOIN supported column types.
32
// ASOF JOIN only supports DateV2, DateTimeV2, and TimestampTZ.
33
// Dispatches to the concrete ColumnVector<T> once so that all compare_at
34
// calls inside `func` are direct (non-virtual) calls.
35
// `func` receives a single argument: a const pointer to the concrete column
36
// (or const IColumn* as fallback for unexpected types).
37
template <typename Func>
38
1.31k
decltype(auto) asof_column_dispatch(const IColumn* col, Func&& func) {
39
1.31k
    if (const auto* c_dv2 = check_and_get_column<ColumnDateV2>(col)) {
40
16
        return std::forward<Func>(func)(c_dv2);
41
1.30k
    } else if (const auto* c_dtv2 = check_and_get_column<ColumnDateTimeV2>(col)) {
42
1.28k
        return std::forward<Func>(func)(c_dtv2);
43
1.28k
    } else if (const auto* c_tstz = check_and_get_column<ColumnTimeStampTz>(col)) {
44
17
        return std::forward<Func>(func)(c_tstz);
45
17
    } else {
46
0
        return std::forward<Func>(func)(col);
47
0
    }
48
1.31k
}
49
template <class T>
50
using PrimaryTypeHashTableContext = MethodOneNumber<T, JoinHashMap<T, HashCRC32Return32<T>, false>>;
51
52
template <class T>
53
using DirectPrimaryTypeHashTableContext =
54
        MethodOneNumberDirect<T, JoinHashMap<T, HashCRC32Return32<T>, true>>;
55
56
template <class Key>
57
using FixedKeyHashTableContext = MethodKeysFixed<JoinHashMap<Key, HashCRC32Return32<Key>, false>>;
58
59
using SerializedHashTableContext =
60
        MethodSerialized<JoinHashMap<StringRef, HashCRC32Return32<StringRef>, false>>;
61
using MethodOneString =
62
        MethodStringNoCache<JoinHashMap<StringRef, HashCRC32Return32<StringRef>, false>>;
63
64
using HashTableVariants = std::variant<
65
        std::monostate, SerializedHashTableContext, PrimaryTypeHashTableContext<UInt8>,
66
        PrimaryTypeHashTableContext<UInt16>, PrimaryTypeHashTableContext<UInt32>,
67
        PrimaryTypeHashTableContext<UInt64>, PrimaryTypeHashTableContext<UInt128>,
68
        PrimaryTypeHashTableContext<UInt256>, DirectPrimaryTypeHashTableContext<UInt8>,
69
        DirectPrimaryTypeHashTableContext<UInt16>, DirectPrimaryTypeHashTableContext<UInt32>,
70
        DirectPrimaryTypeHashTableContext<UInt64>, DirectPrimaryTypeHashTableContext<UInt128>,
71
        FixedKeyHashTableContext<UInt64>, FixedKeyHashTableContext<UInt72>,
72
        FixedKeyHashTableContext<UInt96>, FixedKeyHashTableContext<UInt104>,
73
        FixedKeyHashTableContext<UInt128>, FixedKeyHashTableContext<UInt136>,
74
        FixedKeyHashTableContext<UInt256>, MethodOneString>;
75
76
struct JoinDataVariants {
77
    HashTableVariants method_variant;
78
79
89.5k
    void init(const std::vector<DataTypePtr>& data_types, HashKeyType type) {
80
89.5k
        switch (type) {
81
14.7k
        case HashKeyType::serialized:
82
14.7k
            method_variant.emplace<SerializedHashTableContext>();
83
14.7k
            break;
84
1.23k
        case HashKeyType::int8_key:
85
1.23k
            method_variant.emplace<PrimaryTypeHashTableContext<UInt8>>();
86
1.23k
            break;
87
791
        case HashKeyType::int16_key:
88
791
            method_variant.emplace<PrimaryTypeHashTableContext<UInt16>>();
89
791
            break;
90
24.1k
        case HashKeyType::int32_key:
91
24.1k
            method_variant.emplace<PrimaryTypeHashTableContext<UInt32>>();
92
24.1k
            break;
93
10.5k
        case HashKeyType::int64_key:
94
10.5k
            method_variant.emplace<PrimaryTypeHashTableContext<UInt64>>();
95
10.5k
            break;
96
907
        case HashKeyType::int128_key:
97
907
            method_variant.emplace<PrimaryTypeHashTableContext<UInt128>>();
98
907
            break;
99
43
        case HashKeyType::int256_key:
100
43
            method_variant.emplace<PrimaryTypeHashTableContext<UInt256>>();
101
43
            break;
102
1.63k
        case HashKeyType::string_key:
103
1.63k
            method_variant.emplace<MethodOneString>();
104
1.63k
            break;
105
7.16k
        case HashKeyType::fixed64:
106
7.16k
            method_variant.emplace<FixedKeyHashTableContext<UInt64>>(get_key_sizes(data_types));
107
7.16k
            break;
108
3.24k
        case HashKeyType::fixed72:
109
3.24k
            method_variant.emplace<FixedKeyHashTableContext<UInt72>>(get_key_sizes(data_types));
110
3.24k
            break;
111
8.09k
        case HashKeyType::fixed96:
112
8.09k
            method_variant.emplace<FixedKeyHashTableContext<UInt96>>(get_key_sizes(data_types));
113
8.09k
            break;
114
37
        case HashKeyType::fixed104:
115
37
            method_variant.emplace<FixedKeyHashTableContext<UInt104>>(get_key_sizes(data_types));
116
37
            break;
117
8.08k
        case HashKeyType::fixed128:
118
8.08k
            method_variant.emplace<FixedKeyHashTableContext<UInt128>>(get_key_sizes(data_types));
119
8.08k
            break;
120
960
        case HashKeyType::fixed136:
121
960
            method_variant.emplace<FixedKeyHashTableContext<UInt136>>(get_key_sizes(data_types));
122
960
            break;
123
7.98k
        case HashKeyType::fixed256:
124
7.98k
            method_variant.emplace<FixedKeyHashTableContext<UInt256>>(get_key_sizes(data_types));
125
7.98k
            break;
126
0
        default:
127
0
            throw Exception(ErrorCode::INTERNAL_ERROR,
128
0
                            "JoinDataVariants meet invalid key type, type={}", type);
129
89.5k
        }
130
89.5k
    }
131
};
132
133
template <typename Method>
134
void primary_to_direct_mapping(Method* context, const ColumnRawPtrs& key_columns,
135
31.4k
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
136
31.4k
    using FieldType = typename Method::Base::Key;
137
31.4k
    FieldType max_key = std::numeric_limits<FieldType>::min();
138
31.4k
    FieldType min_key = std::numeric_limits<FieldType>::max();
139
140
31.4k
    size_t num_rows = key_columns[0]->size();
141
31.4k
    if (is_column_nullable(*key_columns[0])) {
142
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
143
0
                                              ->get_nested_column_ptr()
144
0
                                              ->get_raw_data()
145
0
                                              .data;
146
0
        const NullMap& null_map =
147
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
148
        // skip first mocked row
149
0
        for (size_t i = 1; i < num_rows; i++) {
150
0
            if (null_map[i]) {
151
0
                continue;
152
0
            }
153
0
            max_key = std::max(max_key, input_keys[i]);
154
0
            min_key = std::min(min_key, input_keys[i]);
155
0
        }
156
31.4k
    } else {
157
31.4k
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
158
        // skip first mocked row
159
16.2M
        for (size_t i = 1; i < num_rows; i++) {
160
16.1M
            max_key = std::max(max_key, input_keys[i]);
161
16.1M
            min_key = std::min(min_key, input_keys[i]);
162
16.1M
        }
163
31.4k
    }
164
165
31.4k
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
166
31.4k
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
167
31.4k
    if (allow_direct_mapping) {
168
27.7k
        for (const auto& variant_ptr : variant_ptrs) {
169
27.7k
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
170
27.7k
                    max_key, min_key);
171
27.7k
        }
172
22.1k
    }
173
31.4k
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberIhNS_13JoinHashTableIhNS_17HashCRC32Return32IhEELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
135
1.14k
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
136
1.14k
    using FieldType = typename Method::Base::Key;
137
1.14k
    FieldType max_key = std::numeric_limits<FieldType>::min();
138
1.14k
    FieldType min_key = std::numeric_limits<FieldType>::max();
139
140
1.14k
    size_t num_rows = key_columns[0]->size();
141
1.14k
    if (is_column_nullable(*key_columns[0])) {
142
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
143
0
                                              ->get_nested_column_ptr()
144
0
                                              ->get_raw_data()
145
0
                                              .data;
146
0
        const NullMap& null_map =
147
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
148
        // skip first mocked row
149
0
        for (size_t i = 1; i < num_rows; i++) {
150
0
            if (null_map[i]) {
151
0
                continue;
152
0
            }
153
0
            max_key = std::max(max_key, input_keys[i]);
154
0
            min_key = std::min(min_key, input_keys[i]);
155
0
        }
156
1.14k
    } else {
157
1.14k
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
158
        // skip first mocked row
159
4.24k
        for (size_t i = 1; i < num_rows; i++) {
160
3.09k
            max_key = std::max(max_key, input_keys[i]);
161
3.09k
            min_key = std::min(min_key, input_keys[i]);
162
3.09k
        }
163
1.14k
    }
164
165
1.14k
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
166
1.14k
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
167
1.14k
    if (allow_direct_mapping) {
168
1.07k
        for (const auto& variant_ptr : variant_ptrs) {
169
1.07k
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
170
1.07k
                    max_key, min_key);
171
1.07k
        }
172
984
    }
173
1.14k
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberItNS_13JoinHashTableItNS_17HashCRC32Return32ItEELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
135
701
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
136
701
    using FieldType = typename Method::Base::Key;
137
701
    FieldType max_key = std::numeric_limits<FieldType>::min();
138
701
    FieldType min_key = std::numeric_limits<FieldType>::max();
139
140
701
    size_t num_rows = key_columns[0]->size();
141
701
    if (is_column_nullable(*key_columns[0])) {
142
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
143
0
                                              ->get_nested_column_ptr()
144
0
                                              ->get_raw_data()
145
0
                                              .data;
146
0
        const NullMap& null_map =
147
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
148
        // skip first mocked row
149
0
        for (size_t i = 1; i < num_rows; i++) {
150
0
            if (null_map[i]) {
151
0
                continue;
152
0
            }
153
0
            max_key = std::max(max_key, input_keys[i]);
154
0
            min_key = std::min(min_key, input_keys[i]);
155
0
        }
156
701
    } else {
157
701
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
158
        // skip first mocked row
159
4.62k
        for (size_t i = 1; i < num_rows; i++) {
160
3.92k
            max_key = std::max(max_key, input_keys[i]);
161
3.92k
            min_key = std::min(min_key, input_keys[i]);
162
3.92k
        }
163
701
    }
164
165
701
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
166
701
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
167
701
    if (allow_direct_mapping) {
168
701
        for (const auto& variant_ptr : variant_ptrs) {
169
701
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
170
701
                    max_key, min_key);
171
701
        }
172
611
    }
173
701
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberIjNS_13JoinHashTableIjNS_17HashCRC32Return32IjEELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
135
20.0k
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
136
20.0k
    using FieldType = typename Method::Base::Key;
137
20.0k
    FieldType max_key = std::numeric_limits<FieldType>::min();
138
20.0k
    FieldType min_key = std::numeric_limits<FieldType>::max();
139
140
20.0k
    size_t num_rows = key_columns[0]->size();
141
20.0k
    if (is_column_nullable(*key_columns[0])) {
142
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
143
0
                                              ->get_nested_column_ptr()
144
0
                                              ->get_raw_data()
145
0
                                              .data;
146
0
        const NullMap& null_map =
147
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
148
        // skip first mocked row
149
0
        for (size_t i = 1; i < num_rows; i++) {
150
0
            if (null_map[i]) {
151
0
                continue;
152
0
            }
153
0
            max_key = std::max(max_key, input_keys[i]);
154
0
            min_key = std::min(min_key, input_keys[i]);
155
0
        }
156
20.0k
    } else {
157
20.0k
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
158
        // skip first mocked row
159
15.9M
        for (size_t i = 1; i < num_rows; i++) {
160
15.8M
            max_key = std::max(max_key, input_keys[i]);
161
15.8M
            min_key = std::min(min_key, input_keys[i]);
162
15.8M
        }
163
20.0k
    }
164
165
20.0k
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
166
20.0k
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
167
20.0k
    if (allow_direct_mapping) {
168
19.1k
        for (const auto& variant_ptr : variant_ptrs) {
169
19.1k
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
170
19.1k
                    max_key, min_key);
171
19.1k
        }
172
15.2k
    }
173
20.0k
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberImNS_13JoinHashTableImNS_17HashCRC32Return32ImEELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
135
8.81k
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
136
8.81k
    using FieldType = typename Method::Base::Key;
137
8.81k
    FieldType max_key = std::numeric_limits<FieldType>::min();
138
8.81k
    FieldType min_key = std::numeric_limits<FieldType>::max();
139
140
8.81k
    size_t num_rows = key_columns[0]->size();
141
8.81k
    if (is_column_nullable(*key_columns[0])) {
142
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
143
0
                                              ->get_nested_column_ptr()
144
0
                                              ->get_raw_data()
145
0
                                              .data;
146
0
        const NullMap& null_map =
147
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
148
        // skip first mocked row
149
0
        for (size_t i = 1; i < num_rows; i++) {
150
0
            if (null_map[i]) {
151
0
                continue;
152
0
            }
153
0
            max_key = std::max(max_key, input_keys[i]);
154
0
            min_key = std::min(min_key, input_keys[i]);
155
0
        }
156
8.81k
    } else {
157
8.81k
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
158
        // skip first mocked row
159
298k
        for (size_t i = 1; i < num_rows; i++) {
160
289k
            max_key = std::max(max_key, input_keys[i]);
161
289k
            min_key = std::min(min_key, input_keys[i]);
162
289k
        }
163
8.81k
    }
164
165
8.81k
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
166
8.81k
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
167
8.81k
    if (allow_direct_mapping) {
168
6.08k
        for (const auto& variant_ptr : variant_ptrs) {
169
6.08k
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
170
6.08k
                    max_key, min_key);
171
6.08k
        }
172
4.70k
    }
173
8.81k
}
_ZN5doris25primary_to_direct_mappingINS_15MethodOneNumberIN4wide7integerILm128EjEENS_13JoinHashTableIS4_NS_17HashCRC32Return32IS4_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
135
778
                               const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
136
778
    using FieldType = typename Method::Base::Key;
137
778
    FieldType max_key = std::numeric_limits<FieldType>::min();
138
778
    FieldType min_key = std::numeric_limits<FieldType>::max();
139
140
778
    size_t num_rows = key_columns[0]->size();
141
778
    if (is_column_nullable(*key_columns[0])) {
142
0
        const FieldType* input_keys = (FieldType*)assert_cast<const ColumnNullable*>(key_columns[0])
143
0
                                              ->get_nested_column_ptr()
144
0
                                              ->get_raw_data()
145
0
                                              .data;
146
0
        const NullMap& null_map =
147
0
                assert_cast<const ColumnNullable*>(key_columns[0])->get_null_map_data();
148
        // skip first mocked row
149
0
        for (size_t i = 1; i < num_rows; i++) {
150
0
            if (null_map[i]) {
151
0
                continue;
152
0
            }
153
0
            max_key = std::max(max_key, input_keys[i]);
154
0
            min_key = std::min(min_key, input_keys[i]);
155
0
        }
156
778
    } else {
157
778
        const FieldType* input_keys = (FieldType*)key_columns[0]->get_raw_data().data;
158
        // skip first mocked row
159
2.63k
        for (size_t i = 1; i < num_rows; i++) {
160
1.85k
            max_key = std::max(max_key, input_keys[i]);
161
1.85k
            min_key = std::min(min_key, input_keys[i]);
162
1.85k
        }
163
778
    }
164
165
778
    constexpr auto MAX_MAPPING_RANGE = 1 << 23;
166
778
    bool allow_direct_mapping = (max_key >= min_key && max_key - min_key < MAX_MAPPING_RANGE - 1);
167
778
    if (allow_direct_mapping) {
168
715
        for (const auto& variant_ptr : variant_ptrs) {
169
715
            variant_ptr->method_variant.emplace<DirectPrimaryTypeHashTableContext<FieldType>>(
170
715
                    max_key, min_key);
171
715
        }
172
590
    }
173
778
}
174
175
template <typename Method>
176
void try_convert_to_direct_mapping(
177
        Method* method, const ColumnRawPtrs& key_columns,
178
50.5k
        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_9StringRefENS_17HashCRC32Return32IS3_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
178
14.6k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodOneNumberIN4wide7integerILm256EjEENS_13JoinHashTableIS4_NS_17HashCRC32Return32IS4_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
178
29
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectIhNS_13JoinHashTableIhNS_17HashCRC32Return32IhEELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectItNS_13JoinHashTableItNS_17HashCRC32Return32ItEELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectIjNS_13JoinHashTableIjNS_17HashCRC32Return32IjEELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectImNS_13JoinHashTableImNS_17HashCRC32Return32ImEELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Unexecuted instantiation: _ZN5doris29try_convert_to_direct_mappingINS_21MethodOneNumberDirectIN4wide7integerILm128EjEENS_13JoinHashTableIS4_NS_17HashCRC32Return32IS4_EELb1EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableImNS_17HashCRC32Return32ImEELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISC_EERKS9_ISt10shared_ptrINS_16JoinDataVariantsEESaISJ_EE
Line
Count
Source
178
6.22k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_6UInt72ENS_17HashCRC32Return32IS3_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
178
3.24k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_6UInt96ENS_17HashCRC32Return32IS3_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
178
8.09k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_7UInt104ENS_17HashCRC32Return32IS3_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
178
37
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableIN4wide7integerILm128EjEENS_17HashCRC32Return32IS5_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
178
8.06k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableINS_7UInt136ENS_17HashCRC32Return32IS3_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
178
960
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_15MethodKeysFixedINS_13JoinHashTableIN4wide7integerILm256EjEENS_17HashCRC32Return32IS5_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISF_EERKSC_ISt10shared_ptrINS_16JoinDataVariantsEESaISM_EE
Line
Count
Source
178
7.98k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
_ZN5doris29try_convert_to_direct_mappingINS_19MethodStringNoCacheINS_13JoinHashTableINS_9StringRefENS_17HashCRC32Return32IS3_EELb0EEEEEEEvPT_RKSt6vectorIPKNS_7IColumnESaISD_EERKSA_ISt10shared_ptrINS_16JoinDataVariantsEESaISK_EE
Line
Count
Source
178
1.23k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {}
179
180
inline void try_convert_to_direct_mapping(
181
        PrimaryTypeHashTableContext<UInt8>* context, const ColumnRawPtrs& key_columns,
182
1.14k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
183
1.14k
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
184
1.14k
}
185
186
inline void try_convert_to_direct_mapping(
187
        PrimaryTypeHashTableContext<UInt16>* context, const ColumnRawPtrs& key_columns,
188
701
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
189
701
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
190
701
}
191
192
inline void try_convert_to_direct_mapping(
193
        PrimaryTypeHashTableContext<UInt32>* context, const ColumnRawPtrs& key_columns,
194
20.0k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
195
20.0k
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
196
20.0k
}
197
198
inline void try_convert_to_direct_mapping(
199
        PrimaryTypeHashTableContext<UInt64>* context, const ColumnRawPtrs& key_columns,
200
8.81k
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
201
8.81k
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
202
8.81k
}
203
204
inline void try_convert_to_direct_mapping(
205
        PrimaryTypeHashTableContext<UInt128>* context, const ColumnRawPtrs& key_columns,
206
778
        const std::vector<std::shared_ptr<JoinDataVariants>>& variant_ptrs) {
207
778
    primary_to_direct_mapping(context, key_columns, variant_ptrs);
208
778
}
209
210
} // namespace doris