Coverage Report

Created: 2026-09-09 07:36

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/data_type_variant_v2.h"
36
#include "core/data_type/define_primitive_type.h"
37
#include "core/data_type/primitive_type.h"
38
#include "exprs/function/function.h"
39
#include "exprs/function_context.h"
40
#include "exprs/vexpr.h"
41
42
namespace doris {
43
class RowDescriptor;
44
class RuntimeState;
45
class TExprNode;
46
47
class Block;
48
} // namespace doris
49
50
namespace doris {
51
52
class VCaseExpr final : public VExpr {
53
    ENABLE_FACTORY_CREATOR(VCaseExpr);
54
55
public:
56
    VCaseExpr(const TExprNode& node);
57
    ~VCaseExpr() override = default;
58
    Status execute_column_impl(VExprContext* context, const Block* block, const Selector* selector,
59
                               size_t count, ColumnPtr& result_column) const override;
60
    Status prepare(RuntimeState* state, const RowDescriptor& desc, VExprContext* context) override;
61
    Status open(RuntimeState* state, VExprContext* context,
62
                FunctionContext::FunctionStateScope scope) override;
63
    void close(VExprContext* context, FunctionContext::FunctionStateScope scope) override;
64
    const std::string& expr_name() const override;
65
    std::string debug_string() const override;
66
0
    bool has_else_expr() const { return _has_else_expr; }
67
1
    Status clone_node(VExprSPtr* cloned_expr) const override {
68
1
        DORIS_CHECK(cloned_expr != nullptr);
69
1
        auto node = clone_texpr_node();
70
1
        TCaseExpr case_node;
71
1
        case_node.__set_has_case_expr(false);
72
1
        case_node.__set_has_else_expr(_has_else_expr);
73
1
        node.__set_case_expr(case_node);
74
1
        *cloned_expr = VCaseExpr::create_shared(node);
75
1
        return Status::OK();
76
1
    }
77
78
private:
79
    template <typename IndexType, typename ColumnType>
80
    ColumnPtr _execute_update_result_impl(const IndexType* then_idx,
81
                                          std::vector<ColumnPtr>& then_columns,
82
1.74k
                                          size_t rows_count) const {
83
1.74k
        auto result_column_ptr = data_type()->create_column();
84
1.74k
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
102
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
102
            if (data_type()->is_nullable()) {
99
43
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
43
                                                                  then_columns, rows_count);
101
59
            } else {
102
59
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
59
                                                                   then_columns, rows_count);
104
59
            }
105
1.64k
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
59
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
59
                                                              then_columns, rows_count);
109
1.58k
        } else {
110
1.58k
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
1.58k
                                                           then_columns, rows_count);
112
1.58k
        }
113
1.74k
        return result_column_ptr;
114
1.74k
    }
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_13PrimitiveTypeE43EEEEENS_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
82
1.46k
                                          size_t rows_count) const {
83
1.46k
        auto result_column_ptr = data_type()->create_column();
84
1.46k
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
1.46k
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
2
                                                              then_columns, rows_count);
109
1.46k
        } else {
110
1.46k
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
1.46k
                                                           then_columns, rows_count);
112
1.46k
        }
113
1.46k
        return result_column_ptr;
114
1.46k
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE4EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE5EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
40
                                          size_t rows_count) const {
83
40
        auto result_column_ptr = data_type()->create_column();
84
40
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
40
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
40
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
40
                                                              then_columns, rows_count);
109
40
        } else {
110
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
0
                                                           then_columns, rows_count);
112
0
        }
113
40
        return result_column_ptr;
114
40
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
122
                                          size_t rows_count) const {
83
122
        auto result_column_ptr = data_type()->create_column();
84
122
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
122
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
6
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
6
                                                              then_columns, rows_count);
109
116
        } else {
110
116
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
116
                                                           then_columns, rows_count);
112
116
        }
113
122
        return result_column_ptr;
114
122
    }
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
82
3
                                          size_t rows_count) const {
83
3
        auto result_column_ptr = data_type()->create_column();
84
3
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
3
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
3
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
3
                                                              then_columns, rows_count);
109
3
        } else {
110
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
0
                                                           then_columns, rows_count);
112
0
        }
113
3
        return result_column_ptr;
114
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
82
2
                                          size_t rows_count) const {
83
2
        auto result_column_ptr = data_type()->create_column();
84
2
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
2
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
2
                                                              then_columns, rows_count);
109
2
        } else {
110
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
0
                                                           then_columns, rows_count);
112
0
        }
113
2
        return result_column_ptr;
114
2
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
2
                                          size_t rows_count) const {
83
2
        auto result_column_ptr = data_type()->create_column();
84
2
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
2
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
2
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
2
                                                              then_columns, rows_count);
109
2
        } else {
110
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
0
                                                           then_columns, rows_count);
112
0
        }
113
2
        return result_column_ptr;
114
2
    }
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
1
                                          size_t rows_count) const {
83
1
        auto result_column_ptr = data_type()->create_column();
84
1
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
1
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
1
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
1
                                                              then_columns, rows_count);
109
1
        } else {
110
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
0
                                                           then_columns, rows_count);
112
0
        }
113
1
        return result_column_ptr;
114
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_9ColumnStrIjEEEENS_3COWINS_7IColumnEE13immutable_ptrIS5_EEPKT_RSt6vectorIS8_SaIS8_EEm
Line
Count
Source
82
99
                                          size_t rows_count) const {
83
99
        auto result_column_ptr = data_type()->create_column();
84
99
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
99
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
99
            if (data_type()->is_nullable()) {
99
40
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
40
                                                                  then_columns, rows_count);
101
59
            } else {
102
59
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
59
                                                                   then_columns, rows_count);
104
59
            }
105
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
                                                              then_columns, rows_count);
109
        } else {
110
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
                                                           then_columns, rows_count);
112
        }
113
99
        return result_column_ptr;
114
99
    }
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
82
2
                                          size_t rows_count) const {
83
2
        auto result_column_ptr = data_type()->create_column();
84
2
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
2
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
0
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
0
                                                              then_columns, rows_count);
109
2
        } else {
110
2
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
2
                                                           then_columns, rows_count);
112
2
        }
113
2
        return result_column_ptr;
114
2
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
3
                                          size_t rows_count) const {
83
3
        auto result_column_ptr = data_type()->create_column();
84
3
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
            if (data_type()->is_nullable()) {
99
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
                                                                  then_columns, rows_count);
101
            } else {
102
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
                                                                   then_columns, rows_count);
104
            }
105
3
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
3
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
3
                                                              then_columns, rows_count);
109
3
        } else {
110
0
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
0
                                                           then_columns, rows_count);
112
0
        }
113
3
        return result_column_ptr;
114
3
    }
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
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_11ColumnArrayEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Line
Count
Source
82
1
                                          size_t rows_count) const {
83
1
        auto result_column_ptr = data_type()->create_column();
84
1
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
1
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
1
            if (data_type()->is_nullable()) {
99
1
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
1
                                                                  then_columns, rows_count);
101
1
            } else {
102
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
0
                                                                   then_columns, rows_count);
104
0
            }
105
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
                                                              then_columns, rows_count);
109
        } else {
110
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
                                                           then_columns, rows_count);
112
        }
113
1
        return result_column_ptr;
114
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_9ColumnMapEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_12ColumnStructEEENS_3COWINS_7IColumnEE13immutable_ptrIS4_EEPKT_RSt6vectorIS7_SaIS7_EEm
_ZNK5doris9VCaseExpr27_execute_update_result_implIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEEEENS_3COWINS_7IColumnEE13immutable_ptrIS6_EEPKT_RSt6vectorIS9_SaIS9_EEm
Line
Count
Source
82
2
                                          size_t rows_count) const {
83
2
        auto result_column_ptr = data_type()->create_column();
84
2
        result_column_ptr->reserve(rows_count);
85
        if constexpr (std::is_same_v<ColumnType, ColumnString> ||
86
                      std::is_same_v<ColumnType, ColumnBitmap> ||
87
                      std::is_same_v<ColumnType, ColumnArray> ||
88
                      std::is_same_v<ColumnType, ColumnMap> ||
89
                      std::is_same_v<ColumnType, ColumnStruct> ||
90
                      std::is_same_v<ColumnType, ColumnVariant> ||
91
                      std::is_same_v<ColumnType, ColumnVariantV2> ||
92
                      std::is_same_v<ColumnType, ColumnHLL> ||
93
                      std::is_same_v<ColumnType, ColumnQuantileState> ||
94
                      std::is_same_v<ColumnType, ColumnIPv4> ||
95
2
                      std::is_same_v<ColumnType, ColumnIPv6>) {
96
            // result_column and all then_column is not nullable.
97
            // can't simd when type is string.
98
2
            if (data_type()->is_nullable()) {
99
2
                update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
100
2
                                                                  then_columns, rows_count);
101
2
            } else {
102
0
                update_result_normal<IndexType, ColumnType, false>(result_column_ptr, then_idx,
103
0
                                                                   then_columns, rows_count);
104
0
            }
105
        } else if (data_type()->is_nullable()) {
106
            // result_column and all then_column is nullable.
107
            update_result_normal<IndexType, ColumnType, true>(result_column_ptr, then_idx,
108
                                                              then_columns, rows_count);
109
        } else {
110
            update_result_auto_simd<IndexType, ColumnType>(result_column_ptr, then_idx,
111
                                                           then_columns, rows_count);
112
        }
113
2
        return result_column_ptr;
114
2
    }
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
115
116
    template <typename IndexType>
117
    ColumnPtr _execute_update_result(const IndexType* then_idx,
118
                                     std::vector<ColumnPtr>& then_columns,
119
1.74k
                                     size_t rows_count) const {
120
1.74k
#define CASE_TYPE(ptype, coltype) \
121
1.74k
    case PrimitiveType::ptype:    \
122
1.74k
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
123
124
1.74k
        switch (data_type()->get_primitive_type()) {
125
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
126
1.46k
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
127
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
128
40
            CASE_TYPE(TYPE_INT, ColumnInt32)
129
122
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
130
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
131
0
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
132
2
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
133
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
134
2
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
135
2
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
136
1
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
137
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
138
30
            CASE_TYPE(TYPE_STRING, ColumnString)
139
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
140
69
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
141
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
142
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
143
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
144
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
145
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
146
3
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
147
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
148
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
149
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
150
1
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
151
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
152
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
153
2
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
154
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
155
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
156
0
        case PrimitiveType::TYPE_VARIANT: {
157
0
            const IDataType* variant_type = remove_nullable(data_type()).get();
158
0
            if (dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr) {
159
0
                return _execute_update_result_impl<IndexType, ColumnVariantV2>(
160
0
                        then_idx, then_columns, rows_count);
161
0
            }
162
0
            DORIS_CHECK(dynamic_cast<const DataTypeVariant*>(variant_type) != nullptr);
163
0
            return _execute_update_result_impl<IndexType, ColumnVariant>(then_idx, then_columns,
164
0
                                                                         rows_count);
165
0
        }
166
0
        default:
167
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
168
0
                            data_type()->get_name());
169
1.74k
        }
170
1.74k
#undef CASE_TYPE
171
1.74k
    }
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
119
1.74k
                                     size_t rows_count) const {
120
1.74k
#define CASE_TYPE(ptype, coltype) \
121
1.74k
    case PrimitiveType::ptype:    \
122
1.74k
        return _execute_update_result_impl<IndexType, coltype>(then_idx, then_columns, rows_count);
123
124
1.74k
        switch (data_type()->get_primitive_type()) {
125
0
            CASE_TYPE(TYPE_BOOLEAN, ColumnUInt8)
126
1.46k
            CASE_TYPE(TYPE_TINYINT, ColumnInt8)
127
0
            CASE_TYPE(TYPE_SMALLINT, ColumnInt16)
128
40
            CASE_TYPE(TYPE_INT, ColumnInt32)
129
122
            CASE_TYPE(TYPE_BIGINT, ColumnInt64)
130
0
            CASE_TYPE(TYPE_LARGEINT, ColumnInt128)
131
0
            CASE_TYPE(TYPE_FLOAT, ColumnFloat32)
132
2
            CASE_TYPE(TYPE_DOUBLE, ColumnFloat64)
133
0
            CASE_TYPE(TYPE_DECIMAL32, ColumnDecimal32)
134
2
            CASE_TYPE(TYPE_DECIMAL64, ColumnDecimal64)
135
2
            CASE_TYPE(TYPE_DECIMAL256, ColumnDecimal256)
136
1
            CASE_TYPE(TYPE_DECIMAL128I, ColumnDecimal128V3)
137
0
            CASE_TYPE(TYPE_DECIMALV2, ColumnDecimal128V2)
138
30
            CASE_TYPE(TYPE_STRING, ColumnString)
139
0
            CASE_TYPE(TYPE_CHAR, ColumnString)
140
69
            CASE_TYPE(TYPE_VARCHAR, ColumnString)
141
0
            CASE_TYPE(TYPE_JSONB, ColumnString)
142
0
            CASE_TYPE(TYPE_DATE, ColumnDate)
143
0
            CASE_TYPE(TYPE_DATETIME, ColumnDateTime)
144
2
            CASE_TYPE(TYPE_DATEV2, ColumnDateV2)
145
0
            CASE_TYPE(TYPE_DATETIMEV2, ColumnDateTimeV2)
146
3
            CASE_TYPE(TYPE_TIMESTAMP_NS, ColumnTimeStampNs)
147
0
            CASE_TYPE(TYPE_TIMESTAMPTZ, ColumnTimeStampTz)
148
0
            CASE_TYPE(TYPE_IPV6, ColumnIPv6)
149
0
            CASE_TYPE(TYPE_IPV4, ColumnIPv4)
150
1
            CASE_TYPE(TYPE_ARRAY, ColumnArray)
151
0
            CASE_TYPE(TYPE_MAP, ColumnMap)
152
0
            CASE_TYPE(TYPE_STRUCT, ColumnStruct)
153
2
            CASE_TYPE(TYPE_BITMAP, ColumnBitmap)
154
0
            CASE_TYPE(TYPE_HLL, ColumnHLL)
155
0
            CASE_TYPE(TYPE_QUANTILE_STATE, ColumnQuantileState)
156
0
        case PrimitiveType::TYPE_VARIANT: {
157
0
            const IDataType* variant_type = remove_nullable(data_type()).get();
158
0
            if (dynamic_cast<const DataTypeVariantV2*>(variant_type) != nullptr) {
159
0
                return _execute_update_result_impl<IndexType, ColumnVariantV2>(
160
0
                        then_idx, then_columns, rows_count);
161
0
            }
162
0
            DORIS_CHECK(dynamic_cast<const DataTypeVariant*>(variant_type) != nullptr);
163
0
            return _execute_update_result_impl<IndexType, ColumnVariant>(then_idx, then_columns,
164
0
                                                                         rows_count);
165
0
        }
166
0
        default:
167
0
            throw Exception(ErrorCode::NOT_IMPLEMENTED_ERROR, "argument_type {} not supported",
168
0
                            data_type()->get_name());
169
1.74k
        }
170
1.74k
#undef CASE_TYPE
171
1.74k
    }
172
173
    template <typename IndexType, typename ColumnType, bool then_null>
174
    void update_result_normal(MutableColumnPtr& result_column_ptr,
175
                              const IndexType* __restrict then_idx,
176
161
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
161
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
161
        std::vector<uint8_t> is_consts(then_columns.size());
179
161
        std::vector<uint8_t> is_nullable(then_columns.size());
180
490
        for (size_t i = 0; i < then_columns.size(); i++) {
181
329
            if (!then_columns[i]) {
182
10
                continue;
183
10
            }
184
319
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
319
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
319
        }
187
188
161
        auto* raw_result_column = result_column_ptr.get();
189
1.43k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
1.27k
            if (!_has_else_expr && !then_idx[row_idx]) {
191
8
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
8
                        ->insert_default();
193
8
                continue;
194
8
            }
195
1.26k
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
1.26k
            if constexpr (then_null) {
197
1.10k
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
1.10k
                        result_column_ptr.get());
199
1.10k
                if (is_nullable[then_idx[row_idx]]) {
200
95
                    nullable->insert_from_with_type<ColumnType>(
201
95
                            *raw_then_columns[then_idx[row_idx]], target);
202
1.00k
                } else {
203
1.00k
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
1.00k
                            nullable->get_nested_column_ptr().get());
205
1.00k
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
1.00k
                    nullable->push_false_to_nullmap(1);
207
1.00k
                }
208
1.10k
            } else {
209
161
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
161
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
161
            }
212
1.26k
        }
213
161
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE2EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE3EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE4EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE5EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE7EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE8EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE9EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnStrIjEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE43EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE19EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_17ColumnComplexTypeILNS_13PrimitiveTypeE24EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVariantV2ELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalItNS_15ColumnVariantV2ELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_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
176
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
2
        std::vector<uint8_t> is_consts(then_columns.size());
179
2
        std::vector<uint8_t> is_nullable(then_columns.size());
180
5
        for (size_t i = 0; i < then_columns.size(); i++) {
181
3
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
3
        }
187
188
2
        auto* raw_result_column = result_column_ptr.get();
189
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
2
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
2
            if constexpr (then_null) {
197
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
2
                        result_column_ptr.get());
199
2
                if (is_nullable[then_idx[row_idx]]) {
200
2
                    nullable->insert_from_with_type<ColumnType>(
201
2
                            *raw_then_columns[then_idx[row_idx]], target);
202
2
                } else {
203
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
0
                            nullable->get_nested_column_ptr().get());
205
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
0
                    nullable->push_false_to_nullmap(1);
207
0
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
2
        }
213
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
176
40
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
40
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
40
        std::vector<uint8_t> is_consts(then_columns.size());
179
40
        std::vector<uint8_t> is_nullable(then_columns.size());
180
107
        for (size_t i = 0; i < then_columns.size(); i++) {
181
67
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
67
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
67
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
67
        }
187
188
40
        auto* raw_result_column = result_column_ptr.get();
189
98
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
58
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
58
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
58
            if constexpr (then_null) {
197
58
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
58
                        result_column_ptr.get());
199
58
                if (is_nullable[then_idx[row_idx]]) {
200
58
                    nullable->insert_from_with_type<ColumnType>(
201
58
                            *raw_then_columns[then_idx[row_idx]], target);
202
58
                } else {
203
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
0
                            nullable->get_nested_column_ptr().get());
205
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
0
                    nullable->push_false_to_nullmap(1);
207
0
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
58
        }
213
40
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE6EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
176
6
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
6
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
6
        std::vector<uint8_t> is_consts(then_columns.size());
179
6
        std::vector<uint8_t> is_nullable(then_columns.size());
180
16
        for (size_t i = 0; i < then_columns.size(); i++) {
181
10
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
10
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
10
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
10
        }
187
188
6
        auto* raw_result_column = result_column_ptr.get();
189
14
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
8
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
8
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
8
            if constexpr (then_null) {
197
8
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
8
                        result_column_ptr.get());
199
8
                if (is_nullable[then_idx[row_idx]]) {
200
8
                    nullable->insert_from_with_type<ColumnType>(
201
8
                            *raw_then_columns[then_idx[row_idx]], target);
202
8
                } else {
203
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
0
                            nullable->get_nested_column_ptr().get());
205
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
0
                    nullable->push_false_to_nullmap(1);
207
0
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
8
        }
213
6
    }
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
176
3
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
3
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
3
        std::vector<uint8_t> is_consts(then_columns.size());
179
3
        std::vector<uint8_t> is_nullable(then_columns.size());
180
11
        for (size_t i = 0; i < then_columns.size(); i++) {
181
8
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
8
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
8
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
8
        }
187
188
3
        auto* raw_result_column = result_column_ptr.get();
189
13
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
10
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
10
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
10
            if constexpr (then_null) {
197
10
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
10
                        result_column_ptr.get());
199
10
                if (is_nullable[then_idx[row_idx]]) {
200
7
                    nullable->insert_from_with_type<ColumnType>(
201
7
                            *raw_then_columns[then_idx[row_idx]], target);
202
7
                } else {
203
3
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
3
                            nullable->get_nested_column_ptr().get());
205
3
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
3
                    nullable->push_false_to_nullmap(1);
207
3
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
10
        }
213
3
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE28EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
176
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
2
        std::vector<uint8_t> is_consts(then_columns.size());
179
2
        std::vector<uint8_t> is_nullable(then_columns.size());
180
5
        for (size_t i = 0; i < then_columns.size(); i++) {
181
3
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
3
        }
187
188
2
        auto* raw_result_column = result_column_ptr.get();
189
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
2
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
2
            if constexpr (then_null) {
197
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
2
                        result_column_ptr.get());
199
2
                if (is_nullable[then_idx[row_idx]]) {
200
2
                    nullable->insert_from_with_type<ColumnType>(
201
2
                            *raw_then_columns[then_idx[row_idx]], target);
202
2
                } else {
203
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
0
                            nullable->get_nested_column_ptr().get());
205
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
0
                    nullable->push_false_to_nullmap(1);
207
0
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
2
        }
213
2
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
176
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
2
        std::vector<uint8_t> is_consts(then_columns.size());
179
2
        std::vector<uint8_t> is_nullable(then_columns.size());
180
8
        for (size_t i = 0; i < then_columns.size(); i++) {
181
6
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
6
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
6
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
6
        }
187
188
2
        auto* raw_result_column = result_column_ptr.get();
189
6
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
4
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
4
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
4
            if constexpr (then_null) {
197
4
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
4
                        result_column_ptr.get());
199
4
                if (is_nullable[then_idx[row_idx]]) {
200
4
                    nullable->insert_from_with_type<ColumnType>(
201
4
                            *raw_then_columns[then_idx[row_idx]], target);
202
4
                } else {
203
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
0
                            nullable->get_nested_column_ptr().get());
205
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
0
                    nullable->push_false_to_nullmap(1);
207
0
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
4
        }
213
2
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
176
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
1
        std::vector<uint8_t> is_consts(then_columns.size());
179
1
        std::vector<uint8_t> is_nullable(then_columns.size());
180
3
        for (size_t i = 0; i < then_columns.size(); i++) {
181
2
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
2
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
2
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
2
        }
187
188
1
        auto* raw_result_column = result_column_ptr.get();
189
2
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
1
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
1
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
1
            if constexpr (then_null) {
197
1
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
1
                        result_column_ptr.get());
199
1
                if (is_nullable[then_idx[row_idx]]) {
200
1
                    nullable->insert_from_with_type<ColumnType>(
201
1
                            *raw_then_columns[then_idx[row_idx]], target);
202
1
                } else {
203
0
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
0
                            nullable->get_nested_column_ptr().get());
205
0
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
0
                    nullable->push_false_to_nullmap(1);
207
0
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
1
        }
213
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
176
40
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
40
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
40
        std::vector<uint8_t> is_consts(then_columns.size());
179
40
        std::vector<uint8_t> is_nullable(then_columns.size());
180
127
        for (size_t i = 0; i < then_columns.size(); i++) {
181
87
            if (!then_columns[i]) {
182
10
                continue;
183
10
            }
184
77
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
77
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
77
        }
187
188
40
        auto* raw_result_column = result_column_ptr.get();
189
1.04k
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
1.00k
            if (!_has_else_expr && !then_idx[row_idx]) {
191
8
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
8
                        ->insert_default();
193
8
                continue;
194
8
            }
195
999
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
999
            if constexpr (then_null) {
197
999
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
999
                        result_column_ptr.get());
199
999
                if (is_nullable[then_idx[row_idx]]) {
200
0
                    nullable->insert_from_with_type<ColumnType>(
201
0
                            *raw_then_columns[then_idx[row_idx]], target);
202
999
                } else {
203
999
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
999
                            nullable->get_nested_column_ptr().get());
205
999
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
999
                    nullable->push_false_to_nullmap(1);
207
999
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
999
        }
213
40
    }
_ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnStrIjEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS5_EEPKT_RSt6vectorINS6_13immutable_ptrIS5_EESaISF_EEm
Line
Count
Source
176
59
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
59
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
59
        std::vector<uint8_t> is_consts(then_columns.size());
179
59
        std::vector<uint8_t> is_nullable(then_columns.size());
180
184
        for (size_t i = 0; i < then_columns.size(); i++) {
181
125
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
125
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
125
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
125
        }
187
188
59
        auto* raw_result_column = result_column_ptr.get();
189
220
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
161
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
161
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
            if constexpr (then_null) {
197
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
                        result_column_ptr.get());
199
                if (is_nullable[then_idx[row_idx]]) {
200
                    nullable->insert_from_with_type<ColumnType>(
201
                            *raw_then_columns[then_idx[row_idx]], target);
202
                } else {
203
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
                            nullable->get_nested_column_ptr().get());
205
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
                    nullable->push_false_to_nullmap(1);
207
                }
208
161
            } else {
209
161
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
161
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
161
            }
212
161
        }
213
59
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE11EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE12EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE25EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE26EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE43EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
176
3
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
3
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
3
        std::vector<uint8_t> is_consts(then_columns.size());
179
3
        std::vector<uint8_t> is_nullable(then_columns.size());
180
14
        for (size_t i = 0; i < then_columns.size(); i++) {
181
11
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
11
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
11
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
11
        }
187
188
3
        auto* raw_result_column = result_column_ptr.get();
189
16
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
13
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
13
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
13
            if constexpr (then_null) {
197
13
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
13
                        result_column_ptr.get());
199
13
                if (is_nullable[then_idx[row_idx]]) {
200
12
                    nullable->insert_from_with_type<ColumnType>(
201
12
                            *raw_then_columns[then_idx[row_idx]], target);
202
12
                } else {
203
1
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
1
                            nullable->get_nested_column_ptr().get());
205
1
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
1
                    nullable->push_false_to_nullmap(1);
207
1
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
13
        }
213
3
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE42EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE37EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnVectorILNS_13PrimitiveTypeE36EEELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Line
Count
Source
176
1
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
1
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
1
        std::vector<uint8_t> is_consts(then_columns.size());
179
1
        std::vector<uint8_t> is_nullable(then_columns.size());
180
4
        for (size_t i = 0; i < then_columns.size(); i++) {
181
3
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
3
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
3
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
3
        }
187
188
1
        auto* raw_result_column = result_column_ptr.get();
189
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
3
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
3
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
3
            if constexpr (then_null) {
197
3
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
3
                        result_column_ptr.get());
199
3
                if (is_nullable[then_idx[row_idx]]) {
200
1
                    nullable->insert_from_with_type<ColumnType>(
201
1
                            *raw_then_columns[then_idx[row_idx]], target);
202
2
                } else {
203
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
2
                            nullable->get_nested_column_ptr().get());
205
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
2
                    nullable->push_false_to_nullmap(1);
207
2
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
3
        }
213
1
    }
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_11ColumnArrayELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_9ColumnMapELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr20update_result_normalIhNS_12ColumnStructELb0EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS4_EEPKT_RSt6vectorINS5_13immutable_ptrIS4_EESaISE_EEm
_ZNK5doris9VCaseExpr20update_result_normalIhNS_17ColumnComplexTypeILNS_13PrimitiveTypeE22EEELb1EEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Line
Count
Source
176
2
                              std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
177
2
        std::vector<ColumnPtr> raw_then_columns(then_columns.size());
178
2
        std::vector<uint8_t> is_consts(then_columns.size());
179
2
        std::vector<uint8_t> is_nullable(then_columns.size());
180
6
        for (size_t i = 0; i < then_columns.size(); i++) {
181
4
            if (!then_columns[i]) {
182
0
                continue;
183
0
            }
184
4
            std::tie(raw_then_columns[i], is_consts[i]) = unpack_if_const(then_columns[i]);
185
4
            is_nullable[i] = is_column_nullable(*raw_then_columns[i]);
186
4
        }
187
188
2
        auto* raw_result_column = result_column_ptr.get();
189
4
        for (int row_idx = 0; row_idx < rows_count; row_idx++) {
190
2
            if (!_has_else_expr && !then_idx[row_idx]) {
191
0
                assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(raw_result_column)
192
0
                        ->insert_default();
193
0
                continue;
194
0
            }
195
2
            size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx;
196
2
            if constexpr (then_null) {
197
2
                auto* nullable = assert_cast<ColumnNullable*, TypeCheckOnRelease::DISABLE>(
198
2
                        result_column_ptr.get());
199
2
                if (is_nullable[then_idx[row_idx]]) {
200
0
                    nullable->insert_from_with_type<ColumnType>(
201
0
                            *raw_then_columns[then_idx[row_idx]], target);
202
2
                } else {
203
2
                    auto* nested = assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(
204
2
                            nullable->get_nested_column_ptr().get());
205
2
                    nested->insert_from(*raw_then_columns[then_idx[row_idx]], target);
206
2
                    nullable->push_false_to_nullmap(1);
207
2
                }
208
            } else {
209
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
210
                        ->insert_from(*raw_then_columns[then_idx[row_idx]], target);
211
            }
212
2
        }
213
2
    }
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
214
215
    template <typename IndexType, typename ColumnType>
216
    void update_result_auto_simd(MutableColumnPtr& result_column_ptr,
217
                                 const IndexType* __restrict then_idx,
218
1.58k
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
219
2.44k
        for (auto& then_ptr : then_columns) {
220
2.44k
            then_ptr = then_ptr->convert_to_full_column_if_const();
221
2.44k
        }
222
223
1.58k
        result_column_ptr->resize(rows_count);
224
1.58k
        auto* __restrict result_raw_data =
225
1.58k
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
226
1.58k
                        ->get_data()
227
1.58k
                        .data();
228
229
        // set default value
230
3.38k
        for (int i = 0; i < rows_count; i++) {
231
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
232
                          std::is_same_v<ColumnType, ColumnDateTime> ||
233
                          std::is_same_v<ColumnType, ColumnDateV2> ||
234
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
235
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
236
10
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
237
10
                result_raw_data[i] = ColumnType::default_value();
238
1.79k
            } else {
239
1.79k
                result_raw_data[i] = {};
240
1.79k
            }
241
1.80k
        }
242
243
4.02k
        for (IndexType i = 0; i < then_columns.size(); i++) {
244
2.44k
            if (!then_columns[i]) {
245
0
                continue;
246
0
            }
247
2.44k
            const auto* __restrict column_raw_data =
248
2.44k
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
249
2.44k
                            then_columns[i].get())
250
2.44k
                            ->get_data()
251
2.44k
                            .data();
252
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
253
                          std::is_same_v<ColumnType, ColumnDateTime> ||
254
                          std::is_same_v<ColumnType, ColumnDateV2> ||
255
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
256
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
257
6
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
258
36
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
259
30
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
260
30
                                                                        : result_raw_data[row_idx];
261
30
                }
262
2.43k
            } else {
263
5.29k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
264
2.85k
                    result_raw_data[row_idx] +=
265
2.85k
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
266
2.85k
                            column_raw_data[row_idx];
267
2.85k
                }
268
2.43k
            }
269
2.44k
        }
270
1.58k
    }
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_13PrimitiveTypeE43EEEEEvRNS_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
218
1.46k
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
219
2.25k
        for (auto& then_ptr : then_columns) {
220
2.25k
            then_ptr = then_ptr->convert_to_full_column_if_const();
221
2.25k
        }
222
223
1.46k
        result_column_ptr->resize(rows_count);
224
1.46k
        auto* __restrict result_raw_data =
225
1.46k
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
226
1.46k
                        ->get_data()
227
1.46k
                        .data();
228
229
        // set default value
230
2.93k
        for (int i = 0; i < rows_count; i++) {
231
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
232
                          std::is_same_v<ColumnType, ColumnDateTime> ||
233
                          std::is_same_v<ColumnType, ColumnDateV2> ||
234
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
235
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
236
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
237
                result_raw_data[i] = ColumnType::default_value();
238
1.46k
            } else {
239
1.46k
                result_raw_data[i] = {};
240
1.46k
            }
241
1.46k
        }
242
243
3.71k
        for (IndexType i = 0; i < then_columns.size(); i++) {
244
2.25k
            if (!then_columns[i]) {
245
0
                continue;
246
0
            }
247
2.25k
            const auto* __restrict column_raw_data =
248
2.25k
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
249
2.25k
                            then_columns[i].get())
250
2.25k
                            ->get_data()
251
2.25k
                            .data();
252
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
253
                          std::is_same_v<ColumnType, ColumnDateTime> ||
254
                          std::is_same_v<ColumnType, ColumnDateV2> ||
255
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
256
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
257
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
258
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
259
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
260
                                                                        : result_raw_data[row_idx];
261
                }
262
2.25k
            } else {
263
4.50k
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
264
2.25k
                    result_raw_data[row_idx] +=
265
2.25k
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
266
2.25k
                            column_raw_data[row_idx];
267
2.25k
                }
268
2.25k
            }
269
2.25k
        }
270
1.46k
    }
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
218
116
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
219
185
        for (auto& then_ptr : then_columns) {
220
185
            then_ptr = then_ptr->convert_to_full_column_if_const();
221
185
        }
222
223
116
        result_column_ptr->resize(rows_count);
224
116
        auto* __restrict result_raw_data =
225
116
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
226
116
                        ->get_data()
227
116
                        .data();
228
229
        // set default value
230
438
        for (int i = 0; i < rows_count; i++) {
231
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
232
                          std::is_same_v<ColumnType, ColumnDateTime> ||
233
                          std::is_same_v<ColumnType, ColumnDateV2> ||
234
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
235
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
236
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
237
                result_raw_data[i] = ColumnType::default_value();
238
322
            } else {
239
322
                result_raw_data[i] = {};
240
322
            }
241
322
        }
242
243
301
        for (IndexType i = 0; i < then_columns.size(); i++) {
244
185
            if (!then_columns[i]) {
245
0
                continue;
246
0
            }
247
185
            const auto* __restrict column_raw_data =
248
185
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
249
185
                            then_columns[i].get())
250
185
                            ->get_data()
251
185
                            .data();
252
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
253
                          std::is_same_v<ColumnType, ColumnDateTime> ||
254
                          std::is_same_v<ColumnType, ColumnDateV2> ||
255
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
256
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
257
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
258
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
259
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
260
                                                                        : result_raw_data[row_idx];
261
                }
262
185
            } else {
263
784
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
264
599
                    result_raw_data[row_idx] +=
265
599
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
266
599
                            column_raw_data[row_idx];
267
599
                }
268
185
            }
269
185
        }
270
116
    }
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
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE29EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE35EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE30EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
Unexecuted instantiation: _ZNK5doris9VCaseExpr23update_result_auto_simdIhNS_13ColumnDecimalILNS_13PrimitiveTypeE20EEEEEvRNS_3COWINS_7IColumnEE11mutable_ptrIS6_EEPKT_RSt6vectorINS7_13immutable_ptrIS6_EESaISG_EEm
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
218
2
                                 std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
219
6
        for (auto& then_ptr : then_columns) {
220
6
            then_ptr = then_ptr->convert_to_full_column_if_const();
221
6
        }
222
223
2
        result_column_ptr->resize(rows_count);
224
2
        auto* __restrict result_raw_data =
225
2
                assert_cast<ColumnType*, TypeCheckOnRelease::DISABLE>(result_column_ptr.get())
226
2
                        ->get_data()
227
2
                        .data();
228
229
        // set default value
230
12
        for (int i = 0; i < rows_count; i++) {
231
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
232
                          std::is_same_v<ColumnType, ColumnDateTime> ||
233
                          std::is_same_v<ColumnType, ColumnDateV2> ||
234
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
235
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
236
10
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
237
10
                result_raw_data[i] = ColumnType::default_value();
238
            } else {
239
                result_raw_data[i] = {};
240
            }
241
10
        }
242
243
8
        for (IndexType i = 0; i < then_columns.size(); i++) {
244
6
            if (!then_columns[i]) {
245
0
                continue;
246
0
            }
247
6
            const auto* __restrict column_raw_data =
248
6
                    assert_cast<const ColumnType*, TypeCheckOnRelease::DISABLE>(
249
6
                            then_columns[i].get())
250
6
                            ->get_data()
251
6
                            .data();
252
            if constexpr (std::is_same_v<ColumnType, ColumnDate> ||
253
                          std::is_same_v<ColumnType, ColumnDateTime> ||
254
                          std::is_same_v<ColumnType, ColumnDateV2> ||
255
                          std::is_same_v<ColumnType, ColumnDateTimeV2> ||
256
                          std::is_same_v<ColumnType, ColumnTimeStampNs> ||
257
6
                          std::is_same_v<ColumnType, ColumnTimeStampTz>) {
258
36
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
259
30
                    result_raw_data[row_idx] = (then_idx[row_idx] == i) ? column_raw_data[row_idx]
260
30
                                                                        : result_raw_data[row_idx];
261
30
                }
262
            } else {
263
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
264
                    result_raw_data[row_idx] +=
265
                            typename ColumnType::value_type(then_idx[row_idx] == i) *
266
                            column_raw_data[row_idx];
267
                }
268
            }
269
6
        }
270
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_13PrimitiveTypeE43EEEEEvRNS_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
271
272
    template <typename IndexType>
273
    ColumnPtr _execute_impl(const std::vector<ColumnPtr>& when_columns,
274
1.74k
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
275
1.74k
        std::vector<IndexType> then_idx(rows_count, 0);
276
1.74k
        IndexType* __restrict then_idx_ptr = then_idx.data();
277
2.73k
        for (IndexType i = 0; i < when_columns.size(); i++) {
278
1.02k
            IndexType column_idx = i + 1;
279
1.02k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
280
281
1.02k
            if (is_consts) {
282
30
                if (raw_when_column->get_bool(0)) {
283
993
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
284
963
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
285
963
                    }
286
30
                    break;
287
30
                }
288
0
                continue;
289
30
            }
290
291
994
            if (is_column_nullable(*raw_when_column)) {
292
655
                const auto* column_nullable_ptr =
293
655
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
294
655
                                raw_when_column.get());
295
655
                const auto* __restrict cond_raw_data =
296
655
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
297
655
                                column_nullable_ptr->get_nested_column_ptr().get())
298
655
                                ->get_data()
299
655
                                .data();
300
655
                if (!column_nullable_ptr->has_null()) {
301
1.43k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
302
830
                        then_idx_ptr[row_idx] |=
303
830
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
304
830
                    }
305
607
                    continue;
306
607
                }
307
48
                const auto* __restrict cond_raw_nullmap =
308
48
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
309
276
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
310
228
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
311
228
                                              !cond_raw_nullmap[row_idx]) *
312
228
                                             column_idx;
313
228
                }
314
339
            } else {
315
339
                const auto* __restrict cond_raw_data =
316
339
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
317
339
                                raw_when_column.get())
318
339
                                ->get_data()
319
339
                                .data();
320
762
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
321
423
                    then_idx_ptr[row_idx] |=
322
423
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
323
423
                }
324
339
            }
325
994
        }
326
327
1.74k
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
328
1.74k
    }
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
274
1.74k
                            std::vector<ColumnPtr>& then_columns, size_t rows_count) const {
275
1.74k
        std::vector<IndexType> then_idx(rows_count, 0);
276
1.74k
        IndexType* __restrict then_idx_ptr = then_idx.data();
277
2.73k
        for (IndexType i = 0; i < when_columns.size(); i++) {
278
1.02k
            IndexType column_idx = i + 1;
279
1.02k
            auto [raw_when_column, is_consts] = unpack_if_const(when_columns[i]);
280
281
1.02k
            if (is_consts) {
282
30
                if (raw_when_column->get_bool(0)) {
283
993
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
284
963
                        then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx]) * column_idx;
285
963
                    }
286
30
                    break;
287
30
                }
288
0
                continue;
289
30
            }
290
291
994
            if (is_column_nullable(*raw_when_column)) {
292
655
                const auto* column_nullable_ptr =
293
655
                        assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
294
655
                                raw_when_column.get());
295
655
                const auto* __restrict cond_raw_data =
296
655
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
297
655
                                column_nullable_ptr->get_nested_column_ptr().get())
298
655
                                ->get_data()
299
655
                                .data();
300
655
                if (!column_nullable_ptr->has_null()) {
301
1.43k
                    for (int row_idx = 0; row_idx < rows_count; row_idx++) {
302
830
                        then_idx_ptr[row_idx] |=
303
830
                                (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
304
830
                    }
305
607
                    continue;
306
607
                }
307
48
                const auto* __restrict cond_raw_nullmap =
308
48
                        column_nullable_ptr->get_null_map_column_ptr()->get_data().data();
309
276
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
310
228
                    then_idx_ptr[row_idx] |= (!then_idx_ptr[row_idx] * cond_raw_data[row_idx] *
311
228
                                              !cond_raw_nullmap[row_idx]) *
312
228
                                             column_idx;
313
228
                }
314
339
            } else {
315
339
                const auto* __restrict cond_raw_data =
316
339
                        assert_cast<const ColumnUInt8*, TypeCheckOnRelease::DISABLE>(
317
339
                                raw_when_column.get())
318
339
                                ->get_data()
319
339
                                .data();
320
762
                for (int row_idx = 0; row_idx < rows_count; row_idx++) {
321
423
                    then_idx_ptr[row_idx] |=
322
423
                            (!then_idx_ptr[row_idx]) * cond_raw_data[row_idx] * column_idx;
323
423
                }
324
339
            }
325
994
        }
326
327
1.74k
        return _execute_update_result<IndexType>(then_idx_ptr, then_columns, rows_count);
328
1.74k
    }
329
330
    bool _has_else_expr;
331
332
    inline static const std::string FUNCTION_NAME = "case";
333
    inline static const std::string EXPR_NAME = "vcase expr";
334
};
335
} // namespace doris