Coverage Report

Created: 2026-07-29 07:17

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/function_width_bucket.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
#include <stdint.h>
20
21
#include <algorithm>
22
#include <boost/iterator/iterator_facade.hpp>
23
#include <memory>
24
#include <utility>
25
26
#include "common/status.h"
27
#include "core/assert_cast.h"
28
#include "core/block/block.h"
29
#include "core/block/column_numbers.h"
30
#include "core/block/column_with_type_and_name.h"
31
#include "core/column/column.h"
32
#include "core/column/column_vector.h"
33
#include "core/data_type/data_type.h"
34
#include "core/data_type/data_type_nullable.h"
35
#include "core/data_type/data_type_number.h"
36
#include "core/data_type/primitive_type.h"
37
#include "core/types.h"
38
#include "exprs/aggregate/aggregate_function.h"
39
#include "exprs/function/function.h"
40
#include "exprs/function/simple_function_factory.h"
41
42
namespace doris {
43
class FunctionContext;
44
} // namespace doris
45
46
namespace doris {
47
class FunctionWidthBucket : public IFunction {
48
public:
49
    static constexpr auto name = "width_bucket";
50
55
    static FunctionPtr create() { return std::make_shared<FunctionWidthBucket>(); }
51
52
    /// Get function name.
53
1
    String get_name() const override { return name; }
54
55
47
    bool is_variadic() const override { return false; }
56
57
46
    size_t get_number_of_arguments() const override { return 4; }
58
59
46
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
60
46
        return std::make_shared<DataTypeInt64>();
61
46
    }
62
63
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
64
110
                        uint32_t result, size_t input_rows_count) const override {
65
110
        ColumnPtr expr_ptr =
66
110
                block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();
67
110
        ColumnPtr min_value_ptr =
68
110
                block.get_by_position(arguments[1]).column->convert_to_full_column_if_const();
69
110
        ColumnPtr max_value_ptr =
70
110
                block.get_by_position(arguments[2]).column->convert_to_full_column_if_const();
71
110
        ColumnPtr num_buckets_ptr = block.get_by_position(arguments[3]).column;
72
110
        int64_t num_buckets = num_buckets_ptr->get_int(0);
73
74
110
        if (num_buckets <= 0) {
75
1
            return Status::InternalError(
76
1
                    "The desired number({}) of buckets must be a positive integer value.",
77
1
                    num_buckets);
78
1
        }
79
80
109
        auto nested_column_ptr = ColumnInt64::create(input_rows_count, 0);
81
109
        DataTypePtr expr_type = block.get_by_position(arguments[0]).type;
82
83
109
        if (!_execute_by_type(*expr_ptr, *min_value_ptr, *max_value_ptr, num_buckets,
84
109
                              nested_column_ptr, expr_type)) {
85
0
            return Status::InvalidArgument("Unsupported type for width_bucket: {}",
86
0
                                           expr_type->get_name());
87
0
        }
88
89
109
        block.replace_by_position(result, std::move(nested_column_ptr));
90
109
        return Status::OK();
91
109
    }
92
93
private:
94
    template <typename ColumnType>
95
    void _execute(const IColumn& expr_column, const IColumn& min_value_column,
96
                  const IColumn& max_value_column, const int64_t num_buckets,
97
109
                  ColumnInt64::MutablePtr& nested_column) const {
98
109
        const auto& expr_column_concrete = assert_cast<const ColumnType&>(expr_column);
99
109
        const auto& min_value_column_concrete = assert_cast<const ColumnType&>(min_value_column);
100
109
        const auto& max_value_column_concrete = assert_cast<const ColumnType&>(max_value_column);
101
109
        auto& nested_column_concrete = *nested_column;
102
103
109
        size_t input_rows_count = expr_column.size();
104
109
        const auto* expr_data = expr_column_concrete.get_data().data();
105
109
        const auto* min_value_data = min_value_column_concrete.get_data().data();
106
109
        const auto* max_value_data = max_value_column_concrete.get_data().data();
107
109
        auto* nested_data = nested_column_concrete.get_data().data();
108
109
454
        for (size_t i = 0; i < input_rows_count; ++i) {
110
345
            auto min_value = min_value_data[i];
111
345
            auto max_value = max_value_data[i];
112
345
            auto average_value = (max_value - min_value) / (1.0 * num_buckets);
113
345
            if (expr_data[i] < min_value) {
114
8
                continue;
115
337
            } else if (expr_data[i] >= max_value) {
116
24
                nested_data[i] = num_buckets + 1;
117
313
            } else {
118
313
                if ((max_value - min_value) / num_buckets == 0) {
119
0
                    continue;
120
0
                }
121
313
                nested_data[i] = (int64_t)(1 + (expr_data[i] - min_value) / average_value);
122
313
            }
123
345
        }
124
109
    }
_ZNK5doris19FunctionWidthBucket8_executeINS_12ColumnVectorILNS_13PrimitiveTypeE3EEEEEvRKNS_7IColumnES7_S7_lRNS_3COWIS5_E11mutable_ptrINS2_ILS3_6EEEEE
Line
Count
Source
97
4
                  ColumnInt64::MutablePtr& nested_column) const {
98
4
        const auto& expr_column_concrete = assert_cast<const ColumnType&>(expr_column);
99
4
        const auto& min_value_column_concrete = assert_cast<const ColumnType&>(min_value_column);
100
4
        const auto& max_value_column_concrete = assert_cast<const ColumnType&>(max_value_column);
101
4
        auto& nested_column_concrete = *nested_column;
102
103
4
        size_t input_rows_count = expr_column.size();
104
4
        const auto* expr_data = expr_column_concrete.get_data().data();
105
4
        const auto* min_value_data = min_value_column_concrete.get_data().data();
106
4
        const auto* max_value_data = max_value_column_concrete.get_data().data();
107
4
        auto* nested_data = nested_column_concrete.get_data().data();
108
109
8
        for (size_t i = 0; i < input_rows_count; ++i) {
110
4
            auto min_value = min_value_data[i];
111
4
            auto max_value = max_value_data[i];
112
4
            auto average_value = (max_value - min_value) / (1.0 * num_buckets);
113
4
            if (expr_data[i] < min_value) {
114
1
                continue;
115
3
            } else if (expr_data[i] >= max_value) {
116
1
                nested_data[i] = num_buckets + 1;
117
2
            } else {
118
2
                if ((max_value - min_value) / num_buckets == 0) {
119
0
                    continue;
120
0
                }
121
2
                nested_data[i] = (int64_t)(1 + (expr_data[i] - min_value) / average_value);
122
2
            }
123
4
        }
124
4
    }
Unexecuted instantiation: _ZNK5doris19FunctionWidthBucket8_executeINS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEEvRKNS_7IColumnES7_S7_lRNS_3COWIS5_E11mutable_ptrINS2_ILS3_6EEEEE
Unexecuted instantiation: _ZNK5doris19FunctionWidthBucket8_executeINS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEEvRKNS_7IColumnES7_S7_lRNS_3COWIS5_E11mutable_ptrINS2_ILS3_6EEEEE
_ZNK5doris19FunctionWidthBucket8_executeINS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEEvRKNS_7IColumnES7_S7_lRNS_3COWIS5_E11mutable_ptrIS4_EE
Line
Count
Source
97
8
                  ColumnInt64::MutablePtr& nested_column) const {
98
8
        const auto& expr_column_concrete = assert_cast<const ColumnType&>(expr_column);
99
8
        const auto& min_value_column_concrete = assert_cast<const ColumnType&>(min_value_column);
100
8
        const auto& max_value_column_concrete = assert_cast<const ColumnType&>(max_value_column);
101
8
        auto& nested_column_concrete = *nested_column;
102
103
8
        size_t input_rows_count = expr_column.size();
104
8
        const auto* expr_data = expr_column_concrete.get_data().data();
105
8
        const auto* min_value_data = min_value_column_concrete.get_data().data();
106
8
        const auto* max_value_data = max_value_column_concrete.get_data().data();
107
8
        auto* nested_data = nested_column_concrete.get_data().data();
108
109
33
        for (size_t i = 0; i < input_rows_count; ++i) {
110
25
            auto min_value = min_value_data[i];
111
25
            auto max_value = max_value_data[i];
112
25
            auto average_value = (max_value - min_value) / (1.0 * num_buckets);
113
25
            if (expr_data[i] < min_value) {
114
0
                continue;
115
25
            } else if (expr_data[i] >= max_value) {
116
0
                nested_data[i] = num_buckets + 1;
117
25
            } else {
118
25
                if ((max_value - min_value) / num_buckets == 0) {
119
0
                    continue;
120
0
                }
121
25
                nested_data[i] = (int64_t)(1 + (expr_data[i] - min_value) / average_value);
122
25
            }
123
25
        }
124
8
    }
Unexecuted instantiation: _ZNK5doris19FunctionWidthBucket8_executeINS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEEvRKNS_7IColumnES7_S7_lRNS_3COWIS5_E11mutable_ptrINS2_ILS3_6EEEEE
_ZNK5doris19FunctionWidthBucket8_executeINS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRKNS_7IColumnES7_S7_lRNS_3COWIS5_E11mutable_ptrINS2_ILS3_6EEEEE
Line
Count
Source
97
97
                  ColumnInt64::MutablePtr& nested_column) const {
98
97
        const auto& expr_column_concrete = assert_cast<const ColumnType&>(expr_column);
99
97
        const auto& min_value_column_concrete = assert_cast<const ColumnType&>(min_value_column);
100
97
        const auto& max_value_column_concrete = assert_cast<const ColumnType&>(max_value_column);
101
97
        auto& nested_column_concrete = *nested_column;
102
103
97
        size_t input_rows_count = expr_column.size();
104
97
        const auto* expr_data = expr_column_concrete.get_data().data();
105
97
        const auto* min_value_data = min_value_column_concrete.get_data().data();
106
97
        const auto* max_value_data = max_value_column_concrete.get_data().data();
107
97
        auto* nested_data = nested_column_concrete.get_data().data();
108
109
413
        for (size_t i = 0; i < input_rows_count; ++i) {
110
316
            auto min_value = min_value_data[i];
111
316
            auto max_value = max_value_data[i];
112
316
            auto average_value = (max_value - min_value) / (1.0 * num_buckets);
113
316
            if (expr_data[i] < min_value) {
114
7
                continue;
115
309
            } else if (expr_data[i] >= max_value) {
116
23
                nested_data[i] = num_buckets + 1;
117
286
            } else {
118
286
                if ((max_value - min_value) / num_buckets == 0) {
119
0
                    continue;
120
0
                }
121
286
                nested_data[i] = (int64_t)(1 + (expr_data[i] - min_value) / average_value);
122
286
            }
123
316
        }
124
97
    }
125
126
    bool _execute_by_type(const IColumn& expr_column, const IColumn& min_value_column,
127
                          const IColumn& max_value_column, const int64_t num_buckets,
128
                          ColumnInt64::MutablePtr& nested_column_column,
129
109
                          DataTypePtr& expr_type) const {
130
109
        switch (expr_type->get_primitive_type()) {
131
4
        case PrimitiveType::TYPE_TINYINT:
132
4
            _execute<ColumnInt8>(expr_column, min_value_column, max_value_column, num_buckets,
133
4
                                 nested_column_column);
134
4
            break;
135
0
        case PrimitiveType::TYPE_SMALLINT:
136
0
            _execute<ColumnInt16>(expr_column, min_value_column, max_value_column, num_buckets,
137
0
                                  nested_column_column);
138
0
            break;
139
0
        case PrimitiveType::TYPE_INT:
140
0
            _execute<ColumnInt32>(expr_column, min_value_column, max_value_column, num_buckets,
141
0
                                  nested_column_column);
142
0
            break;
143
8
        case PrimitiveType::TYPE_BIGINT:
144
8
            _execute<ColumnInt64>(expr_column, min_value_column, max_value_column, num_buckets,
145
8
                                  nested_column_column);
146
8
            break;
147
0
        case PrimitiveType::TYPE_FLOAT:
148
0
            _execute<ColumnFloat32>(expr_column, min_value_column, max_value_column, num_buckets,
149
0
                                    nested_column_column);
150
0
            break;
151
97
        case PrimitiveType::TYPE_DOUBLE:
152
97
            _execute<ColumnFloat64>(expr_column, min_value_column, max_value_column, num_buckets,
153
97
                                    nested_column_column);
154
97
            break;
155
0
        default:
156
0
            return false;
157
0
            break;
158
109
        }
159
109
        return true;
160
109
    }
161
};
162
163
8
void register_function_width_bucket(SimpleFunctionFactory& factory) {
164
8
    factory.register_function<FunctionWidthBucket>();
165
8
}
166
167
} // namespace doris