Coverage Report

Created: 2026-10-31 01:00

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_spatial.h"
31
#include "core/column/column_struct.h"
32
#include "core/column/column_varbinary.h"
33
#include "core/column/variant_v2/column_variant_v2.h"
34
#include "core/data_type/data_type_nullable.h"
35
#include "core/data_type/data_type_variant_v2.h"
36
#include "core/data_type/define_primitive_type.h"
37
#include "core/data_type/primitive_type.h"
38
#include "exprs/function/function.h"
39
#include "exprs/function_context.h"
40
#include "exprs/vexpr.h"
41
42
namespace doris {
43
class RowDescriptor;
44
class RuntimeState;
45
class TExprNode;
46
47
class Block;
48
} // namespace doris
49
50
namespace doris {
51
52
class VCaseExpr final : public VExpr {
53
    ENABLE_FACTORY_CREATOR(VCaseExpr);
54
55
public:
56
    VCaseExpr(const TExprNode& node);
57
    ~VCaseExpr() override = default;
58
    Status execute_column_impl(VExprContext* context, const Block* block, const Selector* selector,
59
                               size_t count, ColumnPtr& result_column) const override;
60
    Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override;
61
    Status open(RuntimeState* state, VExprContext* context,
62
                FunctionContext::FunctionStateScope scope) override;
63
    void close(VExprContext* context, FunctionContext::FunctionStateScope scope) override;
64
    const std::string& expr_name() const override;
65
    std::string debug_string() const override;
66
0
    bool has_else_expr() const { return _has_else_expr; }
67
1
    Status clone_node(VExprSPtr* cloned_expr) const override {
68
1
        DORIS_CHECK(cloned_expr != nullptr);
69
1
        auto node = clone_texpr_node();
70
1
        TCaseExpr case_node;
71
1
        case_node.__set_has_case_expr(false);
72
1
        case_node.__set_has_else_expr(_has_else_expr);
73
1
        node.__set_case_expr(case_node);
74
1
        *cloned_expr = VCaseExpr::create_shared(node);
75
1
        return Status::OK();
76
1
    }
77
78
private:
79
    template <typename IndexType, typename ColumnType>
80
    ColumnPtr _execute_update_result_impl(const IndexType* then_idx,
81
                                          std::vector<ColumnPtr>& then_columns,
82
1.98k
                                          size_t rows_count) const {
83
1.98k
        auto result_column_ptr = data_type()->create_column();
84
1.98k
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
1.46k
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
1.46k
            if (data_type()->is_nullable()) {
103
1.37k
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
1.37k
                                                                  then_columns, rows_count);
105
1.37k
            } else {
106
87
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
87
                                                                   then_columns, rows_count);
108
87
            }
109
1.46k
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
75
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
75
                                                              then_columns, rows_count);
113
445
        } else {
114
445
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
445
                                                           then_columns, rows_count);
116
445
        }
117
1.98k
        return result_column_ptr;
118
1.98k
    }
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
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
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
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_15ColumnVarbinaryEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE44EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnSpatialEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_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
82
7
                                          size_t rows_count) const {
83
7
        auto result_column_ptr = data_type()->create_column();
84
7
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
7
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
3
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
3
                                                              then_columns, rows_count);
113
4
        } else {
114
4
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
4
                                                           then_columns, rows_count);
116
4
        }
117
7
        return result_column_ptr;
118
7
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
38
                                          size_t rows_count) const {
83
38
        auto result_column_ptr = data_type()->create_column();
84
38
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
38
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
32
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
32
                                                              then_columns, rows_count);
113
32
        } else {
114
6
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
6
                                                           then_columns, rows_count);
116
6
        }
117
38
        return result_column_ptr;
118
38
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
160
                                          size_t rows_count) const {
83
160
        auto result_column_ptr = data_type()->create_column();
84
160
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
160
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
31
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
31
                                                              then_columns, rows_count);
113
129
        } else {
114
129
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
129
                                                           then_columns, rows_count);
116
129
        }
117
160
        return result_column_ptr;
118
160
    }
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
82
26
                                          size_t rows_count) const {
83
26
        auto result_column_ptr = data_type()->create_column();
84
26
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
26
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
1
                                                              then_columns, rows_count);
113
25
        } else {
114
25
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
25
                                                           then_columns, rows_count);
116
25
        }
117
26
        return result_column_ptr;
118
26
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
31
                                          size_t rows_count) const {
83
31
        auto result_column_ptr = data_type()->create_column();
84
31
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
31
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
4
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
4
                                                              then_columns, rows_count);
113
27
        } else {
114
27
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
27
                                                           then_columns, rows_count);
116
27
        }
117
31
        return result_column_ptr;
118
31
    }
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
82
1
                                          size_t rows_count) const {
83
1
        auto result_column_ptr = data_type()->create_column();
84
1
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
1
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
1
                                                              then_columns, rows_count);
113
1
        } else {
114
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
0
                                                           then_columns, rows_count);
116
0
        }
117
1
        return result_column_ptr;
118
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
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
82
1.42k
                                          size_t rows_count) const {
83
1.42k
        auto result_column_ptr = data_type()->create_column();
84
1.42k
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
1.42k
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
1.42k
            if (data_type()->is_nullable()) {
103
1.33k
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
1.33k
                                                                  then_columns, rows_count);
105
1.33k
            } else {
106
83
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
83
                                                                   then_columns, rows_count);
108
83
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
1.42k
        return result_column_ptr;
118
1.42k
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_15ColumnVarbinaryEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Line
Count
Source
82
12
                                          size_t rows_count) const {
83
12
        auto result_column_ptr = data_type()->create_column();
84
12
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
12
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
12
            if (data_type()->is_nullable()) {
103
10
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
10
                                                                  then_columns, rows_count);
105
10
            } else {
106
2
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
2
                                                                   then_columns, rows_count);
108
2
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
12
        return result_column_ptr;
118
12
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
20
                                          size_t rows_count) const {
83
20
        auto result_column_ptr = data_type()->create_column();
84
20
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
20
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
20
        } else {
114
20
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
20
                                                           then_columns, rows_count);
116
20
        }
117
20
        return result_column_ptr;
118
20
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
21
                                          size_t rows_count) const {
83
21
        auto result_column_ptr = data_type()->create_column();
84
21
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
21
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
3
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
3
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
21
        return result_column_ptr;
118
21
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
18
                                          size_t rows_count) const {
83
18
        auto result_column_ptr = data_type()->create_column();
84
18
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
            if (data_type()->is_nullable()) {
103
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
                                                                  then_columns, rows_count);
105
            } else {
106
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
                                                                   then_columns, rows_count);
108
            }
109
18
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
0
                                                              then_columns, rows_count);
113
18
        } else {
114
18
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
18
                                                           then_columns, rows_count);
116
18
        }
117
18
        return result_column_ptr;
118
18
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE44EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
12
                                          size_t rows_count) const {
83
12
        auto result_column_ptr = data_type()->create_column();
84
12
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
12
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
12
            if (data_type()->is_nullable()) {
103
12
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
12
                                                                  then_columns, rows_count);
105
12
            } else {
106
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
0
                                                                   then_columns, rows_count);
108
0
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
12
        return result_column_ptr;
118
12
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnSpatialEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Line
Count
Source
82
12
                                          size_t rows_count) const {
83
12
        auto result_column_ptr = data_type()->create_column();
84
12
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
12
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
12
            if (data_type()->is_nullable()) {
103
10
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
10
                                                                  then_columns, rows_count);
105
10
            } else {
106
2
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
2
                                                                   then_columns, rows_count);
108
2
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
12
        return result_column_ptr;
118
12
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Line
Count
Source
82
1
                                          size_t rows_count) const {
83
1
        auto result_column_ptr = data_type()->create_column();
84
1
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
1
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
1
            if (data_type()->is_nullable()) {
103
1
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
1
                                                                  then_columns, rows_count);
105
1
            } else {
106
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
0
                                                                   then_columns, rows_count);
108
0
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
1
        return result_column_ptr;
118
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_9ColumnMapEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnStructEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
7
                                          size_t rows_count) const {
83
7
        auto result_column_ptr = data_type()->create_column();
84
7
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
7
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
7
            if (data_type()->is_nullable()) {
103
7
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
7
                                                                  then_columns, rows_count);
105
7
            } else {
106
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
0
                                                                   then_columns, rows_count);
108
0
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
7
        return result_column_ptr;
118
7
    }
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
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_15ColumnVariantV2EEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Line
Count
Source
82
1
                                          size_t rows_count) const {
83
1
        auto result_column_ptr = data_type()->create_column();
84
1
        result_column_ptr->reserve(rows_count);
85
        // Spatial StringViews require insert_from to copy WKB into the result's arena;
86
        // the fixed-width SIMD path would copy only the views.
87
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
88
                      std::is_same_v<ColumnType, ColumnVarbinary> ||
89
                      std::is_same_v<ColumnType, ColumnBitmap> ||
90
                      std::is_same_v<ColumnType, ColumnArray> ||
91
                      std::is_same_v<ColumnType, ColumnMap> ||
92
                      std::is_same_v<ColumnType, ColumnStruct> ||
93
                      std::is_same_v<ColumnType, ColumnSpatial> ||
94
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
95
                      std::is_same_v<ColumnType, ColumnHLL> ||
96
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
97
                      std::is_same_v<ColumnType, ColumnIPv4> ||
98
                      std::is_same_v<ColumnType, ColumnIPv6> ||
99
1
                      std::is_same_v<ColumnType, ColumnUUID>) {
100
            // result_column and all then_column is not nullable.
101
            // can't simd when type is string.
102
1
            if (data_type()->is_nullable()) {
103
1
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
104
1
                                                                  then_columns, rows_count);
105
1
            } else {
106
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
107
0
                                                                   then_columns, rows_count);
108
0
            }
109
        } else if (data_type()->is_nullable()) {
110
            // result_column and all then_column is nullable.
111
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
112
                                                              then_columns, rows_count);
113
        } else {
114
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
115
                                                           then_columns, rows_count);
116
        }
117
1
        return result_column_ptr;
118
1
    }
119
120
    template <typename IndexType>
121
    ColumnPtr _execute_update_result(const IndexType* then_idx,
122
                                     std::vector<ColumnPtr>& then_columns,
123
1.69k
                                     size_t rows_count) const {
124
1.69k
#define CASE_TYPE(ptype, coltype) \
125
1.69k
    case PrimitiveType::ptype:    \
126
1.69k
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
127
128
1.69k
        switch (data_type()->get_primitive_type()) {
129
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
130
7
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
131
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
132
38
            CASE_TYPE(TYPE_INT, ColumnInt32)
133
160
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
134
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
135
8
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
136
13
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
137
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
138
1
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
139
0
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
140
0
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
141
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
142
0
            CASE_TYPE(TYPE_STRING, ColumnString)
143
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
144
1.42k
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
145
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
146
12
            CASE_TYPE(TYPE_VARBINARY, ColumnVarbinary)
147
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
148
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
149
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
150
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
151
3
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
152
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
153
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
154
12
            CASE_TYPE(TYPE_UUID, ColumnUUID)
155
6
            CASE_TYPE(TYPE_GEOMETRY, ColumnSpatial)
156
6
            CASE_TYPE(TYPE_GEOGRAPHY, ColumnSpatial)
157
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
158
1
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
159
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
160
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
161
7
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
162
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
163
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
164
1
        case PrimitiveType::TYPE_VARIANT: {
165
1
            const IDataType* variant_type = remove_nullable(data_type()).get();
166
1
            DORIS_CHECK(dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr);
167
1
            return _execute_update_result_impl<IndexType, ColumnVariantV2>(then_idx, then_columns,
168
1
                                                                           rows_count);
169
0
        }
170
0
        default:
171
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
172
0
                            data_type()->get_name());
173
1.69k
        }
174
1.69k
#undef CASE_TYPE
175
1.69k
    }
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
123
1.69k
                                     size_t rows_count) const {
124
1.69k
#define CASE_TYPE(ptype, coltype) \
125
1.69k
    case PrimitiveType::ptype:    \
126
1.69k
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
127
128
1.69k
        switch (data_type()->get_primitive_type()) {
129
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
130
7
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
131
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
132
38
            CASE_TYPE(TYPE_INT, ColumnInt32)
133
160
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
134
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
135
8
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
136
13
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
137
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
138
1
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
139
0
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
140
0
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
141
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
142
0
            CASE_TYPE(TYPE_STRING, ColumnString)
143
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
144
1.42k
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
145
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
146
12
            CASE_TYPE(TYPE_VARBINARY, ColumnVarbinary)
147
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
148
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
149
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
150
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
151
3
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
152
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
153
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
154
12
            CASE_TYPE(TYPE_UUID, ColumnUUID)
155
6
            CASE_TYPE(TYPE_GEOMETRY, ColumnSpatial)
156
6
            CASE_TYPE(TYPE_GEOGRAPHY, ColumnSpatial)
157
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
158
1
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
159
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
160
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
161
7
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
162
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
163
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
164
1
        case PrimitiveType::TYPE_VARIANT: {
165
1
            const IDataType* variant_type = remove_nullable(data_type()).get();
166
1
            DORIS_CHECK(dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr);
167
1
            return _execute_update_result_impl<IndexType, ColumnVariantV2>(then_idx, then_columns,
168
1
                                                                           rows_count);
169
0
        }
170
0
        default:
171
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
172
0
                            data_type()->get_name());
173
1.69k
        }
174
1.69k
#undef CASE_TYPE
175
1.69k
    }
176
177
    template <typename IndexType, typename ColumnType, bool then_null>
178
    void update_result_normal(MutableColumnPtr& result_column_ptr,
179
                              const IndexType* __restrict then_idx,
180
1.54k
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
1.54k
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
1.54k
        std::vector<uint8_t> is_consts(then_columns.size());
183
1.54k
        std::vector<uint8_t> is_nullable(then_columns.size());
184
5.05k
        for (size_t i = 0; i < then_columns.size(); i++) {
185
3.51k
            if (!then_columns[i]) {
186
45
                continue;
187
45
            }
188
3.47k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
3.47k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
3.47k
        }
191
192
1.54k
        auto* raw_result_column = result_column_ptr.get();
193
406k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
405k
            if (!_has_else_expr && !then_idx[row_idx]) {
195
24
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
24
                        ->insert_default();
197
24
                continue;
198
24
            }
199
405k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
405k
            if constexpr (then_null) {
201
153k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
153k
                        result_column_ptr.get());
203
153k
                if (is_nullable[then_idx[row_idx]]) {
204
120k
                    nullable->insert_from_with_type<ColumnType>(
205
120k
                            *raw_then_columns[then_idx[row_idx]], target);
206
120k
                } else {
207
33.4k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
33.4k
                            nullable->get_nested_column_ptr().get());
209
33.4k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
33.4k
                    nullable->push_false_to_nullmap(1);
211
33.4k
                }
212
251k
            } else {
213
251k
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
251k
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
251k
            }
216
405k
        }
217
1.54k
    }
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_15ColumnVarbinaryELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVarbinaryELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnSpatialELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnSpatialELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_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
180
3
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
3
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
3
        std::vector<uint8_t> is_consts(then_columns.size());
183
3
        std::vector<uint8_t> is_nullable(then_columns.size());
184
8
        for (size_t i = 0; i < then_columns.size(); i++) {
185
5
            if (!then_columns[i]) {
186
2
                continue;
187
2
            }
188
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
3
        }
191
192
3
        auto* raw_result_column = result_column_ptr.get();
193
7
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
4
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
4
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
4
            if constexpr (then_null) {
201
4
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
4
                        result_column_ptr.get());
203
4
                if (is_nullable[then_idx[row_idx]]) {
204
1
                    nullable->insert_from_with_type<ColumnType>(
205
1
                            *raw_then_columns[then_idx[row_idx]], target);
206
3
                } else {
207
3
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
3
                            nullable->get_nested_column_ptr().get());
209
3
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
3
                    nullable->push_false_to_nullmap(1);
211
3
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
4
        }
217
3
    }
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
180
32
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
32
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
32
        std::vector<uint8_t> is_consts(then_columns.size());
183
32
        std::vector<uint8_t> is_nullable(then_columns.size());
184
77
        for (size_t i = 0; i < then_columns.size(); i++) {
185
45
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
45
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
45
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
45
        }
191
192
32
        auto* raw_result_column = result_column_ptr.get();
193
79
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
47
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
47
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
47
            if constexpr (then_null) {
201
47
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
47
                        result_column_ptr.get());
203
47
                if (is_nullable[then_idx[row_idx]]) {
204
47
                    nullable->insert_from_with_type<ColumnType>(
205
47
                            *raw_then_columns[then_idx[row_idx]], target);
206
47
                } else {
207
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
0
                            nullable->get_nested_column_ptr().get());
209
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
0
                    nullable->push_false_to_nullmap(1);
211
0
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
47
        }
217
32
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
180
31
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
31
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
31
        std::vector<uint8_t> is_consts(then_columns.size());
183
31
        std::vector<uint8_t> is_nullable(then_columns.size());
184
98
        for (size_t i = 0; i < then_columns.size(); i++) {
185
67
            if (!then_columns[i]) {
186
13
                continue;
187
13
            }
188
54
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
54
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
54
        }
191
192
31
        auto* raw_result_column = result_column_ptr.get();
193
100k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
100k
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
100k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
100k
            if constexpr (then_null) {
201
100k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
100k
                        result_column_ptr.get());
203
100k
                if (is_nullable[then_idx[row_idx]]) {
204
100k
                    nullable->insert_from_with_type<ColumnType>(
205
100k
                            *raw_then_columns[then_idx[row_idx]], target);
206
100k
                } else {
207
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
0
                            nullable->get_nested_column_ptr().get());
209
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
0
                    nullable->push_false_to_nullmap(1);
211
0
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
100k
        }
217
31
    }
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
180
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
1
        std::vector<uint8_t> is_consts(then_columns.size());
183
1
        std::vector<uint8_t> is_nullable(then_columns.size());
184
4
        for (size_t i = 0; i < then_columns.size(); i++) {
185
3
            if (!then_columns[i]) {
186
1
                continue;
187
1
            }
188
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
2
        }
191
192
1
        auto* raw_result_column = result_column_ptr.get();
193
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
3
            if (!_has_else_expr && !then_idx[row_idx]) {
195
1
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
1
                        ->insert_default();
197
1
                continue;
198
1
            }
199
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
2
            if constexpr (then_null) {
201
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
2
                        result_column_ptr.get());
203
2
                if (is_nullable[then_idx[row_idx]]) {
204
0
                    nullable->insert_from_with_type<ColumnType>(
205
0
                            *raw_then_columns[then_idx[row_idx]], target);
206
2
                } else {
207
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
2
                            nullable->get_nested_column_ptr().get());
209
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
2
                    nullable->push_false_to_nullmap(1);
211
2
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
2
        }
217
1
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
180
4
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
4
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
4
        std::vector<uint8_t> is_consts(then_columns.size());
183
4
        std::vector<uint8_t> is_nullable(then_columns.size());
184
15
        for (size_t i = 0; i < then_columns.size(); i++) {
185
11
            if (!then_columns[i]) {
186
1
                continue;
187
1
            }
188
10
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
10
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
10
        }
191
192
4
        auto* raw_result_column = result_column_ptr.get();
193
17
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
13
            if (!_has_else_expr && !then_idx[row_idx]) {
195
1
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
1
                        ->insert_default();
197
1
                continue;
198
1
            }
199
12
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
12
            if constexpr (then_null) {
201
12
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
12
                        result_column_ptr.get());
203
12
                if (is_nullable[then_idx[row_idx]]) {
204
7
                    nullable->insert_from_with_type<ColumnType>(
205
7
                            *raw_then_columns[then_idx[row_idx]], target);
206
7
                } else {
207
5
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
5
                            nullable->get_nested_column_ptr().get());
209
5
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
5
                    nullable->push_false_to_nullmap(1);
211
5
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
12
        }
217
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
180
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
1
        std::vector<uint8_t> is_consts(then_columns.size());
183
1
        std::vector<uint8_t> is_nullable(then_columns.size());
184
2
        for (size_t i = 0; i < then_columns.size(); i++) {
185
1
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
1
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
1
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
1
        }
191
192
1
        auto* raw_result_column = result_column_ptr.get();
193
2
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
1
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
1
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
1
            if constexpr (then_null) {
201
1
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
1
                        result_column_ptr.get());
203
1
                if (is_nullable[then_idx[row_idx]]) {
204
1
                    nullable->insert_from_with_type<ColumnType>(
205
1
                            *raw_then_columns[then_idx[row_idx]], target);
206
1
                } else {
207
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
0
                            nullable->get_nested_column_ptr().get());
209
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
0
                    nullable->push_false_to_nullmap(1);
211
0
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
1
        }
217
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
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
180
1.33k
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
1.33k
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
1.33k
        std::vector<uint8_t> is_consts(then_columns.size());
183
1.33k
        std::vector<uint8_t> is_nullable(then_columns.size());
184
4.36k
        for (size_t i = 0; i < then_columns.size(); i++) {
185
3.02k
            if (!then_columns[i]) {
186
24
                continue;
187
24
            }
188
3.00k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
3.00k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
3.00k
        }
191
192
1.33k
        auto* raw_result_column = result_column_ptr.get();
193
5.77k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
4.43k
            if (!_has_else_expr && !then_idx[row_idx]) {
195
11
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
11
                        ->insert_default();
197
11
                continue;
198
11
            }
199
4.42k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
4.42k
            if constexpr (then_null) {
201
4.42k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
4.42k
                        result_column_ptr.get());
203
4.42k
                if (is_nullable[then_idx[row_idx]]) {
204
521
                    nullable->insert_from_with_type<ColumnType>(
205
521
                            *raw_then_columns[then_idx[row_idx]], target);
206
3.90k
                } else {
207
3.90k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
3.90k
                            nullable->get_nested_column_ptr().get());
209
3.90k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
3.90k
                    nullable->push_false_to_nullmap(1);
211
3.90k
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
4.42k
        }
217
1.33k
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
180
83
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
83
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
83
        std::vector<uint8_t> is_consts(then_columns.size());
183
83
        std::vector<uint8_t> is_nullable(then_columns.size());
184
293
        for (size_t i = 0; i < then_columns.size(); i++) {
185
210
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
210
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
210
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
210
        }
191
192
83
        auto* raw_result_column = result_column_ptr.get();
193
251k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
251k
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
251k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
            if constexpr (then_null) {
201
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
                        result_column_ptr.get());
203
                if (is_nullable[then_idx[row_idx]]) {
204
                    nullable->insert_from_with_type<ColumnType>(
205
                            *raw_then_columns[then_idx[row_idx]], target);
206
                } else {
207
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
                            nullable->get_nested_column_ptr().get());
209
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
                    nullable->push_false_to_nullmap(1);
211
                }
212
251k
            } else {
213
251k
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
251k
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
251k
            }
216
251k
        }
217
83
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVarbinaryELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
180
10
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
10
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
10
        std::vector<uint8_t> is_consts(then_columns.size());
183
10
        std::vector<uint8_t> is_nullable(then_columns.size());
184
40
        for (size_t i = 0; i < then_columns.size(); i++) {
185
30
            if (!then_columns[i]) {
186
4
                continue;
187
4
            }
188
26
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
26
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
26
        }
191
192
10
        auto* raw_result_column = result_column_ptr.get();
193
88
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
78
            if (!_has_else_expr && !then_idx[row_idx]) {
195
11
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
11
                        ->insert_default();
197
11
                continue;
198
11
            }
199
67
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
67
            if constexpr (then_null) {
201
67
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
67
                        result_column_ptr.get());
203
67
                if (is_nullable[then_idx[row_idx]]) {
204
36
                    nullable->insert_from_with_type<ColumnType>(
205
36
                            *raw_then_columns[then_idx[row_idx]], target);
206
36
                } else {
207
31
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
31
                            nullable->get_nested_column_ptr().get());
209
31
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
31
                    nullable->push_false_to_nullmap(1);
211
31
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
67
        }
217
10
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVarbinaryELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
180
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
2
        std::vector<uint8_t> is_consts(then_columns.size());
183
2
        std::vector<uint8_t> is_nullable(then_columns.size());
184
7
        for (size_t i = 0; i < then_columns.size(); i++) {
185
5
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
5
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
5
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
5
        }
191
192
2
        auto* raw_result_column = result_column_ptr.get();
193
9
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
7
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
7
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
            if constexpr (then_null) {
201
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
                        result_column_ptr.get());
203
                if (is_nullable[then_idx[row_idx]]) {
204
                    nullable->insert_from_with_type<ColumnType>(
205
                            *raw_then_columns[then_idx[row_idx]], target);
206
                } else {
207
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
                            nullable->get_nested_column_ptr().get());
209
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
                    nullable->push_false_to_nullmap(1);
211
                }
212
7
            } else {
213
7
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
7
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
7
            }
216
7
        }
217
2
    }
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
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
180
3
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
3
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
3
        std::vector<uint8_t> is_consts(then_columns.size());
183
3
        std::vector<uint8_t> is_nullable(then_columns.size());
184
14
        for (size_t i = 0; i < then_columns.size(); i++) {
185
11
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
11
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
11
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
11
        }
191
192
3
        auto* raw_result_column = result_column_ptr.get();
193
16
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
13
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
13
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
13
            if constexpr (then_null) {
201
13
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
13
                        result_column_ptr.get());
203
13
                if (is_nullable[then_idx[row_idx]]) {
204
12
                    nullable->insert_from_with_type<ColumnType>(
205
12
                            *raw_then_columns[then_idx[row_idx]], target);
206
12
                } else {
207
1
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
1
                            nullable->get_nested_column_ptr().get());
209
1
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
1
                    nullable->push_false_to_nullmap(1);
211
1
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
13
        }
217
3
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
180
12
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
12
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
12
        std::vector<uint8_t> is_consts(then_columns.size());
183
12
        std::vector<uint8_t> is_nullable(then_columns.size());
184
58
        for (size_t i = 0; i < then_columns.size(); i++) {
185
46
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
46
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
46
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
46
        }
191
192
12
        auto* raw_result_column = result_column_ptr.get();
193
49.1k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
49.1k
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
49.1k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
49.1k
            if constexpr (then_null) {
201
49.1k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
49.1k
                        result_column_ptr.get());
203
49.1k
                if (is_nullable[then_idx[row_idx]]) {
204
19.6k
                    nullable->insert_from_with_type<ColumnType>(
205
19.6k
                            *raw_then_columns[then_idx[row_idx]], target);
206
29.4k
                } else {
207
29.4k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
29.4k
                            nullable->get_nested_column_ptr().get());
209
29.4k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
29.4k
                    nullable->push_false_to_nullmap(1);
211
29.4k
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
49.1k
        }
217
12
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE44EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnSpatialELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
180
10
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
10
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
10
        std::vector<uint8_t> is_consts(then_columns.size());
183
10
        std::vector<uint8_t> is_nullable(then_columns.size());
184
40
        for (size_t i = 0; i < then_columns.size(); i++) {
185
30
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
30
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
30
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
30
        }
191
192
10
        auto* raw_result_column = result_column_ptr.get();
193
70
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
60
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
60
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
60
            if constexpr (then_null) {
201
60
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
60
                        result_column_ptr.get());
203
60
                if (is_nullable[then_idx[row_idx]]) {
204
44
                    nullable->insert_from_with_type<ColumnType>(
205
44
                            *raw_then_columns[then_idx[row_idx]], target);
206
44
                } else {
207
16
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
16
                            nullable->get_nested_column_ptr().get());
209
16
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
16
                    nullable->push_false_to_nullmap(1);
211
16
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
60
        }
217
10
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnSpatialELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
180
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
2
        std::vector<uint8_t> is_consts(then_columns.size());
183
2
        std::vector<uint8_t> is_nullable(then_columns.size());
184
8
        for (size_t i = 0; i < then_columns.size(); i++) {
185
6
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
6
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
6
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
6
        }
191
192
2
        auto* raw_result_column = result_column_ptr.get();
193
14
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
12
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
12
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
            if constexpr (then_null) {
201
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
                        result_column_ptr.get());
203
                if (is_nullable[then_idx[row_idx]]) {
204
                    nullable->insert_from_with_type<ColumnType>(
205
                            *raw_then_columns[then_idx[row_idx]], target);
206
                } else {
207
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
                            nullable->get_nested_column_ptr().get());
209
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
                    nullable->push_false_to_nullmap(1);
211
                }
212
12
            } else {
213
12
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
12
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
12
            }
216
12
        }
217
2
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
180
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
1
        std::vector<uint8_t> is_consts(then_columns.size());
183
1
        std::vector<uint8_t> is_nullable(then_columns.size());
184
4
        for (size_t i = 0; i < then_columns.size(); i++) {
185
3
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
3
        }
191
192
1
        auto* raw_result_column = result_column_ptr.get();
193
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
3
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
3
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
3
            if constexpr (then_null) {
201
3
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
3
                        result_column_ptr.get());
203
3
                if (is_nullable[then_idx[row_idx]]) {
204
1
                    nullable->insert_from_with_type<ColumnType>(
205
1
                            *raw_then_columns[then_idx[row_idx]], target);
206
2
                } else {
207
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
2
                            nullable->get_nested_column_ptr().get());
209
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
2
                    nullable->push_false_to_nullmap(1);
211
2
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
3
        }
217
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
180
7
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
7
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
7
        std::vector<uint8_t> is_consts(then_columns.size());
183
7
        std::vector<uint8_t> is_nullable(then_columns.size());
184
18
        for (size_t i = 0; i < then_columns.size(); i++) {
185
11
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
11
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
11
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
11
        }
191
192
7
        auto* raw_result_column = result_column_ptr.get();
193
15
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
8
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
8
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
8
            if constexpr (then_null) {
201
8
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
8
                        result_column_ptr.get());
203
8
                if (is_nullable[then_idx[row_idx]]) {
204
4
                    nullable->insert_from_with_type<ColumnType>(
205
4
                            *raw_then_columns[then_idx[row_idx]], target);
206
4
                } else {
207
4
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
4
                            nullable->get_nested_column_ptr().get());
209
4
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
4
                    nullable->push_false_to_nullmap(1);
211
4
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
8
        }
217
7
    }
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
_ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVariantV2ELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
180
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
181
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
182
1
        std::vector<uint8_t> is_consts(then_columns.size());
183
1
        std::vector<uint8_t> is_nullable(then_columns.size());
184
5
        for (size_t i = 0; i < then_columns.size(); i++) {
185
4
            if (!then_columns[i]) {
186
0
                continue;
187
0
            }
188
4
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
189
4
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
190
4
        }
191
192
1
        auto* raw_result_column = result_column_ptr.get();
193
5
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
194
4
            if (!_has_else_expr && !then_idx[row_idx]) {
195
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
196
0
                        ->insert_default();
197
0
                continue;
198
0
            }
199
4
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
200
4
            if constexpr (then_null) {
201
4
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
202
4
                        result_column_ptr.get());
203
4
                if (is_nullable[then_idx[row_idx]]) {
204
1
                    nullable->insert_from_with_type<ColumnType>(
205
1
                            *raw_then_columns[then_idx[row_idx]], target);
206
3
                } else {
207
3
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
208
3
                            nullable->get_nested_column_ptr().get());
209
3
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
3
                    nullable->push_false_to_nullmap(1);
211
3
                }
212
            } else {
213
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
214
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
215
            }
216
4
        }
217
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVariantV2ELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
218
219
    template <typename IndexType, typename ColumnType>
220
    void update_result_auto_simd(MutableColumnPtr& result_column_ptr,
221
                                 const IndexType* __restrict then_idx,
222
445
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
10.7k
        for (auto& then_ptr : then_columns) {
224
10.7k
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
10.7k
        }
226
227
445
        result_column_ptr->resize(rows_count);
228
445
        auto* __restrict result_raw_data =
229
445
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
445
                        ->get_data()
231
445
                        .data();
232
233
        // set default value
234
405k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
297k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
297k
                result_raw_data[i] = ColumnType::default_value();
242
297k
            } else {
243
107k
                result_raw_data[i] = {};
244
107k
            }
245
405k
        }
246
247
11.1k
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
10.7k
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
10.7k
            const auto* __restrict column_raw_data =
252
10.7k
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
10.7k
                            then_columns[i].get())
254
10.7k
                            ->get_data()
255
10.7k
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
10.5k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
36.0M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
35.9M
                    if (then_idx[row_idx] == i) {
269
404k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
404k
                    }
271
35.9M
                }
272
10.5k
            } else {
273
525
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
355
                    result_raw_data[row_idx] +=
275
355
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
355
                            column_raw_data[row_idx];
277
355
                }
278
170
            }
279
10.7k
        }
280
445
    }
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
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
24.7k
            } else {
243
24.7k
                result_raw_data[i] = {};
244
24.7k
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
24.7k
            } else {
243
24.7k
                result_raw_data[i] = {};
244
24.7k
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
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
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
658
        for (auto& then_ptr : then_columns) {
224
658
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
658
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
676
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
658
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
658
            const auto* __restrict column_raw_data =
252
658
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
658
                            then_columns[i].get())
254
658
                            ->get_data()
255
658
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
658
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
658
        }
280
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
222
4
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
8
        for (auto& then_ptr : then_columns) {
224
8
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
8
        }
226
227
4
        result_column_ptr->resize(rows_count);
228
4
        auto* __restrict result_raw_data =
229
4
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
4
                        ->get_data()
231
4
                        .data();
232
233
        // set default value
234
10
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
6
            } else {
243
6
                result_raw_data[i] = {};
244
6
            }
245
6
        }
246
247
12
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
8
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
8
            const auto* __restrict column_raw_data =
252
8
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
8
                            then_columns[i].get())
254
8
                            ->get_data()
255
8
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
                    if (then_idx[row_idx] == i) {
269
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
                    }
271
                }
272
8
            } else {
273
21
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
13
                    result_raw_data[row_idx] +=
275
13
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
13
                            column_raw_data[row_idx];
277
13
                }
278
8
            }
279
8
        }
280
4
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
6
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
18
        for (auto& then_ptr : then_columns) {
224
18
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
18
        }
226
227
6
        result_column_ptr->resize(rows_count);
228
6
        auto* __restrict result_raw_data =
229
6
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
6
                        ->get_data()
231
6
                        .data();
232
233
        // set default value
234
24
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
18
            } else {
243
18
                result_raw_data[i] = {};
244
18
            }
245
18
        }
246
247
24
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
18
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
18
            const auto* __restrict column_raw_data =
252
18
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
18
                            then_columns[i].get())
254
18
                            ->get_data()
255
18
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
                    if (then_idx[row_idx] == i) {
269
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
                    }
271
                }
272
18
            } else {
273
72
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
54
                    result_raw_data[row_idx] +=
275
54
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
54
                            column_raw_data[row_idx];
277
54
                }
278
18
            }
279
18
        }
280
6
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
129
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
144
        for (auto& then_ptr : then_columns) {
224
144
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
144
        }
226
227
129
        result_column_ptr->resize(rows_count);
228
129
        auto* __restrict result_raw_data =
229
129
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
129
                        ->get_data()
231
129
                        .data();
232
233
        // set default value
234
399
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
270
            } else {
243
270
                result_raw_data[i] = {};
244
270
            }
245
270
        }
246
247
273
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
144
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
144
            const auto* __restrict column_raw_data =
252
144
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
144
                            then_columns[i].get())
254
144
                            ->get_data()
255
144
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
                    if (then_idx[row_idx] == i) {
269
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
                    }
271
                }
272
144
            } else {
273
432
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
288
                    result_raw_data[row_idx] +=
275
288
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
288
                            column_raw_data[row_idx];
277
288
                }
278
144
            }
279
144
        }
280
129
    }
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
222
25
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
675
        for (auto& then_ptr : then_columns) {
224
675
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
675
        }
226
227
25
        result_column_ptr->resize(rows_count);
228
25
        auto* __restrict result_raw_data =
229
25
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
25
                        ->get_data()
231
25
                        .data();
232
233
        // set default value
234
28.9k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
28.8k
            } else {
243
28.8k
                result_raw_data[i] = {};
244
28.8k
            }
245
28.8k
        }
246
247
700
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
675
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
675
            const auto* __restrict column_raw_data =
252
675
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
675
                            then_columns[i].get())
254
675
                            ->get_data()
255
675
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
675
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
28.8k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
28.8k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
675
        }
280
25
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
27
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
691
        for (auto& then_ptr : then_columns) {
224
691
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
691
        }
226
227
27
        result_column_ptr->resize(rows_count);
228
27
        auto* __restrict result_raw_data =
229
27
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
27
                        ->get_data()
231
27
                        .data();
232
233
        // set default value
234
29.1k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
                result_raw_data[i] = ColumnType::default_value();
242
29.1k
            } else {
243
29.1k
                result_raw_data[i] = {};
244
29.1k
            }
245
29.1k
        }
246
247
718
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
691
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
691
            const auto* __restrict column_raw_data =
252
691
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
691
                            then_columns[i].get())
254
691
                            ->get_data()
255
691
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
691
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.25M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.25M
                    if (then_idx[row_idx] == i) {
269
29.1k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
29.1k
                    }
271
2.25M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
691
        }
280
27
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
654
        for (auto& then_ptr : then_columns) {
224
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
654
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
654
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
654
            const auto* __restrict column_raw_data =
252
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
654
                            then_columns[i].get())
254
654
                            ->get_data()
255
654
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.23M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.23M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
654
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
654
        for (auto& then_ptr : then_columns) {
224
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
654
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
654
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
654
            const auto* __restrict column_raw_data =
252
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
654
                            then_columns[i].get())
254
654
                            ->get_data()
255
654
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.23M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.23M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
654
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
20
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
660
        for (auto& then_ptr : then_columns) {
224
660
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
660
        }
226
227
20
        result_column_ptr->resize(rows_count);
228
20
        auto* __restrict result_raw_data =
229
20
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
20
                        ->get_data()
231
20
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
680
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
660
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
660
            const auto* __restrict column_raw_data =
252
660
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
660
                            then_columns[i].get())
254
660
                            ->get_data()
255
660
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
660
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.23M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.23M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
660
        }
280
20
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
654
        for (auto& then_ptr : then_columns) {
224
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
654
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
654
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
654
            const auto* __restrict column_raw_data =
252
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
654
                            then_columns[i].get())
254
654
                            ->get_data()
255
654
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.23M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.23M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
654
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
654
        for (auto& then_ptr : then_columns) {
224
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
654
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
654
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
654
            const auto* __restrict column_raw_data =
252
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
654
                            then_columns[i].get())
254
654
                            ->get_data()
255
654
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.23M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.23M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
654
        }
280
18
    }
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
222
18
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
223
654
        for (auto& then_ptr : then_columns) {
224
654
            then_ptr = then_ptr->convert_to_full_column_if_const();
225
654
        }
226
227
18
        result_column_ptr->resize(rows_count);
228
18
        auto* __restrict result_raw_data =
229
18
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
230
18
                        ->get_data()
231
18
                        .data();
232
233
        // set default value
234
24.7k
        for (int i = 0; i < rows_count; i++) {
235
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
236
                          std::is_same_v<ColumnType, ColumnDateTime> ||
237
                          std::is_same_v<ColumnType, ColumnDateV2> ||
238
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
239
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
240
24.7k
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
241
24.7k
                result_raw_data[i] = ColumnType::default_value();
242
            } else {
243
                result_raw_data[i] = {};
244
            }
245
24.7k
        }
246
247
672
        for (IndexType i = 0; i < then_columns.size(); i++) {
248
654
            if (!then_columns[i]) {
249
0
                continue;
250
0
            }
251
654
            const auto* __restrict column_raw_data =
252
654
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
253
654
                            then_columns[i].get())
254
654
                            ->get_data()
255
654
                            .data();
256
            if constexpr (std::is_same_v<ColumnType, ColumnFloat32> ||
257
                          std::is_same_v<ColumnType, ColumnFloat64> ||
258
                          std::is_same_v<ColumnType, ColumnDate> ||
259
                          std::is_same_v<ColumnType, ColumnDateTime> ||
260
                          std::is_same_v<ColumnType, ColumnDateV2> ||
261
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
262
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
263
654
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
264
                // Arithmetic masking propagates unselected NaN/Infinity and loses signed zero.
265
                // Conditional stores also let the compiler vectorize without loading from a
266
                // selected source/destination pointer, as a ternary assignment can do.
267
2.24M
                for (size_t row_idx = 0; row_idx < rows_count; row_idx++) {
268
2.23M
                    if (then_idx[row_idx] == i) {
269
24.7k
                        result_raw_data[row_idx] = column_raw_data[row_idx];
270
24.7k
                    }
271
2.23M
                }
272
            } else {
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
274
                    result_raw_data[row_idx] +=
275
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
276
                            column_raw_data[row_idx];
277
                }
278
            }
279
654
        }
280
18
    }
281
282
    template <typename IndexType>
283
    ColumnPtr _execute_impl(const std::vector<ColumnPtr>& when_columns,
284
1.68k
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
285
1.68k
        std::vector<IndexType> then_idx(rows_count, 0);
286
1.68k
        IndexType* __restrict then_idx_ptr = then_idx.data();
287
3.72k
        for (IndexType i = 0; i < when_columns.size(); i++) {
288
2.03k
            IndexType column_idx = i + 1;
289
2.03k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
290
291
2.03k
            if (is_consts) {
292
3
                if (raw_when_column->get_bool(0)) {
293
6
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
294
3
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
295
3
                    }
296
3
                    break;
297
3
                }
298
0
                continue;
299
3
            }
300
301
2.03k
            if (is_column_nullable(*raw_when_column)) {
302
1.94k
                const auto* column_nullable_ptr =
303
1.94k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
304
1.94k
                                raw_when_column.get());
305
1.94k
                const auto* __restrict cond_raw_data =
306
1.94k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
307
1.94k
                                column_nullable_ptr->get_nested_column_ptr().get())
308
1.94k
                                ->get_data()
309
1.94k
                                .data();
310
1.94k
                if (!column_nullable_ptr->has_null()) {
311
658k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
312
656k
                        then_idx_ptr[row_idx] |=
313
656k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
314
656k
                    }
315
1.89k
                    continue;
316
1.89k
                }
317
55
                const auto* __restrict cond_raw_nullmap =
318
55
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
319
200k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
320
200k
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
321
200k
                                              !cond_raw_nullmap[row_idx]) *
322
200k
                                             column_idx;
323
200k
                }
324
86
            } else {
325
86
                const auto* __restrict cond_raw_data =
326
86
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
327
86
                                raw_when_column.get())
328
86
                                ->get_data()
329
86
                                .data();
330
33.0k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
331
32.9k
                    then_idx_ptr[row_idx] |=
332
32.9k
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
333
32.9k
                }
334
86
            }
335
2.03k
        }
336
337
1.68k
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
338
1.68k
    }
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
284
1.68k
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
285
1.68k
        std::vector<IndexType> then_idx(rows_count, 0);
286
1.68k
        IndexType* __restrict then_idx_ptr = then_idx.data();
287
3.72k
        for (IndexType i = 0; i < when_columns.size(); i++) {
288
2.03k
            IndexType column_idx = i + 1;
289
2.03k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
290
291
2.03k
            if (is_consts) {
292
3
                if (raw_when_column->get_bool(0)) {
293
6
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
294
3
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
295
3
                    }
296
3
                    break;
297
3
                }
298
0
                continue;
299
3
            }
300
301
2.03k
            if (is_column_nullable(*raw_when_column)) {
302
1.94k
                const auto* column_nullable_ptr =
303
1.94k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
304
1.94k
                                raw_when_column.get());
305
1.94k
                const auto* __restrict cond_raw_data =
306
1.94k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
307
1.94k
                                column_nullable_ptr->get_nested_column_ptr().get())
308
1.94k
                                ->get_data()
309
1.94k
                                .data();
310
1.94k
                if (!column_nullable_ptr->has_null()) {
311
658k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
312
656k
                        then_idx_ptr[row_idx] |=
313
656k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
314
656k
                    }
315
1.89k
                    continue;
316
1.89k
                }
317
55
                const auto* __restrict cond_raw_nullmap =
318
55
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
319
200k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
320
200k
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
321
200k
                                              !cond_raw_nullmap[row_idx]) *
322
200k
                                             column_idx;
323
200k
                }
324
86
            } else {
325
86
                const auto* __restrict cond_raw_data =
326
86
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
327
86
                                raw_when_column.get())
328
86
                                ->get_data()
329
86
                                .data();
330
33.0k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
331
32.9k
                    then_idx_ptr[row_idx] |=
332
32.9k
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
333
32.9k
                }
334
86
            }
335
2.03k
        }
336
337
1.68k
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
338
1.68k
    }
339
340
    bool _has_else_expr;
341
342
    inline static const std::string FUNCTION_NAME = "case";
343
    inline static const std::string EXPR_NAME = "vcase expr";
344
};
345
} // namespace doris