Coverage Report

Created: 2026-09-16 10:57

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
786
                                          size_t rows_count) const {
81
786
        auto result_column_ptr = data_type()->create_column();
82
786
        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
214
                      std::is_same_v<ColumnType, ColumnIPv6>) {
93
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
214
            if (data_type()->is_nullable()) {
96
162
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
162
                                                                  then_columns, rows_count);
98
162
            } else {
99
52
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
52
                                                                   then_columns, rows_count);
101
52
            }
102
572
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
68
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
68
                                                              then_columns, rows_count);
106
504
        } else {
107
504
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
504
                                                           then_columns, rows_count);
109
504
        }
110
786
        return result_column_ptr;
111
786
    }
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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_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
11
                                          size_t rows_count) const {
81
11
        auto result_column_ptr = data_type()->create_column();
82
11
        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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
11
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
4
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
4
                                                              then_columns, rows_count);
106
7
        } else {
107
7
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
7
                                                           then_columns, rows_count);
109
7
        }
110
11
        return result_column_ptr;
111
11
    }
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
37
                                          size_t rows_count) const {
81
37
        auto result_column_ptr = data_type()->create_column();
82
37
        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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
37
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
37
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
37
                                                              then_columns, rows_count);
106
37
        } else {
107
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
0
                                                           then_columns, rows_count);
109
0
        }
110
37
        return result_column_ptr;
111
37
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
80
144
                                          size_t rows_count) const {
81
144
        auto result_column_ptr = data_type()->create_column();
82
144
        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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
144
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
17
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
17
                                                              then_columns, rows_count);
106
127
        } else {
107
127
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
127
                                                           then_columns, rows_count);
109
127
        }
110
144
        return result_column_ptr;
111
144
    }
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
26
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
1
                                                              then_columns, rows_count);
106
25
        } else {
107
25
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
25
                                                           then_columns, rows_count);
109
25
        }
110
26
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
29
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
4
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
4
                                                              then_columns, rows_count);
106
25
        } else {
107
25
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
25
                                                           then_columns, rows_count);
109
25
        }
110
29
        return result_column_ptr;
111
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
70
                                          size_t rows_count) const {
81
70
        auto result_column_ptr = data_type()->create_column();
82
70
        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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
70
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
2
                                                              then_columns, rows_count);
106
68
        } else {
107
68
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
68
                                                           then_columns, rows_count);
109
68
        }
110
70
        return result_column_ptr;
111
70
    }
_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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
2
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
2
                                                              then_columns, rows_count);
106
2
        } else {
107
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
0
                                                           then_columns, rows_count);
109
0
        }
110
2
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
1
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
1
                                                              then_columns, rows_count);
106
1
        } else {
107
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
0
                                                           then_columns, rows_count);
109
0
        }
110
1
        return result_column_ptr;
111
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
203
                                          size_t rows_count) const {
81
203
        auto result_column_ptr = data_type()->create_column();
82
203
        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
203
                      std::is_same_v<ColumnType, ColumnIPv6>) {
93
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
203
            if (data_type()->is_nullable()) {
96
151
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
151
                                                                  then_columns, rows_count);
98
151
            } else {
99
52
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
52
                                                                   then_columns, rows_count);
101
52
            }
102
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
                                                              then_columns, rows_count);
106
        } else {
107
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
                                                           then_columns, rows_count);
109
        }
110
203
        return result_column_ptr;
111
203
    }
_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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
18
    }
_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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
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
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
            if (data_type()->is_nullable()) {
96
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
                                                                  then_columns, rows_count);
98
            } else {
99
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
                                                                   then_columns, rows_count);
101
            }
102
18
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
0
                                                              then_columns, rows_count);
106
18
        } else {
107
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
18
                                                           then_columns, rows_count);
109
18
        }
110
18
        return result_column_ptr;
111
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
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
11
                                          size_t rows_count) const {
81
11
        auto result_column_ptr = data_type()->create_column();
82
11
        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
11
                      std::is_same_v<ColumnType, ColumnIPv6>) {
93
            // result_column and all then_column is not nullable.
94
            // can't simd when type is string.
95
11
            if (data_type()->is_nullable()) {
96
11
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
97
11
                                                                  then_columns, rows_count);
98
11
            } else {
99
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
100
0
                                                                   then_columns, rows_count);
101
0
            }
102
        } else if (data_type()->is_nullable()) {
103
            // result_column and all then_column is nullable.
104
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
105
                                                              then_columns, rows_count);
106
        } else {
107
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
108
                                                           then_columns, rows_count);
109
        }
110
11
        return result_column_ptr;
111
11
    }
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
112
113
    template <typename IndexType>
114
    ColumnPtr _execute_update_result(const IndexType* then_idx,
115
                                     std::vector<ColumnPtr>& then_columns,
116
497
                                     size_t rows_count) const {
117
497
#define CASE_TYPE(ptype, coltype) \
118
498
    case PrimitiveType::ptype:    \
119
498
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
120
121
497
        switch (data_type()->get_primitive_type()) {
122
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
123
11
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
124
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
125
37
            CASE_TYPE(TYPE_INT, ColumnInt32)
126
144
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
127
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
128
8
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
129
11
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
130
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
131
70
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
132
2
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
133
1
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
134
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
135
30
            CASE_TYPE(TYPE_STRING, ColumnString)
136
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
137
173
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
138
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
139
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
140
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
141
0
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
142
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
143
0
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
144
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
145
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
146
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
147
0
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
148
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
149
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
150
11
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
151
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
152
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
153
0
        case PrimitiveType::TYPE_VARIANT: {
154
0
            const IDataType* variant_type = remove_nullable(data_type()).get();
155
0
            DORIS_CHECK(dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr);
156
0
            return _execute_update_result_impl<IndexType, ColumnVariantV2>(then_idx, then_columns,
157
0
                                                                           rows_count);
158
0
        }
159
0
        default:
160
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
161
0
                            data_type()->get_name());
162
497
        }
163
497
#undef CASE_TYPE
164
497
    }
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
116
497
                                     size_t rows_count) const {
117
497
#define CASE_TYPE(ptype, coltype) \
118
497
    case PrimitiveType::ptype:    \
119
497
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
120
121
497
        switch (data_type()->get_primitive_type()) {
122
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
123
11
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
124
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
125
37
            CASE_TYPE(TYPE_INT, ColumnInt32)
126
144
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
127
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
128
8
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
129
11
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
130
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
131
70
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
132
2
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
133
1
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
134
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
135
30
            CASE_TYPE(TYPE_STRING, ColumnString)
136
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
137
173
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
138
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
139
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
140
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
141
0
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
142
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
143
0
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
144
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
145
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
146
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
147
0
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
148
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
149
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
150
11
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
151
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
152
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
153
0
        case PrimitiveType::TYPE_VARIANT: {
154
0
            const IDataType* variant_type = remove_nullable(data_type()).get();
155
0
            DORIS_CHECK(dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr);
156
0
            return _execute_update_result_impl<IndexType, ColumnVariantV2>(then_idx, then_columns,
157
0
                                                                           rows_count);
158
0
        }
159
0
        default:
160
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
161
0
                            data_type()->get_name());
162
497
        }
163
497
#undef CASE_TYPE
164
497
    }
165
166
    template <typename IndexType, typename ColumnType, bool then_null>
167
    void update_result_normal(MutableColumnPtr& result_column_ptr,
168
                              const IndexType* __restrict then_idx,
169
282
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
282
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
282
        std::vector<uint8_t> is_consts(then_columns.size());
172
282
        std::vector<uint8_t> is_nullable(then_columns.size());
173
1.60k
        for (size_t i = 0; i < then_columns.size(); i++) {
174
1.32k
            if (!then_columns[i]) {
175
30
                continue;
176
30
            }
177
1.29k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
1.29k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
1.29k
        }
180
181
282
        auto* raw_result_column = result_column_ptr.get();
182
4.60k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
4.32k
            if (!_has_else_expr && !then_idx[row_idx]) {
184
13
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
13
                        ->insert_default();
186
13
                continue;
187
13
            }
188
4.31k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
4.31k
            if constexpr (then_null) {
190
4.15k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
4.15k
                        result_column_ptr.get());
192
4.15k
                if (is_nullable[then_idx[row_idx]]) {
193
394
                    nullable->insert_from_with_type<ColumnType>(
194
394
                            *raw_then_columns[then_idx[row_idx]], target);
195
3.75k
                } else {
196
3.75k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
3.75k
                            nullable->get_nested_column_ptr().get());
198
3.75k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
3.75k
                    nullable->push_false_to_nullmap(1);
200
3.75k
                }
201
4.15k
            } else {
202
162
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
162
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
162
            }
205
4.31k
        }
206
282
    }
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_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
169
4
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
4
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
4
        std::vector<uint8_t> is_consts(then_columns.size());
172
4
        std::vector<uint8_t> is_nullable(then_columns.size());
173
11
        for (size_t i = 0; i < then_columns.size(); i++) {
174
7
            if (!then_columns[i]) {
175
2
                continue;
176
2
            }
177
5
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
5
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
5
        }
180
181
4
        auto* raw_result_column = result_column_ptr.get();
182
9
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
5
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
5
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
5
            if constexpr (then_null) {
190
5
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
5
                        result_column_ptr.get());
192
5
                if (is_nullable[then_idx[row_idx]]) {
193
2
                    nullable->insert_from_with_type<ColumnType>(
194
2
                            *raw_then_columns[then_idx[row_idx]], target);
195
3
                } else {
196
3
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
3
                            nullable->get_nested_column_ptr().get());
198
3
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
3
                    nullable->push_false_to_nullmap(1);
200
3
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
5
        }
206
4
    }
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
169
37
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
37
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
37
        std::vector<uint8_t> is_consts(then_columns.size());
172
37
        std::vector<uint8_t> is_nullable(then_columns.size());
173
91
        for (size_t i = 0; i < then_columns.size(); i++) {
174
54
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
54
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
54
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
54
        }
180
181
37
        auto* raw_result_column = result_column_ptr.get();
182
88
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
51
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
51
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
51
            if constexpr (then_null) {
190
51
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
51
                        result_column_ptr.get());
192
51
                if (is_nullable[then_idx[row_idx]]) {
193
51
                    nullable->insert_from_with_type<ColumnType>(
194
51
                            *raw_then_columns[then_idx[row_idx]], target);
195
51
                } else {
196
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
0
                            nullable->get_nested_column_ptr().get());
198
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
0
                    nullable->push_false_to_nullmap(1);
200
0
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
51
        }
206
37
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
169
17
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
17
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
17
        std::vector<uint8_t> is_consts(then_columns.size());
172
17
        std::vector<uint8_t> is_nullable(then_columns.size());
173
48
        for (size_t i = 0; i < then_columns.size(); i++) {
174
31
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
31
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
31
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
31
        }
180
181
17
        auto* raw_result_column = result_column_ptr.get();
182
39
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
22
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
22
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
22
            if constexpr (then_null) {
190
22
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
22
                        result_column_ptr.get());
192
22
                if (is_nullable[then_idx[row_idx]]) {
193
22
                    nullable->insert_from_with_type<ColumnType>(
194
22
                            *raw_then_columns[then_idx[row_idx]], target);
195
22
                } else {
196
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
0
                            nullable->get_nested_column_ptr().get());
198
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
0
                    nullable->push_false_to_nullmap(1);
200
0
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
22
        }
206
17
    }
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
169
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
1
        std::vector<uint8_t> is_consts(then_columns.size());
172
1
        std::vector<uint8_t> is_nullable(then_columns.size());
173
4
        for (size_t i = 0; i < then_columns.size(); i++) {
174
3
            if (!then_columns[i]) {
175
1
                continue;
176
1
            }
177
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
2
        }
180
181
1
        auto* raw_result_column = result_column_ptr.get();
182
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
3
            if (!_has_else_expr && !then_idx[row_idx]) {
184
1
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
1
                        ->insert_default();
186
1
                continue;
187
1
            }
188
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
2
            if constexpr (then_null) {
190
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
2
                        result_column_ptr.get());
192
2
                if (is_nullable[then_idx[row_idx]]) {
193
0
                    nullable->insert_from_with_type<ColumnType>(
194
0
                            *raw_then_columns[then_idx[row_idx]], target);
195
2
                } else {
196
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
2
                            nullable->get_nested_column_ptr().get());
198
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
2
                    nullable->push_false_to_nullmap(1);
200
2
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
2
        }
206
1
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
169
4
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
4
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
4
        std::vector<uint8_t> is_consts(then_columns.size());
172
4
        std::vector<uint8_t> is_nullable(then_columns.size());
173
15
        for (size_t i = 0; i < then_columns.size(); i++) {
174
11
            if (!then_columns[i]) {
175
1
                continue;
176
1
            }
177
10
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
10
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
10
        }
180
181
4
        auto* raw_result_column = result_column_ptr.get();
182
17
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
13
            if (!_has_else_expr && !then_idx[row_idx]) {
184
1
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
1
                        ->insert_default();
186
1
                continue;
187
1
            }
188
12
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
12
            if constexpr (then_null) {
190
12
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
12
                        result_column_ptr.get());
192
12
                if (is_nullable[then_idx[row_idx]]) {
193
7
                    nullable->insert_from_with_type<ColumnType>(
194
7
                            *raw_then_columns[then_idx[row_idx]], target);
195
7
                } else {
196
5
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
5
                            nullable->get_nested_column_ptr().get());
198
5
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
5
                    nullable->push_false_to_nullmap(1);
200
5
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
12
        }
206
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
169
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
2
        std::vector<uint8_t> is_consts(then_columns.size());
172
2
        std::vector<uint8_t> is_nullable(then_columns.size());
173
5
        for (size_t i = 0; i < then_columns.size(); i++) {
174
3
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
3
        }
180
181
2
        auto* raw_result_column = result_column_ptr.get();
182
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
2
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
2
            if constexpr (then_null) {
190
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
2
                        result_column_ptr.get());
192
2
                if (is_nullable[then_idx[row_idx]]) {
193
2
                    nullable->insert_from_with_type<ColumnType>(
194
2
                            *raw_then_columns[then_idx[row_idx]], target);
195
2
                } else {
196
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
0
                            nullable->get_nested_column_ptr().get());
198
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
0
                    nullable->push_false_to_nullmap(1);
200
0
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
2
        }
206
2
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
169
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
2
        std::vector<uint8_t> is_consts(then_columns.size());
172
2
        std::vector<uint8_t> is_nullable(then_columns.size());
173
8
        for (size_t i = 0; i < then_columns.size(); i++) {
174
6
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
6
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
6
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
6
        }
180
181
2
        auto* raw_result_column = result_column_ptr.get();
182
6
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
4
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
4
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
4
            if constexpr (then_null) {
190
4
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
4
                        result_column_ptr.get());
192
4
                if (is_nullable[then_idx[row_idx]]) {
193
4
                    nullable->insert_from_with_type<ColumnType>(
194
4
                            *raw_then_columns[then_idx[row_idx]], target);
195
4
                } else {
196
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
0
                            nullable->get_nested_column_ptr().get());
198
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
0
                    nullable->push_false_to_nullmap(1);
200
0
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
4
        }
206
2
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
169
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
1
        std::vector<uint8_t> is_consts(then_columns.size());
172
1
        std::vector<uint8_t> is_nullable(then_columns.size());
173
3
        for (size_t i = 0; i < then_columns.size(); i++) {
174
2
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
2
        }
180
181
1
        auto* raw_result_column = result_column_ptr.get();
182
2
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
1
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
1
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
1
            if constexpr (then_null) {
190
1
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
1
                        result_column_ptr.get());
192
1
                if (is_nullable[then_idx[row_idx]]) {
193
1
                    nullable->insert_from_with_type<ColumnType>(
194
1
                            *raw_then_columns[then_idx[row_idx]], target);
195
1
                } else {
196
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
0
                            nullable->get_nested_column_ptr().get());
198
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
0
                    nullable->push_false_to_nullmap(1);
200
0
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
1
        }
206
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
169
151
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
151
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
151
        std::vector<uint8_t> is_consts(then_columns.size());
172
151
        std::vector<uint8_t> is_nullable(then_columns.size());
173
1.21k
        for (size_t i = 0; i < then_columns.size(); i++) {
174
1.06k
            if (!then_columns[i]) {
175
26
                continue;
176
26
            }
177
1.03k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
1.03k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
1.03k
        }
180
181
151
        auto* raw_result_column = result_column_ptr.get();
182
4.19k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
4.04k
            if (!_has_else_expr && !then_idx[row_idx]) {
184
11
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
11
                        ->insert_default();
186
11
                continue;
187
11
            }
188
4.03k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
4.03k
            if constexpr (then_null) {
190
4.03k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
4.03k
                        result_column_ptr.get());
192
4.03k
                if (is_nullable[then_idx[row_idx]]) {
193
303
                    nullable->insert_from_with_type<ColumnType>(
194
303
                            *raw_then_columns[then_idx[row_idx]], target);
195
3.73k
                } else {
196
3.73k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
3.73k
                            nullable->get_nested_column_ptr().get());
198
3.73k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
3.73k
                    nullable->push_false_to_nullmap(1);
200
3.73k
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
4.03k
        }
206
151
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
169
52
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
52
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
52
        std::vector<uint8_t> is_consts(then_columns.size());
172
52
        std::vector<uint8_t> is_nullable(then_columns.size());
173
174
        for (size_t i = 0; i < then_columns.size(); i++) {
174
122
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
122
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
122
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
122
        }
180
181
52
        auto* raw_result_column = result_column_ptr.get();
182
214
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
162
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
162
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
            if constexpr (then_null) {
190
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
                        result_column_ptr.get());
192
                if (is_nullable[then_idx[row_idx]]) {
193
                    nullable->insert_from_with_type<ColumnType>(
194
                            *raw_then_columns[then_idx[row_idx]], target);
195
                } else {
196
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
                            nullable->get_nested_column_ptr().get());
198
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
                    nullable->push_false_to_nullmap(1);
200
                }
201
162
            } else {
202
162
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
162
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
162
            }
205
162
        }
206
52
    }
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
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
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
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
169
11
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
170
11
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
171
11
        std::vector<uint8_t> is_consts(then_columns.size());
172
11
        std::vector<uint8_t> is_nullable(then_columns.size());
173
31
        for (size_t i = 0; i < then_columns.size(); i++) {
174
20
            if (!then_columns[i]) {
175
0
                continue;
176
0
            }
177
20
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
178
20
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
179
20
        }
180
181
11
        auto* raw_result_column = result_column_ptr.get();
182
26
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
183
15
            if (!_has_else_expr && !then_idx[row_idx]) {
184
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
185
0
                        ->insert_default();
186
0
                continue;
187
0
            }
188
15
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
189
15
            if constexpr (then_null) {
190
15
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
191
15
                        result_column_ptr.get());
192
15
                if (is_nullable[then_idx[row_idx]]) {
193
2
                    nullable->insert_from_with_type<ColumnType>(
194
2
                            *raw_then_columns[then_idx[row_idx]], target);
195
13
                } else {
196
13
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
197
13
                            nullable->get_nested_column_ptr().get());
198
13
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
199
13
                    nullable->push_false_to_nullmap(1);
200
13
                }
201
            } else {
202
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
203
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
204
            }
205
15
        }
206
11
    }
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
207
208
    template <typename IndexType, typename ColumnType>
209
    void update_result_auto_simd(MutableColumnPtr& result_column_ptr,
210
                                 const IndexType* __restrict then_idx,
211
504
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
10.9k
        for (auto& then_ptr : then_columns) {
213
10.9k
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
10.9k
        }
215
216
504
        result_column_ptr->resize(rows_count);
217
504
        auto* __restrict result_raw_data =
218
504
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
504
                        ->get_data()
220
504
                        .data();
221
222
        // set default value
223
405k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
297k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
297k
                result_raw_data[i] = ColumnType::default_value();
231
297k
            } else {
232
107k
                result_raw_data[i] = {};
233
107k
            }
234
404k
        }
235
236
11.4k
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
10.9k
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
10.9k
            const auto* __restrict column_raw_data =
241
10.9k
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
10.9k
                            then_columns[i].get())
243
10.9k
                            ->get_data()
244
10.9k
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
10.5k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
35.9M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
35.9M
                    if (then_idx[row_idx] == i) {
258
404k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
404k
                    }
260
35.9M
                }
261
10.5k
            } else {
262
1.29k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
923
                    result_raw_data[row_idx] +=
264
923
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
923
                            column_raw_data[row_idx];
266
923
                }
267
371
            }
268
10.9k
        }
269
504
    }
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
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
24.7k
            } else {
232
24.7k
                result_raw_data[i] = {};
233
24.7k
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
24.7k
            } else {
232
24.7k
                result_raw_data[i] = {};
233
24.7k
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
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
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
658
        for (auto& then_ptr : then_columns) {
213
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
658
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
658
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
658
            const auto* __restrict column_raw_data =
241
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
658
                            then_columns[i].get())
243
658
                            ->get_data()
244
658
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
658
        }
269
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
211
7
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
11
        for (auto& then_ptr : then_columns) {
213
11
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
11
        }
215
216
7
        result_column_ptr->resize(rows_count);
217
7
        auto* __restrict result_raw_data =
218
7
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
7
                        ->get_data()
220
7
                        .data();
221
222
        // set default value
223
19
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
12
            } else {
232
12
                result_raw_data[i] = {};
233
12
            }
234
12
        }
235
236
18
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
11
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
11
            const auto* __restrict column_raw_data =
241
11
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
11
                            then_columns[i].get())
243
11
                            ->get_data()
244
11
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
                    if (then_idx[row_idx] == i) {
258
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
                    }
260
                }
261
11
            } else {
262
30
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
19
                    result_raw_data[row_idx] +=
264
19
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
19
                            column_raw_data[row_idx];
266
19
                }
267
11
            }
268
11
        }
269
7
    }
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
211
127
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
196
        for (auto& then_ptr : then_columns) {
213
196
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
196
        }
215
216
127
        result_column_ptr->resize(rows_count);
217
127
        auto* __restrict result_raw_data =
218
127
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
127
                        ->get_data()
220
127
                        .data();
221
222
        // set default value
223
449
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
322
            } else {
232
322
                result_raw_data[i] = {};
233
322
            }
234
322
        }
235
236
323
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
196
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
196
            const auto* __restrict column_raw_data =
241
196
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
196
                            then_columns[i].get())
243
196
                            ->get_data()
244
196
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
                    if (then_idx[row_idx] == i) {
258
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
                    }
260
                }
261
196
            } else {
262
796
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
600
                    result_raw_data[row_idx] +=
264
600
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
600
                            column_raw_data[row_idx];
266
600
                }
267
196
            }
268
196
        }
269
127
    }
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
211
25
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
675
        for (auto& then_ptr : then_columns) {
213
675
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
675
        }
215
216
25
        result_column_ptr->resize(rows_count);
217
25
        auto* __restrict result_raw_data =
218
25
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
25
                        ->get_data()
220
25
                        .data();
221
222
        // set default value
223
28.9k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
28.8k
            } else {
232
28.8k
                result_raw_data[i] = {};
233
28.8k
            }
234
28.8k
        }
235
236
700
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
675
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
675
            const auto* __restrict column_raw_data =
241
675
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
675
                            then_columns[i].get())
243
675
                            ->get_data()
244
675
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
675
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
28.8k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
28.8k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
675
        }
269
25
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
25
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
675
        for (auto& then_ptr : then_columns) {
213
675
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
675
        }
215
216
25
        result_column_ptr->resize(rows_count);
217
25
        auto* __restrict result_raw_data =
218
25
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
25
                        ->get_data()
220
25
                        .data();
221
222
        // set default value
223
28.9k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
28.8k
            } else {
232
28.8k
                result_raw_data[i] = {};
233
28.8k
            }
234
28.8k
        }
235
236
700
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
675
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
675
            const auto* __restrict column_raw_data =
241
675
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
675
                            then_columns[i].get())
243
675
                            ->get_data()
244
675
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
675
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.25M
                    if (then_idx[row_idx] == i) {
258
28.8k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
28.8k
                    }
260
2.25M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
675
        }
269
25
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
68
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
164
        for (auto& then_ptr : then_columns) {
213
164
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
164
        }
215
216
68
        result_column_ptr->resize(rows_count);
217
68
        auto* __restrict result_raw_data =
218
68
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
68
                        ->get_data()
220
68
                        .data();
221
222
        // set default value
223
184
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
                result_raw_data[i] = ColumnType::default_value();
231
116
            } else {
232
116
                result_raw_data[i] = {};
233
116
            }
234
116
        }
235
236
232
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
164
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
164
            const auto* __restrict column_raw_data =
241
164
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
164
                            then_columns[i].get())
243
164
                            ->get_data()
244
164
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
                    if (then_idx[row_idx] == i) {
258
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
                    }
260
                }
261
164
            } else {
262
468
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
304
                    result_raw_data[row_idx] +=
264
304
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
304
                            column_raw_data[row_idx];
266
304
                }
267
164
            }
268
164
        }
269
68
    }
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
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
654
        for (auto& then_ptr : then_columns) {
213
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
654
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
654
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
654
            const auto* __restrict column_raw_data =
241
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
654
                            then_columns[i].get())
243
654
                            ->get_data()
244
654
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.23M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.23M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
654
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
654
        for (auto& then_ptr : then_columns) {
213
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
654
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
654
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
654
            const auto* __restrict column_raw_data =
241
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
654
                            then_columns[i].get())
243
654
                            ->get_data()
244
654
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.23M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.23M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
654
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
654
        for (auto& then_ptr : then_columns) {
213
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
654
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
654
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
654
            const auto* __restrict column_raw_data =
241
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
654
                            then_columns[i].get())
243
654
                            ->get_data()
244
654
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.23M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.23M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
654
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
654
        for (auto& then_ptr : then_columns) {
213
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
654
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
654
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
654
            const auto* __restrict column_raw_data =
241
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
654
                            then_columns[i].get())
243
654
                            ->get_data()
244
654
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.23M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.23M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
654
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
654
        for (auto& then_ptr : then_columns) {
213
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
654
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
654
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
654
            const auto* __restrict column_raw_data =
241
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
654
                            then_columns[i].get())
243
654
                            ->get_data()
244
654
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.23M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.23M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
654
        }
269
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
211
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
212
654
        for (auto& then_ptr : then_columns) {
213
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
214
654
        }
215
216
18
        result_column_ptr->resize(rows_count);
217
18
        auto* __restrict result_raw_data =
218
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
219
18
                        ->get_data()
220
18
                        .data();
221
222
        // set default value
223
24.7k
        for (int i = 0; i < rows_count; i++) {
224
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
225
                          std::is_same_v<ColumnType, ColumnDateTime> ||
226
                          std::is_same_v<ColumnType, ColumnDateV2> ||
227
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
228
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
229
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
230
24.7k
                result_raw_data[i] = ColumnType::default_value();
231
            } else {
232
                result_raw_data[i] = {};
233
            }
234
24.7k
        }
235
236
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
237
654
            if (!then_columns[i]) {
238
0
                continue;
239
0
            }
240
654
            const auto* __restrict column_raw_data =
241
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
242
654
                            then_columns[i].get())
243
654
                            ->get_data()
244
654
                            .data();
245
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
246
                          std::is_same_v<ColumnType, ColumnFloat64> ||
247
                          std::is_same_v<ColumnType, ColumnDate> ||
248
                          std::is_same_v<ColumnType, ColumnDateTime> ||
249
                          std::is_same_v<ColumnType, ColumnDateV2> ||
250
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
251
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
252
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
253
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
254
                // Conditional stores also let the compiler vectorize without loading from a
255
                // selected source/destination pointer, as a ternary assignment can do.
256
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
257
2.23M
                    if (then_idx[row_idx] == i) {
258
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
259
24.7k
                    }
260
2.23M
                }
261
            } else {
262
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
263
                    result_raw_data[row_idx] +=
264
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
265
                            column_raw_data[row_idx];
266
                }
267
            }
268
654
        }
269
18
    }
270
271
    template <typename IndexType>
272
    ColumnPtr _execute_impl(const std::vector<ColumnPtr>& when_columns,
273
497
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
274
497
        std::vector<IndexType> then_idx(rows_count, 0);
275
497
        IndexType* __restrict then_idx_ptr = then_idx.data();
276
1.70k
        for (IndexType i = 0; i < when_columns.size(); i++) {
277
1.23k
            IndexType column_idx = i + 1;
278
1.23k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
279
280
1.23k
            if (is_consts) {
281
30
                if (raw_when_column->get_bool(0)) {
282
993
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
283
963
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
284
963
                    }
285
30
                    break;
286
30
                }
287
0
                continue;
288
30
            }
289
290
1.20k
            if (is_column_nullable(*raw_when_column)) {
291
1.07k
                const auto* column_nullable_ptr =
292
1.07k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
293
1.07k
                                raw_when_column.get());
294
1.07k
                const auto* __restrict cond_raw_data =
295
1.07k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
296
1.07k
                                column_nullable_ptr->get_nested_column_ptr().get())
297
1.07k
                                ->get_data()
298
1.07k
                                .data();
299
1.07k
                if (!column_nullable_ptr->has_null()) {
300
28.4k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
301
27.4k
                        then_idx_ptr[row_idx] |=
302
27.4k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
303
27.4k
                    }
304
1.01k
                    continue;
305
1.01k
                }
306
64
                const auto* __restrict cond_raw_nullmap =
307
64
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
308
364
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
309
300
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
310
300
                                              !cond_raw_nullmap[row_idx]) *
311
300
                                             column_idx;
312
300
                }
313
131
            } else {
314
131
                const auto* __restrict cond_raw_data =
315
131
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
316
131
                                raw_when_column.get())
317
131
                                ->get_data()
318
131
                                .data();
319
16.8k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
320
16.7k
                    then_idx_ptr[row_idx] |=
321
16.7k
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
322
16.7k
                }
323
131
            }
324
1.20k
        }
325
326
497
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
327
497
    }
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
273
497
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
274
497
        std::vector<IndexType> then_idx(rows_count, 0);
275
497
        IndexType* __restrict then_idx_ptr = then_idx.data();
276
1.70k
        for (IndexType i = 0; i < when_columns.size(); i++) {
277
1.23k
            IndexType column_idx = i + 1;
278
1.23k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
279
280
1.23k
            if (is_consts) {
281
30
                if (raw_when_column->get_bool(0)) {
282
993
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
283
963
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
284
963
                    }
285
30
                    break;
286
30
                }
287
0
                continue;
288
30
            }
289
290
1.20k
            if (is_column_nullable(*raw_when_column)) {
291
1.07k
                const auto* column_nullable_ptr =
292
1.07k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
293
1.07k
                                raw_when_column.get());
294
1.07k
                const auto* __restrict cond_raw_data =
295
1.07k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
296
1.07k
                                column_nullable_ptr->get_nested_column_ptr().get())
297
1.07k
                                ->get_data()
298
1.07k
                                .data();
299
1.07k
                if (!column_nullable_ptr->has_null()) {
300
28.4k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
301
27.4k
                        then_idx_ptr[row_idx] |=
302
27.4k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
303
27.4k
                    }
304
1.01k
                    continue;
305
1.01k
                }
306
64
                const auto* __restrict cond_raw_nullmap =
307
64
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
308
364
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
309
300
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
310
300
                                              !cond_raw_nullmap[row_idx]) *
311
300
                                             column_idx;
312
300
                }
313
131
            } else {
314
131
                const auto* __restrict cond_raw_data =
315
131
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
316
131
                                raw_when_column.get())
317
131
                                ->get_data()
318
131
                                .data();
319
16.8k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
320
16.7k
                    then_idx_ptr[row_idx] |=
321
16.7k
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
322
16.7k
                }
323
131
            }
324
1.20k
        }
325
326
497
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
327
497
    }
328
329
    bool _has_else_expr;
330
331
    inline static const std::string FUNCTION_NAME = "case";
332
    inline static const std::string EXPR_NAME = "vcase expr";
333
};
334
} // namespace doris