Coverage Report

Created: 2026-09-23 12:27

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/vcase_expr.h
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
#pragma once
19
20
#include <string>
21
22
#include "common/exception.h"
23
#include "common/status.h"
24
#include "core/column/column_array.h"
25
#include "core/column/column_complex.h"
26
#include "core/column/column_const.h"
27
#include "core/column/column_decimal.h"
28
#include "core/column/column_map.h"
29
#include "core/column/column_nullable.h"
30
#include "core/column/column_struct.h"
31
#include "core/column/variant_v2/column_variant_v2.h"
32
#include "core/data_type/data_type_nullable.h"
33
#include "core/data_type/data_type_variant_v2.h"
34
#include "core/data_type/define_primitive_type.h"
35
#include "core/data_type/primitive_type.h"
36
#include "exprs/function/function.h"
37
#include "exprs/function_context.h"
38
#include "exprs/vexpr.h"
39
40
namespace doris {
41
class RowDescriptor;
42
class RuntimeState;
43
class TExprNode;
44
45
class Block;
46
} // namespace doris
47
48
namespace doris {
49
50
class VCaseExpr final : public VExpr {
51
    ENABLE_FACTORY_CREATOR(VCaseExpr);
52
53
public:
54
    VCaseExpr(const TExprNode& node);
55
    ~VCaseExpr() override = default;
56
    Status execute_column_impl(VExprContext* context, const Block* block, const Selector* selector,
57
                               size_t count, ColumnPtr& result_column) const override;
58
    Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override;
59
    Status open(RuntimeState* state, VExprContext* context,
60
                FunctionContext::FunctionStateScope scope) override;
61
    void close(VExprContext* context, FunctionContext::FunctionStateScope scope) override;
62
    const std::string& expr_name() const override;
63
    std::string debug_string() const override;
64
0
    bool has_else_expr() const { return _has_else_expr; }
65
1
    Status clone_node(VExprSPtr* cloned_expr) const override {
66
1
        DORIS_CHECK(cloned_expr != nullptr);
67
1
        auto node = clone_texpr_node();
68
1
        TCaseExpr case_node;
69
1
        case_node.__set_has_case_expr(false);
70
1
        case_node.__set_has_else_expr(_has_else_expr);
71
1
        node.__set_case_expr(case_node);
72
1
        *cloned_expr = VCaseExpr::create_shared(node);
73
1
        return Status::OK();
74
1
    }
75
76
private:
77
    template <typename IndexType, typename ColumnType>
78
    ColumnPtr _execute_update_result_impl(const IndexType* then_idx,
79
                                          std::vector<ColumnPtr>& then_columns,
80
712
                                          size_t rows_count) const {
81
712
        auto result_column_ptr = data_type()->create_column();
82
712
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
235
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
235
            if (data_type()->is_nullable()) {
97
148
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
148
                                                                  then_columns, rows_count);
99
148
            } else {
100
87
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
87
                                                                   then_columns, rows_count);
102
87
            }
103
477
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
62
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
62
                                                              then_columns, rows_count);
107
415
        } else {
108
415
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
415
                                                           then_columns, rows_count);
110
415
        }
111
712
        return result_column_ptr;
112
712
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE2EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE3EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE7EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_9ColumnStrIjEEEENS_3COWINS_7IColumnEE13immutable_ptrIS5_EEPKT_RSt6vectorIS8_SaIS8_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE44EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_9ColumnMapEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnStructEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_15ColumnVariantV2EEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE2EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE3EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
7
                                          size_t rows_count) const {
81
7
        auto result_column_ptr = data_type()->create_column();
82
7
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
7
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
2
                                                              then_columns, rows_count);
107
5
        } else {
108
5
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
5
                                                           then_columns, rows_count);
110
5
        }
111
7
        return result_column_ptr;
112
7
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
32
                                          size_t rows_count) const {
81
32
        auto result_column_ptr = data_type()->create_column();
82
32
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
32
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
32
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
32
                                                              then_columns, rows_count);
107
32
        } else {
108
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
0
                                                           then_columns, rows_count);
110
0
        }
111
32
        return result_column_ptr;
112
32
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
125
                                          size_t rows_count) const {
81
125
        auto result_column_ptr = data_type()->create_column();
82
125
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
125
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
19
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
19
                                                              then_columns, rows_count);
107
106
        } else {
108
106
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
106
                                                           then_columns, rows_count);
110
106
        }
111
125
        return result_column_ptr;
112
125
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE7EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
26
                                          size_t rows_count) const {
81
26
        auto result_column_ptr = data_type()->create_column();
82
26
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
26
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
1
                                                              then_columns, rows_count);
107
25
        } else {
108
25
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
25
                                                           then_columns, rows_count);
110
25
        }
111
26
        return result_column_ptr;
112
26
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
29
                                          size_t rows_count) const {
81
29
        auto result_column_ptr = data_type()->create_column();
82
29
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
29
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
4
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
4
                                                              then_columns, rows_count);
107
25
        } else {
108
25
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
25
                                                           then_columns, rows_count);
110
25
        }
111
29
        return result_column_ptr;
112
29
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
1
                                          size_t rows_count) const {
81
1
        auto result_column_ptr = data_type()->create_column();
82
1
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
1
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
1
                                                              then_columns, rows_count);
107
1
        } else {
108
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
0
                                                           then_columns, rows_count);
110
0
        }
111
1
        return result_column_ptr;
112
1
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
2
                                          size_t rows_count) const {
81
2
        auto result_column_ptr = data_type()->create_column();
82
2
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
2
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
2
                                                              then_columns, rows_count);
107
2
        } else {
108
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
0
                                                           then_columns, rows_count);
110
0
        }
111
2
        return result_column_ptr;
112
2
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
1
                                          size_t rows_count) const {
81
1
        auto result_column_ptr = data_type()->create_column();
82
1
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
1
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
1
                                                              then_columns, rows_count);
107
1
        } else {
108
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
0
                                                           then_columns, rows_count);
110
0
        }
111
1
        return result_column_ptr;
112
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_9ColumnStrIjEEEENS_3COWINS_7IColumnEE13immutable_ptrIS5_EEPKT_RSt6vectorIS8_SaIS8_EEm
Line
Count
Source
80
219
                                          size_t rows_count) const {
81
219
        auto result_column_ptr = data_type()->create_column();
82
219
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
219
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
219
            if (data_type()->is_nullable()) {
97
132
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
132
                                                                  then_columns, rows_count);
99
132
            } else {
100
87
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
87
                                                                   then_columns, rows_count);
102
87
            }
103
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
                                                              then_columns, rows_count);
107
        } else {
108
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
                                                           then_columns, rows_count);
110
        }
111
219
        return result_column_ptr;
112
219
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
20
                                          size_t rows_count) const {
81
20
        auto result_column_ptr = data_type()->create_column();
82
20
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
20
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
20
        } else {
108
20
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
20
                                                           then_columns, rows_count);
110
20
        }
111
20
        return result_column_ptr;
112
20
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
18
                                          size_t rows_count) const {
81
18
        auto result_column_ptr = data_type()->create_column();
82
18
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
            if (data_type()->is_nullable()) {
97
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
                                                                  then_columns, rows_count);
99
            } else {
100
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
                                                                   then_columns, rows_count);
102
            }
103
18
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
0
                                                              then_columns, rows_count);
107
18
        } else {
108
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
18
                                                           then_columns, rows_count);
110
18
        }
111
18
        return result_column_ptr;
112
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE44EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
3
                                          size_t rows_count) const {
81
3
        auto result_column_ptr = data_type()->create_column();
82
3
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
3
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
3
            if (data_type()->is_nullable()) {
97
3
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
3
                                                                  then_columns, rows_count);
99
3
            } else {
100
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
0
                                                                   then_columns, rows_count);
102
0
            }
103
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
                                                              then_columns, rows_count);
107
        } else {
108
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
                                                           then_columns, rows_count);
110
        }
111
3
        return result_column_ptr;
112
3
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Line
Count
Source
80
1
                                          size_t rows_count) const {
81
1
        auto result_column_ptr = data_type()->create_column();
82
1
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
1
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
1
            if (data_type()->is_nullable()) {
97
1
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
1
                                                                  then_columns, rows_count);
99
1
            } else {
100
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
0
                                                                   then_columns, rows_count);
102
0
            }
103
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
                                                              then_columns, rows_count);
107
        } else {
108
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
                                                           then_columns, rows_count);
110
        }
111
1
        return result_column_ptr;
112
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_9ColumnMapEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnStructEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
12
                                          size_t rows_count) const {
81
12
        auto result_column_ptr = data_type()->create_column();
82
12
        result_column_ptr->reserve(rows_count);
83
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
84
                      std::is_same_v<ColumnType, ColumnBitmap> ||
85
                      std::is_same_v<ColumnType, ColumnArray> ||
86
                      std::is_same_v<ColumnType, ColumnMap> ||
87
                      std::is_same_v<ColumnType, ColumnStruct> ||
88
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
89
                      std::is_same_v<ColumnType, ColumnHLL> ||
90
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
91
                      std::is_same_v<ColumnType, ColumnIPv4> ||
92
                      std::is_same_v<ColumnType, ColumnIPv6> ||
93
12
                      std::is_same_v<ColumnType, ColumnUUID>) {
94
            // result_column and all then_column is not nullable.
95
            // can't simd when type is string.
96
12
            if (data_type()->is_nullable()) {
97
12
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
98
12
                                                                  then_columns, rows_count);
99
12
            } else {
100
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
101
0
                                                                   then_columns, rows_count);
102
0
            }
103
        } else if (data_type()->is_nullable()) {
104
            // result_column and all then_column is nullable.
105
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
106
                                                              then_columns, rows_count);
107
        } else {
108
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
109
                                                           then_columns, rows_count);
110
        }
111
12
        return result_column_ptr;
112
12
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_15ColumnVariantV2EEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
113
114
    template <typename IndexType>
115
    ColumnPtr _execute_update_result(const IndexType* then_idx,
116
                                     std::vector<ColumnPtr>& then_columns,
117
424
                                     size_t rows_count) const {
118
424
#define CASE_TYPE(ptype, coltype) \
119
424
    case PrimitiveType::ptype:    \
120
424
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
121
122
424
        switch (data_type()->get_primitive_type()) {
123
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
124
7
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
125
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
126
32
            CASE_TYPE(TYPE_INT, ColumnInt32)
127
125
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
128
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
129
8
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
130
11
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
131
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
132
1
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
133
2
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
134
1
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
135
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
136
32
            CASE_TYPE(TYPE_STRING, ColumnString)
137
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
138
187
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
139
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
140
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
141
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
142
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
143
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
144
0
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
145
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
146
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
147
3
            CASE_TYPE(TYPE_UUID, ColumnUUID)
148
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
149
1
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
150
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
151
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
152
12
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
153
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
154
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
155
0
        case PrimitiveType::TYPE_VARIANT: {
156
0
            const IDataType* variant_type = remove_nullable(data_type()).get();
157
0
            DORIS_CHECK(dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr);
158
0
            return _execute_update_result_impl<IndexType, ColumnVariantV2>(then_idx, then_columns,
159
0
                                                                           rows_count);
160
0
        }
161
0
        default:
162
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
163
0
                            data_type()->get_name());
164
424
        }
165
424
#undef CASE_TYPE
166
424
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr22_execute_update_resultItEENS_3COWINS_7IColumnEE13immutable_ptrIS3_EEPKT_RSt6vectorIS6_SaIS6_EEm
_ZNK5doris9VCaseExpr22_execute_update_resultIhEENS_3COWINS_7IColumnEE13immutable_ptrIS3_EEPKT_RSt6vectorIS6_SaIS6_EEm
Line
Count
Source
117
424
                                     size_t rows_count) const {
118
424
#define CASE_TYPE(ptype, coltype) \
119
424
    case PrimitiveType::ptype:    \
120
424
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
121
122
424
        switch (data_type()->get_primitive_type()) {
123
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
124
7
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
125
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
126
32
            CASE_TYPE(TYPE_INT, ColumnInt32)
127
125
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
128
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
129
8
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
130
11
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
131
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
132
1
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
133
2
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
134
1
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
135
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
136
32
            CASE_TYPE(TYPE_STRING, ColumnString)
137
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
138
187
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
139
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
140
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
141
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
142
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
143
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
144
0
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
145
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
146
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
147
3
            CASE_TYPE(TYPE_UUID, ColumnUUID)
148
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
149
1
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
150
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
151
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
152
12
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
153
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
154
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
155
0
        case PrimitiveType::TYPE_VARIANT: {
156
0
            const IDataType* variant_type = remove_nullable(data_type()).get();
157
0
            DORIS_CHECK(dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr);
158
0
            return _execute_update_result_impl<IndexType, ColumnVariantV2>(then_idx, then_columns,
159
0
                                                                           rows_count);
160
0
        }
161
0
        default:
162
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
163
0
                            data_type()->get_name());
164
424
        }
165
424
#undef CASE_TYPE
166
424
    }
167
168
    template <typename IndexType, typename ColumnType, bool then_null>
169
    void update_result_normal(MutableColumnPtr& result_column_ptr,
170
                              const IndexType* __restrict then_idx,
171
297
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
297
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
297
        std::vector<uint8_t> is_consts(then_columns.size());
174
297
        std::vector<uint8_t> is_nullable(then_columns.size());
175
1.69k
        for (size_t i = 0; i < then_columns.size(); i++) {
176
1.40k
            if (!then_columns[i]) {
177
23
                continue;
178
23
            }
179
1.37k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
1.37k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
1.37k
        }
182
183
297
        auto* raw_result_column = result_column_ptr.get();
184
352k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
351k
            if (!_has_else_expr && !then_idx[row_idx]) {
186
10
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
10
                        ->insert_default();
188
10
                continue;
189
10
            }
190
351k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
351k
            if constexpr (then_null) {
192
120k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
120k
                        result_column_ptr.get());
194
120k
                if (is_nullable[then_idx[row_idx]]) {
195
112k
                    nullable->insert_from_with_type<ColumnType>(
196
112k
                            *raw_then_columns[then_idx[row_idx]], target);
197
112k
                } else {
198
7.80k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
7.80k
                            nullable->get_nested_column_ptr().get());
200
7.80k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
7.80k
                    nullable->push_false_to_nullmap(1);
202
7.80k
                }
203
231k
            } else {
204
231k
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
231k
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
231k
            }
207
351k
        }
208
297
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE2EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE3EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE4EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE5EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE7EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnStrIjEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVariantV2ELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVariantV2ELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE2EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE3EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
2
        std::vector<uint8_t> is_consts(then_columns.size());
174
2
        std::vector<uint8_t> is_nullable(then_columns.size());
175
6
        for (size_t i = 0; i < then_columns.size(); i++) {
176
4
            if (!then_columns[i]) {
177
1
                continue;
178
1
            }
179
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
3
        }
182
183
2
        auto* raw_result_column = result_column_ptr.get();
184
5
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
3
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
3
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
3
            if constexpr (then_null) {
192
3
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
3
                        result_column_ptr.get());
194
3
                if (is_nullable[then_idx[row_idx]]) {
195
1
                    nullable->insert_from_with_type<ColumnType>(
196
1
                            *raw_then_columns[then_idx[row_idx]], target);
197
2
                } else {
198
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
2
                            nullable->get_nested_column_ptr().get());
200
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
2
                    nullable->push_false_to_nullmap(1);
202
2
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
3
        }
208
2
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
32
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
32
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
32
        std::vector<uint8_t> is_consts(then_columns.size());
174
32
        std::vector<uint8_t> is_nullable(then_columns.size());
175
83
        for (size_t i = 0; i < then_columns.size(); i++) {
176
51
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
51
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
51
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
51
        }
182
183
32
        auto* raw_result_column = result_column_ptr.get();
184
84
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
52
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
52
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
52
            if constexpr (then_null) {
192
52
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
52
                        result_column_ptr.get());
194
52
                if (is_nullable[then_idx[row_idx]]) {
195
52
                    nullable->insert_from_with_type<ColumnType>(
196
52
                            *raw_then_columns[then_idx[row_idx]], target);
197
52
                } else {
198
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
0
                            nullable->get_nested_column_ptr().get());
200
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
0
                    nullable->push_false_to_nullmap(1);
202
0
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
52
        }
208
32
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
19
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
19
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
19
        std::vector<uint8_t> is_consts(then_columns.size());
174
19
        std::vector<uint8_t> is_nullable(then_columns.size());
175
68
        for (size_t i = 0; i < then_columns.size(); i++) {
176
49
            if (!then_columns[i]) {
177
13
                continue;
178
13
            }
179
36
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
36
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
36
        }
182
183
19
        auto* raw_result_column = result_column_ptr.get();
184
100k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
100k
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
100k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
100k
            if constexpr (then_null) {
192
100k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
100k
                        result_column_ptr.get());
194
100k
                if (is_nullable[then_idx[row_idx]]) {
195
100k
                    nullable->insert_from_with_type<ColumnType>(
196
100k
                            *raw_then_columns[then_idx[row_idx]], target);
197
100k
                } else {
198
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
0
                            nullable->get_nested_column_ptr().get());
200
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
0
                    nullable->push_false_to_nullmap(1);
202
0
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
100k
        }
208
19
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE7EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE8EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
1
        std::vector<uint8_t> is_consts(then_columns.size());
174
1
        std::vector<uint8_t> is_nullable(then_columns.size());
175
4
        for (size_t i = 0; i < then_columns.size(); i++) {
176
3
            if (!then_columns[i]) {
177
1
                continue;
178
1
            }
179
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
2
        }
182
183
1
        auto* raw_result_column = result_column_ptr.get();
184
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
3
            if (!_has_else_expr && !then_idx[row_idx]) {
186
1
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
1
                        ->insert_default();
188
1
                continue;
189
1
            }
190
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
2
            if constexpr (then_null) {
192
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
2
                        result_column_ptr.get());
194
2
                if (is_nullable[then_idx[row_idx]]) {
195
0
                    nullable->insert_from_with_type<ColumnType>(
196
0
                            *raw_then_columns[then_idx[row_idx]], target);
197
2
                } else {
198
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
2
                            nullable->get_nested_column_ptr().get());
200
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
2
                    nullable->push_false_to_nullmap(1);
202
2
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
2
        }
208
1
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
4
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
4
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
4
        std::vector<uint8_t> is_consts(then_columns.size());
174
4
        std::vector<uint8_t> is_nullable(then_columns.size());
175
15
        for (size_t i = 0; i < then_columns.size(); i++) {
176
11
            if (!then_columns[i]) {
177
1
                continue;
178
1
            }
179
10
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
10
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
10
        }
182
183
4
        auto* raw_result_column = result_column_ptr.get();
184
17
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
13
            if (!_has_else_expr && !then_idx[row_idx]) {
186
1
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
1
                        ->insert_default();
188
1
                continue;
189
1
            }
190
12
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
12
            if constexpr (then_null) {
192
12
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
12
                        result_column_ptr.get());
194
12
                if (is_nullable[then_idx[row_idx]]) {
195
7
                    nullable->insert_from_with_type<ColumnType>(
196
7
                            *raw_then_columns[then_idx[row_idx]], target);
197
7
                } else {
198
5
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
5
                            nullable->get_nested_column_ptr().get());
200
5
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
5
                    nullable->push_false_to_nullmap(1);
202
5
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
12
        }
208
4
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
1
        std::vector<uint8_t> is_consts(then_columns.size());
174
1
        std::vector<uint8_t> is_nullable(then_columns.size());
175
2
        for (size_t i = 0; i < then_columns.size(); i++) {
176
1
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
1
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
1
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
1
        }
182
183
1
        auto* raw_result_column = result_column_ptr.get();
184
2
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
1
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
1
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
1
            if constexpr (then_null) {
192
1
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
1
                        result_column_ptr.get());
194
1
                if (is_nullable[then_idx[row_idx]]) {
195
1
                    nullable->insert_from_with_type<ColumnType>(
196
1
                            *raw_then_columns[then_idx[row_idx]], target);
197
1
                } else {
198
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
0
                            nullable->get_nested_column_ptr().get());
200
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
0
                    nullable->push_false_to_nullmap(1);
202
0
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
1
        }
208
1
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
2
        std::vector<uint8_t> is_consts(then_columns.size());
174
2
        std::vector<uint8_t> is_nullable(then_columns.size());
175
8
        for (size_t i = 0; i < then_columns.size(); i++) {
176
6
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
6
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
6
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
6
        }
182
183
2
        auto* raw_result_column = result_column_ptr.get();
184
6
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
4
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
4
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
4
            if constexpr (then_null) {
192
4
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
4
                        result_column_ptr.get());
194
4
                if (is_nullable[then_idx[row_idx]]) {
195
4
                    nullable->insert_from_with_type<ColumnType>(
196
4
                            *raw_then_columns[then_idx[row_idx]], target);
197
4
                } else {
198
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
0
                            nullable->get_nested_column_ptr().get());
200
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
0
                    nullable->push_false_to_nullmap(1);
202
0
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
4
        }
208
2
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
1
        std::vector<uint8_t> is_consts(then_columns.size());
174
1
        std::vector<uint8_t> is_nullable(then_columns.size());
175
3
        for (size_t i = 0; i < then_columns.size(); i++) {
176
2
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
2
        }
182
183
1
        auto* raw_result_column = result_column_ptr.get();
184
2
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
1
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
1
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
1
            if constexpr (then_null) {
192
1
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
1
                        result_column_ptr.get());
194
1
                if (is_nullable[then_idx[row_idx]]) {
195
1
                    nullable->insert_from_with_type<ColumnType>(
196
1
                            *raw_then_columns[then_idx[row_idx]], target);
197
1
                } else {
198
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
0
                            nullable->get_nested_column_ptr().get());
200
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
0
                    nullable->push_false_to_nullmap(1);
202
0
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
1
        }
208
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
171
132
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
132
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
132
        std::vector<uint8_t> is_consts(then_columns.size());
174
132
        std::vector<uint8_t> is_nullable(then_columns.size());
175
1.15k
        for (size_t i = 0; i < then_columns.size(); i++) {
176
1.02k
            if (!then_columns[i]) {
177
7
                continue;
178
7
            }
179
1.01k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
1.01k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
1.01k
        }
182
183
132
        auto* raw_result_column = result_column_ptr.get();
184
4.13k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
4.00k
            if (!_has_else_expr && !then_idx[row_idx]) {
186
8
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
8
                        ->insert_default();
188
8
                continue;
189
8
            }
190
3.99k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
3.99k
            if constexpr (then_null) {
192
3.99k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
3.99k
                        result_column_ptr.get());
194
3.99k
                if (is_nullable[then_idx[row_idx]]) {
195
305
                    nullable->insert_from_with_type<ColumnType>(
196
305
                            *raw_then_columns[then_idx[row_idx]], target);
197
3.69k
                } else {
198
3.69k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
3.69k
                            nullable->get_nested_column_ptr().get());
200
3.69k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
3.69k
                    nullable->push_false_to_nullmap(1);
202
3.69k
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
3.99k
        }
208
132
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
171
87
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
87
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
87
        std::vector<uint8_t> is_consts(then_columns.size());
174
87
        std::vector<uint8_t> is_nullable(then_columns.size());
175
305
        for (size_t i = 0; i < then_columns.size(); i++) {
176
218
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
218
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
218
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
218
        }
182
183
87
        auto* raw_result_column = result_column_ptr.get();
184
231k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
231k
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
231k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
            if constexpr (then_null) {
192
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
                        result_column_ptr.get());
194
                if (is_nullable[then_idx[row_idx]]) {
195
                    nullable->insert_from_with_type<ColumnType>(
196
                            *raw_then_columns[then_idx[row_idx]], target);
197
                } else {
198
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
                            nullable->get_nested_column_ptr().get());
200
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
                    nullable->push_false_to_nullmap(1);
202
                }
203
231k
            } else {
204
231k
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
231k
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
231k
            }
207
231k
        }
208
87
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
3
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
3
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
3
        std::vector<uint8_t> is_consts(then_columns.size());
174
3
        std::vector<uint8_t> is_nullable(then_columns.size());
175
15
        for (size_t i = 0; i < then_columns.size(); i++) {
176
12
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
12
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
12
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
12
        }
182
183
3
        auto* raw_result_column = result_column_ptr.get();
184
16.3k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
16.3k
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
16.3k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
16.3k
            if constexpr (then_null) {
192
16.3k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
16.3k
                        result_column_ptr.get());
194
16.3k
                if (is_nullable[then_idx[row_idx]]) {
195
12.2k
                    nullable->insert_from_with_type<ColumnType>(
196
12.2k
                            *raw_then_columns[then_idx[row_idx]], target);
197
12.2k
                } else {
198
4.09k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
4.09k
                            nullable->get_nested_column_ptr().get());
200
4.09k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
4.09k
                    nullable->push_false_to_nullmap(1);
202
4.09k
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
16.3k
        }
208
3
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
171
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
1
        std::vector<uint8_t> is_consts(then_columns.size());
174
1
        std::vector<uint8_t> is_nullable(then_columns.size());
175
4
        for (size_t i = 0; i < then_columns.size(); i++) {
176
3
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
3
        }
182
183
1
        auto* raw_result_column = result_column_ptr.get();
184
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
3
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
3
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
3
            if constexpr (then_null) {
192
3
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
3
                        result_column_ptr.get());
194
3
                if (is_nullable[then_idx[row_idx]]) {
195
1
                    nullable->insert_from_with_type<ColumnType>(
196
1
                            *raw_then_columns[then_idx[row_idx]], target);
197
2
                } else {
198
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
2
                            nullable->get_nested_column_ptr().get());
200
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
2
                    nullable->push_false_to_nullmap(1);
202
2
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
3
        }
208
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
171
12
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
172
12
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
173
12
        std::vector<uint8_t> is_consts(then_columns.size());
174
12
        std::vector<uint8_t> is_nullable(then_columns.size());
175
32
        for (size_t i = 0; i < then_columns.size(); i++) {
176
20
            if (!then_columns[i]) {
177
0
                continue;
178
0
            }
179
20
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
180
20
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
181
20
        }
182
183
12
        auto* raw_result_column = result_column_ptr.get();
184
24
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
185
12
            if (!_has_else_expr && !then_idx[row_idx]) {
186
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
187
0
                        ->insert_default();
188
0
                continue;
189
0
            }
190
12
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
191
12
            if constexpr (then_null) {
192
12
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
193
12
                        result_column_ptr.get());
194
12
                if (is_nullable[then_idx[row_idx]]) {
195
4
                    nullable->insert_from_with_type<ColumnType>(
196
4
                            *raw_then_columns[then_idx[row_idx]], target);
197
8
                } else {
198
8
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
199
8
                            nullable->get_nested_column_ptr().get());
200
8
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
201
8
                    nullable->push_false_to_nullmap(1);
202
8
                }
203
            } else {
204
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
205
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
            }
207
12
        }
208
12
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVariantV2ELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVariantV2ELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
209
210
    template <typename IndexType, typename ColumnType>
211
    void update_result_auto_simd(MutableColumnPtr& result_column_ptr,
212
                                 const IndexType* __restrict then_idx,
213
415
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
10.6k
        for (auto& then_ptr : then_columns) {
215
10.6k
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
10.6k
        }
217
218
415
        result_column_ptr->resize(rows_count);
219
415
        auto* __restrict result_raw_data =
220
415
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
415
                        ->get_data()
222
415
                        .data();
223
224
        // set default value
225
505k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
297k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
297k
                result_raw_data[i] = ColumnType::default_value();
233
297k
            } else {
234
207k
                result_raw_data[i] = {};
235
207k
            }
236
504k
        }
237
238
11.1k
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
10.6k
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
10.6k
            const auto* __restrict column_raw_data =
243
10.6k
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
10.6k
                            then_columns[i].get())
245
10.6k
                            ->get_data()
246
10.6k
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
10.5k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
35.9M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
35.9M
                    if (then_idx[row_idx] == i) {
260
404k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
404k
                    }
262
35.9M
                }
263
10.5k
            } else {
264
300k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
300k
                    result_raw_data[row_idx] +=
266
300k
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
300k
                            column_raw_data[row_idx];
268
300k
                }
269
146
            }
270
10.6k
        }
271
415
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE2EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE3EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE7EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
                result_raw_data[i] = ColumnType::default_value();
233
24.7k
            } else {
234
24.7k
                result_raw_data[i] = {};
235
24.7k
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
                result_raw_data[i] = ColumnType::default_value();
233
24.7k
            } else {
234
24.7k
                result_raw_data[i] = {};
235
24.7k
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
658
        for (auto& then_ptr : then_columns) {
215
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
658
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
658
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
658
            const auto* __restrict column_raw_data =
243
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
658
                            then_columns[i].get())
245
658
                            ->get_data()
246
658
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
658
        }
271
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE2EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE3EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
5
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
12
        for (auto& then_ptr : then_columns) {
215
12
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
12
        }
217
218
5
        result_column_ptr->resize(rows_count);
219
5
        auto* __restrict result_raw_data =
220
5
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
5
                        ->get_data()
222
5
                        .data();
223
224
        // set default value
225
21
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
                result_raw_data[i] = ColumnType::default_value();
233
16
            } else {
234
16
                result_raw_data[i] = {};
235
16
            }
236
16
        }
237
238
17
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
12
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
12
            const auto* __restrict column_raw_data =
243
12
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
12
                            then_columns[i].get())
245
12
                            ->get_data()
246
12
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
                    if (then_idx[row_idx] == i) {
260
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
                    }
262
                }
263
12
            } else {
264
56
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
44
                    result_raw_data[row_idx] +=
266
44
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
44
                            column_raw_data[row_idx];
268
44
                }
269
12
            }
270
12
        }
271
5
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
106
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
134
        for (auto& then_ptr : then_columns) {
215
134
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
134
        }
217
218
106
        result_column_ptr->resize(rows_count);
219
106
        auto* __restrict result_raw_data =
220
106
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
106
                        ->get_data()
222
106
                        .data();
223
224
        // set default value
225
100k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
                result_raw_data[i] = ColumnType::default_value();
233
100k
            } else {
234
100k
                result_raw_data[i] = {};
235
100k
            }
236
100k
        }
237
238
240
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
134
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
134
            const auto* __restrict column_raw_data =
243
134
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
134
                            then_columns[i].get())
245
134
                            ->get_data()
246
134
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
                    if (then_idx[row_idx] == i) {
260
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
                    }
262
                }
263
134
            } else {
264
300k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
300k
                    result_raw_data[row_idx] +=
266
300k
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
300k
                            column_raw_data[row_idx];
268
300k
                }
269
134
            }
270
134
        }
271
106
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE7EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
25
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
675
        for (auto& then_ptr : then_columns) {
215
675
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
675
        }
217
218
25
        result_column_ptr->resize(rows_count);
219
25
        auto* __restrict result_raw_data =
220
25
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
25
                        ->get_data()
222
25
                        .data();
223
224
        // set default value
225
28.9k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
                result_raw_data[i] = ColumnType::default_value();
233
28.8k
            } else {
234
28.8k
                result_raw_data[i] = {};
235
28.8k
            }
236
28.8k
        }
237
238
700
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
675
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
675
            const auto* __restrict column_raw_data =
243
675
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
675
                            then_columns[i].get())
245
675
                            ->get_data()
246
675
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
675
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
28.8k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
28.8k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
675
        }
271
25
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
25
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
675
        for (auto& then_ptr : then_columns) {
215
675
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
675
        }
217
218
25
        result_column_ptr->resize(rows_count);
219
25
        auto* __restrict result_raw_data =
220
25
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
25
                        ->get_data()
222
25
                        .data();
223
224
        // set default value
225
28.9k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
                result_raw_data[i] = ColumnType::default_value();
233
28.8k
            } else {
234
28.8k
                result_raw_data[i] = {};
235
28.8k
            }
236
28.8k
        }
237
238
700
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
675
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
675
            const auto* __restrict column_raw_data =
243
675
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
675
                            then_columns[i].get())
245
675
                            ->get_data()
246
675
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
675
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.25M
                    if (then_idx[row_idx] == i) {
260
28.8k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
28.8k
                    }
262
2.25M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
675
        }
271
25
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
654
        for (auto& then_ptr : then_columns) {
215
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
654
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
654
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
654
            const auto* __restrict column_raw_data =
243
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
654
                            then_columns[i].get())
245
654
                            ->get_data()
246
654
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.23M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.23M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
654
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
654
        for (auto& then_ptr : then_columns) {
215
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
654
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
654
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
654
            const auto* __restrict column_raw_data =
243
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
654
                            then_columns[i].get())
245
654
                            ->get_data()
246
654
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.23M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.23M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
654
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
20
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
660
        for (auto& then_ptr : then_columns) {
215
660
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
660
        }
217
218
20
        result_column_ptr->resize(rows_count);
219
20
        auto* __restrict result_raw_data =
220
20
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
20
                        ->get_data()
222
20
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
680
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
660
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
660
            const auto* __restrict column_raw_data =
243
660
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
660
                            then_columns[i].get())
245
660
                            ->get_data()
246
660
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
660
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.23M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.23M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
660
        }
271
20
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
654
        for (auto& then_ptr : then_columns) {
215
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
654
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
654
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
654
            const auto* __restrict column_raw_data =
243
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
654
                            then_columns[i].get())
245
654
                            ->get_data()
246
654
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.23M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.23M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
654
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
654
        for (auto& then_ptr : then_columns) {
215
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
654
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
654
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
654
            const auto* __restrict column_raw_data =
243
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
654
                            then_columns[i].get())
245
654
                            ->get_data()
246
654
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.23M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.23M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
654
        }
271
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
213
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
214
654
        for (auto& then_ptr : then_columns) {
215
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
216
654
        }
217
218
18
        result_column_ptr->resize(rows_count);
219
18
        auto* __restrict result_raw_data =
220
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
221
18
                        ->get_data()
222
18
                        .data();
223
224
        // set default value
225
24.7k
        for (int i = 0; i < rows_count; i++) {
226
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
227
                          std::is_same_v<ColumnType, ColumnDateTime> ||
228
                          std::is_same_v<ColumnType, ColumnDateV2> ||
229
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
230
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
231
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
232
24.7k
                result_raw_data[i] = ColumnType::default_value();
233
            } else {
234
                result_raw_data[i] = {};
235
            }
236
24.7k
        }
237
238
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
239
654
            if (!then_columns[i]) {
240
0
                continue;
241
0
            }
242
654
            const auto* __restrict column_raw_data =
243
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
244
654
                            then_columns[i].get())
245
654
                            ->get_data()
246
654
                            .data();
247
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
248
                          std::is_same_v<ColumnType, ColumnFloat64> ||
249
                          std::is_same_v<ColumnType, ColumnDate> ||
250
                          std::is_same_v<ColumnType, ColumnDateTime> ||
251
                          std::is_same_v<ColumnType, ColumnDateV2> ||
252
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
253
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
254
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
256
                // Conditional stores also let the compiler vectorize without loading from a
257
                // selected source/destination pointer, as a ternary assignment can do.
258
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
259
2.23M
                    if (then_idx[row_idx] == i) {
260
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
261
24.7k
                    }
262
2.23M
                }
263
            } else {
264
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
265
                    result_raw_data[row_idx] +=
266
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
267
                            column_raw_data[row_idx];
268
                }
269
            }
270
654
        }
271
18
    }
272
273
    template <typename IndexType>
274
    ColumnPtr _execute_impl(const std::vector<ColumnPtr>& when_columns,
275
424
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
276
424
        std::vector<IndexType> then_idx(rows_count, 0);
277
424
        IndexType* __restrict then_idx_ptr = then_idx.data();
278
1.56k
        for (IndexType i = 0; i < when_columns.size(); i++) {
279
1.17k
            IndexType column_idx = i + 1;
280
1.17k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
281
282
1.17k
            if (is_consts) {
283
30
                if (raw_when_column->get_bool(0)) {
284
993
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
285
963
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
286
963
                    }
287
30
                    break;
288
30
                }
289
0
                continue;
290
30
            }
291
292
1.14k
            if (is_column_nullable(*raw_when_column)) {
293
1.06k
                const auto* column_nullable_ptr =
294
1.06k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
295
1.06k
                                raw_when_column.get());
296
1.06k
                const auto* __restrict cond_raw_data =
297
1.06k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
298
1.06k
                                column_nullable_ptr->get_nested_column_ptr().get())
299
1.06k
                                ->get_data()
300
1.06k
                                .data();
301
1.06k
                if (!column_nullable_ptr->has_null()) {
302
739k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
303
738k
                        then_idx_ptr[row_idx] |=
304
738k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
305
738k
                    }
306
1.00k
                    continue;
307
1.00k
                }
308
61
                const auto* __restrict cond_raw_nullmap =
309
61
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
310
200k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
311
200k
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
312
200k
                                              !cond_raw_nullmap[row_idx]) *
313
200k
                                             column_idx;
314
200k
                }
315
77
            } else {
316
77
                const auto* __restrict cond_raw_data =
317
77
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
318
77
                                raw_when_column.get())
319
77
                                ->get_data()
320
77
                                .data();
321
16.6k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
322
16.5k
                    then_idx_ptr[row_idx] |=
323
16.5k
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
324
16.5k
                }
325
77
            }
326
1.14k
        }
327
328
424
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
329
424
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr13_execute_implItEENS_3COWINS_7IColumnEE13immutable_ptrIS3_EERKSt6vectorIS6_SaIS6_EERS9_m
_ZNK5doris9VCaseExpr13_execute_implIhEENS_3COWINS_7IColumnEE13immutable_ptrIS3_EERKSt6vectorIS6_SaIS6_EERS9_m
Line
Count
Source
275
424
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
276
424
        std::vector<IndexType> then_idx(rows_count, 0);
277
424
        IndexType* __restrict then_idx_ptr = then_idx.data();
278
1.56k
        for (IndexType i = 0; i < when_columns.size(); i++) {
279
1.17k
            IndexType column_idx = i + 1;
280
1.17k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
281
282
1.17k
            if (is_consts) {
283
30
                if (raw_when_column->get_bool(0)) {
284
993
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
285
963
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
286
963
                    }
287
30
                    break;
288
30
                }
289
0
                continue;
290
30
            }
291
292
1.14k
            if (is_column_nullable(*raw_when_column)) {
293
1.06k
                const auto* column_nullable_ptr =
294
1.06k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
295
1.06k
                                raw_when_column.get());
296
1.06k
                const auto* __restrict cond_raw_data =
297
1.06k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
298
1.06k
                                column_nullable_ptr->get_nested_column_ptr().get())
299
1.06k
                                ->get_data()
300
1.06k
                                .data();
301
1.06k
                if (!column_nullable_ptr->has_null()) {
302
739k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
303
738k
                        then_idx_ptr[row_idx] |=
304
738k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
305
738k
                    }
306
1.00k
                    continue;
307
1.00k
                }
308
61
                const auto* __restrict cond_raw_nullmap =
309
61
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
310
200k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
311
200k
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
312
200k
                                              !cond_raw_nullmap[row_idx]) *
313
200k
                                             column_idx;
314
200k
                }
315
77
            } else {
316
77
                const auto* __restrict cond_raw_data =
317
77
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
318
77
                                raw_when_column.get())
319
77
                                ->get_data()
320
77
                                .data();
321
16.6k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
322
16.5k
                    then_idx_ptr[row_idx] |=
323
16.5k
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
324
16.5k
                }
325
77
            }
326
1.14k
        }
327
328
424
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
329
424
    }
330
331
    bool _has_else_expr;
332
333
    inline static const std::string FUNCTION_NAME = "case";
334
    inline static const std::string EXPR_NAME = "vcase expr";
335
};
336
} // namespace doris