Coverage Report

Created: 2026-04-02 09:24

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/call_on_type_index.h"
32
#include "core/column/column.h"
33
#include "core/column/column_const.h"
34
#include "core/column/column_decimal.h"
35
#include "core/column/column_string.h"
36
#include "core/column/column_vector.h"
37
#include "core/data_type/data_type.h"
38
#include "core/data_type/data_type_number.h"
39
#include "core/data_type/define_primitive_type.h"
40
#include "core/pod_array_fwd.h"
41
#include "core/string_ref.h"
42
#include "core/types.h"
43
#include "exec/common/template_helpers.hpp"
44
#include "exprs/aggregate/aggregate_function.h"
45
#include "exprs/function/function_multi_same_args.h"
46
#include "exprs/function/simple_function_factory.h"
47
48
namespace doris {
49
class DecimalV2Value;
50
} // namespace doris
51
52
namespace doris {
53
54
template <template <PrimitiveType> class Op, typename Impl>
55
struct CompareMultiImpl {
56
    static constexpr auto name = Impl::name;
57
58
188
    static DataTypePtr get_return_type_impl(const DataTypes& arguments) { return arguments[0]; }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE20get_return_type_implERKSt6vectorISt10shared_ptrIKNS_9IDataTypeEESaIS8_EE
Line
Count
Source
58
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
58
92
    static DataTypePtr get_return_type_impl(const DataTypes& arguments) { return arguments[0]; }
59
60
    static ColumnPtr execute(Block& block, const ColumnNumbers& arguments,
61
383
                             size_t input_rows_count) {
62
383
        if (arguments.size() == 1) {
63
239
            return block.get_by_position(arguments.back()).column;
64
239
        }
65
66
144
        const auto& data_type = block.get_by_position(arguments.back()).type;
67
144
        MutableColumnPtr result_column = data_type->create_column();
68
69
144
        Columns cols(arguments.size());
70
144
        std::unique_ptr<bool[]> col_const =
71
144
                std::make_unique_for_overwrite<bool[]>(arguments.size());
72
514
        for (int i = 0; i < arguments.size(); ++i) {
73
370
            std::tie(cols[i], col_const[i]) =
74
370
                    unpack_if_const(block.get_by_position(arguments[i]).column);
75
370
        }
76
        // because now the string types does not support random position writing,
77
        // so insert into result data have two methods, one is for string types, one is for others type remaining
78
144
        if (result_column->is_column_string()) {
79
16
            result_column->reserve(input_rows_count);
80
16
            const auto& column_string = reinterpret_cast<const ColumnString&>(*cols[0]);
81
16
            auto& column_res = reinterpret_cast<ColumnString&>(*result_column);
82
83
40
            for (int i = 0; i < input_rows_count; ++i) {
84
24
                auto str_data = column_string.get_data_at(index_check_const(i, col_const[0]));
85
60
                for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
86
36
                    auto temp_data = assert_cast<const ColumnString&>(*cols[cmp_col])
87
36
                                             .get_data_at(index_check_const(i, col_const[cmp_col]));
88
36
                    str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ? temp_data : str_data;
89
36
                }
90
24
                column_res.insert_data(str_data.data, str_data.size);
91
24
            }
92
93
128
        } else {
94
128
            if (col_const[0]) {
95
40
                for (int i = 0; i < input_rows_count; ++i) {
96
30
                    result_column->insert_range_from(*(cols[0]), 0, 1);
97
30
                }
98
118
            } else {
99
118
                result_column->insert_range_from(*(cols[0]), 0, input_rows_count);
100
118
            }
101
102
129
            auto call = [&](const auto& type) -> bool {
103
129
                using DispatchType = std::decay_t<decltype(type)>;
104
326
                for (int i = 1; i < arguments.size(); ++i) {
105
197
                    if (col_const[i]) {
106
14
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
14
                                                                      input_rows_count);
108
183
                    } else {
109
183
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
183
                                                                       input_rows_count);
111
183
                    }
112
197
                }
113
114
129
                return true;
115
129
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE2EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE3EEEEEbSD_
Line
Count
Source
102
6
            auto call = [&](const auto& type) -> bool {
103
6
                using DispatchType = std::decay_t<decltype(type)>;
104
14
                for (int i = 1; i < arguments.size(); ++i) {
105
8
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
8
                    } else {
109
8
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
8
                                                                       input_rows_count);
111
8
                    }
112
8
                }
113
114
6
                return true;
115
6
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE4EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
6
                for (int i = 1; i < arguments.size(); ++i) {
105
4
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
4
                    } else {
109
4
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
4
                                                                       input_rows_count);
111
4
                    }
112
4
                }
113
114
2
                return true;
115
2
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE5EEEEEbSD_
Line
Count
Source
102
17
            auto call = [&](const auto& type) -> bool {
103
17
                using DispatchType = std::decay_t<decltype(type)>;
104
48
                for (int i = 1; i < arguments.size(); ++i) {
105
31
                    if (col_const[i]) {
106
12
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
12
                                                                      input_rows_count);
108
19
                    } else {
109
19
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
19
                                                                       input_rows_count);
111
19
                    }
112
31
                }
113
114
17
                return true;
115
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
102
19
            auto call = [&](const auto& type) -> bool {
103
19
                using DispatchType = std::decay_t<decltype(type)>;
104
55
                for (int i = 1; i < arguments.size(); ++i) {
105
36
                    if (col_const[i]) {
106
1
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
1
                                                                      input_rows_count);
108
35
                    } else {
109
35
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
35
                                                                       input_rows_count);
111
35
                    }
112
36
                }
113
114
19
                return true;
115
19
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE28EEEEEbSD_
Line
Count
Source
102
5
            auto call = [&](const auto& type) -> bool {
103
5
                using DispatchType = std::decay_t<decltype(type)>;
104
14
                for (int i = 1; i < arguments.size(); ++i) {
105
9
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
9
                    } else {
109
9
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
9
                                                                       input_rows_count);
111
9
                    }
112
9
                }
113
114
5
                return true;
115
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
102
4
            auto call = [&](const auto& type) -> bool {
103
4
                using DispatchType = std::decay_t<decltype(type)>;
104
9
                for (int i = 1; i < arguments.size(); ++i) {
105
5
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
5
                    } else {
109
5
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
5
                                                                       input_rows_count);
111
5
                    }
112
5
                }
113
114
4
                return true;
115
4
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE35EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
4
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
2
                    } else {
109
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
2
                                                                       input_rows_count);
111
2
                    }
112
2
                }
113
114
2
                return true;
115
2
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE11EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE25EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
4
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
2
                    } else {
109
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
2
                                                                       input_rows_count);
111
2
                    }
112
2
                }
113
114
2
                return true;
115
2
            };
_ZZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE26EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
4
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
2
                    } else {
109
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
2
                                                                       input_rows_count);
111
2
                    }
112
2
                }
113
114
2
                return true;
115
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
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
6
                for (int i = 1; i < arguments.size(); ++i) {
105
4
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
4
                    } else {
109
4
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
4
                                                                       input_rows_count);
111
4
                    }
112
4
                }
113
114
2
                return true;
115
2
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE4EEEEEbSD_
Line
Count
Source
102
3
            auto call = [&](const auto& type) -> bool {
103
3
                using DispatchType = std::decay_t<decltype(type)>;
104
9
                for (int i = 1; i < arguments.size(); ++i) {
105
6
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
6
                    } else {
109
6
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
6
                                                                       input_rows_count);
111
6
                    }
112
6
                }
113
114
3
                return true;
115
3
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE5EEEEEbSD_
Line
Count
Source
102
30
            auto call = [&](const auto& type) -> bool {
103
30
                using DispatchType = std::decay_t<decltype(type)>;
104
62
                for (int i = 1; i < arguments.size(); ++i) {
105
32
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
32
                    } else {
109
32
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
32
                                                                       input_rows_count);
111
32
                    }
112
32
                }
113
114
30
                return true;
115
30
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE6EEEEEbSD_
Line
Count
Source
102
1
            auto call = [&](const auto& type) -> bool {
103
1
                using DispatchType = std::decay_t<decltype(type)>;
104
3
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
1
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
1
                                                                      input_rows_count);
108
1
                    } else {
109
1
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
1
                                                                       input_rows_count);
111
1
                    }
112
2
                }
113
114
1
                return true;
115
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
102
20
            auto call = [&](const auto& type) -> bool {
103
20
                using DispatchType = std::decay_t<decltype(type)>;
104
56
                for (int i = 1; i < arguments.size(); ++i) {
105
36
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
36
                    } else {
109
36
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
36
                                                                       input_rows_count);
111
36
                    }
112
36
                }
113
114
20
                return true;
115
20
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE28EEEEEbSD_
Line
Count
Source
102
5
            auto call = [&](const auto& type) -> bool {
103
5
                using DispatchType = std::decay_t<decltype(type)>;
104
14
                for (int i = 1; i < arguments.size(); ++i) {
105
9
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
9
                    } else {
109
9
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
9
                                                                       input_rows_count);
111
9
                    }
112
9
                }
113
114
5
                return true;
115
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
102
3
            auto call = [&](const auto& type) -> bool {
103
3
                using DispatchType = std::decay_t<decltype(type)>;
104
6
                for (int i = 1; i < arguments.size(); ++i) {
105
3
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
3
                    } else {
109
3
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
3
                                                                       input_rows_count);
111
3
                    }
112
3
                }
113
114
3
                return true;
115
3
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE35EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
4
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
2
                    } else {
109
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
2
                                                                       input_rows_count);
111
2
                    }
112
2
                }
113
114
2
                return true;
115
2
            };
Unexecuted instantiation: _ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE11EEEEEbSD_
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE25EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
4
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
2
                    } else {
109
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
2
                                                                       input_rows_count);
111
2
                    }
112
2
                }
113
114
2
                return true;
115
2
            };
_ZZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlRKT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE26EEEEEbSD_
Line
Count
Source
102
2
            auto call = [&](const auto& type) -> bool {
103
2
                using DispatchType = std::decay_t<decltype(type)>;
104
4
                for (int i = 1; i < arguments.size(); ++i) {
105
2
                    if (col_const[i]) {
106
0
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
0
                                                                      input_rows_count);
108
2
                    } else {
109
2
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
2
                                                                       input_rows_count);
111
2
                    }
112
2
                }
113
114
2
                return true;
115
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_
116
117
128
            if (!dispatch_switch_scalar(data_type->get_primitive_type(), call)) {
118
0
                throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support type {}",
119
0
                                       data_type->get_name());
120
0
            }
121
128
        }
122
144
        return result_column;
123
144
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEm
Line
Count
Source
61
185
                             size_t input_rows_count) {
62
185
        if (arguments.size() == 1) {
63
119
            return block.get_by_position(arguments.back()).column;
64
119
        }
65
66
66
        const auto& data_type = block.get_by_position(arguments.back()).type;
67
66
        MutableColumnPtr result_column = data_type->create_column();
68
69
66
        Columns cols(arguments.size());
70
66
        std::unique_ptr<bool[]> col_const =
71
66
                std::make_unique_for_overwrite<bool[]>(arguments.size());
72
246
        for (int i = 0; i < arguments.size(); ++i) {
73
180
            std::tie(cols[i], col_const[i]) =
74
180
                    unpack_if_const(block.get_by_position(arguments[i]).column);
75
180
        }
76
        // because now the string types does not support random position writing,
77
        // so insert into result data have two methods, one is for string types, one is for others type remaining
78
66
        if (result_column->is_column_string()) {
79
8
            result_column->reserve(input_rows_count);
80
8
            const auto& column_string = reinterpret_cast<const ColumnString&>(*cols[0]);
81
8
            auto& column_res = reinterpret_cast<ColumnString&>(*result_column);
82
83
20
            for (int i = 0; i < input_rows_count; ++i) {
84
12
                auto str_data = column_string.get_data_at(index_check_const(i, col_const[0]));
85
30
                for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
86
18
                    auto temp_data = assert_cast<const ColumnString&>(*cols[cmp_col])
87
18
                                             .get_data_at(index_check_const(i, col_const[cmp_col]));
88
18
                    str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ? temp_data : str_data;
89
18
                }
90
12
                column_res.insert_data(str_data.data, str_data.size);
91
12
            }
92
93
58
        } else {
94
58
            if (col_const[0]) {
95
20
                for (int i = 0; i < input_rows_count; ++i) {
96
15
                    result_column->insert_range_from(*(cols[0]), 0, 1);
97
15
                }
98
53
            } else {
99
53
                result_column->insert_range_from(*(cols[0]), 0, input_rows_count);
100
53
            }
101
102
58
            auto call = [&](const auto& type) -> bool {
103
58
                using DispatchType = std::decay_t<decltype(type)>;
104
58
                for (int i = 1; i < arguments.size(); ++i) {
105
58
                    if (col_const[i]) {
106
58
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
58
                                                                      input_rows_count);
108
58
                    } else {
109
58
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
58
                                                                       input_rows_count);
111
58
                    }
112
58
                }
113
114
58
                return true;
115
58
            };
116
117
58
            if (!dispatch_switch_scalar(data_type->get_primitive_type(), call)) {
118
0
                throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support type {}",
119
0
                                       data_type->get_name());
120
0
            }
121
58
        }
122
66
        return result_column;
123
66
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE7executeERNS_5BlockERKSt6vectorIjSaIjEEm
Line
Count
Source
61
198
                             size_t input_rows_count) {
62
198
        if (arguments.size() == 1) {
63
120
            return block.get_by_position(arguments.back()).column;
64
120
        }
65
66
78
        const auto& data_type = block.get_by_position(arguments.back()).type;
67
78
        MutableColumnPtr result_column = data_type->create_column();
68
69
78
        Columns cols(arguments.size());
70
78
        std::unique_ptr<bool[]> col_const =
71
78
                std::make_unique_for_overwrite<bool[]>(arguments.size());
72
268
        for (int i = 0; i < arguments.size(); ++i) {
73
190
            std::tie(cols[i], col_const[i]) =
74
190
                    unpack_if_const(block.get_by_position(arguments[i]).column);
75
190
        }
76
        // because now the string types does not support random position writing,
77
        // so insert into result data have two methods, one is for string types, one is for others type remaining
78
78
        if (result_column->is_column_string()) {
79
8
            result_column->reserve(input_rows_count);
80
8
            const auto& column_string = reinterpret_cast<const ColumnString&>(*cols[0]);
81
8
            auto& column_res = reinterpret_cast<ColumnString&>(*result_column);
82
83
20
            for (int i = 0; i < input_rows_count; ++i) {
84
12
                auto str_data = column_string.get_data_at(index_check_const(i, col_const[0]));
85
30
                for (int cmp_col = 1; cmp_col < arguments.size(); ++cmp_col) {
86
18
                    auto temp_data = assert_cast<const ColumnString&>(*cols[cmp_col])
87
18
                                             .get_data_at(index_check_const(i, col_const[cmp_col]));
88
18
                    str_data = Op<TYPE_STRING>::apply(temp_data, str_data) ? temp_data : str_data;
89
18
                }
90
12
                column_res.insert_data(str_data.data, str_data.size);
91
12
            }
92
93
70
        } else {
94
70
            if (col_const[0]) {
95
20
                for (int i = 0; i < input_rows_count; ++i) {
96
15
                    result_column->insert_range_from(*(cols[0]), 0, 1);
97
15
                }
98
65
            } else {
99
65
                result_column->insert_range_from(*(cols[0]), 0, input_rows_count);
100
65
            }
101
102
70
            auto call = [&](const auto& type) -> bool {
103
70
                using DispatchType = std::decay_t<decltype(type)>;
104
70
                for (int i = 1; i < arguments.size(); ++i) {
105
70
                    if (col_const[i]) {
106
70
                        insert_result_data<DispatchType::PType, true>(result_column, cols[i],
107
70
                                                                      input_rows_count);
108
70
                    } else {
109
70
                        insert_result_data<DispatchType::PType, false>(result_column, cols[i],
110
70
                                                                       input_rows_count);
111
70
                    }
112
70
                }
113
114
70
                return true;
115
70
            };
116
117
70
            if (!dispatch_switch_scalar(data_type->get_primitive_type(), call)) {
118
0
                throw doris::Exception(ErrorCode::INTERNAL_ERROR, "not support type {}",
119
0
                                       data_type->get_name());
120
0
            }
121
70
        }
122
78
        return result_column;
123
78
    }
124
125
private:
126
    template <PrimitiveType PType, bool ArgConst>
127
    static void insert_result_data(const MutableColumnPtr& result_column,
128
                                   const ColumnPtr& argument_column,
129
197
                                   const size_t input_rows_count) {
130
197
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
197
        auto* __restrict result_raw_data =
132
197
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
197
        auto* __restrict column_raw_data =
134
197
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
197
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
0
            for (size_t i = 0; i < input_rows_count; ++i) {
138
0
                result_raw_data[i] =
139
0
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
0
                                                  result_raw_data[i])
141
0
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
0
                                : result_raw_data[i];
143
0
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
30
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
70
            for (size_t i = 0; i < input_rows_count; ++i) {
149
40
                result_raw_data[i] =
150
40
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
40
                                         result_raw_data[i].value)
152
40
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
40
                                : result_raw_data[i];
154
40
            }
155
167
        } else {
156
100k
            for (size_t i = 0; i < input_rows_count; ++i) {
157
100k
                result_raw_data[i] =
158
100k
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
100k
                                         result_raw_data[i])
160
100k
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
100k
                                : result_raw_data[i];
162
100k
            }
163
167
        }
164
197
    }
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
129
8
                                   const size_t input_rows_count) {
130
8
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
8
        auto* __restrict result_raw_data =
132
8
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
8
        auto* __restrict column_raw_data =
134
8
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
8
        } else {
156
20
            for (size_t i = 0; i < input_rows_count; ++i) {
157
12
                result_raw_data[i] =
158
12
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
12
                                         result_raw_data[i])
160
12
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
12
                                : result_raw_data[i];
162
12
            }
163
8
        }
164
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
129
4
                                   const size_t input_rows_count) {
130
4
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
4
        auto* __restrict result_raw_data =
132
4
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
4
        auto* __restrict column_raw_data =
134
4
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
4
        } else {
156
8
            for (size_t i = 0; i < input_rows_count; ++i) {
157
4
                result_raw_data[i] =
158
4
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
4
                                         result_raw_data[i])
160
4
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
4
                                : result_raw_data[i];
162
4
            }
163
4
        }
164
4
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE5ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
129
12
                                   const size_t input_rows_count) {
130
12
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
12
        auto* __restrict result_raw_data =
132
12
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
12
        auto* __restrict column_raw_data =
134
12
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
12
        } else {
156
42
            for (size_t i = 0; i < input_rows_count; ++i) {
157
30
                result_raw_data[i] =
158
30
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
30
                                         result_raw_data[i])
160
30
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
30
                                : result_raw_data[i];
162
30
            }
163
12
        }
164
12
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE5ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
129
19
                                   const size_t input_rows_count) {
130
19
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
19
        auto* __restrict result_raw_data =
132
19
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
19
        auto* __restrict column_raw_data =
134
19
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
19
        } else {
156
64
            for (size_t i = 0; i < input_rows_count; ++i) {
157
45
                result_raw_data[i] =
158
45
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
45
                                         result_raw_data[i])
160
45
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
45
                                : result_raw_data[i];
162
45
            }
163
19
        }
164
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
129
1
                                   const size_t input_rows_count) {
130
1
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
1
        auto* __restrict result_raw_data =
132
1
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
1
        auto* __restrict column_raw_data =
134
1
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
1
        } else {
156
2
            for (size_t i = 0; i < input_rows_count; ++i) {
157
1
                result_raw_data[i] =
158
1
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
1
                                         result_raw_data[i])
160
1
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
1
                                : result_raw_data[i];
162
1
            }
163
1
        }
164
1
    }
_ZN5doris16CompareMultiImplINS_6LessOpENS_9LeastNameEE18insert_result_dataILNS_13PrimitiveTypeE9ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
129
35
                                   const size_t input_rows_count) {
130
35
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
35
        auto* __restrict result_raw_data =
132
35
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
35
        auto* __restrict column_raw_data =
134
35
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
35
        } else {
156
74
            for (size_t i = 0; i < input_rows_count; ++i) {
157
39
                result_raw_data[i] =
158
39
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
39
                                         result_raw_data[i])
160
39
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
39
                                : result_raw_data[i];
162
39
            }
163
35
        }
164
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
129
9
                                   const size_t input_rows_count) {
130
9
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
9
        auto* __restrict result_raw_data =
132
9
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
9
        auto* __restrict column_raw_data =
134
9
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
9
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
19
            for (size_t i = 0; i < input_rows_count; ++i) {
149
10
                result_raw_data[i] =
150
10
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
10
                                         result_raw_data[i].value)
152
10
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
10
                                : result_raw_data[i];
154
10
            }
155
        } else {
156
            for (size_t i = 0; i < input_rows_count; ++i) {
157
                result_raw_data[i] =
158
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
                                         result_raw_data[i])
160
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
                                : result_raw_data[i];
162
            }
163
        }
164
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
129
5
                                   const size_t input_rows_count) {
130
5
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
5
        auto* __restrict result_raw_data =
132
5
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
5
        auto* __restrict column_raw_data =
134
5
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
5
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
14
            for (size_t i = 0; i < input_rows_count; ++i) {
149
9
                result_raw_data[i] =
150
9
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
9
                                         result_raw_data[i].value)
152
9
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
9
                                : result_raw_data[i];
154
9
            }
155
        } else {
156
            for (size_t i = 0; i < input_rows_count; ++i) {
157
                result_raw_data[i] =
158
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
                                         result_raw_data[i])
160
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
                                : result_raw_data[i];
162
            }
163
        }
164
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
129
2
                                   const size_t input_rows_count) {
130
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
2
        auto* __restrict result_raw_data =
132
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
2
        auto* __restrict column_raw_data =
134
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
2
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
4
            for (size_t i = 0; i < input_rows_count; ++i) {
149
2
                result_raw_data[i] =
150
2
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
2
                                         result_raw_data[i].value)
152
2
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
2
                                : result_raw_data[i];
154
2
            }
155
        } else {
156
            for (size_t i = 0; i < input_rows_count; ++i) {
157
                result_raw_data[i] =
158
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
                                         result_raw_data[i])
160
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
                                : result_raw_data[i];
162
            }
163
        }
164
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
129
2
                                   const size_t input_rows_count) {
130
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
2
        auto* __restrict result_raw_data =
132
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
2
        auto* __restrict column_raw_data =
134
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
2
        } else {
156
8
            for (size_t i = 0; i < input_rows_count; ++i) {
157
6
                result_raw_data[i] =
158
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
6
                                         result_raw_data[i])
160
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
6
                                : result_raw_data[i];
162
6
            }
163
2
        }
164
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
129
2
                                   const size_t input_rows_count) {
130
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
2
        auto* __restrict result_raw_data =
132
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
2
        auto* __restrict column_raw_data =
134
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
2
        } else {
156
8
            for (size_t i = 0; i < input_rows_count; ++i) {
157
6
                result_raw_data[i] =
158
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
6
                                         result_raw_data[i])
160
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
6
                                : result_raw_data[i];
162
6
            }
163
2
        }
164
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
129
4
                                   const size_t input_rows_count) {
130
4
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
4
        auto* __restrict result_raw_data =
132
4
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
4
        auto* __restrict column_raw_data =
134
4
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
4
        } else {
156
8
            for (size_t i = 0; i < input_rows_count; ++i) {
157
4
                result_raw_data[i] =
158
4
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
4
                                         result_raw_data[i])
160
4
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
4
                                : result_raw_data[i];
162
4
            }
163
4
        }
164
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
129
6
                                   const size_t input_rows_count) {
130
6
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
6
        auto* __restrict result_raw_data =
132
6
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
6
        auto* __restrict column_raw_data =
134
6
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
6
        } else {
156
12
            for (size_t i = 0; i < input_rows_count; ++i) {
157
6
                result_raw_data[i] =
158
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
6
                                         result_raw_data[i])
160
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
6
                                : result_raw_data[i];
162
6
            }
163
6
        }
164
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
129
32
                                   const size_t input_rows_count) {
130
32
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
32
        auto* __restrict result_raw_data =
132
32
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
32
        auto* __restrict column_raw_data =
134
32
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
32
        } else {
156
100k
            for (size_t i = 0; i < input_rows_count; ++i) {
157
100k
                result_raw_data[i] =
158
100k
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
100k
                                         result_raw_data[i])
160
100k
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
100k
                                : result_raw_data[i];
162
100k
            }
163
32
        }
164
32
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE6ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
129
1
                                   const size_t input_rows_count) {
130
1
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
1
        auto* __restrict result_raw_data =
132
1
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
1
        auto* __restrict column_raw_data =
134
1
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
1
        } else {
156
2
            for (size_t i = 0; i < input_rows_count; ++i) {
157
1
                result_raw_data[i] =
158
1
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
1
                                         result_raw_data[i])
160
1
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
1
                                : result_raw_data[i];
162
1
            }
163
1
        }
164
1
    }
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE6ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
129
1
                                   const size_t input_rows_count) {
130
1
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
1
        auto* __restrict result_raw_data =
132
1
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
1
        auto* __restrict column_raw_data =
134
1
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
1
        } else {
156
2
            for (size_t i = 0; i < input_rows_count; ++i) {
157
1
                result_raw_data[i] =
158
1
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
1
                                         result_raw_data[i])
160
1
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
1
                                : result_raw_data[i];
162
1
            }
163
1
        }
164
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
129
36
                                   const size_t input_rows_count) {
130
36
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
36
        auto* __restrict result_raw_data =
132
36
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
36
        auto* __restrict column_raw_data =
134
36
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
36
        } else {
156
76
            for (size_t i = 0; i < input_rows_count; ++i) {
157
40
                result_raw_data[i] =
158
40
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
40
                                         result_raw_data[i])
160
40
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
40
                                : result_raw_data[i];
162
40
            }
163
36
        }
164
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
129
9
                                   const size_t input_rows_count) {
130
9
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
9
        auto* __restrict result_raw_data =
132
9
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
9
        auto* __restrict column_raw_data =
134
9
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
9
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
19
            for (size_t i = 0; i < input_rows_count; ++i) {
149
10
                result_raw_data[i] =
150
10
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
10
                                         result_raw_data[i].value)
152
10
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
10
                                : result_raw_data[i];
154
10
            }
155
        } else {
156
            for (size_t i = 0; i < input_rows_count; ++i) {
157
                result_raw_data[i] =
158
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
                                         result_raw_data[i])
160
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
                                : result_raw_data[i];
162
            }
163
        }
164
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
Unexecuted instantiation: _ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE30ELb1EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
_ZN5doris16CompareMultiImplINS_9GreaterOpENS_10GreastNameEE18insert_result_dataILNS_13PrimitiveTypeE30ELb0EEEvRKNS_3COWINS_7IColumnEE11mutable_ptrIS7_EERKNS8_13immutable_ptrIS7_EEm
Line
Count
Source
129
3
                                   const size_t input_rows_count) {
130
3
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
3
        auto* __restrict result_raw_data =
132
3
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
3
        auto* __restrict column_raw_data =
134
3
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
3
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
10
            for (size_t i = 0; i < input_rows_count; ++i) {
149
7
                result_raw_data[i] =
150
7
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
7
                                         result_raw_data[i].value)
152
7
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
7
                                : result_raw_data[i];
154
7
            }
155
        } else {
156
            for (size_t i = 0; i < input_rows_count; ++i) {
157
                result_raw_data[i] =
158
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
                                         result_raw_data[i])
160
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
                                : result_raw_data[i];
162
            }
163
        }
164
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
129
2
                                   const size_t input_rows_count) {
130
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
2
        auto* __restrict result_raw_data =
132
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
2
        auto* __restrict column_raw_data =
134
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
2
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
4
            for (size_t i = 0; i < input_rows_count; ++i) {
149
2
                result_raw_data[i] =
150
2
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
2
                                         result_raw_data[i].value)
152
2
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
2
                                : result_raw_data[i];
154
2
            }
155
        } else {
156
            for (size_t i = 0; i < input_rows_count; ++i) {
157
                result_raw_data[i] =
158
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
                                         result_raw_data[i])
160
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
                                : result_raw_data[i];
162
            }
163
        }
164
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
129
2
                                   const size_t input_rows_count) {
130
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
2
        auto* __restrict result_raw_data =
132
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
2
        auto* __restrict column_raw_data =
134
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
2
        } else {
156
8
            for (size_t i = 0; i < input_rows_count; ++i) {
157
6
                result_raw_data[i] =
158
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
6
                                         result_raw_data[i])
160
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
6
                                : result_raw_data[i];
162
6
            }
163
2
        }
164
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
129
2
                                   const size_t input_rows_count) {
130
2
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
131
2
        auto* __restrict result_raw_data =
132
2
                reinterpret_cast<ColumnType*>(result_column.get())->get_data().data();
133
2
        auto* __restrict column_raw_data =
134
2
                reinterpret_cast<const ColumnType*>(argument_column.get())->get_data().data();
135
136
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
137
            for (size_t i = 0; i < input_rows_count; ++i) {
138
                result_raw_data[i] =
139
                        Op<TYPE_DECIMALV2>::apply(column_raw_data[index_check_const(i, ArgConst)],
140
                                                  result_raw_data[i])
141
                                ? column_raw_data[index_check_const(i, ArgConst)]
142
                                : result_raw_data[i];
143
            }
144
        } else if constexpr (std::is_same_v<ColumnType, ColumnDecimal32> ||
145
                             std::is_same_v<ColumnType, ColumnDecimal64> ||
146
                             std::is_same_v<ColumnType, ColumnDecimal128V3> ||
147
                             std::is_same_v<ColumnType, ColumnDecimal256>) {
148
            for (size_t i = 0; i < input_rows_count; ++i) {
149
                result_raw_data[i] =
150
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)].value,
151
                                         result_raw_data[i].value)
152
                                ? column_raw_data[index_check_const(i, ArgConst)]
153
                                : result_raw_data[i];
154
            }
155
2
        } else {
156
8
            for (size_t i = 0; i < input_rows_count; ++i) {
157
6
                result_raw_data[i] =
158
6
                        Op<PType>::apply(column_raw_data[index_check_const(i, ArgConst)],
159
6
                                         result_raw_data[i])
160
6
                                ? column_raw_data[index_check_const(i, ArgConst)]
161
6
                                : result_raw_data[i];
162
6
            }
163
2
        }
164
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
165
};
166
167
struct FunctionFieldImpl {
168
    static constexpr auto name = "field";
169
170
34
    static DataTypePtr get_return_type_impl(const DataTypes& /*arguments*/) {
171
34
        return std::make_shared<DataTypeInt32>();
172
34
    }
173
174
    static ColumnPtr execute(Block& block, const ColumnNumbers& arguments,
175
106
                             size_t input_rows_count) {
176
106
        const auto& data_type = block.get_by_position(arguments[0]).type;
177
106
        auto result_column = ColumnInt32::create(input_rows_count, 0);
178
106
        auto& res_data = static_cast<ColumnInt32*>(result_column.get())->get_data();
179
180
106
        const auto& column_size = arguments.size();
181
106
        std::vector<ColumnPtr> argument_columns(column_size);
182
440
        for (int i = 0; i < column_size; ++i) {
183
334
            argument_columns[i] = block.get_by_position(arguments[i]).column;
184
334
        }
185
186
106
        bool arg_const;
187
106
        std::tie(argument_columns[0], arg_const) = unpack_if_const(argument_columns[0]);
188
106
        DCHECK_EQ(arg_const, false);
189
190
        //TODO: maybe could use hashmap to save column data, not use for loop ervey time to test equals.
191
106
        if (data_type->get_primitive_type() == PrimitiveType::TYPE_STRING ||
192
106
            data_type->get_primitive_type() == PrimitiveType::TYPE_CHAR ||
193
106
            data_type->get_primitive_type() == PrimitiveType::TYPE_VARCHAR) {
194
44
            const auto& column_string = assert_cast<const ColumnString&>(*argument_columns[0]);
195
168
            for (int row = 0; row < input_rows_count; ++row) {
196
124
                const auto& str_data = column_string.get_data_at(row);
197
354
                for (int col = 1; col < column_size; ++col) {
198
246
                    auto [column, is_const] = unpack_if_const(argument_columns[col]);
199
246
                    const auto& temp_data = assert_cast<const ColumnString&>(*column).get_data_at(
200
246
                            index_check_const(row, is_const));
201
246
                    if (EqualsOp<TYPE_STRING>::apply(temp_data, str_data)) {
202
16
                        res_data[row] = col;
203
16
                        break;
204
16
                    }
205
246
                }
206
124
            }
207
62
        } else {
208
62
            bool dispatched =
209
64
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
64
                        using DT = std::decay_t<decltype(type_holder)>;
211
192
                        for (int col = 1; col < column_size; ++col) {
212
128
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
128
                                                          argument_columns[col], input_rows_count,
214
128
                                                          col);
215
128
                        }
216
64
                        return true;
217
64
                    });
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE2EEEEEDaS8_
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE3EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE4EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE5EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE6EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE7EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE8EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE9EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
_ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE28EEEEEDaS8_
Line
Count
Source
209
8
                    dispatch_switch_scalar(data_type->get_primitive_type(), [&](auto type_holder) {
210
8
                        using DT = std::decay_t<decltype(type_holder)>;
211
24
                        for (int col = 1; col < column_size; ++col) {
212
16
                            insert_result_data<DT::PType>(res_data, argument_columns[0],
213
16
                                                          argument_columns[col], input_rows_count,
214
16
                                                          col);
215
16
                        }
216
8
                        return true;
217
8
                    });
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE29EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE20EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE30EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE35EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE11EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE25EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE26EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE12EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE27EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE42EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE36EEEEEDaS8_
Unexecuted instantiation: _ZZN5doris17FunctionFieldImpl7executeERNS_5BlockERKSt6vectorIjSaIjEEmENKUlT_E_clINS_16DispatchDataTypeILNS_13PrimitiveTypeE37EEEEEDaS8_
218
18.4E
            DCHECK(dispatched) << "unsupported type: " << data_type->get_name();
219
62
        }
220
221
106
        return result_column;
222
106
    }
223
224
private:
225
    template <PrimitiveType PType>
226
    static void insert_result_data(PaddedPODArray<Int32>& __restrict res_data,
227
                                   ColumnPtr first_column, ColumnPtr argument_column,
228
128
                                   const size_t input_rows_count, const int col) {
229
128
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
128
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
128
        auto* __restrict first_raw_data =
232
128
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
128
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
128
        const auto& arg_data =
236
128
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
128
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
0
            for (size_t i = 0; i < input_rows_count; ++i) {
239
0
                res_data[i] |=
240
0
                        (!res_data[i] *
241
0
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
0
            }
243
16
        } else if constexpr (is_decimal(PType)) {
244
66
            for (size_t i = 0; i < input_rows_count; ++i) {
245
50
                res_data[i] |=
246
50
                        (!res_data[i] *
247
50
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
50
            }
249
112
        } else {
250
462
            for (size_t i = 0; i < input_rows_count; ++i) {
251
350
                res_data[i] |= (!res_data[i] *
252
350
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
350
            }
254
112
        }
255
128
    }
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE2EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE3EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE4EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE5EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE6EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE7EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE8EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE9EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
        } else if constexpr (is_decimal(PType)) {
244
            for (size_t i = 0; i < input_rows_count; ++i) {
245
                res_data[i] |=
246
                        (!res_data[i] *
247
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
            }
249
16
        } else {
250
66
            for (size_t i = 0; i < input_rows_count; ++i) {
251
50
                res_data[i] |= (!res_data[i] *
252
50
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
50
            }
254
16
        }
255
16
    }
_ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE28EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Line
Count
Source
228
16
                                   const size_t input_rows_count, const int col) {
229
16
        using ColumnType = typename PrimitiveTypeTraits<PType>::ColumnType;
230
16
        auto [first_column_raw, first_column_is_const] = unpack_if_const(first_column);
231
16
        auto* __restrict first_raw_data =
232
16
                assert_cast<const ColumnType*>(first_column_raw.get())->get_data().data();
233
234
16
        auto [argument_column_raw, argument_column_is_const] = unpack_if_const(argument_column);
235
16
        const auto& arg_data =
236
16
                assert_cast<const ColumnType&>(*argument_column_raw).get_data().data()[0];
237
        if constexpr (std::is_same_v<ColumnType, ColumnDecimal128V2>) {
238
            for (size_t i = 0; i < input_rows_count; ++i) {
239
                res_data[i] |=
240
                        (!res_data[i] *
241
                         (EqualsOp<TYPE_DECIMALV2>::apply(first_raw_data[i], arg_data)) * col);
242
            }
243
16
        } else if constexpr (is_decimal(PType)) {
244
66
            for (size_t i = 0; i < input_rows_count; ++i) {
245
50
                res_data[i] |=
246
50
                        (!res_data[i] *
247
50
                         (EqualsOp<PType>::apply(first_raw_data[i].value, arg_data.value)) * col);
248
50
            }
249
        } else {
250
            for (size_t i = 0; i < input_rows_count; ++i) {
251
                res_data[i] |= (!res_data[i] *
252
                                (EqualsOp<PType>::apply(first_raw_data[i], arg_data)) * col);
253
            }
254
        }
255
16
    }
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE29EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE20EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE30EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE35EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE11EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE25EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE26EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE12EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE27EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE42EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE36EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
Unexecuted instantiation: _ZN5doris17FunctionFieldImpl18insert_result_dataILNS_13PrimitiveTypeE37EEEvRNS_8PODArrayIiLm4096ENS_9AllocatorILb0ELb0ELb0ENS_22DefaultMemoryAllocatorELb1EEELm16ELm15EEENS_3COWINS_7IColumnEE13immutable_ptrISA_EESD_mi
256
};
257
258
struct LeastName {
259
    static constexpr auto name = "least";
260
};
261
struct GreastName {
262
    static constexpr auto name = "greatest";
263
};
264
265
using FunctionLeast = FunctionMultiSameArgs<CompareMultiImpl<LessOp, LeastName>>;
266
using FunctionGreaest = FunctionMultiSameArgs<CompareMultiImpl<GreaterOp, GreastName>>;
267
using FunctionField = FunctionMultiSameArgs<FunctionFieldImpl>;
268
8
void register_function_least_greast(SimpleFunctionFactory& factory) {
269
8
    factory.register_function<FunctionLeast>();
270
8
    factory.register_function<FunctionGreaest>();
271
8
    factory.register_function<FunctionField>();
272
8
}
273
}; // namespace doris