Coverage Report

Created: 2026-03-13 09:37

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/least_greast.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 <boost/iterator/iterator_facade.hpp>
22
#include <memory>
23
#include <tuple>
24
#include <type_traits>
25
26
#include "core/accurate_comparison.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_const.h"
33
#include "core/column/column_decimal.h"
34
#include "core/column/column_string.h"
35
#include "core/column/column_vector.h"
36
#include "core/data_type/data_type.h"
37
#include "core/data_type/data_type_number.h"
38
#include "core/data_type/define_primitive_type.h"
39
#include "core/pod_array_fwd.h"
40
#include "core/string_ref.h"
41
#include "core/types.h"
42
#include "exec/common/template_helpers.hpp"
43
#include "exprs/aggregate/aggregate_function.h"
44
#include "exprs/function/function_multi_same_args.h"
45
#include "exprs/function/simple_function_factory.h"
46
47
namespace doris {
48
class DecimalV2Value;
49
} // namespace doris
50
51
namespace doris {
52
53
template <template <PrimitiveType> class Op, typename Impl>
54
struct CompareMultiImpl {
55
    static constexpr auto name = Impl::name;
56
57
192
    static DataTypePtr get_return_type_impl(const DataTypes& arguments) { return arguments[0]; }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS8_EE
Line
Count
Source
57
96
    static DataTypePtr get_return_type_impl(const DataTypes& arguments) { return arguments[0]; }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS8_EE
Line
Count
Source
57
96
    static DataTypePtr get_return_type_impl(const DataTypes& arguments) { return arguments[0]; }
58
59
    static ColumnPtr execute(Block& block, const ColumnNumbers& arguments,
60
385
                             size_t input_rows_count) {
61
385
        if (arguments.size() == 1) {
62
236
            return block.get_by_position(arguments.back()).column;
63
236
        }
64
65
149
        const auto& data_type = block.get_by_position(arguments.back()).type;
66
149
        MutableColumnPtr result_column = data_type->create_column();
67
68
149
        Columns cols(arguments.size());
69
149
        std::unique_ptr<bool[]> col_const =
70
149
                std::make_unique_for_overwrite<bool[]>(arguments.size());
71
527
        for (int i = 0; i < arguments.size(); ++i) {
72
378
            std::tie(cols[i], col_const[i]) =
73
378
                    unpack_if_const(block.get_by_position(arguments[i]).column);
74
378
        }
75
        // because now the string types does not support random position writing,
76
        // so insert into result data have two methods, one is for string types, one is for others type remaining
77
149
        if (result_column->is_column_string()) {
78
16
            result_column->reserve(input_rows_count);
79
16
            const auto& column_string = reinterpret_cast<const ColumnString&>(*cols[0]);
80
16
            auto& column_res = reinterpret_cast<ColumnString&>(*result_column);
81
82
40
            for (int i = 0; i < input_rows_count; ++i) {
83
24
                auto str_data = column_string.get_data_at(index_check_const(i, col_const[0]));
84
60
                for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
85
36
                    auto temp_data = assert_cast<const ColumnString&>(*cols[cmp_col])
86
36
                                             .get_data_at(index_check_const(i, col_const[cmp_col]));
87
36
                    str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ? temp_data : str_data;
88
36
                }
89
24
                column_res.insert_data(str_data.data, str_data.size);
90
24
            }
91
92
133
        } else {
93
133
            if (col_const[0]) {
94
40
                for (int i = 0; i < input_rows_count; ++i) {
95
30
                    result_column->insert_range_from(*(cols[0]), 0, 1);
96
30
                }
97
123
            } else {
98
123
                result_column->insert_range_from(*(cols[0]), 0, input_rows_count);
99
123
            }
100
101
133
            auto call = [&](const auto& type) -> bool {
102
133
                using DispatchType = std::decay_t<decltype(type)>;
103
334
                for (int i = 1; i < arguments.size(); ++i) {
104
201
                    if (col_const[i]) {
105
18
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
18
                                                                      input_rows_count);
107
183
                    } else {
108
183
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
183
                                                                       input_rows_count);
110
183
                    }
111
201
                }
112
113
133
                return true;
114
133
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE2EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE3EEEEEbSD_
Line
Count
Source
101
6
            auto call = [&](const auto& type) -> bool {
102
6
                using DispatchType = std::decay_t<decltype(type)>;
103
14
                for (int i = 1; i < arguments.size(); ++i) {
104
8
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
8
                    } else {
108
8
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
8
                                                                       input_rows_count);
110
8
                    }
111
8
                }
112
113
6
                return true;
114
6
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE4EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
6
                for (int i = 1; i < arguments.size(); ++i) {
104
4
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
4
                    } else {
108
4
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
4
                                                                       input_rows_count);
110
4
                    }
111
4
                }
112
113
2
                return true;
114
2
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE5EEEEEbSD_
Line
Count
Source
101
17
            auto call = [&](const auto& type) -> bool {
102
17
                using DispatchType = std::decay_t<decltype(type)>;
103
48
                for (int i = 1; i < arguments.size(); ++i) {
104
31
                    if (col_const[i]) {
105
12
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
12
                                                                      input_rows_count);
107
19
                    } else {
108
19
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
19
                                                                       input_rows_count);
110
19
                    }
111
31
                }
112
113
17
                return true;
114
17
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE6EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE7EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE8EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE9EEEEEbSD_
Line
Count
Source
101
19
            auto call = [&](const auto& type) -> bool {
102
19
                using DispatchType = std::decay_t<decltype(type)>;
103
55
                for (int i = 1; i < arguments.size(); ++i) {
104
36
                    if (col_const[i]) {
105
1
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
1
                                                                      input_rows_count);
107
35
                    } else {
108
35
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
35
                                                                       input_rows_count);
110
35
                    }
111
36
                }
112
113
19
                return true;
114
19
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE28EEEEEbSD_
Line
Count
Source
101
5
            auto call = [&](const auto& type) -> bool {
102
5
                using DispatchType = std::decay_t<decltype(type)>;
103
14
                for (int i = 1; i < arguments.size(); ++i) {
104
9
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
9
                    } else {
108
9
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
9
                                                                       input_rows_count);
110
9
                    }
111
9
                }
112
113
5
                return true;
114
5
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE29EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE20EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE30EEEEEbSD_
Line
Count
Source
101
4
            auto call = [&](const auto& type) -> bool {
102
4
                using DispatchType = std::decay_t<decltype(type)>;
103
9
                for (int i = 1; i < arguments.size(); ++i) {
104
5
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
5
                    } else {
108
5
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
5
                                                                       input_rows_count);
110
5
                    }
111
5
                }
112
113
4
                return true;
114
4
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE35EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
4
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
2
                    } else {
108
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
2
                                                                       input_rows_count);
110
2
                    }
111
2
                }
112
113
2
                return true;
114
2
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE11EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE25EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
4
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
2
                    } else {
108
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
2
                                                                       input_rows_count);
110
2
                    }
111
2
                }
112
113
2
                return true;
114
2
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE26EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
4
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
2
                    } else {
108
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
2
                                                                       input_rows_count);
110
2
                    }
111
2
                }
112
113
2
                return true;
114
2
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE12EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE27EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE42EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE36EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE37EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE2EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE3EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
6
                for (int i = 1; i < arguments.size(); ++i) {
104
4
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
4
                    } else {
108
4
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
4
                                                                       input_rows_count);
110
4
                    }
111
4
                }
112
113
2
                return true;
114
2
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE4EEEEEbSD_
Line
Count
Source
101
3
            auto call = [&](const auto& type) -> bool {
102
3
                using DispatchType = std::decay_t<decltype(type)>;
103
9
                for (int i = 1; i < arguments.size(); ++i) {
104
6
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
6
                    } else {
108
6
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
6
                                                                       input_rows_count);
110
6
                    }
111
6
                }
112
113
3
                return true;
114
3
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE5EEEEEbSD_
Line
Count
Source
101
30
            auto call = [&](const auto& type) -> bool {
102
30
                using DispatchType = std::decay_t<decltype(type)>;
103
62
                for (int i = 1; i < arguments.size(); ++i) {
104
32
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
32
                    } else {
108
32
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
32
                                                                       input_rows_count);
110
32
                    }
111
32
                }
112
113
30
                return true;
114
30
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE6EEEEEbSD_
Line
Count
Source
101
1
            auto call = [&](const auto& type) -> bool {
102
1
                using DispatchType = std::decay_t<decltype(type)>;
103
3
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
1
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
1
                                                                      input_rows_count);
107
1
                    } else {
108
1
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
1
                                                                       input_rows_count);
110
1
                    }
111
2
                }
112
113
1
                return true;
114
1
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE7EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE8EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE9EEEEEbSD_
Line
Count
Source
101
20
            auto call = [&](const auto& type) -> bool {
102
20
                using DispatchType = std::decay_t<decltype(type)>;
103
56
                for (int i = 1; i < arguments.size(); ++i) {
104
36
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
36
                    } else {
108
36
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
36
                                                                       input_rows_count);
110
36
                    }
111
36
                }
112
113
20
                return true;
114
20
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE28EEEEEbSD_
Line
Count
Source
101
5
            auto call = [&](const auto& type) -> bool {
102
5
                using DispatchType = std::decay_t<decltype(type)>;
103
14
                for (int i = 1; i < arguments.size(); ++i) {
104
9
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
9
                    } else {
108
9
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
9
                                                                       input_rows_count);
110
9
                    }
111
9
                }
112
113
5
                return true;
114
5
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE29EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE20EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE30EEEEEbSD_
Line
Count
Source
101
7
            auto call = [&](const auto& type) -> bool {
102
7
                using DispatchType = std::decay_t<decltype(type)>;
103
14
                for (int i = 1; i < arguments.size(); ++i) {
104
7
                    if (col_const[i]) {
105
4
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
4
                                                                      input_rows_count);
107
4
                    } else {
108
3
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
3
                                                                       input_rows_count);
110
3
                    }
111
7
                }
112
113
7
                return true;
114
7
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE35EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
4
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
2
                    } else {
108
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
2
                                                                       input_rows_count);
110
2
                    }
111
2
                }
112
113
2
                return true;
114
2
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE11EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE25EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
4
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
2
                    } else {
108
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
2
                                                                       input_rows_count);
110
2
                    }
111
2
                }
112
113
2
                return true;
114
2
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE26EEEEEbSD_
Line
Count
Source
101
2
            auto call = [&](const auto& type) -> bool {
102
2
                using DispatchType = std::decay_t<decltype(type)>;
103
4
                for (int i = 1; i < arguments.size(); ++i) {
104
2
                    if (col_const[i]) {
105
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
0
                                                                      input_rows_count);
107
2
                    } else {
108
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
2
                                                                       input_rows_count);
110
2
                    }
111
2
                }
112
113
2
                return true;
114
2
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE12EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE27EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE42EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE36EEEEEbSD_
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE37EEEEEbSD_
115
116
133
            if (!dispatch_switch_scalar(data_type->get_primitive_type(), call)) {
117
0
                throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support type {}",
118
0
                                       data_type->get_name());
119
0
            }
120
133
        }
121
149
        return result_column;
122
149
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEm
Line
Count
Source
60
186
                             size_t input_rows_count) {
61
186
        if (arguments.size() == 1) {
62
119
            return block.get_by_position(arguments.back()).column;
63
119
        }
64
65
67
        const auto& data_type = block.get_by_position(arguments.back()).type;
66
67
        MutableColumnPtr result_column = data_type->create_column();
67
68
67
        Columns cols(arguments.size());
69
67
        std::unique_ptr<bool[]> col_const =
70
67
                std::make_unique_for_overwrite<bool[]>(arguments.size());
71
247
        for (int i = 0; i < arguments.size(); ++i) {
72
180
            std::tie(cols[i], col_const[i]) =
73
180
                    unpack_if_const(block.get_by_position(arguments[i]).column);
74
180
        }
75
        // because now the string types does not support random position writing,
76
        // so insert into result data have two methods, one is for string types, one is for others type remaining
77
67
        if (result_column->is_column_string()) {
78
8
            result_column->reserve(input_rows_count);
79
8
            const auto& column_string = reinterpret_cast<const ColumnString&>(*cols[0]);
80
8
            auto& column_res = reinterpret_cast<ColumnString&>(*result_column);
81
82
20
            for (int i = 0; i < input_rows_count; ++i) {
83
12
                auto str_data = column_string.get_data_at(index_check_const(i, col_const[0]));
84
30
                for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
85
18
                    auto temp_data = assert_cast<const ColumnString&>(*cols[cmp_col])
86
18
                                             .get_data_at(index_check_const(i, col_const[cmp_col]));
87
18
                    str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ? temp_data : str_data;
88
18
                }
89
12
                column_res.insert_data(str_data.data, str_data.size);
90
12
            }
91
92
59
        } else {
93
59
            if (col_const[0]) {
94
20
                for (int i = 0; i < input_rows_count; ++i) {
95
15
                    result_column->insert_range_from(*(cols[0]), 0, 1);
96
15
                }
97
54
            } else {
98
54
                result_column->insert_range_from(*(cols[0]), 0, input_rows_count);
99
54
            }
100
101
59
            auto call = [&](const auto& type) -> bool {
102
59
                using DispatchType = std::decay_t<decltype(type)>;
103
59
                for (int i = 1; i < arguments.size(); ++i) {
104
59
                    if (col_const[i]) {
105
59
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
59
                                                                      input_rows_count);
107
59
                    } else {
108
59
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
59
                                                                       input_rows_count);
110
59
                    }
111
59
                }
112
113
59
                return true;
114
59
            };
115
116
59
            if (!dispatch_switch_scalar(data_type->get_primitive_type(), call)) {
117
0
                throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support type {}",
118
0
                                       data_type->get_name());
119
0
            }
120
59
        }
121
67
        return result_column;
122
67
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEm
Line
Count
Source
60
199
                             size_t input_rows_count) {
61
199
        if (arguments.size() == 1) {
62
117
            return block.get_by_position(arguments.back()).column;
63
117
        }
64
65
82
        const auto& data_type = block.get_by_position(arguments.back()).type;
66
82
        MutableColumnPtr result_column = data_type->create_column();
67
68
82
        Columns cols(arguments.size());
69
82
        std::unique_ptr<bool[]> col_const =
70
82
                std::make_unique_for_overwrite<bool[]>(arguments.size());
71
280
        for (int i = 0; i < arguments.size(); ++i) {
72
198
            std::tie(cols[i], col_const[i]) =
73
198
                    unpack_if_const(block.get_by_position(arguments[i]).column);
74
198
        }
75
        // because now the string types does not support random position writing,
76
        // so insert into result data have two methods, one is for string types, one is for others type remaining
77
82
        if (result_column->is_column_string()) {
78
8
            result_column->reserve(input_rows_count);
79
8
            const auto& column_string = reinterpret_cast<const ColumnString&>(*cols[0]);
80
8
            auto& column_res = reinterpret_cast<ColumnString&>(*result_column);
81
82
20
            for (int i = 0; i < input_rows_count; ++i) {
83
12
                auto str_data = column_string.get_data_at(index_check_const(i, col_const[0]));
84
30
                for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
85
18
                    auto temp_data = assert_cast<const ColumnString&>(*cols[cmp_col])
86
18
                                             .get_data_at(index_check_const(i, col_const[cmp_col]));
87
18
                    str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ? temp_data : str_data;
88
18
                }
89
12
                column_res.insert_data(str_data.data, str_data.size);
90
12
            }
91
92
74
        } else {
93
74
            if (col_const[0]) {
94
20
                for (int i = 0; i < input_rows_count; ++i) {
95
15
                    result_column->insert_range_from(*(cols[0]), 0, 1);
96
15
                }
97
69
            } else {
98
69
                result_column->insert_range_from(*(cols[0]), 0, input_rows_count);
99
69
            }
100
101
74
            auto call = [&](const auto& type) -> bool {
102
74
                using DispatchType = std::decay_t<decltype(type)>;
103
74
                for (int i = 1; i < arguments.size(); ++i) {
104
74
                    if (col_const[i]) {
105
74
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
106
74
                                                                      input_rows_count);
107
74
                    } else {
108
74
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
109
74
                                                                       input_rows_count);
110
74
                    }
111
74
                }
112
113
74
                return true;
114
74
            };
115
116
74
            if (!dispatch_switch_scalar(data_type->get_primitive_type(), call)) {
117
0
                throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support type {}",
118
0
                                       data_type->get_name());
119
0
            }
120
74
        }
121
82
        return result_column;
122
82
    }
123
124
private:
125
    template <PrimitiveType PType, bool ArgConst>
126
    static void insert_result_data(const MutableColumnPtr& result_column,
127
                                   const ColumnPtr& argument_column,
128
201
                                   const size_t input_rows_count) {
129
201
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
201
        auto* __restrict result_raw_data =
131
201
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
201
        auto* __restrict column_raw_data =
133
201
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
201
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
0
            for (size_t i = 0; i < input_rows_count; ++i) {
137
0
                result_raw_data[i] =
138
0
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
0
                                                  result_raw_data[i])
140
0
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
0
                                : result_raw_data[i];
142
0
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
34
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
114
            for (size_t i = 0; i < input_rows_count; ++i) {
148
80
                result_raw_data[i] =
149
80
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
80
                                         result_raw_data[i].value)
151
80
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
80
                                : result_raw_data[i];
153
80
            }
154
167
        } else {
155
100k
            for (size_t i = 0; i < input_rows_count; ++i) {
156
100k
                result_raw_data[i] =
157
100k
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
100k
                                         result_raw_data[i])
159
100k
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
100k
                                : result_raw_data[i];
161
100k
            }
162
167
        }
163
201
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE2ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE2ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE3ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE3ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
8
                                   const size_t input_rows_count) {
129
8
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
8
        auto* __restrict result_raw_data =
131
8
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
8
        auto* __restrict column_raw_data =
133
8
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
8
        } else {
155
20
            for (size_t i = 0; i < input_rows_count; ++i) {
156
12
                result_raw_data[i] =
157
12
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
12
                                         result_raw_data[i])
159
12
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
12
                                : result_raw_data[i];
161
12
            }
162
8
        }
163
8
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE4ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE4ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
4
                                   const size_t input_rows_count) {
129
4
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
4
        auto* __restrict result_raw_data =
131
4
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
4
        auto* __restrict column_raw_data =
133
4
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
4
        } else {
155
8
            for (size_t i = 0; i < input_rows_count; ++i) {
156
4
                result_raw_data[i] =
157
4
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
4
                                         result_raw_data[i])
159
4
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
4
                                : result_raw_data[i];
161
4
            }
162
4
        }
163
4
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE5ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
12
                                   const size_t input_rows_count) {
129
12
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
12
        auto* __restrict result_raw_data =
131
12
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
12
        auto* __restrict column_raw_data =
133
12
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
12
        } else {
155
42
            for (size_t i = 0; i < input_rows_count; ++i) {
156
30
                result_raw_data[i] =
157
30
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
30
                                         result_raw_data[i])
159
30
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
30
                                : result_raw_data[i];
161
30
            }
162
12
        }
163
12
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE5ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
19
                                   const size_t input_rows_count) {
129
19
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
19
        auto* __restrict result_raw_data =
131
19
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
19
        auto* __restrict column_raw_data =
133
19
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
19
        } else {
155
64
            for (size_t i = 0; i < input_rows_count; ++i) {
156
45
                result_raw_data[i] =
157
45
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
45
                                         result_raw_data[i])
159
45
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
45
                                : result_raw_data[i];
161
45
            }
162
19
        }
163
19
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE6ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE6ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE7ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE7ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE8ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE8ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE9ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
1
                                   const size_t input_rows_count) {
129
1
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
1
        auto* __restrict result_raw_data =
131
1
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
1
        auto* __restrict column_raw_data =
133
1
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
1
        } else {
155
2
            for (size_t i = 0; i < input_rows_count; ++i) {
156
1
                result_raw_data[i] =
157
1
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
1
                                         result_raw_data[i])
159
1
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
1
                                : result_raw_data[i];
161
1
            }
162
1
        }
163
1
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE9ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
35
                                   const size_t input_rows_count) {
129
35
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
35
        auto* __restrict result_raw_data =
131
35
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
35
        auto* __restrict column_raw_data =
133
35
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
35
        } else {
155
74
            for (size_t i = 0; i < input_rows_count; ++i) {
156
39
                result_raw_data[i] =
157
39
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
39
                                         result_raw_data[i])
159
39
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
39
                                : result_raw_data[i];
161
39
            }
162
35
        }
163
35
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE28ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE28ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
9
                                   const size_t input_rows_count) {
129
9
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
9
        auto* __restrict result_raw_data =
131
9
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
9
        auto* __restrict column_raw_data =
133
9
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
9
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
19
            for (size_t i = 0; i < input_rows_count; ++i) {
148
10
                result_raw_data[i] =
149
10
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
10
                                         result_raw_data[i].value)
151
10
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
10
                                : result_raw_data[i];
153
10
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
9
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE29ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE29ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE20ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE20ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE30ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE30ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
5
                                   const size_t input_rows_count) {
129
5
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
5
        auto* __restrict result_raw_data =
131
5
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
5
        auto* __restrict column_raw_data =
133
5
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
5
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
14
            for (size_t i = 0; i < input_rows_count; ++i) {
148
9
                result_raw_data[i] =
149
9
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
9
                                         result_raw_data[i].value)
151
9
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
9
                                : result_raw_data[i];
153
9
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
5
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE35ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE35ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
2
                                   const size_t input_rows_count) {
129
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
2
        auto* __restrict result_raw_data =
131
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
2
        auto* __restrict column_raw_data =
133
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
2
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
4
            for (size_t i = 0; i < input_rows_count; ++i) {
148
2
                result_raw_data[i] =
149
2
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
2
                                         result_raw_data[i].value)
151
2
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
2
                                : result_raw_data[i];
153
2
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
2
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE11ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE11ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE25ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE25ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
2
                                   const size_t input_rows_count) {
129
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
2
        auto* __restrict result_raw_data =
131
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
2
        auto* __restrict column_raw_data =
133
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
2
        } else {
155
8
            for (size_t i = 0; i < input_rows_count; ++i) {
156
6
                result_raw_data[i] =
157
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
6
                                         result_raw_data[i])
159
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
6
                                : result_raw_data[i];
161
6
            }
162
2
        }
163
2
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE26ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE26ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
2
                                   const size_t input_rows_count) {
129
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
2
        auto* __restrict result_raw_data =
131
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
2
        auto* __restrict column_raw_data =
133
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
2
        } else {
155
8
            for (size_t i = 0; i < input_rows_count; ++i) {
156
6
                result_raw_data[i] =
157
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
6
                                         result_raw_data[i])
159
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
6
                                : result_raw_data[i];
161
6
            }
162
2
        }
163
2
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE12ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE12ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE27ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE27ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE42ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE42ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE36ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE36ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE37ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE37ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE2ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE2ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE3ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE3ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
4
                                   const size_t input_rows_count) {
129
4
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
4
        auto* __restrict result_raw_data =
131
4
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
4
        auto* __restrict column_raw_data =
133
4
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
4
        } else {
155
8
            for (size_t i = 0; i < input_rows_count; ++i) {
156
4
                result_raw_data[i] =
157
4
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
4
                                         result_raw_data[i])
159
4
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
4
                                : result_raw_data[i];
161
4
            }
162
4
        }
163
4
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE4ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE4ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
6
                                   const size_t input_rows_count) {
129
6
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
6
        auto* __restrict result_raw_data =
131
6
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
6
        auto* __restrict column_raw_data =
133
6
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
6
        } else {
155
12
            for (size_t i = 0; i < input_rows_count; ++i) {
156
6
                result_raw_data[i] =
157
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
6
                                         result_raw_data[i])
159
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
6
                                : result_raw_data[i];
161
6
            }
162
6
        }
163
6
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE5ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE5ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
32
                                   const size_t input_rows_count) {
129
32
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
32
        auto* __restrict result_raw_data =
131
32
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
32
        auto* __restrict column_raw_data =
133
32
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
32
        } else {
155
100k
            for (size_t i = 0; i < input_rows_count; ++i) {
156
100k
                result_raw_data[i] =
157
100k
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
100k
                                         result_raw_data[i])
159
100k
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
100k
                                : result_raw_data[i];
161
100k
            }
162
32
        }
163
32
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE6ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
1
                                   const size_t input_rows_count) {
129
1
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
1
        auto* __restrict result_raw_data =
131
1
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
1
        auto* __restrict column_raw_data =
133
1
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
1
        } else {
155
2
            for (size_t i = 0; i < input_rows_count; ++i) {
156
1
                result_raw_data[i] =
157
1
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
1
                                         result_raw_data[i])
159
1
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
1
                                : result_raw_data[i];
161
1
            }
162
1
        }
163
1
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE6ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
1
                                   const size_t input_rows_count) {
129
1
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
1
        auto* __restrict result_raw_data =
131
1
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
1
        auto* __restrict column_raw_data =
133
1
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
1
        } else {
155
2
            for (size_t i = 0; i < input_rows_count; ++i) {
156
1
                result_raw_data[i] =
157
1
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
1
                                         result_raw_data[i])
159
1
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
1
                                : result_raw_data[i];
161
1
            }
162
1
        }
163
1
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE7ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE7ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE8ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE8ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE9ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE9ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
36
                                   const size_t input_rows_count) {
129
36
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
36
        auto* __restrict result_raw_data =
131
36
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
36
        auto* __restrict column_raw_data =
133
36
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
36
        } else {
155
76
            for (size_t i = 0; i < input_rows_count; ++i) {
156
40
                result_raw_data[i] =
157
40
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
40
                                         result_raw_data[i])
159
40
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
40
                                : result_raw_data[i];
161
40
            }
162
36
        }
163
36
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE28ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE28ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
9
                                   const size_t input_rows_count) {
129
9
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
9
        auto* __restrict result_raw_data =
131
9
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
9
        auto* __restrict column_raw_data =
133
9
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
9
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
19
            for (size_t i = 0; i < input_rows_count; ++i) {
148
10
                result_raw_data[i] =
149
10
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
10
                                         result_raw_data[i].value)
151
10
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
10
                                : result_raw_data[i];
153
10
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
9
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE29ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE29ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE20ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE20ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE30ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
4
                                   const size_t input_rows_count) {
129
4
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
4
        auto* __restrict result_raw_data =
131
4
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
4
        auto* __restrict column_raw_data =
133
4
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
4
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
44
            for (size_t i = 0; i < input_rows_count; ++i) {
148
40
                result_raw_data[i] =
149
40
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
40
                                         result_raw_data[i].value)
151
40
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
40
                                : result_raw_data[i];
153
40
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
4
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE30ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
3
                                   const size_t input_rows_count) {
129
3
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
3
        auto* __restrict result_raw_data =
131
3
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
3
        auto* __restrict column_raw_data =
133
3
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
3
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
10
            for (size_t i = 0; i < input_rows_count; ++i) {
148
7
                result_raw_data[i] =
149
7
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
7
                                         result_raw_data[i].value)
151
7
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
7
                                : result_raw_data[i];
153
7
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
3
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE35ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE35ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
2
                                   const size_t input_rows_count) {
129
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
2
        auto* __restrict result_raw_data =
131
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
2
        auto* __restrict column_raw_data =
133
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
2
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
4
            for (size_t i = 0; i < input_rows_count; ++i) {
148
2
                result_raw_data[i] =
149
2
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
2
                                         result_raw_data[i].value)
151
2
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
2
                                : result_raw_data[i];
153
2
            }
154
        } else {
155
            for (size_t i = 0; i < input_rows_count; ++i) {
156
                result_raw_data[i] =
157
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
                                         result_raw_data[i])
159
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
                                : result_raw_data[i];
161
            }
162
        }
163
2
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE11ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE11ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE25ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE25ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
2
                                   const size_t input_rows_count) {
129
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
2
        auto* __restrict result_raw_data =
131
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
2
        auto* __restrict column_raw_data =
133
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
2
        } else {
155
8
            for (size_t i = 0; i < input_rows_count; ++i) {
156
6
                result_raw_data[i] =
157
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
6
                                         result_raw_data[i])
159
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
6
                                : result_raw_data[i];
161
6
            }
162
2
        }
163
2
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE26ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE26ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
128
2
                                   const size_t input_rows_count) {
129
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
130
2
        auto* __restrict result_raw_data =
131
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
132
2
        auto* __restrict column_raw_data =
133
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
134
135
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
136
            for (size_t i = 0; i < input_rows_count; ++i) {
137
                result_raw_data[i] =
138
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
139
                                                  result_raw_data[i])
140
                                ? column_raw_data[index_check_const(i, ArgConst)]
141
                                : result_raw_data[i];
142
            }
143
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
144
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
147
            for (size_t i = 0; i < input_rows_count; ++i) {
148
                result_raw_data[i] =
149
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
150
                                         result_raw_data[i].value)
151
                                ? column_raw_data[index_check_const(i, ArgConst)]
152
                                : result_raw_data[i];
153
            }
154
2
        } else {
155
8
            for (size_t i = 0; i < input_rows_count; ++i) {
156
6
                result_raw_data[i] =
157
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
158
6
                                         result_raw_data[i])
159
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
160
6
                                : result_raw_data[i];
161
6
            }
162
2
        }
163
2
    }
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE12ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE12ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE27ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE27ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE42ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE42ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE36ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE36ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE37ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE37ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
164
};
165
166
struct FunctionFieldImpl {
167
    static constexpr auto name = "field";
168
169
30
    static DataTypePtr get_return_type_impl(const DataTypes& /*arguments*/) {
170
30
        return std::make_shared<DataTypeInt32>();
171
30
    }
172
173
    static ColumnPtr execute(Block& block, const ColumnNumbers& arguments,
174
107
                             size_t input_rows_count) {
175
107
        const auto& data_type = block.get_by_position(arguments[0]).type;
176
107
        auto result_column = ColumnInt32::create(input_rows_count, 0);
177
107
        auto& res_data = static_cast<ColumnInt32*>(result_column.get())->get_data();
178
179
107
        const auto& column_size = arguments.size();
180
107
        std::vector<ColumnPtr> argument_columns(column_size);
181
431
        for (int i = 0; i < column_size; ++i) {
182
324
            argument_columns[i] = block.get_by_position(arguments[i]).column;
183
324
        }
184
185
107
        bool arg_const;
186
107
        std::tie(argument_columns[0], arg_const) = unpack_if_const(argument_columns[0]);
187
107
        DCHECK_EQ(arg_const, false);
188
189
        //TODO: maybe could use hashmap to save column data, not use for loop ervey time to test equals.
190
107
        switch (data_type->get_primitive_type()) {
191
8
        case PrimitiveType::TYPE_STRING:
192
8
        case PrimitiveType::TYPE_CHAR:
193
44
        case PrimitiveType::TYPE_VARCHAR: {
194
44
            const auto& column_string = assert_cast<const ColumnString&>(*argument_columns[0]);
195
180
            for (int row = 0; row < input_rows_count; ++row) {
196
136
                const auto& str_data = column_string.get_data_at(row);
197
368
                for (int col = 1; col < column_size; ++col) {
198
256
                    auto [column, is_const] = unpack_if_const(argument_columns[col]);
199
256
                    const auto& temp_data = assert_cast<const ColumnString&>(*column).get_data_at(
200
256
                            index_check_const(row, is_const));
201
256
                    if (EqualsOp<TYPE_STRING>::apply(temp_data, str_data)) {
202
24
                        res_data[row] = col;
203
24
                        break;
204
24
                    }
205
256
                }
206
136
            }
207
44
            break;
208
8
        }
209
8
        case PrimitiveType::TYPE_TINYINT: {
210
24
            for (int col = 1; col < arguments.size(); ++col) {
211
16
                insert_result_data<TYPE_TINYINT>(res_data, argument_columns[0],
212
16
                                                 argument_columns[col], input_rows_count, col);
213
16
            }
214
8
            break;
215
8
        }
216
8
        case PrimitiveType::TYPE_SMALLINT: {
217
24
            for (int col = 1; col < arguments.size(); ++col) {
218
16
                insert_result_data<TYPE_SMALLINT>(res_data, argument_columns[0],
219
16
                                                  argument_columns[col], input_rows_count, col);
220
16
            }
221
8
            break;
222
8
        }
223
8
        case PrimitiveType::TYPE_INT: {
224
24
            for (int col = 1; col < arguments.size(); ++col) {
225
16
                insert_result_data<TYPE_INT>(res_data, argument_columns[0], argument_columns[col],
226
16
                                             input_rows_count, col);
227
16
            }
228
8
            break;
229
8
        }
230
8
        case PrimitiveType::TYPE_BIGINT: {
231
24
            for (int col = 1; col < arguments.size(); ++col) {
232
16
                insert_result_data<TYPE_BIGINT>(res_data, argument_columns[0],
233
16
                                                argument_columns[col], input_rows_count, col);
234
16
            }
235
8
            break;
236
8
        }
237
8
        case PrimitiveType::TYPE_LARGEINT: {
238
24
            for (int col = 1; col < arguments.size(); ++col) {
239
16
                insert_result_data<TYPE_LARGEINT>(res_data, argument_columns[0],
240
16
                                                  argument_columns[col], input_rows_count, col);
241
16
            }
242
8
            break;
243
8
        }
244
8
        case PrimitiveType::TYPE_FLOAT: {
245
24
            for (int col = 1; col < arguments.size(); ++col) {
246
16
                insert_result_data<TYPE_FLOAT>(res_data, argument_columns[0], argument_columns[col],
247
16
                                               input_rows_count, col);
248
16
            }
249
8
            break;
250
8
        }
251
8
        case PrimitiveType::TYPE_DOUBLE: {
252
24
            for (int col = 1; col < arguments.size(); ++col) {
253
16
                insert_result_data<TYPE_DOUBLE>(res_data, argument_columns[0],
254
16
                                                argument_columns[col], input_rows_count, col);
255
16
            }
256
8
            break;
257
8
        }
258
8
        case PrimitiveType::TYPE_DECIMAL32: {
259
24
            for (int col = 1; col < arguments.size(); ++col) {
260
16
                insert_result_data<TYPE_DECIMAL32>(res_data, argument_columns[0],
261
16
                                                   argument_columns[col], input_rows_count, col);
262
16
            }
263
8
            break;
264
8
        }
265
0
        case PrimitiveType::TYPE_DECIMAL64: {
266
0
            for (int col = 1; col < arguments.size(); ++col) {
267
0
                insert_result_data<TYPE_DECIMAL64>(res_data, argument_columns[0],
268
0
                                                   argument_columns[col], input_rows_count, col);
269
0
            }
270
0
            break;
271
8
        }
272
0
        case PrimitiveType::TYPE_DECIMALV2: {
273
0
            for (int col = 1; col < arguments.size(); ++col) {
274
0
                insert_result_data<TYPE_DECIMALV2>(res_data, argument_columns[0],
275
0
                                                   argument_columns[col], input_rows_count, col);
276
0
            }
277
0
            break;
278
8
        }
279
0
        case PrimitiveType::TYPE_DECIMAL128I: {
280
0
            for (int col = 1; col < arguments.size(); ++col) {
281
0
                insert_result_data<TYPE_DECIMAL128I>(res_data, argument_columns[0],
282
0
                                                     argument_columns[col], input_rows_count, col);
283
0
            }
284
0
            break;
285
8
        }
286
0
        case PrimitiveType::TYPE_DECIMAL256: {
287
0
            for (int col = 1; col < arguments.size(); ++col) {
288
0
                insert_result_data<TYPE_DECIMAL256>(res_data, argument_columns[0],
289
0
                                                    argument_columns[col], input_rows_count, col);
290
0
            }
291
0
            break;
292
8
        }
293
0
        case PrimitiveType::TYPE_DATEV2: {
294
0
            for (int col = 1; col < arguments.size(); ++col) {
295
0
                insert_result_data<TYPE_DATEV2>(res_data, argument_columns[0],
296
0
                                                argument_columns[col], input_rows_count, col);
297
0
            }
298
0
            break;
299
8
        }
300
0
        case PrimitiveType::TYPE_DATETIMEV2: {
301
0
            for (int col = 1; col < arguments.size(); ++col) {
302
0
                insert_result_data<TYPE_DATETIMEV2>(res_data, argument_columns[0],
303
0
                                                    argument_columns[col], input_rows_count, col);
304
0
            }
305
0
            break;
306
8
        }
307
0
        case PrimitiveType::TYPE_TIMESTAMPTZ: {
308
0
            for (int col = 1; col < arguments.size(); ++col) {
309
0
                insert_result_data<TYPE_TIMESTAMPTZ>(res_data, argument_columns[0],
310
0
                                                     argument_columns[col], input_rows_count, col);
311
0
            }
312
0
            break;
313
8
        }
314
0
        default:
315
0
            break;
316
107
        }
317
318
108
        return result_column;
319
107
    }
320
321
private:
322
    template <PrimitiveType PType>
323
    static void insert_result_data(PaddedPODArray<Int32>& __restrict res_data,
324
                                   ColumnPtr first_column, ColumnPtr argument_column,
325
128
                                   const size_t input_rows_count, const int col) {
326
128
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
128
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
128
        auto* __restrict first_raw_data =
329
128
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
128
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
128
        const auto& arg_data =
333
128
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
128
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
0
            for (size_t i = 0; i < input_rows_count; ++i) {
336
0
                res_data[i] |=
337
0
                        (!res_data[i] *
338
0
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
0
            }
340
16
        } else if constexpr (is_decimal(PType)) {
341
66
            for (size_t i = 0; i < input_rows_count; ++i) {
342
50
                res_data[i] |=
343
50
                        (!res_data[i] *
344
50
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
50
            }
346
112
        } else {
347
462
            for (size_t i = 0; i < input_rows_count; ++i) {
348
350
                res_data[i] |= (!res_data[i] *
349
350
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
350
            }
351
112
        }
352
128
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE3EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE4EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE5EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE6EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE7EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE8EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE9EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
        } else if constexpr (is_decimal(PType)) {
341
            for (size_t i = 0; i < input_rows_count; ++i) {
342
                res_data[i] |=
343
                        (!res_data[i] *
344
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
            }
346
16
        } else {
347
66
            for (size_t i = 0; i < input_rows_count; ++i) {
348
50
                res_data[i] |= (!res_data[i] *
349
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
50
            }
351
16
        }
352
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE28EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
325
16
                                   const size_t input_rows_count, const int col) {
326
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
327
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
328
16
        auto* __restrict first_raw_data =
329
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
330
331
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
332
16
        const auto& arg_data =
333
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
334
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
335
            for (size_t i = 0; i < input_rows_count; ++i) {
336
                res_data[i] |=
337
                        (!res_data[i] *
338
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
339
            }
340
16
        } else if constexpr (is_decimal(PType)) {
341
66
            for (size_t i = 0; i < input_rows_count; ++i) {
342
50
                res_data[i] |=
343
50
                        (!res_data[i] *
344
50
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
345
50
            }
346
        } else {
347
            for (size_t i = 0; i < input_rows_count; ++i) {
348
                res_data[i] |= (!res_data[i] *
349
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
350
            }
351
        }
352
16
    }
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE29EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE20EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE30EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE35EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE25EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE26EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE42EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb0EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
353
};
354
355
struct LeastName {
356
    static constexpr auto name = "least";
357
};
358
struct GreastName {
359
    static constexpr auto name = "greatest";
360
};
361
362
using FunctionLeast = FunctionMultiSameArgs<CompareMultiImpl<LessOp, LeastName>>;
363
using FunctionGreaest = FunctionMultiSameArgs<CompareMultiImpl<GreaterOp, GreastName>>;
364
using FunctionField = FunctionMultiSameArgs<FunctionFieldImpl>;
365
8
void register_function_least_greast(SimpleFunctionFactory& factory) {
366
8
    factory.register_function<FunctionLeast>();
367
8
    factory.register_function<FunctionGreaest>();
368
8
    factory.register_function<FunctionField>();
369
8
}
370
}; // namespace doris