Coverage Report

Created: 2026-03-16 19:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/function_bitmap_variadic.cpp
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
#include <stddef.h>
19
20
#include <algorithm>
21
#include <functional>
22
#include <memory>
23
#include <type_traits>
24
#include <utility>
25
#include <vector>
26
27
#include "common/status.h"
28
#include "core/assert_cast.h"
29
#include "core/block/block.h"
30
#include "core/block/column_numbers.h"
31
#include "core/block/column_with_type_and_name.h"
32
#include "core/column/column.h"
33
#include "core/column/column_complex.h"
34
#include "core/column/column_nullable.h"
35
#include "core/column/column_vector.h"
36
#include "core/data_type/data_type.h"
37
#include "core/data_type/data_type_bitmap.h"
38
#include "core/data_type/data_type_nullable.h"
39
#include "core/data_type/data_type_number.h"
40
#include "core/types.h"
41
#include "core/value/bitmap_value.h"
42
#include "exprs/aggregate/aggregate_function.h"
43
#include "exprs/function/function.h"
44
#include "exprs/function/simple_function_factory.h"
45
46
namespace doris {
47
class FunctionContext;
48
} // namespace doris
49
50
namespace doris {
51
52
// currently only bitmap_or and bitmap_or_count will call this function,
53
// other bitmap functions will use default implementation for nulls
54
#define BITMAP_OR_NULLABLE(nullable, input_rows_count, res, op)                                \
55
5
    const auto& nested_col_ptr = nullable->get_nested_column_ptr();                            \
56
5
    const auto* __restrict null_map_data = nullable->get_null_map_data().data();               \
57
5
    const auto& mid_data = assert_cast<const ColumnBitmap*>(nested_col_ptr.get())->get_data(); \
58
23
    for (size_t row = 0; row < input_rows_count; ++row) {                                      \
59
18
        if (!null_map_data[row]) {                                                             \
60
17
            res[row] op mid_data[row];                                                         \
61
17
        }                                                                                      \
62
18
    }
63
64
#define BITMAP_FUNCTION_VARIADIC(CLASS, FUNCTION_NAME, OP)                                        \
65
    struct CLASS {                                                                                \
66
        static constexpr auto name = #FUNCTION_NAME;                                              \
67
        using ResultDataType = DataTypeBitMap;                                                    \
68
        static Status vector_vector(ColumnPtr argument_columns[], size_t col_size,                \
69
                                    size_t input_rows_count, std::vector<BitmapValue>& res,       \
70
0
                                    IColumn* res_nulls) {                                         \
71
0
            std::vector<const ColumnUInt8::value_type*> null_map_datas(col_size);                 \
72
0
            int nullable_cols_count = 0;                                                          \
73
0
            ColumnUInt8::value_type* __restrict res_nulls_data = nullptr;                         \
74
0
            if (res_nulls) {                                                                      \
75
0
                res_nulls_data = assert_cast<ColumnUInt8*>(res_nulls)->get_data().data();         \
76
0
            }                                                                                     \
77
0
            if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_columns[0])) {    \
78
0
                null_map_datas[nullable_cols_count++] = nullable->get_null_map_data().data();     \
79
0
                BITMAP_OR_NULLABLE(nullable, input_rows_count, res, =);                           \
80
0
            } else {                                                                              \
81
0
                const auto& mid_data =                                                            \
82
0
                        assert_cast<const ColumnBitmap*>(argument_columns[0].get())->get_data();  \
83
0
                for (size_t row = 0; row < input_rows_count; ++row) {                             \
84
0
                    res[row] = mid_data[row];                                                     \
85
0
                }                                                                                 \
86
0
            }                                                                                     \
87
0
            for (size_t col = 1; col < col_size; ++col) {                                         \
88
0
                if (auto* nullable =                                                              \
89
0
                            check_and_get_column<ColumnNullable>(*argument_columns[col])) {       \
90
0
                    null_map_datas[nullable_cols_count++] = nullable->get_null_map_data().data(); \
91
0
                    BITMAP_OR_NULLABLE(nullable, input_rows_count, res, OP);                      \
92
0
                } else {                                                                          \
93
0
                    const auto& col_data =                                                        \
94
0
                            assert_cast<const ColumnBitmap*>(argument_columns[col].get())         \
95
0
                                    ->get_data();                                                 \
96
0
                    for (size_t row = 0; row < input_rows_count; ++row) {                         \
97
0
                        res[row] OP col_data[row];                                                \
98
0
                    }                                                                             \
99
0
                }                                                                                 \
100
0
            }                                                                                     \
101
0
            if (res_nulls_data && nullable_cols_count == col_size) {                              \
102
0
                const auto* null_map_data = null_map_datas[0];                                    \
103
0
                for (size_t row = 0; row < input_rows_count; ++row) {                             \
104
0
                    res_nulls_data[row] = null_map_data[row];                                     \
105
0
                }                                                                                 \
106
0
                for (int i = 1; i < nullable_cols_count; ++i) {                                   \
107
0
                    null_map_data = null_map_datas[i];                                            \
108
0
                    for (size_t row = 0; row < input_rows_count; ++row) {                         \
109
0
                        res_nulls_data[row] &= null_map_data[row];                                \
110
0
                    }                                                                             \
111
0
                }                                                                                 \
112
0
            }                                                                                     \
113
0
            return Status::OK();                                                                  \
114
0
        }                                                                                         \
Unexecuted instantiation: _ZN5doris8BitmapOr13vector_vectorEPNS_3COWINS_7IColumnEE13immutable_ptrIS2_EEmmRSt6vectorINS_11BitmapValueESaIS8_EEPS2_
Unexecuted instantiation: _ZN5doris9BitmapXor13vector_vectorEPNS_3COWINS_7IColumnEE13immutable_ptrIS2_EEmmRSt6vectorINS_11BitmapValueESaIS8_EEPS2_
Unexecuted instantiation: _ZN5doris9BitmapAnd13vector_vectorEPNS_3COWINS_7IColumnEE13immutable_ptrIS2_EEmmRSt6vectorINS_11BitmapValueESaIS8_EEPS2_
115
    }
116
117
#define BITMAP_FUNCTION_COUNT_VARIADIC(CLASS, FUNCTION_NAME, OP)                                  \
118
    struct CLASS {                                                                                \
119
        static constexpr auto name = #FUNCTION_NAME;                                              \
120
        using ResultDataType = DataTypeInt64;                                                     \
121
        using TData = std::vector<BitmapValue>;                                                   \
122
        using ResTData = typename ColumnInt64::Container;                                         \
123
        static Status vector_vector(ColumnPtr argument_columns[], size_t col_size,                \
124
6
                                    size_t input_rows_count, ResTData& res, IColumn* res_nulls) { \
125
6
            TData vals;                                                                           \
126
6
            if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_columns[0])) {    \
127
2
                vals.resize(input_rows_count);                                                    \
128
2
                BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, =);                          \
129
4
            } else {                                                                              \
130
4
                vals = assert_cast<const ColumnBitmap*>(argument_columns[0].get())->get_data();   \
131
4
            }                                                                                     \
132
15
            for (size_t col = 1; col < col_size; ++col) {                                         \
133
9
                if (auto* nullable =                                                              \
134
9
                            check_and_get_column<ColumnNullable>(*argument_columns[col])) {       \
135
3
                    BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, OP);                     \
136
6
                } else {                                                                          \
137
6
                    const auto& col_data =                                                        \
138
6
                            assert_cast<const ColumnBitmap*>(argument_columns[col].get())         \
139
6
                                    ->get_data();                                                 \
140
28
                    for (size_t row = 0; row < input_rows_count; ++row) {                         \
141
22
                        vals[row] OP col_data[row];                                               \
142
22
                    }                                                                             \
143
6
                }                                                                                 \
144
9
            }                                                                                     \
145
27
            for (size_t row = 0; row < input_rows_count; ++row) {                                 \
146
21
                res[row] = vals[row].cardinality();                                               \
147
21
            }                                                                                     \
148
6
            return Status::OK();                                                                  \
149
6
        }                                                                                         \
_ZN5doris13BitmapOrCount13vector_vectorEPNS_3COWINS_7IColumnEE13immutable_ptrIS2_EEmmRNS_8PODArrayIlLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPS2_
Line
Count
Source
124
2
                                    size_t input_rows_count, ResTData& res, IColumn* res_nulls) { \
125
2
            TData vals;                                                                           \
126
2
            if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_columns[0])) {    \
127
2
                vals.resize(input_rows_count);                                                    \
128
2
                BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, =);                          \
129
2
            } else {                                                                              \
130
0
                vals = assert_cast<const ColumnBitmap*>(argument_columns[0].get())->get_data();   \
131
0
            }                                                                                     \
132
5
            for (size_t col = 1; col < col_size; ++col) {                                         \
133
3
                if (auto* nullable =                                                              \
134
3
                            check_and_get_column<ColumnNullable>(*argument_columns[col])) {       \
135
3
                    BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, OP);                     \
136
3
                } else {                                                                          \
137
0
                    const auto& col_data =                                                        \
138
0
                            assert_cast<const ColumnBitmap*>(argument_columns[col].get())         \
139
0
                                    ->get_data();                                                 \
140
0
                    for (size_t row = 0; row < input_rows_count; ++row) {                         \
141
0
                        vals[row] OP col_data[row];                                               \
142
0
                    }                                                                             \
143
0
                }                                                                                 \
144
3
            }                                                                                     \
145
9
            for (size_t row = 0; row < input_rows_count; ++row) {                                 \
146
7
                res[row] = vals[row].cardinality();                                               \
147
7
            }                                                                                     \
148
2
            return Status::OK();                                                                  \
149
2
        }                                                                                         \
_ZN5doris14BitmapAndCount13vector_vectorEPNS_3COWINS_7IColumnEE13immutable_ptrIS2_EEmmRNS_8PODArrayIlLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPS2_
Line
Count
Source
124
2
                                    size_t input_rows_count, ResTData& res, IColumn* res_nulls) { \
125
2
            TData vals;                                                                           \
126
2
            if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_columns[0])) {    \
127
0
                vals.resize(input_rows_count);                                                    \
128
0
                BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, =);                          \
129
2
            } else {                                                                              \
130
2
                vals = assert_cast<const ColumnBitmap*>(argument_columns[0].get())->get_data();   \
131
2
            }                                                                                     \
132
5
            for (size_t col = 1; col < col_size; ++col) {                                         \
133
3
                if (auto* nullable =                                                              \
134
3
                            check_and_get_column<ColumnNullable>(*argument_columns[col])) {       \
135
0
                    BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, OP);                     \
136
3
                } else {                                                                          \
137
3
                    const auto& col_data =                                                        \
138
3
                            assert_cast<const ColumnBitmap*>(argument_columns[col].get())         \
139
3
                                    ->get_data();                                                 \
140
14
                    for (size_t row = 0; row < input_rows_count; ++row) {                         \
141
11
                        vals[row] OP col_data[row];                                               \
142
11
                    }                                                                             \
143
3
                }                                                                                 \
144
3
            }                                                                                     \
145
9
            for (size_t row = 0; row < input_rows_count; ++row) {                                 \
146
7
                res[row] = vals[row].cardinality();                                               \
147
7
            }                                                                                     \
148
2
            return Status::OK();                                                                  \
149
2
        }                                                                                         \
_ZN5doris14BitmapXorCount13vector_vectorEPNS_3COWINS_7IColumnEE13immutable_ptrIS2_EEmmRNS_8PODArrayIlLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEEPS2_
Line
Count
Source
124
2
                                    size_t input_rows_count, ResTData& res, IColumn* res_nulls) { \
125
2
            TData vals;                                                                           \
126
2
            if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_columns[0])) {    \
127
0
                vals.resize(input_rows_count);                                                    \
128
0
                BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, =);                          \
129
2
            } else {                                                                              \
130
2
                vals = assert_cast<const ColumnBitmap*>(argument_columns[0].get())->get_data();   \
131
2
            }                                                                                     \
132
5
            for (size_t col = 1; col < col_size; ++col) {                                         \
133
3
                if (auto* nullable =                                                              \
134
3
                            check_and_get_column<ColumnNullable>(*argument_columns[col])) {       \
135
0
                    BITMAP_OR_NULLABLE(nullable, input_rows_count, vals, OP);                     \
136
3
                } else {                                                                          \
137
3
                    const auto& col_data =                                                        \
138
3
                            assert_cast<const ColumnBitmap*>(argument_columns[col].get())         \
139
3
                                    ->get_data();                                                 \
140
14
                    for (size_t row = 0; row < input_rows_count; ++row) {                         \
141
11
                        vals[row] OP col_data[row];                                               \
142
11
                    }                                                                             \
143
3
                }                                                                                 \
144
3
            }                                                                                     \
145
9
            for (size_t row = 0; row < input_rows_count; ++row) {                                 \
146
7
                res[row] = vals[row].cardinality();                                               \
147
7
            }                                                                                     \
148
2
            return Status::OK();                                                                  \
149
2
        }                                                                                         \
150
    }
151
152
BITMAP_FUNCTION_VARIADIC(BitmapOr, bitmap_or, |=);
153
BITMAP_FUNCTION_VARIADIC(BitmapAnd, bitmap_and, &=);
154
BITMAP_FUNCTION_VARIADIC(BitmapXor, bitmap_xor, ^=);
155
BITMAP_FUNCTION_COUNT_VARIADIC(BitmapOrCount, bitmap_or_count, |=);
156
BITMAP_FUNCTION_COUNT_VARIADIC(BitmapAndCount, bitmap_and_count, &=);
157
BITMAP_FUNCTION_COUNT_VARIADIC(BitmapXorCount, bitmap_xor_count, ^=);
158
159
Status execute_bitmap_op_count_null_to_zero(
160
        FunctionContext* context, Block& block, const ColumnNumbers& arguments, uint32_t result,
161
        size_t input_rows_count,
162
        const std::function<Status(FunctionContext*, Block&, const ColumnNumbers&, size_t, size_t)>&
163
                exec_impl_func);
164
165
template <typename Impl>
166
class FunctionBitMapVariadic : public IFunction {
167
public:
168
    static constexpr auto name = Impl::name;
169
170
18
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
_ZN5doris22FunctionBitMapVariadicINS_8BitmapOrEE6createEv
Line
Count
Source
170
2
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
_ZN5doris22FunctionBitMapVariadicINS_9BitmapXorEE6createEv
Line
Count
Source
170
2
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
_ZN5doris22FunctionBitMapVariadicINS_9BitmapAndEE6createEv
Line
Count
Source
170
2
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
_ZN5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE6createEv
Line
Count
Source
170
4
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
_ZN5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE6createEv
Line
Count
Source
170
4
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
_ZN5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE6createEv
Line
Count
Source
170
4
    static FunctionPtr create() { return std::make_shared<FunctionBitMapVariadic>(); }
171
172
0
    String get_name() const override { return name; }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE8get_nameB5cxx11Ev
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE8get_nameB5cxx11Ev
173
174
0
    size_t get_number_of_arguments() const override { return 0; }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE23get_number_of_argumentsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE23get_number_of_argumentsEv
175
176
12
    bool is_variadic() const override { return true; }
_ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE11is_variadicEv
Line
Count
Source
176
1
    bool is_variadic() const override { return true; }
_ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE11is_variadicEv
Line
Count
Source
176
1
    bool is_variadic() const override { return true; }
_ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE11is_variadicEv
Line
Count
Source
176
1
    bool is_variadic() const override { return true; }
_ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE11is_variadicEv
Line
Count
Source
176
3
    bool is_variadic() const override { return true; }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE11is_variadicEv
Line
Count
Source
176
3
    bool is_variadic() const override { return true; }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE11is_variadicEv
Line
Count
Source
176
3
    bool is_variadic() const override { return true; }
177
178
6
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
179
6
        using ResultDataType = typename Impl::ResultDataType;
180
6
        if (std::is_same_v<Impl, BitmapOr> || is_count()) {
181
6
            bool return_nullable = false;
182
            // result is nullable only when any columns is nullable for bitmap_or and bitmap_or_count
183
6
            for (size_t i = 0; i < arguments.size(); ++i) {
184
6
                if (arguments[i]->is_nullable()) {
185
6
                    return_nullable = true;
186
6
                    break;
187
6
                }
188
6
            }
189
6
            auto result_type = std::make_shared<ResultDataType>();
190
6
            return return_nullable ? make_nullable(result_type) : result_type;
191
6
        } else {
192
0
            return std::make_shared<ResultDataType>();
193
0
        }
194
6
    }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
_ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Line
Count
Source
178
2
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
179
2
        using ResultDataType = typename Impl::ResultDataType;
180
2
        if (std::is_same_v<Impl, BitmapOr> || is_count()) {
181
2
            bool return_nullable = false;
182
            // result is nullable only when any columns is nullable for bitmap_or and bitmap_or_count
183
2
            for (size_t i = 0; i < arguments.size(); ++i) {
184
2
                if (arguments[i]->is_nullable()) {
185
2
                    return_nullable = true;
186
2
                    break;
187
2
                }
188
2
            }
189
2
            auto result_type = std::make_shared<ResultDataType>();
190
2
            return return_nullable ? make_nullable(result_type) : result_type;
191
2
        } else {
192
0
            return std::make_shared<ResultDataType>();
193
0
        }
194
2
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Line
Count
Source
178
2
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
179
2
        using ResultDataType = typename Impl::ResultDataType;
180
2
        if (std::is_same_v<Impl, BitmapOr> || is_count()) {
181
2
            bool return_nullable = false;
182
            // result is nullable only when any columns is nullable for bitmap_or and bitmap_or_count
183
2
            for (size_t i = 0; i < arguments.size(); ++i) {
184
2
                if (arguments[i]->is_nullable()) {
185
2
                    return_nullable = true;
186
2
                    break;
187
2
                }
188
2
            }
189
2
            auto result_type = std::make_shared<ResultDataType>();
190
2
            return return_nullable ? make_nullable(result_type) : result_type;
191
2
        } else {
192
0
            return std::make_shared<ResultDataType>();
193
0
        }
194
2
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS7_EE
Line
Count
Source
178
2
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
179
2
        using ResultDataType = typename Impl::ResultDataType;
180
2
        if (std::is_same_v<Impl, BitmapOr> || is_count()) {
181
2
            bool return_nullable = false;
182
            // result is nullable only when any columns is nullable for bitmap_or and bitmap_or_count
183
2
            for (size_t i = 0; i < arguments.size(); ++i) {
184
2
                if (arguments[i]->is_nullable()) {
185
2
                    return_nullable = true;
186
2
                    break;
187
2
                }
188
2
            }
189
2
            auto result_type = std::make_shared<ResultDataType>();
190
2
            return return_nullable ? make_nullable(result_type) : result_type;
191
2
        } else {
192
0
            return std::make_shared<ResultDataType>();
193
0
        }
194
2
    }
195
196
24
    bool use_default_implementation_for_nulls() const override {
197
        // result is null only when all columns is null for bitmap_or.
198
        // for count functions, result is always not null, and if the bitmap op result is null,
199
        // the count is 0
200
24
        return !static_cast<bool>(std::is_same_v<Impl, BitmapOr> || is_count());
201
24
    }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE36use_default_implementation_for_nullsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE36use_default_implementation_for_nullsEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE36use_default_implementation_for_nullsEv
_ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE36use_default_implementation_for_nullsEv
Line
Count
Source
196
8
    bool use_default_implementation_for_nulls() const override {
197
        // result is null only when all columns is null for bitmap_or.
198
        // for count functions, result is always not null, and if the bitmap op result is null,
199
        // the count is 0
200
8
        return !static_cast<bool>(std::is_same_v<Impl, BitmapOr> || is_count());
201
8
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE36use_default_implementation_for_nullsEv
Line
Count
Source
196
8
    bool use_default_implementation_for_nulls() const override {
197
        // result is null only when all columns is null for bitmap_or.
198
        // for count functions, result is always not null, and if the bitmap op result is null,
199
        // the count is 0
200
8
        return !static_cast<bool>(std::is_same_v<Impl, BitmapOr> || is_count());
201
8
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE36use_default_implementation_for_nullsEv
Line
Count
Source
196
8
    bool use_default_implementation_for_nulls() const override {
197
        // result is null only when all columns is null for bitmap_or.
198
        // for count functions, result is always not null, and if the bitmap op result is null,
199
        // the count is 0
200
8
        return !static_cast<bool>(std::is_same_v<Impl, BitmapOr> || is_count());
201
8
    }
202
203
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
204
6
                        uint32_t result, size_t input_rows_count) const override {
205
6
        if (std::is_same_v<Impl, BitmapAndCount> || std::is_same_v<Impl, BitmapXorCount>) {
206
4
            auto impl_func = [&](FunctionContext* context, Block& block,
207
4
                                 const ColumnNumbers& arguments, uint32_t result,
208
4
                                 size_t input_rows_count) {
209
4
                return execute_impl_internal(context, block, arguments, result, input_rows_count);
210
4
            };
_ZZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjmENKUlS4_S6_SB_jmE_clES4_S6_SB_jm
Line
Count
Source
208
2
                                 size_t input_rows_count) {
209
2
                return execute_impl_internal(context, block, arguments, result, input_rows_count);
210
2
            };
_ZZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjmENKUlS4_S6_SB_jmE_clES4_S6_SB_jm
Line
Count
Source
208
2
                                 size_t input_rows_count) {
209
2
                return execute_impl_internal(context, block, arguments, result, input_rows_count);
210
2
            };
211
4
            return execute_bitmap_op_count_null_to_zero(context, block, arguments, result,
212
4
                                                        input_rows_count, impl_func);
213
4
        } else {
214
2
            return execute_impl_internal(context, block, arguments, result, input_rows_count);
215
2
        }
216
6
    }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
_ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
204
2
                        uint32_t result, size_t input_rows_count) const override {
205
2
        if (std::is_same_v<Impl, BitmapAndCount> || std::is_same_v<Impl, BitmapXorCount>) {
206
0
            auto impl_func = [&](FunctionContext* context, Block& block,
207
0
                                 const ColumnNumbers& arguments, uint32_t result,
208
0
                                 size_t input_rows_count) {
209
0
                return execute_impl_internal(context, block, arguments, result, input_rows_count);
210
0
            };
211
0
            return execute_bitmap_op_count_null_to_zero(context, block, arguments, result,
212
0
                                                        input_rows_count, impl_func);
213
2
        } else {
214
2
            return execute_impl_internal(context, block, arguments, result, input_rows_count);
215
2
        }
216
2
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
204
2
                        uint32_t result, size_t input_rows_count) const override {
205
2
        if (std::is_same_v<Impl, BitmapAndCount> || std::is_same_v<Impl, BitmapXorCount>) {
206
2
            auto impl_func = [&](FunctionContext* context, Block& block,
207
2
                                 const ColumnNumbers& arguments, uint32_t result,
208
2
                                 size_t input_rows_count) {
209
2
                return execute_impl_internal(context, block, arguments, result, input_rows_count);
210
2
            };
211
2
            return execute_bitmap_op_count_null_to_zero(context, block, arguments, result,
212
2
                                                        input_rows_count, impl_func);
213
2
        } else {
214
0
            return execute_impl_internal(context, block, arguments, result, input_rows_count);
215
0
        }
216
2
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
204
2
                        uint32_t result, size_t input_rows_count) const override {
205
2
        if (std::is_same_v<Impl, BitmapAndCount> || std::is_same_v<Impl, BitmapXorCount>) {
206
2
            auto impl_func = [&](FunctionContext* context, Block& block,
207
2
                                 const ColumnNumbers& arguments, uint32_t result,
208
2
                                 size_t input_rows_count) {
209
2
                return execute_impl_internal(context, block, arguments, result, input_rows_count);
210
2
            };
211
2
            return execute_bitmap_op_count_null_to_zero(context, block, arguments, result,
212
2
                                                        input_rows_count, impl_func);
213
2
        } else {
214
0
            return execute_impl_internal(context, block, arguments, result, input_rows_count);
215
0
        }
216
2
    }
217
218
    Status execute_impl_internal(FunctionContext* context, Block& block,
219
                                 const ColumnNumbers& arguments, uint32_t result,
220
6
                                 size_t input_rows_count) const {
221
6
        size_t argument_size = arguments.size();
222
6
        std::vector<ColumnPtr> argument_columns(argument_size);
223
224
21
        for (size_t i = 0; i < argument_size; ++i) {
225
15
            argument_columns[i] =
226
15
                    block.get_by_position(arguments[i]).column->convert_to_full_column_if_const();
227
15
        }
228
229
6
        using ResultDataType = typename Impl::ResultDataType; //DataTypeBitMap or DataTypeInt64
230
6
        using ColVecResult = std::conditional_t<is_complex_v<ResultDataType::PType>,
231
6
                                                ColumnComplexType<ResultDataType::PType>,
232
6
                                                ColumnVector<ResultDataType::PType>>;
233
6
        typename ColVecResult::MutablePtr col_res = nullptr;
234
235
6
        typename ColumnUInt8::MutablePtr col_res_nulls;
236
6
        auto& result_info = block.get_by_position(result);
237
        // special case for bitmap_or and bitmap_or_count
238
6
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
239
6
            col_res_nulls = ColumnUInt8::create(input_rows_count, 0);
240
6
        }
241
242
6
        col_res = ColVecResult::create();
243
244
6
        auto& vec_res = col_res->get_data();
245
6
        vec_res.resize(input_rows_count);
246
247
6
        RETURN_IF_ERROR(Impl::vector_vector(argument_columns.data(), argument_size,
248
6
                                            input_rows_count, vec_res, col_res_nulls.get()));
249
6
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
250
6
            block.replace_by_position(
251
6
                    result, ColumnNullable::create(std::move(col_res), std::move(col_res_nulls)));
252
6
        } else {
253
0
            block.replace_by_position(result, std::move(col_res));
254
0
        }
255
6
        return Status::OK();
256
6
    }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE21execute_impl_internalEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE21execute_impl_internalEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE21execute_impl_internalEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
_ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE21execute_impl_internalEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
220
2
                                 size_t input_rows_count) const {
221
2
        size_t argument_size = arguments.size();
222
2
        std::vector<ColumnPtr> argument_columns(argument_size);
223
224
7
        for (size_t i = 0; i < argument_size; ++i) {
225
5
            argument_columns[i] =
226
5
                    block.get_by_position(arguments[i]).column->convert_to_full_column_if_const();
227
5
        }
228
229
2
        using ResultDataType = typename Impl::ResultDataType; //DataTypeBitMap or DataTypeInt64
230
2
        using ColVecResult = std::conditional_t<is_complex_v<ResultDataType::PType>,
231
2
                                                ColumnComplexType<ResultDataType::PType>,
232
2
                                                ColumnVector<ResultDataType::PType>>;
233
2
        typename ColVecResult::MutablePtr col_res = nullptr;
234
235
2
        typename ColumnUInt8::MutablePtr col_res_nulls;
236
2
        auto& result_info = block.get_by_position(result);
237
        // special case for bitmap_or and bitmap_or_count
238
2
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
239
2
            col_res_nulls = ColumnUInt8::create(input_rows_count, 0);
240
2
        }
241
242
2
        col_res = ColVecResult::create();
243
244
2
        auto& vec_res = col_res->get_data();
245
2
        vec_res.resize(input_rows_count);
246
247
2
        RETURN_IF_ERROR(Impl::vector_vector(argument_columns.data(), argument_size,
248
2
                                            input_rows_count, vec_res, col_res_nulls.get()));
249
2
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
250
2
            block.replace_by_position(
251
2
                    result, ColumnNullable::create(std::move(col_res), std::move(col_res_nulls)));
252
2
        } else {
253
0
            block.replace_by_position(result, std::move(col_res));
254
0
        }
255
2
        return Status::OK();
256
2
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE21execute_impl_internalEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
220
2
                                 size_t input_rows_count) const {
221
2
        size_t argument_size = arguments.size();
222
2
        std::vector<ColumnPtr> argument_columns(argument_size);
223
224
7
        for (size_t i = 0; i < argument_size; ++i) {
225
5
            argument_columns[i] =
226
5
                    block.get_by_position(arguments[i]).column->convert_to_full_column_if_const();
227
5
        }
228
229
2
        using ResultDataType = typename Impl::ResultDataType; //DataTypeBitMap or DataTypeInt64
230
2
        using ColVecResult = std::conditional_t<is_complex_v<ResultDataType::PType>,
231
2
                                                ColumnComplexType<ResultDataType::PType>,
232
2
                                                ColumnVector<ResultDataType::PType>>;
233
2
        typename ColVecResult::MutablePtr col_res = nullptr;
234
235
2
        typename ColumnUInt8::MutablePtr col_res_nulls;
236
2
        auto& result_info = block.get_by_position(result);
237
        // special case for bitmap_or and bitmap_or_count
238
2
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
239
2
            col_res_nulls = ColumnUInt8::create(input_rows_count, 0);
240
2
        }
241
242
2
        col_res = ColVecResult::create();
243
244
2
        auto& vec_res = col_res->get_data();
245
2
        vec_res.resize(input_rows_count);
246
247
2
        RETURN_IF_ERROR(Impl::vector_vector(argument_columns.data(), argument_size,
248
2
                                            input_rows_count, vec_res, col_res_nulls.get()));
249
2
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
250
2
            block.replace_by_position(
251
2
                    result, ColumnNullable::create(std::move(col_res), std::move(col_res_nulls)));
252
2
        } else {
253
0
            block.replace_by_position(result, std::move(col_res));
254
0
        }
255
2
        return Status::OK();
256
2
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE21execute_impl_internalEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
220
2
                                 size_t input_rows_count) const {
221
2
        size_t argument_size = arguments.size();
222
2
        std::vector<ColumnPtr> argument_columns(argument_size);
223
224
7
        for (size_t i = 0; i < argument_size; ++i) {
225
5
            argument_columns[i] =
226
5
                    block.get_by_position(arguments[i]).column->convert_to_full_column_if_const();
227
5
        }
228
229
2
        using ResultDataType = typename Impl::ResultDataType; //DataTypeBitMap or DataTypeInt64
230
2
        using ColVecResult = std::conditional_t<is_complex_v<ResultDataType::PType>,
231
2
                                                ColumnComplexType<ResultDataType::PType>,
232
2
                                                ColumnVector<ResultDataType::PType>>;
233
2
        typename ColVecResult::MutablePtr col_res = nullptr;
234
235
2
        typename ColumnUInt8::MutablePtr col_res_nulls;
236
2
        auto& result_info = block.get_by_position(result);
237
        // special case for bitmap_or and bitmap_or_count
238
2
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
239
2
            col_res_nulls = ColumnUInt8::create(input_rows_count, 0);
240
2
        }
241
242
2
        col_res = ColVecResult::create();
243
244
2
        auto& vec_res = col_res->get_data();
245
2
        vec_res.resize(input_rows_count);
246
247
2
        RETURN_IF_ERROR(Impl::vector_vector(argument_columns.data(), argument_size,
248
2
                                            input_rows_count, vec_res, col_res_nulls.get()));
249
2
        if (!use_default_implementation_for_nulls() && result_info.type->is_nullable()) {
250
2
            block.replace_by_position(
251
2
                    result, ColumnNullable::create(std::move(col_res), std::move(col_res_nulls)));
252
2
        } else {
253
0
            block.replace_by_position(result, std::move(col_res));
254
0
        }
255
2
        return Status::OK();
256
2
    }
257
258
private:
259
30
    bool is_count() const {
260
30
        return (std::is_same_v<Impl, BitmapOrCount> || std::is_same_v<Impl, BitmapAndCount> ||
261
30
                std::is_same_v<Impl, BitmapXorCount>);
262
30
    }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapXorEE8is_countEv
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_9BitmapAndEE8is_countEv
_ZNK5doris22FunctionBitMapVariadicINS_13BitmapOrCountEE8is_countEv
Line
Count
Source
259
10
    bool is_count() const {
260
10
        return (std::is_same_v<Impl, BitmapOrCount> || std::is_same_v<Impl, BitmapAndCount> ||
261
10
                std::is_same_v<Impl, BitmapXorCount>);
262
10
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapAndCountEE8is_countEv
Line
Count
Source
259
10
    bool is_count() const {
260
10
        return (std::is_same_v<Impl, BitmapOrCount> || std::is_same_v<Impl, BitmapAndCount> ||
261
10
                std::is_same_v<Impl, BitmapXorCount>);
262
10
    }
_ZNK5doris22FunctionBitMapVariadicINS_14BitmapXorCountEE8is_countEv
Line
Count
Source
259
10
    bool is_count() const {
260
10
        return (std::is_same_v<Impl, BitmapOrCount> || std::is_same_v<Impl, BitmapAndCount> ||
261
10
                std::is_same_v<Impl, BitmapXorCount>);
262
10
    }
Unexecuted instantiation: _ZNK5doris22FunctionBitMapVariadicINS_8BitmapOrEE8is_countEv
263
};
264
265
using FunctionBitmapOr = FunctionBitMapVariadic<BitmapOr>;
266
using FunctionBitmapXor = FunctionBitMapVariadic<BitmapXor>;
267
using FunctionBitmapAnd = FunctionBitMapVariadic<BitmapAnd>;
268
using FunctionBitmapOrCount = FunctionBitMapVariadic<BitmapOrCount>;
269
using FunctionBitmapAndCount = FunctionBitMapVariadic<BitmapAndCount>;
270
using FunctionBitmapXorCount = FunctionBitMapVariadic<BitmapXorCount>;
271
272
1
void register_function_bitmap_variadic(SimpleFunctionFactory& factory) {
273
1
    factory.register_function<FunctionBitmapOr>();
274
1
    factory.register_function<FunctionBitmapXor>();
275
1
    factory.register_function<FunctionBitmapAnd>();
276
1
    factory.register_function<FunctionBitmapOrCount>();
277
1
    factory.register_function<FunctionBitmapAndCount>();
278
1
    factory.register_function<FunctionBitmapXorCount>();
279
1
}
280
} // namespace doris