Coverage Report

Created: 2026-09-22 20:38

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/in.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
// This file is copied from
18
19
#pragma once
20
21
#include <glog/logging.h>
22
23
#include <boost/iterator/iterator_facade.hpp>
24
#include <cstddef>
25
#include <memory>
26
#include <utility>
27
#include <vector>
28
29
#include "common/status.h"
30
#include "core/block/block.h"
31
#include "core/block/column_numbers.h"
32
#include "core/block/column_with_type_and_name.h"
33
#include "core/column/column.h"
34
#include "core/column/column_const.h"
35
#include "core/column/column_nullable.h"
36
#include "core/column/column_vector.h"
37
#include "core/data_type/data_type.h"
38
#include "core/data_type/data_type_nullable.h"
39
#include "core/data_type/data_type_number.h"
40
#include "core/data_type/define_primitive_type.h"
41
#include "core/field.h"
42
#include "core/string_ref.h"
43
#include "core/types.h"
44
#include "exprs/aggregate/aggregate_function.h"
45
#include "exprs/create_predicate_function.h"
46
#include "exprs/function/function.h"
47
#include "exprs/function_context.h"
48
#include "exprs/hybrid_set.h"
49
#include "storage/index/index_reader_helper.h"
50
51
namespace doris {
52
53
template <typename T>
54
class ColumnStr;
55
using ColumnString = ColumnStr<UInt32>;
56
57
struct InState {
58
    bool use_set = true;
59
    std::shared_ptr<HybridSetBase> hybrid_set;
60
};
61
62
template <bool negative>
63
class FunctionIn : public IFunction {
64
public:
65
    static constexpr auto name = negative ? "not_in" : "in";
66
67
20
    static FunctionPtr create() { return std::make_shared<FunctionIn>(); }
_ZN5doris10FunctionInILb0EE6createEv
Line
Count
Source
67
12
    static FunctionPtr create() { return std::make_shared<FunctionIn>(); }
_ZN5doris10FunctionInILb1EE6createEv
Line
Count
Source
67
8
    static FunctionPtr create() { return std::make_shared<FunctionIn>(); }
68
69
0
    String get_name() const override { return name; }
Unexecuted instantiation: _ZNK5doris10FunctionInILb0EE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris10FunctionInILb1EE8get_nameB5cxx11Ev
70
71
18
    bool is_variadic() const override { return true; }
_ZNK5doris10FunctionInILb0EE11is_variadicEv
Line
Count
Source
71
11
    bool is_variadic() const override { return true; }
_ZNK5doris10FunctionInILb1EE11is_variadicEv
Line
Count
Source
71
7
    bool is_variadic() const override { return true; }
72
73
0
    size_t get_number_of_arguments() const override { return 0; }
Unexecuted instantiation: _ZNK5doris10FunctionInILb0EE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris10FunctionInILb1EE23get_number_of_argumentsEv
74
75
16
    DataTypePtr get_return_type_impl(const DataTypes& args) const override {
76
22
        for (const auto& arg : args) {
77
22
            if (arg->is_nullable()) {
78
16
                return make_nullable(std::make_shared<DataTypeUInt8>());
79
16
            }
80
22
        }
81
0
        return std::make_shared<DataTypeUInt8>();
82
16
    }
_ZNK5doris10FunctionInILb0EE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS6_EE
Line
Count
Source
75
10
    DataTypePtr get_return_type_impl(const DataTypes& args) const override {
76
14
        for (const auto& arg : args) {
77
14
            if (arg->is_nullable()) {
78
10
                return make_nullable(std::make_shared<DataTypeUInt8>());
79
10
            }
80
14
        }
81
0
        return std::make_shared<DataTypeUInt8>();
82
10
    }
_ZNK5doris10FunctionInILb1EE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS6_EE
Line
Count
Source
75
6
    DataTypePtr get_return_type_impl(const DataTypes& args) const override {
76
8
        for (const auto& arg : args) {
77
8
            if (arg->is_nullable()) {
78
6
                return make_nullable(std::make_shared<DataTypeUInt8>());
79
6
            }
80
8
        }
81
0
        return std::make_shared<DataTypeUInt8>();
82
6
    }
83
84
16
    bool use_default_implementation_for_nulls() const override { return false; }
_ZNK5doris10FunctionInILb0EE36use_default_implementation_for_nullsEv
Line
Count
Source
84
10
    bool use_default_implementation_for_nulls() const override { return false; }
_ZNK5doris10FunctionInILb1EE36use_default_implementation_for_nullsEv
Line
Count
Source
84
6
    bool use_default_implementation_for_nulls() const override { return false; }
85
86
    // size of [ in ( 1 , 2  , 3 , null) ]  is 3
87
11
    size_t get_size_with_out_null(FunctionContext* context) {
88
11
        if ((context->get_num_args() - 1) > FIXED_CONTAINER_MAX_SIZE) {
89
0
            return context->get_num_args() - 1;
90
0
        }
91
11
        size_t sz = 0;
92
34
        for (int i = 1; i < context->get_num_args(); ++i) {
93
23
            const auto& const_column_ptr = context->get_constant_col(i);
94
23
            if (const_column_ptr != nullptr) {
95
23
                auto const_data = const_column_ptr->column_ptr->get_data_at(0);
96
23
                if (const_data.data != nullptr) {
97
21
                    sz++;
98
21
                }
99
23
            }
100
23
        }
101
11
        return sz;
102
11
    }
_ZN5doris10FunctionInILb0EE22get_size_with_out_nullEPNS_15FunctionContextE
Line
Count
Source
87
7
    size_t get_size_with_out_null(FunctionContext* context) {
88
7
        if ((context->get_num_args() - 1) > FIXED_CONTAINER_MAX_SIZE) {
89
0
            return context->get_num_args() - 1;
90
0
        }
91
7
        size_t sz = 0;
92
24
        for (int i = 1; i < context->get_num_args(); ++i) {
93
17
            const auto& const_column_ptr = context->get_constant_col(i);
94
17
            if (const_column_ptr != nullptr) {
95
17
                auto const_data = const_column_ptr->column_ptr->get_data_at(0);
96
17
                if (const_data.data != nullptr) {
97
16
                    sz++;
98
16
                }
99
17
            }
100
17
        }
101
7
        return sz;
102
7
    }
_ZN5doris10FunctionInILb1EE22get_size_with_out_nullEPNS_15FunctionContextE
Line
Count
Source
87
4
    size_t get_size_with_out_null(FunctionContext* context) {
88
4
        if ((context->get_num_args() - 1) > FIXED_CONTAINER_MAX_SIZE) {
89
0
            return context->get_num_args() - 1;
90
0
        }
91
4
        size_t sz = 0;
92
10
        for (int i = 1; i < context->get_num_args(); ++i) {
93
6
            const auto& const_column_ptr = context->get_constant_col(i);
94
6
            if (const_column_ptr != nullptr) {
95
6
                auto const_data = const_column_ptr->column_ptr->get_data_at(0);
96
6
                if (const_data.data != nullptr) {
97
5
                    sz++;
98
5
                }
99
6
            }
100
6
        }
101
4
        return sz;
102
4
    }
103
104
26
    Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override {
105
26
        if (scope == FunctionContext::THREAD_LOCAL) {
106
11
            return Status::OK();
107
11
        }
108
        // Binary IO must not route IN through the shared string/storage predicate implementation.
109
15
        if (context->get_arg_type(0)->get_primitive_type() == TYPE_VARBINARY) {
110
4
            return Status::NotSupported("VARBINARY IN/NOT IN is not supported");
111
4
        }
112
11
        std::shared_ptr<InState> state = std::make_shared<InState>();
113
11
        context->set_function_state(scope, state);
114
11
        DCHECK(context->get_num_args() >= 1);
115
11
        if (context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_NULL) {
116
0
            state->hybrid_set.reset(create_set(TYPE_BOOLEAN, 0, true));
117
11
        } else if (context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_CHAR ||
118
11
                   context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_VARCHAR ||
119
11
                   context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_STRING) {
120
            // the StringValue's memory is held by FunctionContext, so we can use StringValueSet here directly
121
3
            state->hybrid_set.reset(create_string_value_set(get_size_with_out_null(context), true));
122
8
        } else {
123
8
            state->hybrid_set.reset(create_set(context->get_arg_type(0)->get_primitive_type(),
124
8
                                               get_size_with_out_null(context), true));
125
8
        }
126
127
34
        for (int i = 1; i < context->get_num_args(); ++i) {
128
23
            const auto& const_column_ptr = context->get_constant_col(i);
129
23
            if (const_column_ptr != nullptr) {
130
23
                auto const_data = const_column_ptr->column_ptr->get_data_at(0);
131
23
                state->hybrid_set->insert((void*)const_data.data, const_data.size);
132
23
            } else {
133
0
                state->use_set = false;
134
0
                state->hybrid_set.reset();
135
0
                break;
136
0
            }
137
23
        }
138
11
        return Status::OK();
139
15
    }
_ZN5doris10FunctionInILb0EE4openEPNS_15FunctionContextENS2_18FunctionStateScopeE
Line
Count
Source
104
16
    Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override {
105
16
        if (scope == FunctionContext::THREAD_LOCAL) {
106
7
            return Status::OK();
107
7
        }
108
        // Binary IO must not route IN through the shared string/storage predicate implementation.
109
9
        if (context->get_arg_type(0)->get_primitive_type() == TYPE_VARBINARY) {
110
2
            return Status::NotSupported("VARBINARY IN/NOT IN is not supported");
111
2
        }
112
7
        std::shared_ptr<InState> state = std::make_shared<InState>();
113
7
        context->set_function_state(scope, state);
114
7
        DCHECK(context->get_num_args() >= 1);
115
7
        if (context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_NULL) {
116
0
            state->hybrid_set.reset(create_set(TYPE_BOOLEAN, 0, true));
117
7
        } else if (context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_CHAR ||
118
7
                   context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_VARCHAR ||
119
7
                   context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_STRING) {
120
            // the StringValue's memory is held by FunctionContext, so we can use StringValueSet here directly
121
2
            state->hybrid_set.reset(create_string_value_set(get_size_with_out_null(context), true));
122
5
        } else {
123
5
            state->hybrid_set.reset(create_set(context->get_arg_type(0)->get_primitive_type(),
124
5
                                               get_size_with_out_null(context), true));
125
5
        }
126
127
24
        for (int i = 1; i < context->get_num_args(); ++i) {
128
17
            const auto& const_column_ptr = context->get_constant_col(i);
129
17
            if (const_column_ptr != nullptr) {
130
17
                auto const_data = const_column_ptr->column_ptr->get_data_at(0);
131
17
                state->hybrid_set->insert((void*)const_data.data, const_data.size);
132
17
            } else {
133
0
                state->use_set = false;
134
0
                state->hybrid_set.reset();
135
0
                break;
136
0
            }
137
17
        }
138
7
        return Status::OK();
139
9
    }
_ZN5doris10FunctionInILb1EE4openEPNS_15FunctionContextENS2_18FunctionStateScopeE
Line
Count
Source
104
10
    Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override {
105
10
        if (scope == FunctionContext::THREAD_LOCAL) {
106
4
            return Status::OK();
107
4
        }
108
        // Binary IO must not route IN through the shared string/storage predicate implementation.
109
6
        if (context->get_arg_type(0)->get_primitive_type() == TYPE_VARBINARY) {
110
2
            return Status::NotSupported("VARBINARY IN/NOT IN is not supported");
111
2
        }
112
4
        std::shared_ptr<InState> state = std::make_shared<InState>();
113
4
        context->set_function_state(scope, state);
114
4
        DCHECK(context->get_num_args() >= 1);
115
4
        if (context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_NULL) {
116
0
            state->hybrid_set.reset(create_set(TYPE_BOOLEAN, 0, true));
117
4
        } else if (context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_CHAR ||
118
4
                   context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_VARCHAR ||
119
4
                   context->get_arg_type(0)->get_primitive_type() == PrimitiveType::TYPE_STRING) {
120
            // the StringValue's memory is held by FunctionContext, so we can use StringValueSet here directly
121
1
            state->hybrid_set.reset(create_string_value_set(get_size_with_out_null(context), true));
122
3
        } else {
123
3
            state->hybrid_set.reset(create_set(context->get_arg_type(0)->get_primitive_type(),
124
3
                                               get_size_with_out_null(context), true));
125
3
        }
126
127
10
        for (int i = 1; i < context->get_num_args(); ++i) {
128
6
            const auto& const_column_ptr = context->get_constant_col(i);
129
6
            if (const_column_ptr != nullptr) {
130
6
                auto const_data = const_column_ptr->column_ptr->get_data_at(0);
131
6
                state->hybrid_set->insert((void*)const_data.data, const_data.size);
132
6
            } else {
133
0
                state->use_set = false;
134
0
                state->hybrid_set.reset();
135
0
                break;
136
0
            }
137
6
        }
138
4
        return Status::OK();
139
6
    }
140
141
    Status evaluate_inverted_index(
142
            const ColumnsWithTypeAndName& arguments,
143
            const std::vector<IndexFieldNameAndTypePair>& data_type_with_names,
144
            std::vector<segment_v2::IndexIterator*> iterators, uint32_t num_rows,
145
            const InvertedIndexAnalyzerCtx* analyzer_ctx,
146
0
            segment_v2::InvertedIndexResultBitmap& bitmap_result) const override {
147
0
        DCHECK(data_type_with_names.size() == 1);
148
0
        DCHECK(iterators.size() == 1);
149
0
        auto* iter = iterators[0];
150
0
        auto data_type_with_name = data_type_with_names[0];
151
0
        std::shared_ptr<roaring::Roaring> roaring = std::make_shared<roaring::Roaring>();
152
0
        std::shared_ptr<roaring::Roaring> null_bitmap = std::make_shared<roaring::Roaring>();
153
154
0
        if (iter == nullptr) {
155
0
            return Status::OK();
156
0
        }
157
0
        if (!segment_v2::IndexReaderHelper::has_string_or_bkd_index(iter)) {
158
            //NOT support in list when parser is FULLTEXT for expr inverted index evaluate.
159
0
            return Status::OK();
160
0
        }
161
0
        if (iter->has_null()) {
162
0
            segment_v2::InvertedIndexQueryCacheHandle null_bitmap_cache_handle;
163
0
            RETURN_IF_ERROR(iter->read_null_bitmap(&null_bitmap_cache_handle));
164
0
            null_bitmap = null_bitmap_cache_handle.get_bitmap();
165
0
        }
166
0
        for (const auto& arg : arguments) {
167
0
            Field param_value;
168
0
            arg.column->get(0, param_value);
169
0
            if (param_value.is_null()) {
170
                // predicate like column NOT IN (NULL, '') should not push down to index.
171
0
                if (negative) {
172
0
                    return Status::OK();
173
0
                }
174
0
                *roaring |= *null_bitmap;
175
0
                continue;
176
0
            }
177
0
            InvertedIndexQueryType query_type = InvertedIndexQueryType::EQUAL_QUERY;
178
0
            segment_v2::InvertedIndexParam param;
179
0
            param.column_name = data_type_with_name.first;
180
0
            param.column_type = data_type_with_name.second;
181
0
            param.query_value = param_value;
182
0
            param.query_type = query_type;
183
0
            param.num_rows = num_rows;
184
0
            param.roaring = std::make_shared<roaring::Roaring>();
185
0
            param.analyzer_ctx = analyzer_ctx;
186
0
            RETURN_IF_ERROR(iter->read_from_index(segment_v2::IndexParam {&param}));
187
0
            *roaring |= *param.roaring;
188
0
        }
189
0
        segment_v2::InvertedIndexResultBitmap result(roaring, null_bitmap);
190
0
        bitmap_result = result;
191
0
        bitmap_result.mask_out_null();
192
0
        if constexpr (negative) {
193
0
            roaring::Roaring full_result;
194
0
            full_result.addRange(0, num_rows);
195
0
            bitmap_result.op_not(&full_result);
196
0
        }
197
0
        return Status::OK();
198
0
    }
Unexecuted instantiation: _ZNK5doris10FunctionInILb0EE23evaluate_inverted_indexERKSt6vectorINS_21ColumnWithTypeAndNameESaIS3_EERKS2_ISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIKNS_9IDataTypeEEESaISJ_EES2_IPNS_10segment_v213IndexIteratorESaISQ_EEjPKNS_24InvertedIndexAnalyzerCtxERNSO_25InvertedIndexResultBitmapE
Unexecuted instantiation: _ZNK5doris10FunctionInILb1EE23evaluate_inverted_indexERKSt6vectorINS_21ColumnWithTypeAndNameESaIS3_EERKS2_ISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIKNS_9IDataTypeEEESaISJ_EES2_IPNS_10segment_v213IndexIteratorESaISQ_EEjPKNS_24InvertedIndexAnalyzerCtxERNSO_25InvertedIndexResultBitmapE
199
200
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
201
0
                        uint32_t result, size_t input_rows_count) const override {
202
0
        auto* in_state = reinterpret_cast<InState*>(
203
0
                context->get_function_state(FunctionContext::FRAGMENT_LOCAL));
204
0
        if (!in_state) {
205
0
            return Status::RuntimeError("funciton context for function '{}' must have Set;",
206
0
                                        get_name());
207
0
        }
208
0
        auto res = ColumnUInt8::create();
209
0
        ColumnUInt8::Container& vec_res = res->get_data();
210
0
        vec_res.resize(input_rows_count);
211
212
0
        ColumnUInt8::MutablePtr col_null_map_to;
213
0
        col_null_map_to = ColumnUInt8::create(input_rows_count, false);
214
0
        auto& vec_null_map_to = col_null_map_to->get_data();
215
216
0
        const ColumnWithTypeAndName& left_arg = block.get_by_position(arguments[0]);
217
0
        const auto& [unpacked_column, col_const] = unpack_if_const(left_arg.column);
218
0
        ColumnPtr materialized_column = unpacked_column;
219
0
        if (in_state->use_set && col_const) {
220
0
            materialized_column = left_arg.column->convert_to_full_column_if_const();
221
0
        }
222
223
0
        if (in_state->use_set) {
224
0
            if (const auto* null_col_ptr =
225
0
                        check_and_get_column<ColumnNullable>(materialized_column.get())) {
226
0
                const auto& null_map = null_col_ptr->get_null_map_column().get_data();
227
0
                const auto* nested_col_ptr = null_col_ptr->get_nested_column_ptr().get();
228
229
0
                if (nested_col_ptr->is_column_string()) {
230
0
                    const auto* column_string_ptr =
231
0
                            assert_cast<const ColumnString*>(nested_col_ptr);
232
0
                    search_hash_set_check_null(in_state, input_rows_count, vec_res, null_map,
233
0
                                               column_string_ptr);
234
0
                } else {
235
                    //TODO: support other column type
236
0
                    search_hash_set_check_null(in_state, input_rows_count, vec_res, null_map,
237
0
                                               nested_col_ptr);
238
0
                }
239
240
0
                if (!in_state->hybrid_set->contain_null()) {
241
0
                    for (size_t i = 0; i < input_rows_count; ++i) {
242
0
                        vec_null_map_to[i] = null_map[i];
243
0
                    }
244
0
                } else {
245
0
                    for (size_t i = 0; i < input_rows_count; ++i) {
246
0
                        vec_null_map_to[i] = null_map[i] || negative == vec_res[i];
247
0
                    }
248
0
                }
249
250
0
            } else { // non-nullable
251
0
                if (is_string_type(left_arg.type->get_primitive_type())) {
252
0
                    const auto* column_string_ptr =
253
0
                            assert_cast<const ColumnString*>(materialized_column.get());
254
0
                    search_hash_set(in_state, input_rows_count, vec_res, column_string_ptr);
255
0
                } else {
256
0
                    search_hash_set(in_state, input_rows_count, vec_res, materialized_column.get());
257
0
                }
258
259
0
                if (in_state->hybrid_set->contain_null()) {
260
0
                    for (size_t i = 0; i < input_rows_count; ++i) {
261
0
                        vec_null_map_to[i] = negative == vec_res[i];
262
0
                    }
263
0
                }
264
0
            }
265
0
        } else { //!in_state->use_set
266
0
            std::vector<ColumnPtr> set_columns;
267
0
            for (int i = 1; i < arguments.size(); ++i) {
268
0
                set_columns.emplace_back(block.get_by_position(arguments[i]).column);
269
0
            }
270
0
            if (col_const) {
271
0
                impl_without_set<true>(context, set_columns, input_rows_count, vec_res,
272
0
                                       vec_null_map_to, materialized_column);
273
0
            } else {
274
0
                impl_without_set<false>(context, set_columns, input_rows_count, vec_res,
275
0
                                        vec_null_map_to, materialized_column);
276
0
            }
277
0
        }
278
279
0
        if (block.get_by_position(result).type->is_nullable()) {
280
0
            block.replace_by_position(
281
0
                    result, ColumnNullable::create(std::move(res), std::move(col_null_map_to)));
282
0
        } else {
283
0
            block.replace_by_position(result, std::move(res));
284
0
        }
285
286
0
        return Status::OK();
287
0
    }
Unexecuted instantiation: _ZNK5doris10FunctionInILb0EE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZNK5doris10FunctionInILb1EE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
288
289
private:
290
    template <typename T>
291
    static void search_hash_set_check_null(InState* in_state, size_t input_rows_count,
292
                                           ColumnUInt8::Container& vec_res,
293
0
                                           const ColumnUInt8::Container& null_map, T* col_ptr) {
294
0
        if constexpr (!negative) {
295
0
            in_state->hybrid_set->find_batch_nullable(*col_ptr, input_rows_count, null_map,
296
0
                                                      vec_res);
297
0
        } else {
298
0
            in_state->hybrid_set->find_batch_nullable_negative(*col_ptr, input_rows_count, null_map,
299
0
                                                               vec_res);
300
0
        }
301
0
    }
Unexecuted instantiation: _ZN5doris10FunctionInILb0EE26search_hash_set_check_nullIKNS_9ColumnStrIjEEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERKSC_PT_
Unexecuted instantiation: _ZN5doris10FunctionInILb0EE26search_hash_set_check_nullIKNS_7IColumnEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERKSB_PT_
Unexecuted instantiation: _ZN5doris10FunctionInILb1EE26search_hash_set_check_nullIKNS_9ColumnStrIjEEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERKSC_PT_
Unexecuted instantiation: _ZN5doris10FunctionInILb1EE26search_hash_set_check_nullIKNS_7IColumnEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEERKSB_PT_
302
303
    template <typename T>
304
    static void search_hash_set(InState* in_state, size_t input_rows_count,
305
0
                                ColumnUInt8::Container& vec_res, T* col_ptr) {
306
0
        if constexpr (!negative) {
307
0
            in_state->hybrid_set->find_batch(*col_ptr, input_rows_count, vec_res);
308
0
        } else {
309
0
            in_state->hybrid_set->find_batch_negative(*col_ptr, input_rows_count, vec_res);
310
0
        }
311
0
    }
Unexecuted instantiation: _ZN5doris10FunctionInILb0EE15search_hash_setIKNS_9ColumnStrIjEEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPT_
Unexecuted instantiation: _ZN5doris10FunctionInILb0EE15search_hash_setIKNS_7IColumnEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPT_
Unexecuted instantiation: _ZN5doris10FunctionInILb1EE15search_hash_setIKNS_9ColumnStrIjEEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPT_
Unexecuted instantiation: _ZN5doris10FunctionInILb1EE15search_hash_setIKNS_7IColumnEEEvPNS_7InStateEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPT_
312
313
    template <bool Const>
314
    static void impl_without_set(FunctionContext* context,
315
                                 const std::vector<ColumnPtr>& set_columns, size_t input_rows_count,
316
                                 ColumnUInt8::Container& vec_res,
317
                                 ColumnUInt8::Container& vec_null_map_to,
318
0
                                 const ColumnPtr& materialized_column) {
319
0
        for (size_t i = 0; i < input_rows_count; ++i) {
320
0
            const auto& ref_data = materialized_column->get_data_at(index_check_const(i, Const));
321
0
            if (ref_data.data == nullptr) {
322
0
                vec_null_map_to[i] = true;
323
0
                continue;
324
0
            }
325
326
0
            std::vector<StringRef> set_datas;
327
            // To comply with the SQL standard, IN() returns NULL not only if the expression on the left hand side is NULL,
328
            // but also if no match is found in the list and one of the expressions in the list is NULL.
329
0
            bool null_in_set = false;
330
331
0
            for (const auto& set_column : set_columns) {
332
0
                auto set_data = set_column->get_data_at(i);
333
0
                if (set_data.data == nullptr) {
334
0
                    null_in_set = true;
335
0
                } else {
336
0
                    set_datas.push_back(set_data);
337
0
                }
338
0
            }
339
0
            std::unique_ptr<HybridSetBase> hybrid_set(create_set(
340
0
                    context->get_arg_type(0)->get_primitive_type(), set_datas.size(), true));
341
0
            for (auto& set_data : set_datas) {
342
0
                hybrid_set->insert((void*)(set_data.data), set_data.size);
343
0
            }
344
345
0
            vec_res[i] = negative ^ hybrid_set->find((void*)ref_data.data, ref_data.size);
346
0
            if (null_in_set) {
347
0
                vec_null_map_to[i] = negative == vec_res[i];
348
0
            } else {
349
0
                vec_null_map_to[i] = false;
350
0
            }
351
0
        }
352
0
    }
Unexecuted instantiation: _ZN5doris10FunctionInILb0EE16impl_without_setILb1EEEvPNS_15FunctionContextERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS7_EESaISA_EEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESK_RKSA_
Unexecuted instantiation: _ZN5doris10FunctionInILb0EE16impl_without_setILb0EEEvPNS_15FunctionContextERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS7_EESaISA_EEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESK_RKSA_
Unexecuted instantiation: _ZN5doris10FunctionInILb1EE16impl_without_setILb1EEEvPNS_15FunctionContextERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS7_EESaISA_EEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESK_RKSA_
Unexecuted instantiation: _ZN5doris10FunctionInILb1EE16impl_without_setILb0EEEvPNS_15FunctionContextERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS7_EESaISA_EEmRNS_8PODArrayIhLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEESK_RKSA_
353
};
354
355
} // namespace doris