Coverage Report

Created: 2026-07-20 16:29

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/vcase_expr.h
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#pragma once
19
20
#include <string>
21
22
#include "common/exception.h"
23
#include "common/status.h"
24
#include "core/column/column_array.h"
25
#include "core/column/column_complex.h"
26
#include "core/column/column_const.h"
27
#include "core/column/column_decimal.h"
28
#include "core/column/column_map.h"
29
#include "core/column/column_nullable.h"
30
#include "core/column/column_struct.h"
31
#include "core/column/column_variant.h"
32
#include "core/column/variant_v2/column_variant_v2.h"
33
#include "core/data_type/data_type_nullable.h"
34
#include "core/data_type/data_type_variant.h"
35
#include "core/data_type/define_primitive_type.h"
36
#include "core/data_type/primitive_type.h"
37
#include "exprs/function/function.h"
38
#include "exprs/function_context.h"
39
#include "exprs/vexpr.h"
40
41
namespace doris {
42
class RowDescriptor;
43
class RuntimeState;
44
class TExprNode;
45
46
class Block;
47
} // namespace doris
48
49
namespace doris {
50
51
class VCaseExpr final : public VExpr {
52
    ENABLE_FACTORY_CREATOR(VCaseExpr);
53
54
public:
55
    VCaseExpr(const TExprNode& node);
56
    ~VCaseExpr() override = default;
57
    Status execute_column_impl(VExprContext* context, const Block* block, const Selector* selector,
58
                               size_t count, ColumnPtr& result_column) const override;
59
    Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override;
60
    Status open(RuntimeState* state, VExprContext* context,
61
                FunctionContext::FunctionStateScope scope) override;
62
    void close(VExprContext* context, FunctionContext::FunctionStateScope scope) override;
63
    const std::string& expr_name() const override;
64
    std::string debug_string() const override;
65
0
    bool has_else_expr() const { return _has_else_expr; }
66
1
    Status clone_node(VExprSPtr* cloned_expr) const override {
67
1
        DORIS_CHECK(cloned_expr != nullptr);
68
1
        auto node = clone_texpr_node();
69
1
        TCaseExpr case_node;
70
1
        case_node.__set_has_case_expr(false);
71
1
        case_node.__set_has_else_expr(_has_else_expr);
72
1
        node.__set_case_expr(case_node);
73
1
        *cloned_expr = VCaseExpr::create_shared(node);
74
1
        return Status::OK();
75
1
    }
76
77
private:
78
    template <typename IndexType, typename ColumnType>
79
    ColumnPtr _execute_update_result_impl(const IndexType* then_idx,
80
                                          std::vector<ColumnPtr>& then_columns,
81
428
                                          size_t rows_count) const {
82
428
        auto result_column_ptr = data_type()->create_column();
83
428
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
191
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
191
            if (data_type()->is_nullable()) {
98
121
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
121
                                                                  then_columns, rows_count);
100
121
            } else {
101
70
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
70
                                                                   then_columns, rows_count);
103
70
            }
104
237
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
15
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
15
                                                              then_columns, rows_count);
108
222
        } else {
109
222
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
222
                                                           then_columns, rows_count);
111
222
        }
112
428
        return result_column_ptr;
113
428
    }
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
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
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_12ColumnVectorILNS_13PrimitiveTypeE11EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_9ColumnMapEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_12ColumnStructEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_15ColumnVariantV2EEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implItNS_13ColumnVariantEEENS_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
81
17
                                          size_t rows_count) const {
82
17
        auto result_column_ptr = data_type()->create_column();
83
17
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
            if (data_type()->is_nullable()) {
98
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
                                                                  then_columns, rows_count);
100
            } else {
101
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
                                                                   then_columns, rows_count);
103
            }
104
17
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
2
                                                              then_columns, rows_count);
108
15
        } else {
109
15
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
15
                                                           then_columns, rows_count);
111
15
        }
112
17
        return result_column_ptr;
113
17
    }
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
81
10
                                          size_t rows_count) const {
82
10
        auto result_column_ptr = data_type()->create_column();
83
10
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
            if (data_type()->is_nullable()) {
98
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
                                                                  then_columns, rows_count);
100
            } else {
101
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
                                                                   then_columns, rows_count);
103
            }
104
10
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
10
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
10
                                                              then_columns, rows_count);
108
10
        } else {
109
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
0
                                                           then_columns, rows_count);
111
0
        }
112
10
        return result_column_ptr;
113
10
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
81
137
                                          size_t rows_count) const {
82
137
        auto result_column_ptr = data_type()->create_column();
83
137
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
            if (data_type()->is_nullable()) {
98
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
                                                                  then_columns, rows_count);
100
            } else {
101
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
                                                                   then_columns, rows_count);
103
            }
104
137
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
0
                                                              then_columns, rows_count);
108
137
        } else {
109
137
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
137
                                                           then_columns, rows_count);
111
137
        }
112
137
        return result_column_ptr;
113
137
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE7EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
81
3
                                          size_t rows_count) const {
82
3
        auto result_column_ptr = data_type()->create_column();
83
3
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
            if (data_type()->is_nullable()) {
98
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
                                                                  then_columns, rows_count);
100
            } else {
101
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
                                                                   then_columns, rows_count);
103
            }
104
3
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
3
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
3
                                                              then_columns, rows_count);
108
3
        } else {
109
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
0
                                                           then_columns, rows_count);
111
0
        }
112
3
        return result_column_ptr;
113
3
    }
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
81
68
                                          size_t rows_count) const {
82
68
        auto result_column_ptr = data_type()->create_column();
83
68
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
            if (data_type()->is_nullable()) {
98
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
                                                                  then_columns, rows_count);
100
            } else {
101
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
                                                                   then_columns, rows_count);
103
            }
104
68
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
0
                                                              then_columns, rows_count);
108
68
        } else {
109
68
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
68
                                                           then_columns, rows_count);
111
68
        }
112
68
        return result_column_ptr;
113
68
    }
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
81
191
                                          size_t rows_count) const {
82
191
        auto result_column_ptr = data_type()->create_column();
83
191
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
191
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
191
            if (data_type()->is_nullable()) {
98
121
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
121
                                                                  then_columns, rows_count);
100
121
            } else {
101
70
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
70
                                                                   then_columns, rows_count);
103
70
            }
104
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
                                                              then_columns, rows_count);
108
        } else {
109
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
                                                           then_columns, rows_count);
111
        }
112
191
        return result_column_ptr;
113
191
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
81
2
                                          size_t rows_count) const {
82
2
        auto result_column_ptr = data_type()->create_column();
83
2
        result_column_ptr->reserve(rows_count);
84
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
85
                      std::is_same_v<ColumnType, ColumnBitmap> ||
86
                      std::is_same_v<ColumnType, ColumnArray> ||
87
                      std::is_same_v<ColumnType, ColumnMap> ||
88
                      std::is_same_v<ColumnType, ColumnStruct> ||
89
                      std::is_same_v<ColumnType, ColumnVariant> ||
90
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
91
                      std::is_same_v<ColumnType, ColumnHLL> ||
92
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
93
                      std::is_same_v<ColumnType, ColumnIPv4> ||
94
                      std::is_same_v<ColumnType, ColumnIPv6>) {
95
            // result_column and all then_column is not nullable.
96
            // can't simd when type is string.
97
            if (data_type()->is_nullable()) {
98
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
99
                                                                  then_columns, rows_count);
100
            } else {
101
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
102
                                                                   then_columns, rows_count);
103
            }
104
2
        } else if (data_type()->is_nullable()) {
105
            // result_column and all then_column is nullable.
106
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
107
0
                                                              then_columns, rows_count);
108
2
        } else {
109
2
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
110
2
                                                           then_columns, rows_count);
111
2
        }
112
2
        return result_column_ptr;
113
2
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_9ColumnMapEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnStructEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_15ColumnVariantV2EEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnVariantEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
114
115
    template <typename IndexType>
116
    ColumnPtr _execute_update_result(const IndexType* then_idx,
117
                                     std::vector<ColumnPtr>& then_columns,
118
428
                                     size_t rows_count) const {
119
428
#define CASE_TYPE(ptype, coltype) \
120
428
    case PrimitiveType::ptype:    \
121
428
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
122
123
428
        switch (data_type()->get_primitive_type()) {
124
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
125
17
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
126
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
127
10
            CASE_TYPE(TYPE_INT, ColumnInt32)
128
137
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
129
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
130
0
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
131
3
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
132
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
133
68
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
134
0
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
135
0
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
136
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
137
2
            CASE_TYPE(TYPE_STRING, ColumnString)
138
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
139
189
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
140
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
141
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
142
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
143
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
144
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
145
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
146
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
147
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
148
0
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
149
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
150
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
151
0
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
152
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
153
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
154
0
        case PrimitiveType::TYPE_VARIANT: {
155
0
            const auto* variant_type =
156
0
                    dynamic_cast<const DataTypeVariant*>(remove_nullable(data_type()).get());
157
0
            DORIS_CHECK(variant_type != nullptr);
158
0
            if (variant_type->is_variant_v2()) {
159
0
                return _execute_update_result_impl<IndexType, ColumnVariantV2>(
160
0
                        then_idx, then_columns, rows_count);
161
0
            }
162
0
            return _execute_update_result_impl<IndexType, ColumnVariant>(then_idx, then_columns,
163
0
                                                                         rows_count);
164
0
        }
165
0
        default:
166
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
167
0
                            data_type()->get_name());
168
428
        }
169
428
#undef CASE_TYPE
170
428
    }
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
118
428
                                     size_t rows_count) const {
119
428
#define CASE_TYPE(ptype, coltype) \
120
428
    case PrimitiveType::ptype:    \
121
428
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
122
123
428
        switch (data_type()->get_primitive_type()) {
124
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
125
17
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
126
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
127
10
            CASE_TYPE(TYPE_INT, ColumnInt32)
128
137
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
129
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
130
0
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
131
3
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
132
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
133
68
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
134
0
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
135
0
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
136
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
137
2
            CASE_TYPE(TYPE_STRING, ColumnString)
138
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
139
189
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
140
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
141
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
142
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
143
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
144
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
145
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
146
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
147
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
148
0
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
149
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
150
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
151
0
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
152
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
153
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
154
0
        case PrimitiveType::TYPE_VARIANT: {
155
0
            const auto* variant_type =
156
0
                    dynamic_cast<const DataTypeVariant*>(remove_nullable(data_type()).get());
157
0
            DORIS_CHECK(variant_type != nullptr);
158
0
            if (variant_type->is_variant_v2()) {
159
0
                return _execute_update_result_impl<IndexType, ColumnVariantV2>(
160
0
                        then_idx, then_columns, rows_count);
161
0
            }
162
0
            return _execute_update_result_impl<IndexType, ColumnVariant>(then_idx, then_columns,
163
0
                                                                         rows_count);
164
0
        }
165
0
        default:
166
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
167
0
                            data_type()->get_name());
168
428
        }
169
428
#undef CASE_TYPE
170
428
    }
171
172
    template <typename IndexType, typename ColumnType, bool then_null>
173
    void update_result_normal(MutableColumnPtr& result_column_ptr,
174
                              const IndexType* __restrict then_idx,
175
204
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
176
204
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
177
204
        std::vector<uint8_t> is_consts(then_columns.size());
178
204
        std::vector<uint8_t> is_nullable(then_columns.size());
179
1.40k
        for (size_t i = 0; i < then_columns.size(); i++) {
180
1.20k
            if (!then_columns[i]) {
181
27
                continue;
182
27
            }
183
1.17k
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
184
1.17k
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
185
1.17k
        }
186
187
204
        auto* raw_result_column = result_column_ptr.get();
188
3.54k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
189
3.34k
            if (!_has_else_expr && !then_idx[row_idx]) {
190
11
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
191
11
                        ->insert_default();
192
11
                continue;
193
11
            }
194
3.32k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
195
3.32k
            if constexpr (then_null) {
196
3.11k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
197
3.11k
                        result_column_ptr.get());
198
3.11k
                if (is_nullable[then_idx[row_idx]]) {
199
335
                    nullable->insert_from_with_type<ColumnType>(
200
335
                            *raw_then_columns[then_idx[row_idx]], target);
201
2.77k
                } else {
202
2.77k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
203
2.77k
                            nullable->get_nested_column_ptr().get());
204
2.77k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
205
2.77k
                    nullable->push_false_to_nullmap(1);
206
2.77k
                }
207
3.11k
            } else {
208
217
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
209
217
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
217
            }
211
3.32k
        }
212
204
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE2EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE3EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE4EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE5EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE7EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnStrIjEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVariantV2ELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVariantV2ELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnVariantELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnVariantELb0EEEvRNS_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
175
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
176
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
177
2
        std::vector<uint8_t> is_consts(then_columns.size());
178
2
        std::vector<uint8_t> is_nullable(then_columns.size());
179
6
        for (size_t i = 0; i < then_columns.size(); i++) {
180
4
            if (!then_columns[i]) {
181
2
                continue;
182
2
            }
183
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
184
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
185
2
        }
186
187
2
        auto* raw_result_column = result_column_ptr.get();
188
5
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
189
3
            if (!_has_else_expr && !then_idx[row_idx]) {
190
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
191
0
                        ->insert_default();
192
0
                continue;
193
0
            }
194
3
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
195
3
            if constexpr (then_null) {
196
3
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
197
3
                        result_column_ptr.get());
198
3
                if (is_nullable[then_idx[row_idx]]) {
199
0
                    nullable->insert_from_with_type<ColumnType>(
200
0
                            *raw_then_columns[then_idx[row_idx]], target);
201
3
                } else {
202
3
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
203
3
                            nullable->get_nested_column_ptr().get());
204
3
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
205
3
                    nullable->push_false_to_nullmap(1);
206
3
                }
207
            } else {
208
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
209
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
            }
211
3
        }
212
2
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
175
10
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
176
10
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
177
10
        std::vector<uint8_t> is_consts(then_columns.size());
178
10
        std::vector<uint8_t> is_nullable(then_columns.size());
179
21
        for (size_t i = 0; i < then_columns.size(); i++) {
180
11
            if (!then_columns[i]) {
181
0
                continue;
182
0
            }
183
11
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
184
11
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
185
11
        }
186
187
10
        auto* raw_result_column = result_column_ptr.get();
188
30
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
189
20
            if (!_has_else_expr && !then_idx[row_idx]) {
190
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
191
0
                        ->insert_default();
192
0
                continue;
193
0
            }
194
20
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
195
20
            if constexpr (then_null) {
196
20
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
197
20
                        result_column_ptr.get());
198
20
                if (is_nullable[then_idx[row_idx]]) {
199
20
                    nullable->insert_from_with_type<ColumnType>(
200
20
                            *raw_then_columns[then_idx[row_idx]], target);
201
20
                } else {
202
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
203
0
                            nullable->get_nested_column_ptr().get());
204
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
205
0
                    nullable->push_false_to_nullmap(1);
206
0
                }
207
            } else {
208
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
209
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
            }
211
20
        }
212
10
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE7EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE8EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
175
3
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
176
3
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
177
3
        std::vector<uint8_t> is_consts(then_columns.size());
178
3
        std::vector<uint8_t> is_nullable(then_columns.size());
179
11
        for (size_t i = 0; i < then_columns.size(); i++) {
180
8
            if (!then_columns[i]) {
181
0
                continue;
182
0
            }
183
8
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
184
8
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
185
8
        }
186
187
3
        auto* raw_result_column = result_column_ptr.get();
188
13
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
189
10
            if (!_has_else_expr && !then_idx[row_idx]) {
190
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
191
0
                        ->insert_default();
192
0
                continue;
193
0
            }
194
10
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
195
10
            if constexpr (then_null) {
196
10
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
197
10
                        result_column_ptr.get());
198
10
                if (is_nullable[then_idx[row_idx]]) {
199
7
                    nullable->insert_from_with_type<ColumnType>(
200
7
                            *raw_then_columns[then_idx[row_idx]], target);
201
7
                } else {
202
3
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
203
3
                            nullable->get_nested_column_ptr().get());
204
3
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
205
3
                    nullable->push_false_to_nullmap(1);
206
3
                }
207
            } else {
208
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
209
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
            }
211
10
        }
212
3
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
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
175
121
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
176
121
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
177
121
        std::vector<uint8_t> is_consts(then_columns.size());
178
121
        std::vector<uint8_t> is_nullable(then_columns.size());
179
1.12k
        for (size_t i = 0; i < then_columns.size(); i++) {
180
1.00k
            if (!then_columns[i]) {
181
25
                continue;
182
25
            }
183
979
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
184
979
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
185
979
        }
186
187
121
        auto* raw_result_column = result_column_ptr.get();
188
3.21k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
189
3.09k
            if (!_has_else_expr && !then_idx[row_idx]) {
190
11
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
191
11
                        ->insert_default();
192
11
                continue;
193
11
            }
194
3.07k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
195
3.07k
            if constexpr (then_null) {
196
3.07k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
197
3.07k
                        result_column_ptr.get());
198
3.07k
                if (is_nullable[then_idx[row_idx]]) {
199
308
                    nullable->insert_from_with_type<ColumnType>(
200
308
                            *raw_then_columns[then_idx[row_idx]], target);
201
2.77k
                } else {
202
2.77k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
203
2.77k
                            nullable->get_nested_column_ptr().get());
204
2.77k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
205
2.77k
                    nullable->push_false_to_nullmap(1);
206
2.77k
                }
207
            } else {
208
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
209
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
            }
211
3.07k
        }
212
121
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
175
68
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
176
68
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
177
68
        std::vector<uint8_t> is_consts(then_columns.size());
178
68
        std::vector<uint8_t> is_nullable(then_columns.size());
179
243
        for (size_t i = 0; i < then_columns.size(); i++) {
180
175
            if (!then_columns[i]) {
181
0
                continue;
182
0
            }
183
175
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
184
175
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
185
175
        }
186
187
68
        auto* raw_result_column = result_column_ptr.get();
188
285
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
189
217
            if (!_has_else_expr && !then_idx[row_idx]) {
190
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
191
0
                        ->insert_default();
192
0
                continue;
193
0
            }
194
217
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
195
            if constexpr (then_null) {
196
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
197
                        result_column_ptr.get());
198
                if (is_nullable[then_idx[row_idx]]) {
199
                    nullable->insert_from_with_type<ColumnType>(
200
                            *raw_then_columns[then_idx[row_idx]], target);
201
                } else {
202
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
203
                            nullable->get_nested_column_ptr().get());
204
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
205
                    nullable->push_false_to_nullmap(1);
206
                }
207
217
            } else {
208
217
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
209
217
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
210
217
            }
211
217
        }
212
68
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVariantV2ELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_15ColumnVariantV2ELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnVariantELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnVariantELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
213
214
    template <typename IndexType, typename ColumnType>
215
    void update_result_auto_simd(MutableColumnPtr& result_column_ptr,
216
                                 const IndexType* __restrict then_idx,
217
222
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
218
425
        for (auto& then_ptr : then_columns) {
219
425
            then_ptr = then_ptr->convert_to_full_column_if_const();
220
425
        }
221
222
222
        result_column_ptr->resize(rows_count);
223
222
        auto* __restrict result_raw_data =
224
222
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
225
222
                        ->get_data()
226
222
                        .data();
227
228
        // set default value
229
776
        for (int i = 0; i < rows_count; i++) {
230
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
231
                          std::is_same_v<ColumnType, ColumnDateTime> ||
232
                          std::is_same_v<ColumnType, ColumnDateV2> ||
233
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
234
10
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
235
10
                result_raw_data[i] = ColumnType::default_value();
236
544
            } else {
237
544
                result_raw_data[i] = {};
238
544
            }
239
554
        }
240
241
647
        for (IndexType i = 0; i < then_columns.size(); i++) {
242
425
            if (!then_columns[i]) {
243
0
                continue;
244
0
            }
245
425
            const auto* __restrict column_raw_data =
246
425
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
247
425
                            then_columns[i].get())
248
425
                            ->get_data()
249
425
                            .data();
250
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
251
                          std::is_same_v<ColumnType, ColumnDateTime> ||
252
                          std::is_same_v<ColumnType, ColumnDateV2> ||
253
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
254
6
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
36
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
256
30
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
257
30
                                                                        : result_raw_data[row_idx];
258
30
                }
259
419
            } else {
260
1.73k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
261
1.31k
                    result_raw_data[row_idx] +=
262
1.31k
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
263
1.31k
                            column_raw_data[row_idx];
264
1.31k
                }
265
419
            }
266
425
        }
267
222
    }
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
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
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
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
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
217
15
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
218
49
        for (auto& then_ptr : then_columns) {
219
49
            then_ptr = then_ptr->convert_to_full_column_if_const();
220
49
        }
221
222
15
        result_column_ptr->resize(rows_count);
223
15
        auto* __restrict result_raw_data =
224
15
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
225
15
                        ->get_data()
226
15
                        .data();
227
228
        // set default value
229
123
        for (int i = 0; i < rows_count; i++) {
230
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
231
                          std::is_same_v<ColumnType, ColumnDateTime> ||
232
                          std::is_same_v<ColumnType, ColumnDateV2> ||
233
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
234
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
235
                result_raw_data[i] = ColumnType::default_value();
236
108
            } else {
237
108
                result_raw_data[i] = {};
238
108
            }
239
108
        }
240
241
64
        for (IndexType i = 0; i < then_columns.size(); i++) {
242
49
            if (!then_columns[i]) {
243
0
                continue;
244
0
            }
245
49
            const auto* __restrict column_raw_data =
246
49
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
247
49
                            then_columns[i].get())
248
49
                            ->get_data()
249
49
                            .data();
250
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
251
                          std::is_same_v<ColumnType, ColumnDateTime> ||
252
                          std::is_same_v<ColumnType, ColumnDateV2> ||
253
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
254
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
256
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
257
                                                                        : result_raw_data[row_idx];
258
                }
259
49
            } else {
260
464
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
261
415
                    result_raw_data[row_idx] +=
262
415
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
263
415
                            column_raw_data[row_idx];
264
415
                }
265
49
            }
266
49
        }
267
15
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
217
137
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
218
206
        for (auto& then_ptr : then_columns) {
219
206
            then_ptr = then_ptr->convert_to_full_column_if_const();
220
206
        }
221
222
137
        result_column_ptr->resize(rows_count);
223
137
        auto* __restrict result_raw_data =
224
137
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
225
137
                        ->get_data()
226
137
                        .data();
227
228
        // set default value
229
457
        for (int i = 0; i < rows_count; i++) {
230
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
231
                          std::is_same_v<ColumnType, ColumnDateTime> ||
232
                          std::is_same_v<ColumnType, ColumnDateV2> ||
233
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
234
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
235
                result_raw_data[i] = ColumnType::default_value();
236
320
            } else {
237
320
                result_raw_data[i] = {};
238
320
            }
239
320
        }
240
241
343
        for (IndexType i = 0; i < then_columns.size(); i++) {
242
206
            if (!then_columns[i]) {
243
0
                continue;
244
0
            }
245
206
            const auto* __restrict column_raw_data =
246
206
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
247
206
                            then_columns[i].get())
248
206
                            ->get_data()
249
206
                            .data();
250
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
251
                          std::is_same_v<ColumnType, ColumnDateTime> ||
252
                          std::is_same_v<ColumnType, ColumnDateV2> ||
253
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
254
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
256
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
257
                                                                        : result_raw_data[row_idx];
258
                }
259
206
            } else {
260
804
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
261
598
                    result_raw_data[row_idx] +=
262
598
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
263
598
                            column_raw_data[row_idx];
264
598
                }
265
206
            }
266
206
        }
267
137
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE7EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE8EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE9EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
217
68
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
218
164
        for (auto& then_ptr : then_columns) {
219
164
            then_ptr = then_ptr->convert_to_full_column_if_const();
220
164
        }
221
222
68
        result_column_ptr->resize(rows_count);
223
68
        auto* __restrict result_raw_data =
224
68
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
225
68
                        ->get_data()
226
68
                        .data();
227
228
        // set default value
229
184
        for (int i = 0; i < rows_count; i++) {
230
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
231
                          std::is_same_v<ColumnType, ColumnDateTime> ||
232
                          std::is_same_v<ColumnType, ColumnDateV2> ||
233
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
234
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
235
                result_raw_data[i] = ColumnType::default_value();
236
116
            } else {
237
116
                result_raw_data[i] = {};
238
116
            }
239
116
        }
240
241
232
        for (IndexType i = 0; i < then_columns.size(); i++) {
242
164
            if (!then_columns[i]) {
243
0
                continue;
244
0
            }
245
164
            const auto* __restrict column_raw_data =
246
164
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
247
164
                            then_columns[i].get())
248
164
                            ->get_data()
249
164
                            .data();
250
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
251
                          std::is_same_v<ColumnType, ColumnDateTime> ||
252
                          std::is_same_v<ColumnType, ColumnDateV2> ||
253
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
254
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
256
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
257
                                                                        : result_raw_data[row_idx];
258
                }
259
164
            } else {
260
468
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
261
304
                    result_raw_data[row_idx] +=
262
304
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
263
304
                            column_raw_data[row_idx];
264
304
                }
265
164
            }
266
164
        }
267
68
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
217
2
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
218
6
        for (auto& then_ptr : then_columns) {
219
6
            then_ptr = then_ptr->convert_to_full_column_if_const();
220
6
        }
221
222
2
        result_column_ptr->resize(rows_count);
223
2
        auto* __restrict result_raw_data =
224
2
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
225
2
                        ->get_data()
226
2
                        .data();
227
228
        // set default value
229
12
        for (int i = 0; i < rows_count; i++) {
230
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
231
                          std::is_same_v<ColumnType, ColumnDateTime> ||
232
                          std::is_same_v<ColumnType, ColumnDateV2> ||
233
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
234
10
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
235
10
                result_raw_data[i] = ColumnType::default_value();
236
            } else {
237
                result_raw_data[i] = {};
238
            }
239
10
        }
240
241
8
        for (IndexType i = 0; i < then_columns.size(); i++) {
242
6
            if (!then_columns[i]) {
243
0
                continue;
244
0
            }
245
6
            const auto* __restrict column_raw_data =
246
6
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
247
6
                            then_columns[i].get())
248
6
                            ->get_data()
249
6
                            .data();
250
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
251
                          std::is_same_v<ColumnType, ColumnDateTime> ||
252
                          std::is_same_v<ColumnType, ColumnDateV2> ||
253
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
254
6
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
255
36
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
256
30
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
257
30
                                                                        : result_raw_data[row_idx];
258
30
                }
259
            } else {
260
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
261
                    result_raw_data[row_idx] +=
262
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
263
                            column_raw_data[row_idx];
264
                }
265
            }
266
6
        }
267
2
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
268
269
    template <typename IndexType>
270
    ColumnPtr _execute_impl(const std::vector<ColumnPtr>& when_columns,
271
428
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
272
428
        std::vector<IndexType> then_idx(rows_count, 0);
273
428
        IndexType* __restrict then_idx_ptr = then_idx.data();
274
1.62k
        for (IndexType i = 0; i < when_columns.size(); i++) {
275
1.19k
            IndexType column_idx = i + 1;
276
1.19k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
277
278
1.19k
            if (is_consts) {
279
0
                if (raw_when_column->get_bool(0)) {
280
0
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
281
0
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
282
0
                    }
283
0
                    break;
284
0
                }
285
0
                continue;
286
0
            }
287
288
1.19k
            if (is_column_nullable(*raw_when_column)) {
289
1.12k
                const auto* column_nullable_ptr =
290
1.12k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
291
1.12k
                                raw_when_column.get());
292
1.12k
                const auto* __restrict cond_raw_data =
293
1.12k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
294
1.12k
                                column_nullable_ptr->get_nested_column_ptr().get())
295
1.12k
                                ->get_data()
296
1.12k
                                .data();
297
1.12k
                if (!column_nullable_ptr->has_null()) {
298
28.8k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
299
27.7k
                        then_idx_ptr[row_idx] |=
300
27.7k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
301
27.7k
                    }
302
1.04k
                    continue;
303
1.04k
                }
304
78
                const auto* __restrict cond_raw_nullmap =
305
78
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
306
508
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
307
430
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
308
430
                                              !cond_raw_nullmap[row_idx]) *
309
430
                                             column_idx;
310
430
                }
311
78
            } else {
312
72
                const auto* __restrict cond_raw_data =
313
72
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
314
72
                                raw_when_column.get())
315
72
                                ->get_data()
316
72
                                .data();
317
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
318
201
                    then_idx_ptr[row_idx] |=
319
201
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
320
201
                }
321
72
            }
322
1.19k
        }
323
324
428
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
325
428
    }
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
271
428
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
272
428
        std::vector<IndexType> then_idx(rows_count, 0);
273
428
        IndexType* __restrict then_idx_ptr = then_idx.data();
274
1.62k
        for (IndexType i = 0; i < when_columns.size(); i++) {
275
1.19k
            IndexType column_idx = i + 1;
276
1.19k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
277
278
1.19k
            if (is_consts) {
279
0
                if (raw_when_column->get_bool(0)) {
280
0
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
281
0
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
282
0
                    }
283
0
                    break;
284
0
                }
285
0
                continue;
286
0
            }
287
288
1.19k
            if (is_column_nullable(*raw_when_column)) {
289
1.12k
                const auto* column_nullable_ptr =
290
1.12k
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
291
1.12k
                                raw_when_column.get());
292
1.12k
                const auto* __restrict cond_raw_data =
293
1.12k
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
294
1.12k
                                column_nullable_ptr->get_nested_column_ptr().get())
295
1.12k
                                ->get_data()
296
1.12k
                                .data();
297
1.12k
                if (!column_nullable_ptr->has_null()) {
298
28.8k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
299
27.7k
                        then_idx_ptr[row_idx] |=
300
27.7k
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
301
27.7k
                    }
302
1.04k
                    continue;
303
1.04k
                }
304
78
                const auto* __restrict cond_raw_nullmap =
305
78
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
306
508
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
307
430
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
308
430
                                              !cond_raw_nullmap[row_idx]) *
309
430
                                             column_idx;
310
430
                }
311
78
            } else {
312
72
                const auto* __restrict cond_raw_data =
313
72
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
314
72
                                raw_when_column.get())
315
72
                                ->get_data()
316
72
                                .data();
317
273
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
318
201
                    then_idx_ptr[row_idx] |=
319
201
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
320
201
                }
321
72
            }
322
1.19k
        }
323
324
428
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
325
428
    }
326
327
    bool _has_else_expr;
328
329
    inline static const std::string FUNCTION_NAME = "case";
330
    inline static const std::string EXPR_NAME = "vcase expr";
331
};
332
} // namespace doris