Coverage Report

Created: 2026-06-05 04:09

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exprs/function/dictionary.cpp
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
#include "exprs/function/dictionary.h"
19
20
#include <variant>
21
22
#include "core/column/column.h"
23
#include "core/data_type/data_type_decimal.h"
24
#include "core/data_type/data_type_ipv4.h"
25
#include "core/data_type/data_type_nullable.h"
26
#include "core/data_type/data_type_number.h" // IWYU pragma: keep
27
#include "runtime/thread_context.h"
28
29
namespace doris {
30
31
IDictionary::IDictionary(std::string name, std::vector<DictionaryAttribute> attributes)
32
770
        : _dict_name(std::move(name)), _attributes(std::move(attributes)) {
33
1.60k
    for (size_t i = 0; i < _attributes.size(); i++) {
34
831
        const auto& nested_name = _attributes[i].name;
35
831
        if (_name_to_attributes_index.contains(nested_name)) {
36
0
            throw doris::Exception(ErrorCode::INVALID_ARGUMENT,
37
0
                                   "The names of attributes should not have duplicates : {}",
38
0
                                   nested_name);
39
0
        }
40
831
        _name_to_attributes_index[nested_name] = i;
41
831
    }
42
770
}
43
44
722
IDictionary::~IDictionary() {
45
722
    if (_mem_tracker) {
46
23
        SCOPED_SWITCH_THREAD_MEM_TRACKER_LIMITER(_mem_tracker);
47
23
        std::vector<ValueData> {}.swap(_values_data);
48
23
        std::string {}.swap(_dict_name);
49
23
        std::vector<DictionaryAttribute> {}.swap(_attributes);
50
23
        _name_to_attributes_index.clear();
51
23
    }
52
722
}
53
54
0
bool IDictionary::has_attribute(const std::string& name) const {
55
0
    return _name_to_attributes_index.contains(name);
56
0
}
57
58
2.53k
size_t IDictionary::attribute_index(const std::string& name) const {
59
2.53k
    auto it = _name_to_attributes_index.find(name);
60
2.53k
    if (it == _name_to_attributes_index.end()) {
61
0
        throw doris::Exception(ErrorCode::INVALID_ARGUMENT, "no this attribute : {}", name);
62
0
    }
63
2.53k
    size_t idx = it->second;
64
2.53k
    return idx;
65
2.53k
}
66
67
0
bool IDictionary::attribute_is_nullable(size_t idx) const {
68
0
    return _attributes[idx].type->is_nullable();
69
0
}
70
71
std::variant<std::false_type, std::true_type> IDictionary::attribute_nullable_variant(
72
1.26k
        size_t idx) const {
73
1.26k
    return make_bool_variant(_attributes[idx].type->is_nullable());
74
1.26k
}
75
76
230
DataTypePtr IDictionary::get_attribute_type(const std::string& name) const {
77
230
    auto it = _name_to_attributes_index.find(name);
78
230
    if (it == _name_to_attributes_index.end()) {
79
0
        throw doris::Exception(ErrorCode::INVALID_ARGUMENT, "no this attribute : {}", name);
80
0
    }
81
230
    size_t idx = it->second;
82
230
    return remove_nullable(_attributes[idx].type);
83
230
}
84
85
5.43k
size_t IDictionary::allocated_bytes() const {
86
5.43k
    size_t bytes = 0;
87
10.3k
    for (const auto& value_data : _values_data) {
88
10.3k
        std::visit(
89
10.3k
                [&](auto&& arg) {
90
10.3k
                    const auto* column = arg.get();
91
10.3k
                    bytes += column->allocated_bytes();
92
10.3k
                    if (arg.get_null_map()) {
93
1.28k
                        bytes += arg.get_null_map()->allocated_bytes();
94
1.28k
                    }
95
10.3k
                },
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE2EEEEEEEDaOT_
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE3EEEEEEEDaOT_
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE4EEEEEEEDaOT_
dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE5EEEEEEEDaOT_
Line
Count
Source
89
2.18k
                [&](auto&& arg) {
90
2.18k
                    const auto* column = arg.get();
91
2.18k
                    bytes += column->allocated_bytes();
92
2.18k
                    if (arg.get_null_map()) {
93
737
                        bytes += arg.get_null_map()->allocated_bytes();
94
737
                    }
95
2.18k
                },
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE6EEEEEEEDaOT_
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE7EEEEEEEDaOT_
dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE8EEEEEEEDaOT_
Line
Count
Source
89
183
                [&](auto&& arg) {
90
183
                    const auto* column = arg.get();
91
183
                    bytes += column->allocated_bytes();
92
183
                    if (arg.get_null_map()) {
93
0
                        bytes += arg.get_null_map()->allocated_bytes();
94
0
                    }
95
183
                },
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeNumberILNS_13PrimitiveTypeE9EEEEEEEDaOT_
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_12DataTypeIPv4EEEEEDaOT_
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_12DataTypeIPv6EEEEEDaOT_
dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeStringEEEEEDaOT_
Line
Count
Source
89
6.66k
                [&](auto&& arg) {
90
6.66k
                    const auto* column = arg.get();
91
6.66k
                    bytes += column->allocated_bytes();
92
6.66k
                    if (arg.get_null_map()) {
93
552
                        bytes += arg.get_null_map()->allocated_bytes();
94
552
                    }
95
6.66k
                },
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaOT_
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_14DataTypeDateV2EEEEEDaOT_
dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_18DataTypeDateTimeV2EEEEEDaOT_
Line
Count
Source
89
916
                [&](auto&& arg) {
90
916
                    const auto* column = arg.get();
91
916
                    bytes += column->allocated_bytes();
92
916
                    if (arg.get_null_map()) {
93
0
                        bytes += arg.get_null_map()->allocated_bytes();
94
0
                    }
95
916
                },
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_15DataTypeDecimalILNS_13PrimitiveTypeE28EEEEEEEDaOT_
dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_15DataTypeDecimalILNS_13PrimitiveTypeE29EEEEEEEDaOT_
Line
Count
Source
89
182
                [&](auto&& arg) {
90
182
                    const auto* column = arg.get();
91
182
                    bytes += column->allocated_bytes();
92
182
                    if (arg.get_null_map()) {
93
0
                        bytes += arg.get_null_map()->allocated_bytes();
94
0
                    }
95
182
                },
dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_15DataTypeDecimalILNS_13PrimitiveTypeE30EEEEEEEDaOT_
Line
Count
Source
89
181
                [&](auto&& arg) {
90
181
                    const auto* column = arg.get();
91
181
                    bytes += column->allocated_bytes();
92
181
                    if (arg.get_null_map()) {
93
0
                        bytes += arg.get_null_map()->allocated_bytes();
94
0
                    }
95
181
                },
Unexecuted instantiation: dictionary.cpp:_ZZNK5doris11IDictionary15allocated_bytesEvENK3$_0clIRKNS0_14ColumnWithTypeINS_15DataTypeDecimalILNS_13PrimitiveTypeE35EEEEEEEDaOT_
96
10.3k
                value_data);
97
10.3k
    }
98
5.43k
    return bytes;
99
5.43k
}
100
101
765
void IDictionary::load_values(const std::vector<ColumnPtr>& values_column) {
102
    // load value column
103
765
    _values_data.resize(values_column.size());
104
1.59k
    for (size_t i = 0; i < values_column.size(); i++) {
105
826
        const DataTypePtr value_type_without_nullable = remove_nullable(_attributes[i].type);
106
826
        ColumnPtr value_column_without_nullable = remove_nullable(values_column[i]);
107
826
        if (_attributes[i].type->is_nullable() != values_column[i]->is_nullable()) {
108
0
            throw doris::Exception(
109
0
                    ErrorCode::INVALID_ARGUMENT,
110
0
                    "Dictionary({}) attribute {} type is : {} , column is : {}  Not supported",
111
0
                    dict_name(), _attributes[i].name, _attributes[i].type->get_name(),
112
0
                    values_column[i]->get_name());
113
0
        }
114
826
        bool valid =
115
826
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
826
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
826
                    auto& att = _values_data[i];
118
826
                    auto init_column_with_type = [&](auto& column_with_type) {
119
826
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
826
                        column_with_type.column =
121
826
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
826
                        if (values_column[i]->is_nullable()) {
124
17
                            column_with_type.null_map =
125
17
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
17
                                            values_column[i].get())
127
17
                                            ->get_null_map_column_ptr();
128
809
                        } else {
129
809
                            column_with_type.null_map = nullptr;
130
809
                        }
131
826
                        att = column_with_type;
132
826
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE2EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE2EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE3EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE3EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE4EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE4EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE5EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE5EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
89
                    auto init_column_with_type = [&](auto& column_with_type) {
119
89
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
89
                        column_with_type.column =
121
89
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
89
                        if (values_column[i]->is_nullable()) {
124
11
                            column_with_type.null_map =
125
11
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
11
                                            values_column[i].get())
127
11
                                            ->get_null_map_column_ptr();
128
78
                        } else {
129
78
                            column_with_type.null_map = nullptr;
130
78
                        }
131
89
                        att = column_with_type;
132
89
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE6EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE6EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
58
                    auto init_column_with_type = [&](auto& column_with_type) {
119
58
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
58
                        column_with_type.column =
121
58
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
58
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
58
                        } else {
129
58
                            column_with_type.null_map = nullptr;
130
58
                        }
131
58
                        att = column_with_type;
132
58
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE7EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE7EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE8EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE8EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
55
                    auto init_column_with_type = [&](auto& column_with_type) {
119
55
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
55
                        column_with_type.column =
121
55
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
55
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
55
                        } else {
129
55
                            column_with_type.null_map = nullptr;
130
55
                        }
131
55
                        att = column_with_type;
132
55
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE9EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE9EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_12DataTypeIPv4EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSH_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_12DataTypeIPv4EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeISD_EEEEDaSH_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_12DataTypeIPv6EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSH_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_12DataTypeIPv6EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeISD_EEEEDaSH_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeStringEEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSH_
Line
Count
Source
118
27
                    auto init_column_with_type = [&](auto& column_with_type) {
119
27
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
27
                        column_with_type.column =
121
27
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
27
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
27
                        } else {
129
27
                            column_with_type.null_map = nullptr;
130
27
                        }
131
27
                        att = column_with_type;
132
27
                    };
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeStringEEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeISD_EEEEDaSH_
Line
Count
Source
118
105
                    auto init_column_with_type = [&](auto& column_with_type) {
119
105
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
105
                        column_with_type.column =
121
105
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
105
                        if (values_column[i]->is_nullable()) {
124
6
                            column_with_type.null_map =
125
6
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
6
                                            values_column[i].get())
127
6
                                            ->get_null_map_column_ptr();
128
99
                        } else {
129
99
                            column_with_type.null_map = nullptr;
130
99
                        }
131
105
                        att = column_with_type;
132
105
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeDateV2EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSH_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeDateV2EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeISD_EEEEDaSH_
Line
Count
Source
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_18DataTypeDateTimeV2EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSH_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_18DataTypeDateTimeV2EEEDaRKT_ENKUlRSE_E_clINS0_14ColumnWithTypeISD_EEEEDaSH_
Line
Count
Source
118
69
                    auto init_column_with_type = [&](auto& column_with_type) {
119
69
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
69
                        column_with_type.column =
121
69
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
69
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
69
                        } else {
129
69
                            column_with_type.null_map = nullptr;
130
69
                        }
131
69
                        att = column_with_type;
132
69
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE28EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE28EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE29EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE29EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
4
                    auto init_column_with_type = [&](auto& column_with_type) {
119
4
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
4
                        column_with_type.column =
121
4
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
4
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
4
                        } else {
129
4
                            column_with_type.null_map = nullptr;
130
4
                        }
131
4
                        att = column_with_type;
132
4
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE30EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE30EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
Line
Count
Source
118
3
                    auto init_column_with_type = [&](auto& column_with_type) {
119
3
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
3
                        column_with_type.column =
121
3
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
3
                        if (values_column[i]->is_nullable()) {
124
0
                            column_with_type.null_map =
125
0
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
0
                                            values_column[i].get())
127
0
                                            ->get_null_map_column_ptr();
128
3
                        } else {
129
3
                            column_with_type.null_map = nullptr;
130
3
                        }
131
3
                        att = column_with_type;
132
3
                    };
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE35EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeINS0_20DictDataTypeString64EEEEEDaSJ_
Unexecuted instantiation: dictionary.cpp:_ZZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE35EEEEEDaRKT_ENKUlRSG_E_clINS0_14ColumnWithTypeISF_EEEEDaSJ_
133
134
826
                    if (value_column_without_nullable->is_column_string64()) {
135
27
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
27
                        init_column_with_type(column_with_type);
137
799
                    } else {
138
799
                        ColumnWithType<ValueRealDataType> column_with_type;
139
799
                        init_column_with_type(column_with_type);
140
799
                    }
141
826
                    return true;
142
826
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE2EEEEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE3EEEEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE4EEEEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE5EEEEEDaRKT_
Line
Count
Source
115
89
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
89
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
89
                    auto& att = _values_data[i];
118
89
                    auto init_column_with_type = [&](auto& column_with_type) {
119
89
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
89
                        column_with_type.column =
121
89
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
89
                        if (values_column[i]->is_nullable()) {
124
89
                            column_with_type.null_map =
125
89
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
89
                                            values_column[i].get())
127
89
                                            ->get_null_map_column_ptr();
128
89
                        } else {
129
89
                            column_with_type.null_map = nullptr;
130
89
                        }
131
89
                        att = column_with_type;
132
89
                    };
133
134
89
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
89
                    } else {
138
89
                        ColumnWithType<ValueRealDataType> column_with_type;
139
89
                        init_column_with_type(column_with_type);
140
89
                    }
141
89
                    return true;
142
89
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE6EEEEEDaRKT_
Line
Count
Source
115
58
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
58
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
58
                    auto& att = _values_data[i];
118
58
                    auto init_column_with_type = [&](auto& column_with_type) {
119
58
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
58
                        column_with_type.column =
121
58
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
58
                        if (values_column[i]->is_nullable()) {
124
58
                            column_with_type.null_map =
125
58
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
58
                                            values_column[i].get())
127
58
                                            ->get_null_map_column_ptr();
128
58
                        } else {
129
58
                            column_with_type.null_map = nullptr;
130
58
                        }
131
58
                        att = column_with_type;
132
58
                    };
133
134
58
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
58
                    } else {
138
58
                        ColumnWithType<ValueRealDataType> column_with_type;
139
58
                        init_column_with_type(column_with_type);
140
58
                    }
141
58
                    return true;
142
58
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE7EEEEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE8EEEEEDaRKT_
Line
Count
Source
115
55
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
55
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
55
                    auto& att = _values_data[i];
118
55
                    auto init_column_with_type = [&](auto& column_with_type) {
119
55
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
55
                        column_with_type.column =
121
55
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
55
                        if (values_column[i]->is_nullable()) {
124
55
                            column_with_type.null_map =
125
55
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
55
                                            values_column[i].get())
127
55
                                            ->get_null_map_column_ptr();
128
55
                        } else {
129
55
                            column_with_type.null_map = nullptr;
130
55
                        }
131
55
                        att = column_with_type;
132
55
                    };
133
134
55
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
55
                    } else {
138
55
                        ColumnWithType<ValueRealDataType> column_with_type;
139
55
                        init_column_with_type(column_with_type);
140
55
                    }
141
55
                    return true;
142
55
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeNumberILNS_13PrimitiveTypeE9EEEEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_12DataTypeIPv4EEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_12DataTypeIPv6EEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeStringEEEDaRKT_
Line
Count
Source
115
132
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
132
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
132
                    auto& att = _values_data[i];
118
132
                    auto init_column_with_type = [&](auto& column_with_type) {
119
132
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
132
                        column_with_type.column =
121
132
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
132
                        if (values_column[i]->is_nullable()) {
124
132
                            column_with_type.null_map =
125
132
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
132
                                            values_column[i].get())
127
132
                                            ->get_null_map_column_ptr();
128
132
                        } else {
129
132
                            column_with_type.null_map = nullptr;
130
132
                        }
131
132
                        att = column_with_type;
132
132
                    };
133
134
132
                    if (value_column_without_nullable->is_column_string64()) {
135
27
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
27
                        init_column_with_type(column_with_type);
137
105
                    } else {
138
105
                        ColumnWithType<ValueRealDataType> column_with_type;
139
105
                        init_column_with_type(column_with_type);
140
105
                    }
141
132
                    return true;
142
132
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_14DataTypeDateV2EEEDaRKT_
Line
Count
Source
115
52
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
52
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
52
                    auto& att = _values_data[i];
118
52
                    auto init_column_with_type = [&](auto& column_with_type) {
119
52
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
52
                        column_with_type.column =
121
52
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
52
                        if (values_column[i]->is_nullable()) {
124
52
                            column_with_type.null_map =
125
52
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
52
                                            values_column[i].get())
127
52
                                            ->get_null_map_column_ptr();
128
52
                        } else {
129
52
                            column_with_type.null_map = nullptr;
130
52
                        }
131
52
                        att = column_with_type;
132
52
                    };
133
134
52
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
52
                    } else {
138
52
                        ColumnWithType<ValueRealDataType> column_with_type;
139
52
                        init_column_with_type(column_with_type);
140
52
                    }
141
52
                    return true;
142
52
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_18DataTypeDateTimeV2EEEDaRKT_
Line
Count
Source
115
69
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
69
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
69
                    auto& att = _values_data[i];
118
69
                    auto init_column_with_type = [&](auto& column_with_type) {
119
69
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
69
                        column_with_type.column =
121
69
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
69
                        if (values_column[i]->is_nullable()) {
124
69
                            column_with_type.null_map =
125
69
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
69
                                            values_column[i].get())
127
69
                                            ->get_null_map_column_ptr();
128
69
                        } else {
129
69
                            column_with_type.null_map = nullptr;
130
69
                        }
131
69
                        att = column_with_type;
132
69
                    };
133
134
69
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
69
                    } else {
138
69
                        ColumnWithType<ValueRealDataType> column_with_type;
139
69
                        init_column_with_type(column_with_type);
140
69
                    }
141
69
                    return true;
142
69
                });
Unexecuted instantiation: dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE28EEEEEDaRKT_
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE29EEEEEDaRKT_
Line
Count
Source
115
4
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
4
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
4
                    auto& att = _values_data[i];
118
4
                    auto init_column_with_type = [&](auto& column_with_type) {
119
4
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
4
                        column_with_type.column =
121
4
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
4
                        if (values_column[i]->is_nullable()) {
124
4
                            column_with_type.null_map =
125
4
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
4
                                            values_column[i].get())
127
4
                                            ->get_null_map_column_ptr();
128
4
                        } else {
129
4
                            column_with_type.null_map = nullptr;
130
4
                        }
131
4
                        att = column_with_type;
132
4
                    };
133
134
4
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
4
                    } else {
138
4
                        ColumnWithType<ValueRealDataType> column_with_type;
139
4
                        init_column_with_type(column_with_type);
140
4
                    }
141
4
                    return true;
142
4
                });
dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE30EEEEEDaRKT_
Line
Count
Source
115
3
                IDictionary::cast_type(value_type_without_nullable.get(), [&](const auto& type) {
116
3
                    using ValueRealDataType = std::decay_t<decltype(type)>;
117
3
                    auto& att = _values_data[i];
118
3
                    auto init_column_with_type = [&](auto& column_with_type) {
119
3
                        using Type = std::decay_t<decltype(column_with_type)>::RealColumnType;
120
3
                        column_with_type.column =
121
3
                                cast_to_column<Type>(value_column_without_nullable);
122
                        // if original value is nullable, the null_map must be not null
123
3
                        if (values_column[i]->is_nullable()) {
124
3
                            column_with_type.null_map =
125
3
                                    assert_cast<const ColumnNullable*, TypeCheckOnRelease::DISABLE>(
126
3
                                            values_column[i].get())
127
3
                                            ->get_null_map_column_ptr();
128
3
                        } else {
129
3
                            column_with_type.null_map = nullptr;
130
3
                        }
131
3
                        att = column_with_type;
132
3
                    };
133
134
3
                    if (value_column_without_nullable->is_column_string64()) {
135
0
                        ColumnWithType<DictDataTypeString64> column_with_type;
136
0
                        init_column_with_type(column_with_type);
137
3
                    } else {
138
3
                        ColumnWithType<ValueRealDataType> column_with_type;
139
3
                        init_column_with_type(column_with_type);
140
3
                    }
141
3
                    return true;
142
3
                });
Unexecuted instantiation: dictionary.cpp:_ZZN5doris11IDictionary11load_valuesERKSt6vectorINS_3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEENK3$_0clINS_15DataTypeDecimalILNS_13PrimitiveTypeE35EEEEEDaRKT_
143
826
        if (!valid) {
144
0
            throw doris::Exception(
145
0
                    ErrorCode::INVALID_ARGUMENT,
146
0
                    "Dictionary({}) attribute {} type is : {} , column is : {}  Not supported",
147
0
                    dict_name(), _attributes[i].name, _attributes[i].type->get_name(),
148
0
                    values_column[i]->get_name());
149
0
        }
150
826
    }
151
765
}
152
153
} // namespace doris