Coverage Report

Created: 2026-03-13 03:47

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/int_div.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
// This file is copied from
18
// https://github.com/ClickHouse/ClickHouse/blob/master/src/Functions/IntDiv.cpp
19
// and modified by Doris
20
21
#include <libdivide.h>
22
23
#include <utility>
24
25
#include "core/data_type/data_type_number.h"
26
#include "exprs/function/simple_function_factory.h"
27
28
namespace doris {
29
30
template <typename Impl>
31
class FunctionIntDiv : public IFunction {
32
public:
33
    static constexpr auto name = "int_divide";
34
35
675
    static FunctionPtr create() { return std::make_shared<FunctionIntDiv>(); }
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE6createEv
Line
Count
Source
35
25
    static FunctionPtr create() { return std::make_shared<FunctionIntDiv>(); }
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE6createEv
Line
Count
Source
35
17
    static FunctionPtr create() { return std::make_shared<FunctionIntDiv>(); }
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE6createEv
Line
Count
Source
35
32
    static FunctionPtr create() { return std::make_shared<FunctionIntDiv>(); }
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE6createEv
Line
Count
Source
35
572
    static FunctionPtr create() { return std::make_shared<FunctionIntDiv>(); }
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE6createEv
Line
Count
Source
35
29
    static FunctionPtr create() { return std::make_shared<FunctionIntDiv>(); }
36
37
675
    FunctionIntDiv() = default;
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEEC2Ev
Line
Count
Source
37
25
    FunctionIntDiv() = default;
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEEC2Ev
Line
Count
Source
37
17
    FunctionIntDiv() = default;
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEEC2Ev
Line
Count
Source
37
32
    FunctionIntDiv() = default;
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEEC2Ev
Line
Count
Source
37
572
    FunctionIntDiv() = default;
_ZN5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEEC2Ev
Line
Count
Source
37
29
    FunctionIntDiv() = default;
38
39
5
    String get_name() const override { return name; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE8get_nameB5cxx11Ev
Line
Count
Source
39
1
    String get_name() const override { return name; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE8get_nameB5cxx11Ev
Line
Count
Source
39
1
    String get_name() const override { return name; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE8get_nameB5cxx11Ev
Line
Count
Source
39
1
    String get_name() const override { return name; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE8get_nameB5cxx11Ev
Line
Count
Source
39
1
    String get_name() const override { return name; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE8get_nameB5cxx11Ev
Line
Count
Source
39
1
    String get_name() const override { return name; }
40
41
630
    size_t get_number_of_arguments() const override { return 2; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE23get_number_of_argumentsEv
Line
Count
Source
41
16
    size_t get_number_of_arguments() const override { return 2; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE23get_number_of_argumentsEv
Line
Count
Source
41
8
    size_t get_number_of_arguments() const override { return 2; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE23get_number_of_argumentsEv
Line
Count
Source
41
23
    size_t get_number_of_arguments() const override { return 2; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE23get_number_of_argumentsEv
Line
Count
Source
41
563
    size_t get_number_of_arguments() const override { return 2; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE23get_number_of_argumentsEv
Line
Count
Source
41
20
    size_t get_number_of_arguments() const override { return 2; }
42
43
40
    DataTypes get_variadic_argument_types_impl() const override {
44
40
        return Impl::get_variadic_argument_types();
45
40
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE32get_variadic_argument_types_implEv
Line
Count
Source
43
8
    DataTypes get_variadic_argument_types_impl() const override {
44
8
        return Impl::get_variadic_argument_types();
45
8
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE32get_variadic_argument_types_implEv
Line
Count
Source
43
8
    DataTypes get_variadic_argument_types_impl() const override {
44
8
        return Impl::get_variadic_argument_types();
45
8
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE32get_variadic_argument_types_implEv
Line
Count
Source
43
8
    DataTypes get_variadic_argument_types_impl() const override {
44
8
        return Impl::get_variadic_argument_types();
45
8
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE32get_variadic_argument_types_implEv
Line
Count
Source
43
8
    DataTypes get_variadic_argument_types_impl() const override {
44
8
        return Impl::get_variadic_argument_types();
45
8
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE32get_variadic_argument_types_implEv
Line
Count
Source
43
8
    DataTypes get_variadic_argument_types_impl() const override {
44
8
        return Impl::get_variadic_argument_types();
45
8
    }
46
47
630
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
48
630
        DataTypePtr type_res =
49
630
                std::make_shared<typename PrimitiveTypeTraits<Impl::ResultType>::DataType>();
50
630
        return make_nullable(type_res);
51
630
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS9_EE
Line
Count
Source
47
16
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
48
16
        DataTypePtr type_res =
49
16
                std::make_shared<typename PrimitiveTypeTraits<Impl::ResultType>::DataType>();
50
16
        return make_nullable(type_res);
51
16
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS9_EE
Line
Count
Source
47
8
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
48
8
        DataTypePtr type_res =
49
8
                std::make_shared<typename PrimitiveTypeTraits<Impl::ResultType>::DataType>();
50
8
        return make_nullable(type_res);
51
8
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS9_EE
Line
Count
Source
47
23
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
48
23
        DataTypePtr type_res =
49
23
                std::make_shared<typename PrimitiveTypeTraits<Impl::ResultType>::DataType>();
50
23
        return make_nullable(type_res);
51
23
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS9_EE
Line
Count
Source
47
563
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
48
563
        DataTypePtr type_res =
49
563
                std::make_shared<typename PrimitiveTypeTraits<Impl::ResultType>::DataType>();
50
563
        return make_nullable(type_res);
51
563
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS9_EE
Line
Count
Source
47
20
    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
48
20
        DataTypePtr type_res =
49
20
                std::make_shared<typename PrimitiveTypeTraits<Impl::ResultType>::DataType>();
50
20
        return make_nullable(type_res);
51
20
    }
52
53
7.26k
    bool use_default_implementation_for_constants() const final { return false; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE40use_default_implementation_for_constantsEv
Line
Count
Source
53
124
    bool use_default_implementation_for_constants() const final { return false; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE40use_default_implementation_for_constantsEv
Line
Count
Source
53
73
    bool use_default_implementation_for_constants() const final { return false; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE40use_default_implementation_for_constantsEv
Line
Count
Source
53
142
    bool use_default_implementation_for_constants() const final { return false; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE40use_default_implementation_for_constantsEv
Line
Count
Source
53
6.70k
    bool use_default_implementation_for_constants() const final { return false; }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE40use_default_implementation_for_constantsEv
Line
Count
Source
53
220
    bool use_default_implementation_for_constants() const final { return false; }
54
55
    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
56
2.40k
                        uint32_t result, size_t input_rows_count) const override {
57
2.40k
        auto& column_left = block.get_by_position(arguments[0]).column;
58
2.40k
        auto& column_right = block.get_by_position(arguments[1]).column;
59
2.40k
        bool is_const_left = is_column_const(*column_left);
60
2.40k
        bool is_const_right = is_column_const(*column_right);
61
62
2.40k
        ColumnPtr column_result = nullptr;
63
2.40k
        if (is_const_left && is_const_right) {
64
23
            column_result = constant_constant(column_left, column_right);
65
2.38k
        } else if (is_const_left) {
66
0
            column_result = constant_vector(column_left, column_right);
67
2.38k
        } else if (is_const_right) {
68
5
            column_result = vector_constant(column_left, column_right);
69
2.38k
        } else {
70
2.38k
            column_result = vector_vector(column_left, column_right);
71
2.38k
        }
72
2.40k
        block.replace_by_position(result, std::move(column_result));
73
2.40k
        return Status::OK();
74
2.40k
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
56
34
                        uint32_t result, size_t input_rows_count) const override {
57
34
        auto& column_left = block.get_by_position(arguments[0]).column;
58
34
        auto& column_right = block.get_by_position(arguments[1]).column;
59
34
        bool is_const_left = is_column_const(*column_left);
60
34
        bool is_const_right = is_column_const(*column_right);
61
62
34
        ColumnPtr column_result = nullptr;
63
34
        if (is_const_left && is_const_right) {
64
10
            column_result = constant_constant(column_left, column_right);
65
24
        } else if (is_const_left) {
66
0
            column_result = constant_vector(column_left, column_right);
67
24
        } else if (is_const_right) {
68
0
            column_result = vector_constant(column_left, column_right);
69
24
        } else {
70
24
            column_result = vector_vector(column_left, column_right);
71
24
        }
72
34
        block.replace_by_position(result, std::move(column_result));
73
34
        return Status::OK();
74
34
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
56
26
                        uint32_t result, size_t input_rows_count) const override {
57
26
        auto& column_left = block.get_by_position(arguments[0]).column;
58
26
        auto& column_right = block.get_by_position(arguments[1]).column;
59
26
        bool is_const_left = is_column_const(*column_left);
60
26
        bool is_const_right = is_column_const(*column_right);
61
62
26
        ColumnPtr column_result = nullptr;
63
26
        if (is_const_left && is_const_right) {
64
2
            column_result = constant_constant(column_left, column_right);
65
24
        } else if (is_const_left) {
66
0
            column_result = constant_vector(column_left, column_right);
67
24
        } else if (is_const_right) {
68
0
            column_result = vector_constant(column_left, column_right);
69
24
        } else {
70
24
            column_result = vector_vector(column_left, column_right);
71
24
        }
72
26
        block.replace_by_position(result, std::move(column_result));
73
26
        return Status::OK();
74
26
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
56
47
                        uint32_t result, size_t input_rows_count) const override {
57
47
        auto& column_left = block.get_by_position(arguments[0]).column;
58
47
        auto& column_right = block.get_by_position(arguments[1]).column;
59
47
        bool is_const_left = is_column_const(*column_left);
60
47
        bool is_const_right = is_column_const(*column_right);
61
62
47
        ColumnPtr column_result = nullptr;
63
47
        if (is_const_left && is_const_right) {
64
10
            column_result = constant_constant(column_left, column_right);
65
37
        } else if (is_const_left) {
66
0
            column_result = constant_vector(column_left, column_right);
67
37
        } else if (is_const_right) {
68
5
            column_result = vector_constant(column_left, column_right);
69
32
        } else {
70
32
            column_result = vector_vector(column_left, column_right);
71
32
        }
72
47
        block.replace_by_position(result, std::move(column_result));
73
47
        return Status::OK();
74
47
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
56
2.22k
                        uint32_t result, size_t input_rows_count) const override {
57
2.22k
        auto& column_left = block.get_by_position(arguments[0]).column;
58
2.22k
        auto& column_right = block.get_by_position(arguments[1]).column;
59
2.22k
        bool is_const_left = is_column_const(*column_left);
60
2.22k
        bool is_const_right = is_column_const(*column_right);
61
62
2.22k
        ColumnPtr column_result = nullptr;
63
2.22k
        if (is_const_left && is_const_right) {
64
1
            column_result = constant_constant(column_left, column_right);
65
2.22k
        } else if (is_const_left) {
66
0
            column_result = constant_vector(column_left, column_right);
67
2.22k
        } else if (is_const_right) {
68
0
            column_result = vector_constant(column_left, column_right);
69
2.22k
        } else {
70
2.22k
            column_result = vector_vector(column_left, column_right);
71
2.22k
        }
72
2.22k
        block.replace_by_position(result, std::move(column_result));
73
2.22k
        return Status::OK();
74
2.22k
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE12execute_implEPNS_15FunctionContextERNS_5BlockERKSt6vectorIjSaIjEEjm
Line
Count
Source
56
80
                        uint32_t result, size_t input_rows_count) const override {
57
80
        auto& column_left = block.get_by_position(arguments[0]).column;
58
80
        auto& column_right = block.get_by_position(arguments[1]).column;
59
80
        bool is_const_left = is_column_const(*column_left);
60
80
        bool is_const_right = is_column_const(*column_right);
61
62
80
        ColumnPtr column_result = nullptr;
63
80
        if (is_const_left && is_const_right) {
64
0
            column_result = constant_constant(column_left, column_right);
65
80
        } else if (is_const_left) {
66
0
            column_result = constant_vector(column_left, column_right);
67
80
        } else if (is_const_right) {
68
0
            column_result = vector_constant(column_left, column_right);
69
80
        } else {
70
80
            column_result = vector_vector(column_left, column_right);
71
80
        }
72
80
        block.replace_by_position(result, std::move(column_result));
73
80
        return Status::OK();
74
80
    }
75
76
private:
77
23
    ColumnPtr constant_constant(ColumnPtr column_left, ColumnPtr column_right) const {
78
23
        const auto* column_left_ptr = assert_cast<const ColumnConst*>(column_left.get());
79
23
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
80
23
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
81
82
23
        ColumnPtr column_result = nullptr;
83
84
23
        column_result =
85
23
                Impl::constant_constant(column_left_ptr->template get_value<Impl::ResultType>(),
86
23
                                        column_right_ptr->template get_value<Impl::ResultType>());
87
88
23
        return ColumnConst::create(std::move(column_result), column_left->size());
89
23
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE17constant_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
77
10
    ColumnPtr constant_constant(ColumnPtr column_left, ColumnPtr column_right) const {
78
10
        const auto* column_left_ptr = assert_cast<const ColumnConst*>(column_left.get());
79
10
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
80
10
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
81
82
10
        ColumnPtr column_result = nullptr;
83
84
10
        column_result =
85
10
                Impl::constant_constant(column_left_ptr->template get_value<Impl::ResultType>(),
86
10
                                        column_right_ptr->template get_value<Impl::ResultType>());
87
88
10
        return ColumnConst::create(std::move(column_result), column_left->size());
89
10
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE17constant_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
77
2
    ColumnPtr constant_constant(ColumnPtr column_left, ColumnPtr column_right) const {
78
2
        const auto* column_left_ptr = assert_cast<const ColumnConst*>(column_left.get());
79
2
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
80
2
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
81
82
2
        ColumnPtr column_result = nullptr;
83
84
2
        column_result =
85
2
                Impl::constant_constant(column_left_ptr->template get_value<Impl::ResultType>(),
86
2
                                        column_right_ptr->template get_value<Impl::ResultType>());
87
88
2
        return ColumnConst::create(std::move(column_result), column_left->size());
89
2
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE17constant_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
77
10
    ColumnPtr constant_constant(ColumnPtr column_left, ColumnPtr column_right) const {
78
10
        const auto* column_left_ptr = assert_cast<const ColumnConst*>(column_left.get());
79
10
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
80
10
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
81
82
10
        ColumnPtr column_result = nullptr;
83
84
10
        column_result =
85
10
                Impl::constant_constant(column_left_ptr->template get_value<Impl::ResultType>(),
86
10
                                        column_right_ptr->template get_value<Impl::ResultType>());
87
88
10
        return ColumnConst::create(std::move(column_result), column_left->size());
89
10
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE17constant_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
77
1
    ColumnPtr constant_constant(ColumnPtr column_left, ColumnPtr column_right) const {
78
1
        const auto* column_left_ptr = assert_cast<const ColumnConst*>(column_left.get());
79
1
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
80
1
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
81
82
1
        ColumnPtr column_result = nullptr;
83
84
1
        column_result =
85
1
                Impl::constant_constant(column_left_ptr->template get_value<Impl::ResultType>(),
86
1
                                        column_right_ptr->template get_value<Impl::ResultType>());
87
88
1
        return ColumnConst::create(std::move(column_result), column_left->size());
89
1
    }
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE17constant_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
90
91
5
    ColumnPtr vector_constant(ColumnPtr column_left, ColumnPtr column_right) const {
92
5
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
93
5
        DCHECK(column_right_ptr != nullptr);
94
95
5
        return Impl::vector_constant(column_left->get_ptr(),
96
5
                                     column_right_ptr->template get_value<Impl::ResultType>());
97
5
    }
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
91
5
    ColumnPtr vector_constant(ColumnPtr column_left, ColumnPtr column_right) const {
92
5
        const auto* column_right_ptr = assert_cast<const ColumnConst*>(column_right.get());
93
5
        DCHECK(column_right_ptr != nullptr);
94
95
5
        return Impl::vector_constant(column_left->get_ptr(),
96
5
                                     column_right_ptr->template get_value<Impl::ResultType>());
97
5
    }
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
98
99
0
    ColumnPtr constant_vector(ColumnPtr column_left, ColumnPtr column_right) const {
100
0
        const auto* column_left_ptr = assert_cast<const ColumnConst*>(column_left.get());
101
0
        DCHECK(column_left_ptr != nullptr);
102
103
0
        return Impl::constant_vector(column_left_ptr->template get_value<Impl::ResultType>(),
104
0
                                     column_right->get_ptr());
105
0
    }
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE15constant_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE15constant_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE15constant_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE15constant_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Unexecuted instantiation: _ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE15constant_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
106
107
2.38k
    ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) const {
108
2.38k
        return Impl::vector_vector(column_left->get_ptr(), column_right->get_ptr());
109
2.38k
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE3EEEE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
107
24
    ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) const {
108
24
        return Impl::vector_vector(column_left->get_ptr(), column_right->get_ptr());
109
24
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE4EEEE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
107
24
    ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) const {
108
24
        return Impl::vector_vector(column_left->get_ptr(), column_right->get_ptr());
109
24
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE5EEEE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
107
32
    ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) const {
108
32
        return Impl::vector_vector(column_left->get_ptr(), column_right->get_ptr());
109
32
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE6EEEE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
107
2.22k
    ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) const {
108
2.22k
        return Impl::vector_vector(column_left->get_ptr(), column_right->get_ptr());
109
2.22k
    }
_ZNK5doris14FunctionIntDivINS_18DivideIntegralImplILNS_13PrimitiveTypeE7EEEE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS6_EES9_
Line
Count
Source
107
80
    ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) const {
108
80
        return Impl::vector_vector(column_left->get_ptr(), column_right->get_ptr());
109
80
    }
110
};
111
112
template <PrimitiveType Type>
113
struct DivideIntegralImpl {
114
    using Arg = typename PrimitiveTypeTraits<Type>::CppType;
115
    using ColumnType = typename PrimitiveTypeTraits<Type>::ColumnType;
116
    static constexpr PrimitiveType ResultType = Type;
117
118
40
    static DataTypes get_variadic_argument_types() {
119
40
        return {std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>(),
120
40
                std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>()};
121
40
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE27get_variadic_argument_typesEv
Line
Count
Source
118
8
    static DataTypes get_variadic_argument_types() {
119
8
        return {std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>(),
120
8
                std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>()};
121
8
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE27get_variadic_argument_typesEv
Line
Count
Source
118
8
    static DataTypes get_variadic_argument_types() {
119
8
        return {std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>(),
120
8
                std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>()};
121
8
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE27get_variadic_argument_typesEv
Line
Count
Source
118
8
    static DataTypes get_variadic_argument_types() {
119
8
        return {std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>(),
120
8
                std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>()};
121
8
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE27get_variadic_argument_typesEv
Line
Count
Source
118
8
    static DataTypes get_variadic_argument_types() {
119
8
        return {std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>(),
120
8
                std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>()};
121
8
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE27get_variadic_argument_typesEv
Line
Count
Source
118
8
    static DataTypes get_variadic_argument_types() {
119
8
        return {std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>(),
120
8
                std::make_shared<typename PrimitiveTypeTraits<Type>::DataType>()};
121
8
    }
122
123
    static void apply(const typename ColumnType::Container& a, Arg b,
124
                      typename PrimitiveTypeTraits<ResultType>::ColumnType::Container& c,
125
5
                      PaddedPODArray<UInt8>& null_map) {
126
5
        size_t size = c.size();
127
5
        UInt8 is_null = b == 0;
128
5
        memset(null_map.data(), is_null, size);
129
130
5
        if (!is_null) {
131
            if constexpr (!std::is_floating_point_v<Arg> && !std::is_same_v<Arg, Int128> &&
132
5
                          !std::is_same_v<Arg, Int8> && !std::is_same_v<Arg, UInt8>) {
133
5
                const auto divider = libdivide::divider<Arg>(Arg(b));
134
64
                for (size_t i = 0; i < size; i++) {
135
59
                    c[i] = a[i] / divider;
136
59
                }
137
5
            } else {
138
0
                for (size_t i = 0; i < size; i++) {
139
0
                    c[i] = typename PrimitiveTypeTraits<ResultType>::CppType(a[i] / b);
140
0
                }
141
0
            }
142
5
        }
143
5
    }
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE5applyERKNS_8PODArrayIaLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEEaRS7_RNS3_IhLm4096ES6_Lm16ELm15EEE
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE5applyERKNS_8PODArrayIsLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEEsRS7_RNS3_IhLm4096ES6_Lm16ELm15EEE
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE5applyERKNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEEiRS7_RNS3_IhLm4096ES6_Lm16ELm15EEE
Line
Count
Source
125
5
                      PaddedPODArray<UInt8>& null_map) {
126
5
        size_t size = c.size();
127
5
        UInt8 is_null = b == 0;
128
5
        memset(null_map.data(), is_null, size);
129
130
5
        if (!is_null) {
131
            if constexpr (!std::is_floating_point_v<Arg> && !std::is_same_v<Arg, Int128> &&
132
5
                          !std::is_same_v<Arg, Int8> && !std::is_same_v<Arg, UInt8>) {
133
5
                const auto divider = libdivide::divider<Arg>(Arg(b));
134
64
                for (size_t i = 0; i < size; i++) {
135
59
                    c[i] = a[i] / divider;
136
59
                }
137
            } else {
138
                for (size_t i = 0; i < size; i++) {
139
                    c[i] = typename PrimitiveTypeTraits<ResultType>::CppType(a[i] / b);
140
                }
141
            }
142
5
        }
143
5
    }
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE5applyERKNS_8PODArrayIlLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEElRS7_RNS3_IhLm4096ES6_Lm16ELm15EEE
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE5applyERKNS_8PODArrayInLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEEnRS7_RNS3_IhLm4096ES6_Lm16ELm15EEE
144
145
    static inline typename PrimitiveTypeTraits<ResultType>::CppType apply(Arg a, Arg b,
146
14.5k
                                                                          UInt8& is_null) {
147
14.5k
        is_null = b == 0;
148
14.5k
        return typename PrimitiveTypeTraits<ResultType>::CppType(a / (b + is_null));
149
14.5k
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE5applyEaaRh
Line
Count
Source
146
157
                                                                          UInt8& is_null) {
147
157
        is_null = b == 0;
148
157
        return typename PrimitiveTypeTraits<ResultType>::CppType(a / (b + is_null));
149
157
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE5applyEssRh
Line
Count
Source
146
149
                                                                          UInt8& is_null) {
147
149
        is_null = b == 0;
148
149
        return typename PrimitiveTypeTraits<ResultType>::CppType(a / (b + is_null));
149
149
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE5applyEiiRh
Line
Count
Source
146
206
                                                                          UInt8& is_null) {
147
206
        is_null = b == 0;
148
206
        return typename PrimitiveTypeTraits<ResultType>::CppType(a / (b + is_null));
149
206
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE5applyEllRh
Line
Count
Source
146
13.5k
                                                                          UInt8& is_null) {
147
13.5k
        is_null = b == 0;
148
13.5k
        return typename PrimitiveTypeTraits<ResultType>::CppType(a / (b + is_null));
149
13.5k
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE5applyEnnRh
Line
Count
Source
146
490
                                                                          UInt8& is_null) {
147
490
        is_null = b == 0;
148
490
        return typename PrimitiveTypeTraits<ResultType>::CppType(a / (b + is_null));
149
490
    }
150
151
23
    static ColumnPtr constant_constant(Arg a, Arg b) {
152
23
        auto column_result = ColumnType ::create(1);
153
154
23
        auto null_map = ColumnUInt8::create(1, 0);
155
23
        column_result->get_element(0) = apply(a, b, null_map->get_element(0));
156
23
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
157
23
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE17constant_constantEaa
Line
Count
Source
151
10
    static ColumnPtr constant_constant(Arg a, Arg b) {
152
10
        auto column_result = ColumnType ::create(1);
153
154
10
        auto null_map = ColumnUInt8::create(1, 0);
155
10
        column_result->get_element(0) = apply(a, b, null_map->get_element(0));
156
10
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
157
10
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE17constant_constantEss
Line
Count
Source
151
2
    static ColumnPtr constant_constant(Arg a, Arg b) {
152
2
        auto column_result = ColumnType ::create(1);
153
154
2
        auto null_map = ColumnUInt8::create(1, 0);
155
2
        column_result->get_element(0) = apply(a, b, null_map->get_element(0));
156
2
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
157
2
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE17constant_constantEii
Line
Count
Source
151
10
    static ColumnPtr constant_constant(Arg a, Arg b) {
152
10
        auto column_result = ColumnType ::create(1);
153
154
10
        auto null_map = ColumnUInt8::create(1, 0);
155
10
        column_result->get_element(0) = apply(a, b, null_map->get_element(0));
156
10
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
157
10
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE17constant_constantEll
Line
Count
Source
151
1
    static ColumnPtr constant_constant(Arg a, Arg b) {
152
1
        auto column_result = ColumnType ::create(1);
153
154
1
        auto null_map = ColumnUInt8::create(1, 0);
155
1
        column_result->get_element(0) = apply(a, b, null_map->get_element(0));
156
1
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
157
1
    }
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE17constant_constantEnn
158
159
5
    static ColumnPtr vector_constant(ColumnPtr column_left, Arg b) {
160
5
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
161
5
        auto column_result = ColumnType::create(column_left->size());
162
5
        DCHECK(column_left_ptr != nullptr);
163
164
5
        auto null_map = ColumnUInt8::create(column_left->size(), 0);
165
5
        apply(column_left_ptr->get_data(), b, column_result->get_data(), null_map->get_data());
166
5
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
167
5
    }
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEa
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEs
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEi
Line
Count
Source
159
5
    static ColumnPtr vector_constant(ColumnPtr column_left, Arg b) {
160
5
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
161
5
        auto column_result = ColumnType::create(column_left->size());
162
5
        DCHECK(column_left_ptr != nullptr);
163
164
5
        auto null_map = ColumnUInt8::create(column_left->size(), 0);
165
5
        apply(column_left_ptr->get_data(), b, column_result->get_data(), null_map->get_data());
166
5
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
167
5
    }
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEl
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE15vector_constantENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEn
168
169
0
    static ColumnPtr constant_vector(Arg a, ColumnPtr column_right) {
170
0
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
171
0
        auto column_result = ColumnType::create(column_right->size());
172
0
        DCHECK(column_right_ptr != nullptr);
173
174
0
        auto null_map = ColumnUInt8::create(column_right->size(), 0);
175
0
        auto& b = column_right_ptr->get_data();
176
0
        auto& c = column_result->get_data();
177
0
        auto& n = null_map->get_data();
178
0
        size_t size = b.size();
179
0
        for (size_t i = 0; i < size; ++i) {
180
0
            c[i] = apply(a, b[i], n[i]);
181
0
        }
182
0
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
183
0
    }
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE15constant_vectorEaNS_3COWINS_7IColumnEE13immutable_ptrIS4_EE
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE15constant_vectorEsNS_3COWINS_7IColumnEE13immutable_ptrIS4_EE
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE15constant_vectorEiNS_3COWINS_7IColumnEE13immutable_ptrIS4_EE
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE15constant_vectorElNS_3COWINS_7IColumnEE13immutable_ptrIS4_EE
Unexecuted instantiation: _ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE15constant_vectorEnNS_3COWINS_7IColumnEE13immutable_ptrIS4_EE
184
185
2.38k
    static ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) {
186
2.38k
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
187
2.38k
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
188
189
2.38k
        auto column_result = ColumnType::create(column_left->size());
190
2.38k
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
191
192
2.38k
        auto null_map = ColumnUInt8::create(column_result->size(), 0);
193
2.38k
        auto& a = column_left_ptr->get_data();
194
2.38k
        auto& b = column_right_ptr->get_data();
195
2.38k
        auto& c = column_result->get_data();
196
2.38k
        auto& n = null_map->get_data();
197
2.38k
        size_t size = a.size();
198
16.8k
        for (size_t i = 0; i < size; ++i) {
199
14.4k
            c[i] = apply(a[i], b[i], n[i]);
200
14.4k
        }
201
2.38k
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
202
2.38k
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE3EE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS4_EES7_
Line
Count
Source
185
24
    static ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) {
186
24
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
187
24
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
188
189
24
        auto column_result = ColumnType::create(column_left->size());
190
24
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
191
192
24
        auto null_map = ColumnUInt8::create(column_result->size(), 0);
193
24
        auto& a = column_left_ptr->get_data();
194
24
        auto& b = column_right_ptr->get_data();
195
24
        auto& c = column_result->get_data();
196
24
        auto& n = null_map->get_data();
197
24
        size_t size = a.size();
198
171
        for (size_t i = 0; i < size; ++i) {
199
147
            c[i] = apply(a[i], b[i], n[i]);
200
147
        }
201
24
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
202
24
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE4EE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS4_EES7_
Line
Count
Source
185
24
    static ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) {
186
24
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
187
24
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
188
189
24
        auto column_result = ColumnType::create(column_left->size());
190
24
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
191
192
24
        auto null_map = ColumnUInt8::create(column_result->size(), 0);
193
24
        auto& a = column_left_ptr->get_data();
194
24
        auto& b = column_right_ptr->get_data();
195
24
        auto& c = column_result->get_data();
196
24
        auto& n = null_map->get_data();
197
24
        size_t size = a.size();
198
171
        for (size_t i = 0; i < size; ++i) {
199
147
            c[i] = apply(a[i], b[i], n[i]);
200
147
        }
201
24
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
202
24
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE5EE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS4_EES7_
Line
Count
Source
185
32
    static ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) {
186
32
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
187
32
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
188
189
32
        auto column_result = ColumnType::create(column_left->size());
190
32
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
191
192
32
        auto null_map = ColumnUInt8::create(column_result->size(), 0);
193
32
        auto& a = column_left_ptr->get_data();
194
32
        auto& b = column_right_ptr->get_data();
195
32
        auto& c = column_result->get_data();
196
32
        auto& n = null_map->get_data();
197
32
        size_t size = a.size();
198
228
        for (size_t i = 0; i < size; ++i) {
199
196
            c[i] = apply(a[i], b[i], n[i]);
200
196
        }
201
32
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
202
32
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE6EE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS4_EES7_
Line
Count
Source
185
2.22k
    static ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) {
186
2.22k
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
187
2.22k
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
188
189
2.22k
        auto column_result = ColumnType::create(column_left->size());
190
2.22k
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
191
192
2.22k
        auto null_map = ColumnUInt8::create(column_result->size(), 0);
193
2.22k
        auto& a = column_left_ptr->get_data();
194
2.22k
        auto& b = column_right_ptr->get_data();
195
2.22k
        auto& c = column_result->get_data();
196
2.22k
        auto& n = null_map->get_data();
197
2.22k
        size_t size = a.size();
198
15.7k
        for (size_t i = 0; i < size; ++i) {
199
13.5k
            c[i] = apply(a[i], b[i], n[i]);
200
13.5k
        }
201
2.22k
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
202
2.22k
    }
_ZN5doris18DivideIntegralImplILNS_13PrimitiveTypeE7EE13vector_vectorENS_3COWINS_7IColumnEE13immutable_ptrIS4_EES7_
Line
Count
Source
185
80
    static ColumnPtr vector_vector(ColumnPtr column_left, ColumnPtr column_right) {
186
80
        const auto* column_left_ptr = assert_cast<const ColumnType*>(column_left.get());
187
80
        const auto* column_right_ptr = assert_cast<const ColumnType*>(column_right.get());
188
189
80
        auto column_result = ColumnType::create(column_left->size());
190
80
        DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr);
191
192
80
        auto null_map = ColumnUInt8::create(column_result->size(), 0);
193
80
        auto& a = column_left_ptr->get_data();
194
80
        auto& b = column_right_ptr->get_data();
195
80
        auto& c = column_result->get_data();
196
80
        auto& n = null_map->get_data();
197
80
        size_t size = a.size();
198
570
        for (size_t i = 0; i < size; ++i) {
199
490
            c[i] = apply(a[i], b[i], n[i]);
200
490
        }
201
80
        return ColumnNullable::create(std::move(column_result), std::move(null_map));
202
80
    }
203
};
204
205
8
void register_function_int_div(SimpleFunctionFactory& factory) {
206
8
    factory.register_function<FunctionIntDiv<DivideIntegralImpl<TYPE_TINYINT>>>();
207
8
    factory.register_function<FunctionIntDiv<DivideIntegralImpl<TYPE_SMALLINT>>>();
208
8
    factory.register_function<FunctionIntDiv<DivideIntegralImpl<TYPE_INT>>>();
209
8
    factory.register_function<FunctionIntDiv<DivideIntegralImpl<TYPE_BIGINT>>>();
210
8
    factory.register_function<FunctionIntDiv<DivideIntegralImpl<TYPE_LARGEINT>>>();
211
8
}
212
213
} // namespace doris