Coverage Report

Created: 2026-03-24 05:59

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/storage/olap_scan_common.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 <gen_cpp/Metrics_types.h>
21
#include <gen_cpp/PaloInternalService_types.h>
22
#include <glog/logging.h>
23
#include <stddef.h>
24
25
#include <boost/container/detail/std_fwd.hpp>
26
#include <boost/lexical_cast.hpp>
27
#include <cstdint>
28
#include <iterator>
29
#include <limits>
30
#include <memory>
31
#include <set>
32
#include <sstream>
33
#include <string>
34
#include <utility>
35
#include <variant>
36
#include <vector>
37
38
#include "common/compare.h"
39
#include "common/status.h"
40
#include "core/data_type/define_primitive_type.h"
41
#include "core/data_type/primitive_type.h"
42
#include "core/type_limit.h"
43
#include "core/types.h"
44
#include "core/value/ipv4_value.h"
45
#include "core/value/ipv6_value.h"
46
#include "core/value/time_value.h"
47
#include "core/value/vdatetime_value.h"
48
#include "exprs/function/cast/cast_to_string.h"
49
#include "runtime/runtime_profile.h"
50
#include "storage/olap_common.h"
51
#include "storage/olap_tuple.h"
52
#include "storage/olap_utils.h"
53
#include "storage/predicate/filter_olap_param.h"
54
#include "util/io_helper.h"
55
56
namespace doris {
57
#include "common/compile_check_begin.h"
58
59
template <PrimitiveType primitive_type, class T>
60
1.64M
std::string cast_to_string(T value, int scale) {
61
1.64M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.51k
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.67k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.67k
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.92k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.92k
        return ((Decimal<int128_t>)value).to_string(scale);
67
2.92k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
981
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
208k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
208k
        return std::to_string(static_cast<int>(value));
71
208k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.77k
        return int128_to_string(value);
73
8.77k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.91k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.91k
        char buf[30];
76
4.91k
        datetimev2_val.to_string(buf);
77
4.91k
        std::stringstream ss;
78
4.91k
        ss << buf;
79
4.91k
        return ss.str();
80
5.82k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
5.82k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
5.82k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
0
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
0
        return IPv4Value::to_string(value);
87
4
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
4
        return IPv6Value::to_string(value);
89
3.11k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.11k
        return CastToString::from_number(value);
91
1.40M
    } else {
92
1.40M
        return boost::lexical_cast<std::string>(value);
93
1.40M
    }
94
1.64M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
208k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
208k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
208k
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
208k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE4EsEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
22.2k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
22.2k
    } else {
92
22.2k
        return boost::lexical_cast<std::string>(value);
93
22.2k
    }
94
22.2k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE5EiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
160k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
160k
    } else {
92
160k
        return boost::lexical_cast<std::string>(value);
93
160k
    }
94
160k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
170k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
170k
    } else {
92
170k
        return boost::lexical_cast<std::string>(value);
93
170k
    }
94
170k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
8.77k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
8.77k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.77k
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
8.77k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE8EfEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE9EdEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE36EjEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE37EoEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
4
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
4
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
4
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE15ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
978
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
978
    } else {
92
978
        return boost::lexical_cast<std::string>(value);
93
978
    }
94
978
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
778k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
778k
    } else {
92
778k
        return boost::lexical_cast<std::string>(value);
93
778k
    }
94
778k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE23ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE11ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
590
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
590
    } else {
92
590
        return boost::lexical_cast<std::string>(value);
93
590
    }
94
590
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
269k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
269k
    } else {
92
269k
        return boost::lexical_cast<std::string>(value);
93
269k
    }
94
269k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE12ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
76
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
76
    } else {
92
76
        return boost::lexical_cast<std::string>(value);
93
76
    }
94
76
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE26ENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4.91k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
4.91k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.91k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.91k
        char buf[30];
76
4.91k
        datetimev2_val.to_string(buf);
77
4.91k
        std::stringstream ss;
78
4.91k
        ss << buf;
79
4.91k
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
4.91k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE42ENS_16TimestampTzValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
5.82k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
5.82k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
5.82k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
5.82k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
5.82k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE20ENS_14DecimalV2ValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
168
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
168
    } else {
92
168
        return boost::lexical_cast<std::string>(value);
93
168
    }
94
168
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.11k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
3.11k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.11k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
3.11k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE19ENS_9StringRefEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE28ENS_7DecimalIiEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.51k
std::string cast_to_string(T value, int scale) {
61
1.51k
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.51k
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
1.51k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.67k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.67k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.67k
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
1.67k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
2.92k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.92k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.92k
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
2.92k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
981
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
981
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
981
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
981
}
95
96
/**
97
 * @brief Column's value range
98
 **/
99
template <PrimitiveType primitive_type>
100
class ColumnValueRange {
101
public:
102
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
103
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
104
    using SetType = std::set<CppType, doris::Less<CppType>>;
105
    using IteratorType = typename SetType::iterator;
106
107
    ColumnValueRange();
108
109
    ColumnValueRange(std::string col_name, bool is_nullable_col, int precision, int scale);
110
111
    // should add fixed value before add range
112
    Status add_fixed_value(const CppType& value);
113
114
    // should remove fixed value after add fixed value
115
    void remove_fixed_value(const CppType& value);
116
117
    Status add_range(SQLFilterOp op, CppType value);
118
119
    bool is_fixed_value_range() const;
120
121
    bool is_scope_value_range() const;
122
123
    bool is_empty_value_range() const;
124
125
    bool is_fixed_value_convertible() const;
126
127
    bool is_range_value_convertible() const;
128
129
    void convert_to_range_value();
130
131
    bool convert_to_avg_range_value(std::vector<OlapTuple>& begin_scan_keys,
132
                                    std::vector<OlapTuple>& end_scan_keys, bool& begin_include,
133
                                    bool& end_include, int32_t max_scan_key_num);
134
135
    bool convert_to_close_range(std::vector<OlapTuple>& begin_scan_keys,
136
                                std::vector<OlapTuple>& end_scan_keys, bool& begin_include,
137
                                bool& end_include);
138
139
157k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
2.42k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_reject_split_typeEv
Line
Count
Source
139
229
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_reject_split_typeEv
Line
Count
Source
139
65.7k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
82.2k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
4.18k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_reject_split_typeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_reject_split_typeEv
Line
Count
Source
139
1
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_reject_split_typeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_reject_split_typeEv
Line
Count
Source
139
6
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_reject_split_typeEv
Line
Count
Source
139
2.87k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_reject_split_typeEv
140
141
    void intersection(ColumnValueRange<primitive_type>& range);
142
143
25.2k
    void set_empty_value_range() {
144
25.2k
        _fixed_values.clear();
145
25.2k
        _low_value = TYPE_MAX;
146
25.2k
        _high_value = TYPE_MIN;
147
25.2k
        _contain_null = false;
148
25.2k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
141
    void set_empty_value_range() {
144
141
        _fixed_values.clear();
145
141
        _low_value = TYPE_MAX;
146
141
        _high_value = TYPE_MIN;
147
141
        _contain_null = false;
148
141
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_empty_value_rangeEv
Line
Count
Source
143
66
    void set_empty_value_range() {
144
66
        _fixed_values.clear();
145
66
        _low_value = TYPE_MAX;
146
66
        _high_value = TYPE_MIN;
147
66
        _contain_null = false;
148
66
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_empty_value_rangeEv
Line
Count
Source
143
826
    void set_empty_value_range() {
144
826
        _fixed_values.clear();
145
826
        _low_value = TYPE_MAX;
146
826
        _high_value = TYPE_MIN;
147
826
        _contain_null = false;
148
826
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
22.8k
    void set_empty_value_range() {
144
22.8k
        _fixed_values.clear();
145
22.8k
        _low_value = TYPE_MAX;
146
22.8k
        _high_value = TYPE_MIN;
147
22.8k
        _contain_null = false;
148
22.8k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_empty_value_rangeEv
Line
Count
Source
143
14
    void set_empty_value_range() {
144
14
        _fixed_values.clear();
145
14
        _low_value = TYPE_MAX;
146
14
        _high_value = TYPE_MIN;
147
14
        _contain_null = false;
148
14
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_empty_value_rangeEv
Line
Count
Source
143
80
    void set_empty_value_range() {
144
80
        _fixed_values.clear();
145
80
        _low_value = TYPE_MAX;
146
80
        _high_value = TYPE_MIN;
147
80
        _contain_null = false;
148
80
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_empty_value_rangeEv
Line
Count
Source
143
93
    void set_empty_value_range() {
144
93
        _fixed_values.clear();
145
93
        _low_value = TYPE_MAX;
146
93
        _high_value = TYPE_MIN;
147
93
        _contain_null = false;
148
93
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_empty_value_rangeEv
Line
Count
Source
143
75
    void set_empty_value_range() {
144
75
        _fixed_values.clear();
145
75
        _low_value = TYPE_MAX;
146
75
        _high_value = TYPE_MIN;
147
75
        _contain_null = false;
148
75
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_empty_value_rangeEv
Line
Count
Source
143
372
    void set_empty_value_range() {
144
372
        _fixed_values.clear();
145
372
        _low_value = TYPE_MAX;
146
372
        _high_value = TYPE_MIN;
147
372
        _contain_null = false;
148
372
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_empty_value_rangeEv
Line
Count
Source
143
264
    void set_empty_value_range() {
144
264
        _fixed_values.clear();
145
264
        _low_value = TYPE_MAX;
146
264
        _high_value = TYPE_MIN;
147
264
        _contain_null = false;
148
264
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_empty_value_rangeEv
Line
Count
Source
143
151
    void set_empty_value_range() {
144
151
        _fixed_values.clear();
145
151
        _low_value = TYPE_MAX;
146
151
        _high_value = TYPE_MIN;
147
151
        _contain_null = false;
148
151
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_empty_value_rangeEv
Line
Count
Source
143
70
    void set_empty_value_range() {
144
70
        _fixed_values.clear();
145
70
        _low_value = TYPE_MAX;
146
70
        _high_value = TYPE_MIN;
147
70
        _contain_null = false;
148
70
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_empty_value_rangeEv
Line
Count
Source
143
18
    void set_empty_value_range() {
144
18
        _fixed_values.clear();
145
18
        _low_value = TYPE_MAX;
146
18
        _high_value = TYPE_MIN;
147
18
        _contain_null = false;
148
18
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_empty_value_rangeEv
Line
Count
Source
143
74
    void set_empty_value_range() {
144
74
        _fixed_values.clear();
145
74
        _low_value = TYPE_MAX;
146
74
        _high_value = TYPE_MIN;
147
74
        _contain_null = false;
148
74
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_empty_value_rangeEv
Line
Count
Source
143
8
    void set_empty_value_range() {
144
8
        _fixed_values.clear();
145
8
        _low_value = TYPE_MAX;
146
8
        _high_value = TYPE_MIN;
147
8
        _contain_null = false;
148
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_empty_value_rangeEv
Line
Count
Source
143
136
    void set_empty_value_range() {
144
136
        _fixed_values.clear();
145
136
        _low_value = TYPE_MAX;
146
136
        _high_value = TYPE_MIN;
147
136
        _contain_null = false;
148
136
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_empty_value_rangeEv
Line
Count
Source
143
2
    void set_empty_value_range() {
144
2
        _fixed_values.clear();
145
2
        _low_value = TYPE_MAX;
146
2
        _high_value = TYPE_MIN;
147
2
        _contain_null = false;
148
2
    }
149
150
288k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_fixed_value_setEv
Line
Count
Source
150
7
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_fixed_value_setEv
Line
Count
Source
150
3
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_fixed_value_setEv
Line
Count
Source
150
2.19k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_fixed_value_setEv
Line
Count
Source
150
854
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
142
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE19get_fixed_value_setEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE19get_fixed_value_setEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE19get_fixed_value_setEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE19get_fixed_value_setEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
14
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
284k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_fixed_value_setB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_fixed_value_setEv
Line
Count
Source
150
3
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_fixed_value_setEv
Line
Count
Source
150
304
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_fixed_value_setEv
Line
Count
Source
150
8
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_fixed_value_setEv
Line
Count
Source
150
73
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_fixed_value_setEv
Line
Count
Source
150
125
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_fixed_value_setEv
Line
Count
Source
150
1
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_fixed_value_setEv
Line
Count
Source
150
7
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_fixed_value_setEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_fixed_value_setEv
Line
Count
Source
150
31
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_fixed_value_setEv
Line
Count
Source
150
20
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_fixed_value_setEv
Line
Count
Source
150
6
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_fixed_value_setEv
Line
Count
Source
150
16
    const SetType& get_fixed_value_set() const { return _fixed_values; }
151
152
550k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
2.51k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
580
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
136k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
165k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
8.48k
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE19get_range_max_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE19get_range_max_valueEv
Line
Count
Source
152
18
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE19get_range_max_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE19get_range_max_valueEv
Line
Count
Source
152
4
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
865
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
212k
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_range_max_valueB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_range_max_valueEv
Line
Count
Source
152
6
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_max_valueEv
Line
Count
Source
152
3.06k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_max_valueEv
Line
Count
Source
152
44
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_max_valueEv
Line
Count
Source
152
4.77k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
5.37k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
166
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
3.06k
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_range_max_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_range_max_valueEv
Line
Count
Source
152
1.41k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.60k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
2.89k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
942
    CppType get_range_max_value() const { return _high_value; }
153
154
550k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.51k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
580
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
136k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
165k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
8.51k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE19get_range_min_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE19get_range_min_valueEv
Line
Count
Source
154
18
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE19get_range_min_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE19get_range_min_valueEv
Line
Count
Source
154
4
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
865
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
212k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_range_min_valueB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_range_min_valueEv
Line
Count
Source
154
6
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_min_valueEv
Line
Count
Source
154
3.06k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_min_valueEv
Line
Count
Source
154
42
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_min_valueEv
Line
Count
Source
154
4.77k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
5.37k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
168
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
3.08k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_range_min_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_range_min_valueEv
Line
Count
Source
154
1.41k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.60k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
2.89k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
928
    CppType get_range_min_value() const { return _low_value; }
155
156
    const CppType* get_range_max_value_ptr() const { return &_high_value; }
157
158
    const CppType* get_range_min_value_ptr() const { return &_low_value; }
159
160
    SQLFilterOp get_range_high_op() const { return _high_op; }
161
162
    SQLFilterOp get_range_low_op() const { return _low_op; }
163
164
    bool is_low_value_minimum() const { return Compare::equal(_low_value, TYPE_MIN); }
165
166
    bool is_high_value_maximum() const { return Compare::equal(_high_value, TYPE_MAX); }
167
168
274k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
2.45k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
287
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
66.1k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
82.6k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
4.18k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE16is_begin_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16is_begin_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE16is_begin_includeEv
Line
Count
Source
168
2
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE16is_begin_includeEv
Line
Count
Source
168
395
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
105k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16is_begin_includeEv
Line
Count
Source
168
6
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16is_begin_includeEv
Line
Count
Source
168
2.97k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16is_begin_includeEv
Line
Count
Source
168
20
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16is_begin_includeEv
Line
Count
Source
168
2.37k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
2.73k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
85
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
1.53k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16is_begin_includeEv
Line
Count
Source
168
710
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
784
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.43k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
478
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
169
170
275k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14is_end_includeEv
Line
Count
Source
170
2.46k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14is_end_includeEv
Line
Count
Source
170
287
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
66.1k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
82.7k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
4.22k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE14is_end_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14is_end_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14is_end_includeEv
Line
Count
Source
170
2
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14is_end_includeEv
Line
Count
Source
170
397
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
105k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14is_end_includeEv
Line
Count
Source
170
6
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14is_end_includeEv
Line
Count
Source
170
2.97k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14is_end_includeEv
Line
Count
Source
170
20
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14is_end_includeEv
Line
Count
Source
170
2.37k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
2.73k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
85
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
1.53k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14is_end_includeEv
Line
Count
Source
170
713
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
790
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.44k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
478
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
171
172
    PrimitiveType type() const { return _column_type; }
173
174
    const std::string& column_name() const { return _column_name; }
175
176
659k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
3.51k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
764
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
76.3k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12contain_nullEv
Line
Count
Source
176
161k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12contain_nullEv
Line
Count
Source
176
4.46k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
234
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
318
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE12contain_nullEv
Line
Count
Source
176
6
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE12contain_nullEv
Line
Count
Source
176
4
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12contain_nullEv
Line
Count
Source
176
730
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
391k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
4.71k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12contain_nullEv
Line
Count
Source
176
9
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12contain_nullEv
Line
Count
Source
176
3.73k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12contain_nullEv
Line
Count
Source
176
30
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12contain_nullEv
Line
Count
Source
176
2.72k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
3.01k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
86
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
1.77k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
816
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
1.68k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.47k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
526
    bool contain_null() const { return _contain_null; }
177
178
852k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.50k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
293
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
71.9k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
84.5k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.58k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20get_fixed_value_sizeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20get_fixed_value_sizeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20get_fixed_value_sizeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20get_fixed_value_sizeEv
Line
Count
Source
178
2
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20get_fixed_value_sizeEv
Line
Count
Source
178
424
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20get_fixed_value_sizeEv
Line
Count
Source
178
673k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20get_fixed_value_sizeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20get_fixed_value_sizeEv
Line
Count
Source
178
12
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20get_fixed_value_sizeEv
Line
Count
Source
178
3.58k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20get_fixed_value_sizeEv
Line
Count
Source
178
40
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.53k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.95k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
86
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.56k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20get_fixed_value_sizeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20get_fixed_value_sizeEv
Line
Count
Source
178
770
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
840
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.46k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
500
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
3.60k
    void set_whole_value_range() {
181
3.60k
        _fixed_values.clear();
182
3.60k
        _low_value = TYPE_MIN;
183
3.60k
        _high_value = TYPE_MAX;
184
3.60k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3.60k
        _high_op = FILTER_LESS_OR_EQUAL;
186
3.60k
        _contain_null = _is_nullable_col;
187
3.60k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
199
    void set_whole_value_range() {
181
199
        _fixed_values.clear();
182
199
        _low_value = TYPE_MIN;
183
199
        _high_value = TYPE_MAX;
184
199
        _low_op = FILTER_LARGER_OR_EQUAL;
185
199
        _high_op = FILTER_LESS_OR_EQUAL;
186
199
        _contain_null = _is_nullable_col;
187
199
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_whole_value_rangeEv
Line
Count
Source
180
34
    void set_whole_value_range() {
181
34
        _fixed_values.clear();
182
34
        _low_value = TYPE_MIN;
183
34
        _high_value = TYPE_MAX;
184
34
        _low_op = FILTER_LARGER_OR_EQUAL;
185
34
        _high_op = FILTER_LESS_OR_EQUAL;
186
34
        _contain_null = _is_nullable_col;
187
34
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
677
    void set_whole_value_range() {
181
677
        _fixed_values.clear();
182
677
        _low_value = TYPE_MIN;
183
677
        _high_value = TYPE_MAX;
184
677
        _low_op = FILTER_LARGER_OR_EQUAL;
185
677
        _high_op = FILTER_LESS_OR_EQUAL;
186
677
        _contain_null = _is_nullable_col;
187
677
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_whole_value_rangeEv
Line
Count
Source
180
18
    void set_whole_value_range() {
181
18
        _fixed_values.clear();
182
18
        _low_value = TYPE_MIN;
183
18
        _high_value = TYPE_MAX;
184
18
        _low_op = FILTER_LARGER_OR_EQUAL;
185
18
        _high_op = FILTER_LESS_OR_EQUAL;
186
18
        _contain_null = _is_nullable_col;
187
18
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_whole_value_rangeEv
Line
Count
Source
180
3
    void set_whole_value_range() {
181
3
        _fixed_values.clear();
182
3
        _low_value = TYPE_MIN;
183
3
        _high_value = TYPE_MAX;
184
3
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3
        _high_op = FILTER_LESS_OR_EQUAL;
186
3
        _contain_null = _is_nullable_col;
187
3
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_whole_value_rangeEv
Line
Count
Source
180
18
    void set_whole_value_range() {
181
18
        _fixed_values.clear();
182
18
        _low_value = TYPE_MIN;
183
18
        _high_value = TYPE_MAX;
184
18
        _low_op = FILTER_LARGER_OR_EQUAL;
185
18
        _high_op = FILTER_LESS_OR_EQUAL;
186
18
        _contain_null = _is_nullable_col;
187
18
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_whole_value_rangeEv
Line
Count
Source
180
36
    void set_whole_value_range() {
181
36
        _fixed_values.clear();
182
36
        _low_value = TYPE_MIN;
183
36
        _high_value = TYPE_MAX;
184
36
        _low_op = FILTER_LARGER_OR_EQUAL;
185
36
        _high_op = FILTER_LESS_OR_EQUAL;
186
36
        _contain_null = _is_nullable_col;
187
36
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_whole_value_rangeEv
Line
Count
Source
180
3
    void set_whole_value_range() {
181
3
        _fixed_values.clear();
182
3
        _low_value = TYPE_MIN;
183
3
        _high_value = TYPE_MAX;
184
3
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3
        _high_op = FILTER_LESS_OR_EQUAL;
186
3
        _contain_null = _is_nullable_col;
187
3
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_whole_value_rangeEv
Line
Count
Source
180
1
    void set_whole_value_range() {
181
1
        _fixed_values.clear();
182
1
        _low_value = TYPE_MIN;
183
1
        _high_value = TYPE_MAX;
184
1
        _low_op = FILTER_LARGER_OR_EQUAL;
185
1
        _high_op = FILTER_LESS_OR_EQUAL;
186
1
        _contain_null = _is_nullable_col;
187
1
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_whole_value_rangeEv
Line
Count
Source
180
21
    void set_whole_value_range() {
181
21
        _fixed_values.clear();
182
21
        _low_value = TYPE_MIN;
183
21
        _high_value = TYPE_MAX;
184
21
        _low_op = FILTER_LARGER_OR_EQUAL;
185
21
        _high_op = FILTER_LESS_OR_EQUAL;
186
21
        _contain_null = _is_nullable_col;
187
21
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_whole_value_rangeEv
Line
Count
Source
180
63
    void set_whole_value_range() {
181
63
        _fixed_values.clear();
182
63
        _low_value = TYPE_MIN;
183
63
        _high_value = TYPE_MAX;
184
63
        _low_op = FILTER_LARGER_OR_EQUAL;
185
63
        _high_op = FILTER_LESS_OR_EQUAL;
186
63
        _contain_null = _is_nullable_col;
187
63
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_whole_value_rangeEv
Line
Count
Source
180
2.07k
    void set_whole_value_range() {
181
2.07k
        _fixed_values.clear();
182
2.07k
        _low_value = TYPE_MIN;
183
2.07k
        _high_value = TYPE_MAX;
184
2.07k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
2.07k
        _high_op = FILTER_LESS_OR_EQUAL;
186
2.07k
        _contain_null = _is_nullable_col;
187
2.07k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
46
    void set_whole_value_range() {
181
46
        _fixed_values.clear();
182
46
        _low_value = TYPE_MIN;
183
46
        _high_value = TYPE_MAX;
184
46
        _low_op = FILTER_LARGER_OR_EQUAL;
185
46
        _high_op = FILTER_LESS_OR_EQUAL;
186
46
        _contain_null = _is_nullable_col;
187
46
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_whole_value_rangeEv
Line
Count
Source
180
43
    void set_whole_value_range() {
181
43
        _fixed_values.clear();
182
43
        _low_value = TYPE_MIN;
183
43
        _high_value = TYPE_MAX;
184
43
        _low_op = FILTER_LARGER_OR_EQUAL;
185
43
        _high_op = FILTER_LESS_OR_EQUAL;
186
43
        _contain_null = _is_nullable_col;
187
43
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
42
    void set_whole_value_range() {
181
42
        _fixed_values.clear();
182
42
        _low_value = TYPE_MIN;
183
42
        _high_value = TYPE_MAX;
184
42
        _low_op = FILTER_LARGER_OR_EQUAL;
185
42
        _high_op = FILTER_LESS_OR_EQUAL;
186
42
        _contain_null = _is_nullable_col;
187
42
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_whole_value_rangeEv
Line
Count
Source
180
10
    void set_whole_value_range() {
181
10
        _fixed_values.clear();
182
10
        _low_value = TYPE_MIN;
183
10
        _high_value = TYPE_MAX;
184
10
        _low_op = FILTER_LARGER_OR_EQUAL;
185
10
        _high_op = FILTER_LESS_OR_EQUAL;
186
10
        _contain_null = _is_nullable_col;
187
10
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_whole_value_rangeEv
Line
Count
Source
180
35
    void set_whole_value_range() {
181
35
        _fixed_values.clear();
182
35
        _low_value = TYPE_MIN;
183
35
        _high_value = TYPE_MAX;
184
35
        _low_op = FILTER_LARGER_OR_EQUAL;
185
35
        _high_op = FILTER_LESS_OR_EQUAL;
186
35
        _contain_null = _is_nullable_col;
187
35
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_whole_value_rangeEv
Line
Count
Source
180
256
    void set_whole_value_range() {
181
256
        _fixed_values.clear();
182
256
        _low_value = TYPE_MIN;
183
256
        _high_value = TYPE_MAX;
184
256
        _low_op = FILTER_LARGER_OR_EQUAL;
185
256
        _high_op = FILTER_LESS_OR_EQUAL;
186
256
        _contain_null = _is_nullable_col;
187
256
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_whole_value_rangeEv
Line
Count
Source
180
8
    void set_whole_value_range() {
181
8
        _fixed_values.clear();
182
8
        _low_value = TYPE_MIN;
183
8
        _high_value = TYPE_MAX;
184
8
        _low_op = FILTER_LARGER_OR_EQUAL;
185
8
        _high_op = FILTER_LESS_OR_EQUAL;
186
8
        _contain_null = _is_nullable_col;
187
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_whole_value_rangeEv
Line
Count
Source
180
13
    void set_whole_value_range() {
181
13
        _fixed_values.clear();
182
13
        _low_value = TYPE_MIN;
183
13
        _high_value = TYPE_MAX;
184
13
        _low_op = FILTER_LARGER_OR_EQUAL;
185
13
        _high_op = FILTER_LESS_OR_EQUAL;
186
13
        _contain_null = _is_nullable_col;
187
13
    }
188
189
1.94k
    bool is_whole_value_range() const {
190
18.4E
        DCHECK(_is_nullable_col || !contain_null())
191
18.4E
                << "Non-nullable column cannot contains null value";
192
193
1.94k
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
1.94k
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
1.94k
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
1.94k
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_whole_value_rangeEv
Line
Count
Source
189
64
    bool is_whole_value_range() const {
190
64
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
64
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
64
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
64
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
64
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_whole_value_rangeEv
Line
Count
Source
189
62
    bool is_whole_value_range() const {
190
62
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
62
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
62
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
62
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
62
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_whole_value_rangeEv
Line
Count
Source
189
428
    bool is_whole_value_range() const {
190
428
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
429
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
428
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
428
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
428
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_whole_value_rangeEv
Line
Count
Source
189
66
    bool is_whole_value_range() const {
190
66
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
66
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
66
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
66
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
66
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_whole_value_rangeEv
Line
Count
Source
189
14
    bool is_whole_value_range() const {
190
14
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
14
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
14
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
14
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
14
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_whole_value_rangeEv
Line
Count
Source
189
80
    bool is_whole_value_range() const {
190
80
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
80
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
80
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
80
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
80
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_whole_value_rangeEv
Line
Count
Source
189
94
    bool is_whole_value_range() const {
190
94
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
94
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
94
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
94
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
94
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_whole_value_rangeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_whole_value_rangeEv
Line
Count
Source
189
68
    bool is_whole_value_range() const {
190
68
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
68
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
68
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
68
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
68
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_whole_value_rangeEv
Line
Count
Source
189
372
    bool is_whole_value_range() const {
190
18.4E
        DCHECK(_is_nullable_col || !contain_null())
191
18.4E
                << "Non-nullable column cannot contains null value";
192
193
373
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
372
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
372
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
372
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_whole_value_rangeEv
Line
Count
Source
189
267
    bool is_whole_value_range() const {
190
267
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
267
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
267
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
267
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
267
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
120
    bool is_whole_value_range() const {
190
120
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
120
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
120
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
120
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
120
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_whole_value_rangeEv
Line
Count
Source
189
70
    bool is_whole_value_range() const {
190
70
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
70
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
70
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
70
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
70
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_whole_value_rangeEv
Line
Count
Source
189
18
    bool is_whole_value_range() const {
190
18
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
18
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
18
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
18
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
18
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_whole_value_rangeEv
Line
Count
Source
189
74
    bool is_whole_value_range() const {
190
74
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
74
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
74
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
74
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
74
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_whole_value_rangeEv
Line
Count
Source
189
8
    bool is_whole_value_range() const {
190
8
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
8
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
8
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
8
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
8
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_whole_value_rangeEv
Line
Count
Source
189
136
    bool is_whole_value_range() const {
190
136
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
136
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
136
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
136
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
136
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_whole_value_rangeEv
Line
Count
Source
189
2
    bool is_whole_value_range() const {
190
2
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
2
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
2
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
2
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
2
    }
197
198
    // only two case will set range contain null, call by temp_range in olap scan node
199
    // 'is null' and 'is not null'
200
    // 1. if the pred is 'is null' means the range should be
201
    // empty in fixed_range and _high_value < _low_value
202
    // 2. if the pred is 'is not null' means the range should be whole range and
203
    // 'is not null' be effective
204
5.57k
    void set_contain_null(bool contain_null) {
205
5.57k
        if (contain_null) {
206
1.96k
            set_empty_value_range();
207
3.61k
        } else {
208
3.61k
            set_whole_value_range();
209
3.61k
        }
210
5.57k
        _contain_null = _is_nullable_col && contain_null;
211
5.57k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
263
    void set_contain_null(bool contain_null) {
205
263
        if (contain_null) {
206
64
            set_empty_value_range();
207
199
        } else {
208
199
            set_whole_value_range();
209
199
        }
210
264
        _contain_null = _is_nullable_col && contain_null;
211
263
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
98
    void set_contain_null(bool contain_null) {
205
98
        if (contain_null) {
206
64
            set_empty_value_range();
207
64
        } else {
208
34
            set_whole_value_range();
209
34
        }
210
98
        _contain_null = _is_nullable_col && contain_null;
211
98
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
1.11k
    void set_contain_null(bool contain_null) {
205
1.11k
        if (contain_null) {
206
437
            set_empty_value_range();
207
676
        } else {
208
676
            set_whole_value_range();
209
676
        }
210
1.11k
        _contain_null = _is_nullable_col && contain_null;
211
1.11k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
86
    void set_contain_null(bool contain_null) {
205
86
        if (contain_null) {
206
67
            set_empty_value_range();
207
67
        } else {
208
19
            set_whole_value_range();
209
19
        }
210
86
        _contain_null = _is_nullable_col && contain_null;
211
86
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16set_contain_nullEb
Line
Count
Source
204
17
    void set_contain_null(bool contain_null) {
205
17
        if (contain_null) {
206
14
            set_empty_value_range();
207
14
        } else {
208
3
            set_whole_value_range();
209
3
        }
210
17
        _contain_null = _is_nullable_col && contain_null;
211
17
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE16set_contain_nullEb
Line
Count
Source
204
98
    void set_contain_null(bool contain_null) {
205
98
        if (contain_null) {
206
80
            set_empty_value_range();
207
80
        } else {
208
18
            set_whole_value_range();
209
18
        }
210
98
        _contain_null = _is_nullable_col && contain_null;
211
98
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
129
    void set_contain_null(bool contain_null) {
205
129
        if (contain_null) {
206
93
            set_empty_value_range();
207
93
        } else {
208
36
            set_whole_value_range();
209
36
        }
210
129
        _contain_null = _is_nullable_col && contain_null;
211
129
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE16set_contain_nullEb
Line
Count
Source
204
3
    void set_contain_null(bool contain_null) {
205
3
        if (contain_null) {
206
0
            set_empty_value_range();
207
3
        } else {
208
3
            set_whole_value_range();
209
3
        }
210
3
        _contain_null = _is_nullable_col && contain_null;
211
3
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE16set_contain_nullEb
Line
Count
Source
204
1
    void set_contain_null(bool contain_null) {
205
1
        if (contain_null) {
206
0
            set_empty_value_range();
207
1
        } else {
208
1
            set_whole_value_range();
209
1
        }
210
1
        _contain_null = _is_nullable_col && contain_null;
211
1
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE16set_contain_nullEb
Line
Count
Source
204
90
    void set_contain_null(bool contain_null) {
205
90
        if (contain_null) {
206
68
            set_empty_value_range();
207
68
        } else {
208
22
            set_whole_value_range();
209
22
        }
210
90
        _contain_null = _is_nullable_col && contain_null;
211
90
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16set_contain_nullEb
Line
Count
Source
204
436
    void set_contain_null(bool contain_null) {
205
436
        if (contain_null) {
206
373
            set_empty_value_range();
207
373
        } else {
208
63
            set_whole_value_range();
209
63
        }
210
436
        _contain_null = _is_nullable_col && contain_null;
211
436
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
2.35k
    void set_contain_null(bool contain_null) {
205
2.35k
        if (contain_null) {
206
266
            set_empty_value_range();
207
2.08k
        } else {
208
2.08k
            set_whole_value_range();
209
2.08k
        }
210
2.35k
        _contain_null = _is_nullable_col && contain_null;
211
2.35k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
173
    void set_contain_null(bool contain_null) {
205
173
        if (contain_null) {
206
126
            set_empty_value_range();
207
126
        } else {
208
47
            set_whole_value_range();
209
47
        }
210
173
        _contain_null = _is_nullable_col && contain_null;
211
173
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
113
    void set_contain_null(bool contain_null) {
205
113
        if (contain_null) {
206
70
            set_empty_value_range();
207
70
        } else {
208
43
            set_whole_value_range();
209
43
        }
210
113
        _contain_null = _is_nullable_col && contain_null;
211
113
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
61
    void set_contain_null(bool contain_null) {
205
61
        if (contain_null) {
206
18
            set_empty_value_range();
207
43
        } else {
208
43
            set_whole_value_range();
209
43
        }
210
61
        _contain_null = _is_nullable_col && contain_null;
211
61
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16set_contain_nullEb
Line
Count
Source
204
84
    void set_contain_null(bool contain_null) {
205
84
        if (contain_null) {
206
74
            set_empty_value_range();
207
74
        } else {
208
10
            set_whole_value_range();
209
10
        }
210
84
        _contain_null = _is_nullable_col && contain_null;
211
84
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16set_contain_nullEb
Line
Count
Source
204
43
    void set_contain_null(bool contain_null) {
205
43
        if (contain_null) {
206
8
            set_empty_value_range();
207
35
        } else {
208
35
            set_whole_value_range();
209
35
        }
210
43
        _contain_null = _is_nullable_col && contain_null;
211
43
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16set_contain_nullEb
Line
Count
Source
204
392
    void set_contain_null(bool contain_null) {
205
392
        if (contain_null) {
206
136
            set_empty_value_range();
207
256
        } else {
208
256
            set_whole_value_range();
209
256
        }
210
392
        _contain_null = _is_nullable_col && contain_null;
211
392
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16set_contain_nullEb
Line
Count
Source
204
8
    void set_contain_null(bool contain_null) {
205
8
        if (contain_null) {
206
0
            set_empty_value_range();
207
8
        } else {
208
8
            set_whole_value_range();
209
8
        }
210
8
        _contain_null = _is_nullable_col && contain_null;
211
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16set_contain_nullEb
Line
Count
Source
204
15
    void set_contain_null(bool contain_null) {
205
15
        if (contain_null) {
206
2
            set_empty_value_range();
207
13
        } else {
208
13
            set_whole_value_range();
209
13
        }
210
15
        _contain_null = _is_nullable_col && contain_null;
211
15
    }
212
213
577k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
123k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
1.89k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
20.1k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
91.4k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
349
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
290
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
607
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
74
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
69
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.37k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9precisionEv
Line
Count
Source
213
295k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9precisionEv
Line
Count
Source
213
4.20k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9precisionEv
Line
Count
Source
213
61
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
29.8k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
54
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
4.55k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
860
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
465
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
302
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
1.39k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
399
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
192
    int precision() const { return _precision; }
214
215
2.22M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
332k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
24.3k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
183k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
262k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
9.13k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
290
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
608
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
74
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
73
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.35k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE5scaleEv
Line
Count
Source
215
1.07M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE5scaleEv
Line
Count
Source
215
4.20k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
651
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
299k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
134
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
9.50k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
6.70k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
172
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
3.60k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.82k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
3.08k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
3.32k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
1.17k
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
474k
                                      const CppType& value) {
219
474k
        static_cast<void>(range.add_fixed_value(value));
220
474k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
120k
                                      const CppType& value) {
219
120k
        static_cast<void>(range.add_fixed_value(value));
220
120k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
340
                                      const CppType& value) {
219
340
        static_cast<void>(range.add_fixed_value(value));
220
340
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
42.1k
                                      const CppType& value) {
219
42.1k
        static_cast<void>(range.add_fixed_value(value));
220
42.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
1.95k
                                      const CppType& value) {
219
1.95k
        static_cast<void>(range.add_fixed_value(value));
220
1.95k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
190
                                      const CppType& value) {
219
190
        static_cast<void>(range.add_fixed_value(value));
220
190
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
63
                                      const CppType& value) {
219
63
        static_cast<void>(range.add_fixed_value(value));
220
63
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
175
                                      const CppType& value) {
219
175
        static_cast<void>(range.add_fixed_value(value));
220
175
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
218
59
                                      const CppType& value) {
219
59
        static_cast<void>(range.add_fixed_value(value));
220
59
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
218
59
                                      const CppType& value) {
219
59
        static_cast<void>(range.add_fixed_value(value));
220
59
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
571
                                      const CppType& value) {
219
571
        static_cast<void>(range.add_fixed_value(value));
220
571
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
294k
                                      const CppType& value) {
219
294k
        static_cast<void>(range.add_fixed_value(value));
220
294k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
1.54k
                                      const CppType& value) {
219
1.54k
        static_cast<void>(range.add_fixed_value(value));
220
1.54k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
70
                                      const CppType& value) {
219
70
        static_cast<void>(range.add_fixed_value(value));
220
70
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
9.32k
                                      const CppType& value) {
219
9.32k
        static_cast<void>(range.add_fixed_value(value));
220
9.32k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
64
                                      const CppType& value) {
219
64
        static_cast<void>(range.add_fixed_value(value));
220
64
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
691
                                      const CppType& value) {
219
691
        static_cast<void>(range.add_fixed_value(value));
220
691
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
202
                                      const CppType& value) {
219
202
        static_cast<void>(range.add_fixed_value(value));
220
202
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
Line
Count
Source
218
1
                                      const CppType& value) {
219
1
        static_cast<void>(range.add_fixed_value(value));
220
1
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
218
379
                                      const CppType& value) {
219
379
        static_cast<void>(range.add_fixed_value(value));
220
379
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
218
101
                                      const CppType& value) {
219
101
        static_cast<void>(range.add_fixed_value(value));
220
101
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
218
359
                                      const CppType& value) {
219
359
        static_cast<void>(range.add_fixed_value(value));
220
359
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
239
                                      const CppType& value) {
219
239
        static_cast<void>(range.add_fixed_value(value));
220
239
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
40
                                      const CppType& value) {
219
40
        static_cast<void>(range.add_fixed_value(value));
220
40
    }
221
222
    static void remove_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
223
3
                                         const CppType& value) {
224
3
        range.remove_fixed_value(value);
225
3
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
223
3
                                         const CppType& value) {
224
3
        range.remove_fixed_value(value);
225
3
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
226
227
    static void empty_function(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
228
2.86k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
46
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
27
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
1.00k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14empty_functionERS2_NS_11SQLFilterOpERKl
Line
Count
Source
228
26
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14empty_functionERS2_NS_11SQLFilterOpERKn
Line
Count
Source
228
2
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE14empty_functionERS2_NS_11SQLFilterOpERKf
Line
Count
Source
228
51
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
140
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14empty_functionERS2_NS_11SQLFilterOpERKj
Line
Count
Source
228
18
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14empty_functionERS2_NS_11SQLFilterOpERKo
Line
Count
Source
228
18
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
143
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
452
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
292
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
49
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
27
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
45
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
228
81
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
300
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
10
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
27
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
228
6
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14empty_functionERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
228
30
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
69
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
112k
                                const CppType& value) {
232
112k
        static_cast<void>(range.add_range(op, value));
233
112k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
2.00k
                                const CppType& value) {
232
2.00k
        static_cast<void>(range.add_range(op, value));
233
2.00k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.64k
                                const CppType& value) {
232
1.64k
        static_cast<void>(range.add_range(op, value));
233
1.64k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
11.7k
                                const CppType& value) {
232
11.7k
        static_cast<void>(range.add_range(op, value));
233
11.7k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
67.3k
                                const CppType& value) {
232
67.3k
        static_cast<void>(range.add_range(op, value));
233
67.3k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
151
                                const CppType& value) {
232
151
        static_cast<void>(range.add_range(op, value));
233
151
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
138
                                const CppType& value) {
232
138
        static_cast<void>(range.add_range(op, value));
233
138
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
326
                                const CppType& value) {
232
326
        static_cast<void>(range.add_range(op, value));
233
326
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
20
                                const CppType& value) {
232
20
        static_cast<void>(range.add_range(op, value));
233
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
20
                                const CppType& value) {
232
20
        static_cast<void>(range.add_range(op, value));
233
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
744
                                const CppType& value) {
232
744
        static_cast<void>(range.add_range(op, value));
233
744
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.72k
                                const CppType& value) {
232
1.72k
        static_cast<void>(range.add_range(op, value));
233
1.72k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
412
                                const CppType& value) {
232
412
        static_cast<void>(range.add_range(op, value));
233
412
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
20.4k
                                const CppType& value) {
232
20.4k
        static_cast<void>(range.add_range(op, value));
233
20.4k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
3.77k
                                const CppType& value) {
232
3.77k
        static_cast<void>(range.add_range(op, value));
233
3.77k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
525
                                const CppType& value) {
232
525
        static_cast<void>(range.add_range(op, value));
233
525
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
231
48
                                const CppType& value) {
232
48
        static_cast<void>(range.add_range(op, value));
233
48
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
162
                                const CppType& value) {
232
162
        static_cast<void>(range.add_range(op, value));
233
162
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
785
                                const CppType& value) {
232
785
        static_cast<void>(range.add_range(op, value));
233
785
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
231
147
                                const CppType& value) {
232
147
        static_cast<void>(range.add_range(op, value));
233
147
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
231
88
                                const CppType& value) {
232
88
        static_cast<void>(range.add_range(op, value));
233
88
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
576k
                                                                            int scale) {
238
576k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
576k
                                                precision, scale);
240
576k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
123k
                                                                            int scale) {
238
123k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
123k
                                                precision, scale);
240
123k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.87k
                                                                            int scale) {
238
1.87k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.87k
                                                precision, scale);
240
1.87k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
20.0k
                                                                            int scale) {
238
20.0k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
20.0k
                                                precision, scale);
240
20.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
91.3k
                                                                            int scale) {
238
91.3k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
91.3k
                                                precision, scale);
240
91.3k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
347
                                                                            int scale) {
238
347
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
347
                                                precision, scale);
240
347
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
285
                                                                            int scale) {
238
285
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
285
                                                precision, scale);
240
285
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
602
                                                                            int scale) {
238
602
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
602
                                                precision, scale);
240
602
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
72
                                                                            int scale) {
238
72
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
72
                                                precision, scale);
240
72
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
66
                                                                            int scale) {
238
66
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
66
                                                precision, scale);
240
66
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.36k
                                                                            int scale) {
238
1.36k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.36k
                                                precision, scale);
240
1.36k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
294k
                                                                            int scale) {
238
294k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
294k
                                                precision, scale);
240
294k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.14k
                                                                            int scale) {
238
4.14k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.14k
                                                precision, scale);
240
4.14k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
62
                                                                            int scale) {
238
62
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
62
                                                precision, scale);
240
62
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
29.7k
                                                                            int scale) {
238
29.7k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
29.7k
                                                precision, scale);
240
29.7k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
53
                                                                            int scale) {
238
53
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
53
                                                precision, scale);
240
53
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.52k
                                                                            int scale) {
238
4.52k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.52k
                                                precision, scale);
240
4.52k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
846
                                                                            int scale) {
238
846
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
846
                                                precision, scale);
240
846
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1
                                                                            int scale) {
238
1
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1
                                                precision, scale);
240
1
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
465
                                                                            int scale) {
238
465
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
465
                                                precision, scale);
240
465
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
300
                                                                            int scale) {
238
300
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
300
                                                precision, scale);
240
300
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.39k
                                                                            int scale) {
238
1.39k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.39k
                                                precision, scale);
240
1.39k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
399
                                                                            int scale) {
238
399
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
399
                                                precision, scale);
240
399
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
188
                                                                            int scale) {
238
188
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
188
                                                precision, scale);
240
188
    }
241
242
protected:
243
    bool is_in_range(const CppType& value);
244
245
private:
246
    ColumnValueRange(std::string col_name, const CppType& min, const CppType& max,
247
                     bool contain_null);
248
249
    ColumnValueRange(std::string col_name, const CppType& min, const CppType& max,
250
                     bool is_nullable_col, bool contain_null, int precision, int scale);
251
252
    const static CppType TYPE_MIN; // Column type's min value
253
    const static CppType TYPE_MAX; // Column type's max value
254
255
    std::string _column_name;
256
    PrimitiveType _column_type; // Column type (eg: TINYINT,SMALLINT,INT,BIGINT)
257
    CppType _low_value;         // Column's low value, closed interval at left
258
    CppType _high_value;        // Column's high value, open interval at right
259
    SQLFilterOp _low_op;
260
    SQLFilterOp _high_op;
261
    SetType _fixed_values; // Column's fixed int value
262
263
    bool _is_nullable_col;
264
    bool _contain_null;
265
    int _precision;
266
    int _scale;
267
268
    static constexpr bool _is_reject_split_type =
269
            primitive_type == PrimitiveType::TYPE_FLOAT ||
270
            primitive_type == PrimitiveType::TYPE_DOUBLE ||
271
            primitive_type == PrimitiveType::TYPE_LARGEINT ||
272
            primitive_type == PrimitiveType::TYPE_DECIMALV2 ||
273
            primitive_type == PrimitiveType::TYPE_HLL ||
274
            primitive_type == PrimitiveType::TYPE_VARCHAR ||
275
            primitive_type == PrimitiveType::TYPE_CHAR ||
276
            primitive_type == PrimitiveType::TYPE_STRING ||
277
            primitive_type == PrimitiveType::TYPE_BOOLEAN ||
278
            primitive_type == PrimitiveType::TYPE_DATETIME ||
279
            primitive_type == PrimitiveType::TYPE_DATETIMEV2 ||
280
            primitive_type == PrimitiveType::TYPE_TIMESTAMPTZ ||
281
            primitive_type == PrimitiveType::TYPE_DECIMAL256;
282
};
283
template <>
284
const typename ColumnValueRange<TYPE_FLOAT>::CppType ColumnValueRange<TYPE_FLOAT>::TYPE_MIN;
285
template <>
286
const typename ColumnValueRange<TYPE_FLOAT>::CppType ColumnValueRange<TYPE_FLOAT>::TYPE_MAX;
287
template <>
288
const typename ColumnValueRange<TYPE_DOUBLE>::CppType ColumnValueRange<TYPE_DOUBLE>::TYPE_MIN;
289
template <>
290
const typename ColumnValueRange<TYPE_DOUBLE>::CppType ColumnValueRange<TYPE_DOUBLE>::TYPE_MAX;
291
292
class OlapScanKeys {
293
public:
294
    // TODO(gabriel): use ColumnPredicate to extend scan key
295
    template <PrimitiveType primitive_type>
296
    Status extend_scan_key(ColumnValueRange<primitive_type>& range, int32_t max_scan_key_num,
297
                           bool* exact_value, bool* eos, bool* should_break);
298
299
    Status get_key_range(std::vector<std::unique_ptr<OlapScanRange>>* key_range);
300
301
825k
    bool has_range_value() const { return _has_range_value; }
302
303
0
    void clear() {
304
0
        _has_range_value = false;
305
0
        _begin_scan_keys.clear();
306
0
        _end_scan_keys.clear();
307
0
    }
308
309
1.58k
    std::string debug_string() {
310
1.58k
        std::stringstream ss;
311
1.58k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
1.58k
        ss << "ScanKeys:";
313
314
10.8k
        for (int i = 0; i < _begin_scan_keys.size(); ++i) {
315
9.31k
            ss << "ScanKey=" << (_begin_include ? "[" : "(") << _begin_scan_keys[i] << " : "
316
9.31k
               << _end_scan_keys[i] << (_end_include ? "]" : ")");
317
9.31k
        }
318
1.58k
        return ss.str();
319
1.58k
    }
320
321
0
    size_t size() {
322
0
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
323
0
        return _begin_scan_keys.size();
324
0
    }
325
326
326k
    void set_is_convertible(bool is_convertible) { _is_convertible = is_convertible; }
327
328
private:
329
    std::vector<OlapTuple> _begin_scan_keys;
330
    std::vector<OlapTuple> _end_scan_keys;
331
    bool _has_range_value = false;
332
    bool _begin_include = false;
333
    bool _end_include = false;
334
    bool _is_convertible = false;
335
};
336
337
using ColumnValueRangeType = std::variant<
338
        ColumnValueRange<TYPE_TINYINT>, ColumnValueRange<TYPE_SMALLINT>, ColumnValueRange<TYPE_INT>,
339
        ColumnValueRange<TYPE_BIGINT>, ColumnValueRange<TYPE_LARGEINT>,
340
        ColumnValueRange<TYPE_FLOAT>, ColumnValueRange<TYPE_DOUBLE>, ColumnValueRange<TYPE_IPV4>,
341
        ColumnValueRange<TYPE_IPV6>, ColumnValueRange<TYPE_CHAR>, ColumnValueRange<TYPE_VARCHAR>,
342
        ColumnValueRange<TYPE_STRING>, ColumnValueRange<TYPE_DATE>, ColumnValueRange<TYPE_DATEV2>,
343
        ColumnValueRange<TYPE_DATETIME>, ColumnValueRange<TYPE_DATETIMEV2>,
344
        ColumnValueRange<TYPE_TIMESTAMPTZ>, ColumnValueRange<TYPE_DECIMALV2>,
345
        ColumnValueRange<TYPE_BOOLEAN>, ColumnValueRange<TYPE_HLL>,
346
        ColumnValueRange<TYPE_DECIMAL32>, ColumnValueRange<TYPE_DECIMAL64>,
347
        ColumnValueRange<TYPE_DECIMAL128I>, ColumnValueRange<TYPE_DECIMAL256>>;
348
349
template <PrimitiveType primitive_type>
350
const typename ColumnValueRange<primitive_type>::CppType
351
        ColumnValueRange<primitive_type>::TYPE_MIN =
352
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::min();
353
template <PrimitiveType primitive_type>
354
const typename ColumnValueRange<primitive_type>::CppType
355
        ColumnValueRange<primitive_type>::TYPE_MAX =
356
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::max();
357
358
template <PrimitiveType primitive_type>
359
ColumnValueRange<primitive_type>::ColumnValueRange()
360
2.41M
        : _column_type(INVALID_TYPE), _precision(-1), _scale(-1) {}
361
362
template <PrimitiveType primitive_type>
363
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, const CppType& min,
364
                                                   const CppType& max, bool contain_null)
365
        : _column_name(std::move(col_name)),
366
          _column_type(primitive_type),
367
          _low_value(min),
368
          _high_value(max),
369
          _low_op(FILTER_LARGER_OR_EQUAL),
370
          _high_op(FILTER_LESS_OR_EQUAL),
371
          _is_nullable_col(true),
372
          _contain_null(contain_null),
373
          _precision(-1),
374
          _scale(-1) {}
375
376
template <PrimitiveType primitive_type>
377
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, const CppType& min,
378
                                                   const CppType& max, bool is_nullable_col,
379
                                                   bool contain_null, int precision, int scale)
380
2.99M
        : _column_name(std::move(col_name)),
381
2.99M
          _column_type(primitive_type),
382
1.75M
          _low_value(min),
383
1.75M
          _high_value(max),
384
2.99M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.99M
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.99M
          _is_nullable_col(is_nullable_col),
387
2.99M
          _contain_null(is_nullable_col && contain_null),
388
2.99M
          _precision(precision),
389
2.99M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKaSA_bbii
Line
Count
Source
380
267k
        : _column_name(std::move(col_name)),
381
267k
          _column_type(primitive_type),
382
267k
          _low_value(min),
383
267k
          _high_value(max),
384
267k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
267k
          _high_op(FILTER_LESS_OR_EQUAL),
386
267k
          _is_nullable_col(is_nullable_col),
387
267k
          _contain_null(is_nullable_col && contain_null),
388
267k
          _precision(precision),
389
267k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
20.8k
        : _column_name(std::move(col_name)),
381
20.8k
          _column_type(primitive_type),
382
20.8k
          _low_value(min),
383
20.8k
          _high_value(max),
384
20.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
20.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
20.8k
          _is_nullable_col(is_nullable_col),
387
20.8k
          _contain_null(is_nullable_col && contain_null),
388
20.8k
          _precision(precision),
389
20.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
271k
        : _column_name(std::move(col_name)),
381
271k
          _column_type(primitive_type),
382
271k
          _low_value(min),
383
271k
          _high_value(max),
384
271k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
271k
          _high_op(FILTER_LESS_OR_EQUAL),
386
271k
          _is_nullable_col(is_nullable_col),
387
271k
          _contain_null(is_nullable_col && contain_null),
388
271k
          _precision(precision),
389
271k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
626k
        : _column_name(std::move(col_name)),
381
626k
          _column_type(primitive_type),
382
626k
          _low_value(min),
383
626k
          _high_value(max),
384
626k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
626k
          _high_op(FILTER_LESS_OR_EQUAL),
386
626k
          _is_nullable_col(is_nullable_col),
387
626k
          _contain_null(is_nullable_col && contain_null),
388
626k
          _precision(precision),
389
626k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_bbii
Line
Count
Source
380
11.7k
        : _column_name(std::move(col_name)),
381
11.7k
          _column_type(primitive_type),
382
11.7k
          _low_value(min),
383
11.7k
          _high_value(max),
384
11.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.7k
          _is_nullable_col(is_nullable_col),
387
11.7k
          _contain_null(is_nullable_col && contain_null),
388
11.7k
          _precision(precision),
389
11.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
12.4k
        : _column_name(std::move(col_name)),
381
12.4k
          _column_type(primitive_type),
382
12.4k
          _low_value(min),
383
12.4k
          _high_value(max),
384
12.4k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.4k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.4k
          _is_nullable_col(is_nullable_col),
387
12.4k
          _contain_null(is_nullable_col && contain_null),
388
12.4k
          _precision(precision),
389
12.4k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
17.8k
        : _column_name(std::move(col_name)),
381
17.8k
          _column_type(primitive_type),
382
17.8k
          _low_value(min),
383
17.8k
          _high_value(max),
384
17.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
17.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
17.8k
          _is_nullable_col(is_nullable_col),
387
17.8k
          _contain_null(is_nullable_col && contain_null),
388
17.8k
          _precision(precision),
389
17.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
499
        : _column_name(std::move(col_name)),
381
499
          _column_type(primitive_type),
382
499
          _low_value(min),
383
499
          _high_value(max),
384
499
          _low_op(FILTER_LARGER_OR_EQUAL),
385
499
          _high_op(FILTER_LESS_OR_EQUAL),
386
499
          _is_nullable_col(is_nullable_col),
387
499
          _contain_null(is_nullable_col && contain_null),
388
499
          _precision(precision),
389
499
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
496
        : _column_name(std::move(col_name)),
381
496
          _column_type(primitive_type),
382
496
          _low_value(min),
383
496
          _high_value(max),
384
496
          _low_op(FILTER_LARGER_OR_EQUAL),
385
496
          _high_op(FILTER_LESS_OR_EQUAL),
386
496
          _is_nullable_col(is_nullable_col),
387
496
          _contain_null(is_nullable_col && contain_null),
388
496
          _precision(precision),
389
496
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
20.3k
        : _column_name(std::move(col_name)),
381
20.3k
          _column_type(primitive_type),
382
20.3k
          _low_value(min),
383
20.3k
          _high_value(max),
384
20.3k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
20.3k
          _high_op(FILTER_LESS_OR_EQUAL),
386
20.3k
          _is_nullable_col(is_nullable_col),
387
20.3k
          _contain_null(is_nullable_col && contain_null),
388
20.3k
          _precision(precision),
389
20.3k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
1.24M
        : _column_name(std::move(col_name)),
381
1.24M
          _column_type(primitive_type),
382
1.24M
          _low_value(min),
383
1.24M
          _high_value(max),
384
1.24M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.24M
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.24M
          _is_nullable_col(is_nullable_col),
387
1.24M
          _contain_null(is_nullable_col && contain_null),
388
1.24M
          _precision(precision),
389
1.24M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
162k
        : _column_name(std::move(col_name)),
381
162k
          _column_type(primitive_type),
382
162k
          _low_value(min),
383
162k
          _high_value(max),
384
162k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
162k
          _high_op(FILTER_LESS_OR_EQUAL),
386
162k
          _is_nullable_col(is_nullable_col),
387
162k
          _contain_null(is_nullable_col && contain_null),
388
162k
          _precision(precision),
389
162k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
559
        : _column_name(std::move(col_name)),
381
559
          _column_type(primitive_type),
382
559
          _low_value(min),
383
559
          _high_value(max),
384
559
          _low_op(FILTER_LARGER_OR_EQUAL),
385
559
          _high_op(FILTER_LESS_OR_EQUAL),
386
559
          _is_nullable_col(is_nullable_col),
387
559
          _contain_null(is_nullable_col && contain_null),
388
559
          _precision(precision),
389
559
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_15DateV2ValueTypeEEESD_bbii
Line
Count
Source
380
126k
        : _column_name(std::move(col_name)),
381
126k
          _column_type(primitive_type),
382
126k
          _low_value(min),
383
126k
          _high_value(max),
384
126k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
126k
          _high_op(FILTER_LESS_OR_EQUAL),
386
126k
          _is_nullable_col(is_nullable_col),
387
126k
          _contain_null(is_nullable_col && contain_null),
388
126k
          _precision(precision),
389
126k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
552
        : _column_name(std::move(col_name)),
381
552
          _column_type(primitive_type),
382
552
          _low_value(min),
383
552
          _high_value(max),
384
552
          _low_op(FILTER_LARGER_OR_EQUAL),
385
552
          _high_op(FILTER_LESS_OR_EQUAL),
386
552
          _is_nullable_col(is_nullable_col),
387
552
          _contain_null(is_nullable_col && contain_null),
388
552
          _precision(precision),
389
552
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
135k
        : _column_name(std::move(col_name)),
381
135k
          _column_type(primitive_type),
382
135k
          _low_value(min),
383
135k
          _high_value(max),
384
135k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
135k
          _high_op(FILTER_LESS_OR_EQUAL),
386
135k
          _is_nullable_col(is_nullable_col),
387
135k
          _contain_null(is_nullable_col && contain_null),
388
135k
          _precision(precision),
389
135k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
6.51k
        : _column_name(std::move(col_name)),
381
6.51k
          _column_type(primitive_type),
382
6.51k
          _low_value(min),
383
6.51k
          _high_value(max),
384
6.51k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
6.51k
          _high_op(FILTER_LESS_OR_EQUAL),
386
6.51k
          _is_nullable_col(is_nullable_col),
387
6.51k
          _contain_null(is_nullable_col && contain_null),
388
6.51k
          _precision(precision),
389
6.51k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
425
        : _column_name(std::move(col_name)),
381
425
          _column_type(primitive_type),
382
425
          _low_value(min),
383
425
          _high_value(max),
384
425
          _low_op(FILTER_LARGER_OR_EQUAL),
385
425
          _high_op(FILTER_LESS_OR_EQUAL),
386
425
          _is_nullable_col(is_nullable_col),
387
425
          _contain_null(is_nullable_col && contain_null),
388
425
          _precision(precision),
389
425
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
11.2k
        : _column_name(std::move(col_name)),
381
11.2k
          _column_type(primitive_type),
382
11.2k
          _low_value(min),
383
11.2k
          _high_value(max),
384
11.2k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.2k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.2k
          _is_nullable_col(is_nullable_col),
387
11.2k
          _contain_null(is_nullable_col && contain_null),
388
11.2k
          _precision(precision),
389
11.2k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
517
        : _column_name(std::move(col_name)),
381
517
          _column_type(primitive_type),
382
517
          _low_value(min),
383
517
          _high_value(max),
384
517
          _low_op(FILTER_LARGER_OR_EQUAL),
385
517
          _high_op(FILTER_LESS_OR_EQUAL),
386
517
          _is_nullable_col(is_nullable_col),
387
517
          _contain_null(is_nullable_col && contain_null),
388
517
          _precision(precision),
389
517
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
13.4k
        : _column_name(std::move(col_name)),
381
13.4k
          _column_type(primitive_type),
382
13.4k
          _low_value(min),
383
13.4k
          _high_value(max),
384
13.4k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.4k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.4k
          _is_nullable_col(is_nullable_col),
387
13.4k
          _contain_null(is_nullable_col && contain_null),
388
13.4k
          _precision(precision),
389
13.4k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
30.9k
        : _column_name(std::move(col_name)),
381
30.9k
          _column_type(primitive_type),
382
30.9k
          _low_value(min),
383
30.9k
          _high_value(max),
384
30.9k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
30.9k
          _high_op(FILTER_LESS_OR_EQUAL),
386
30.9k
          _is_nullable_col(is_nullable_col),
387
30.9k
          _contain_null(is_nullable_col && contain_null),
388
30.9k
          _precision(precision),
389
30.9k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
14.7k
        : _column_name(std::move(col_name)),
381
14.7k
          _column_type(primitive_type),
382
14.7k
          _low_value(min),
383
14.7k
          _high_value(max),
384
14.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
14.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
14.7k
          _is_nullable_col(is_nullable_col),
387
14.7k
          _contain_null(is_nullable_col && contain_null),
388
14.7k
          _precision(precision),
389
14.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
1.63k
        : _column_name(std::move(col_name)),
381
1.63k
          _column_type(primitive_type),
382
1.63k
          _low_value(min),
383
1.63k
          _high_value(max),
384
1.63k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.63k
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.63k
          _is_nullable_col(is_nullable_col),
387
1.63k
          _contain_null(is_nullable_col && contain_null),
388
1.63k
          _precision(precision),
389
1.63k
          _scale(scale) {}
390
391
template <PrimitiveType primitive_type>
392
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, bool is_nullable_col,
393
                                                   int precision, int scale)
394
2.41M
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
2.41M
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
143k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
143k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
18.8k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
18.8k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
250k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
250k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
534k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
534k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.0k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.0k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
17.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
17.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
18.9k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
18.9k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
491
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
491
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
490
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
490
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
96.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
96.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
130k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
130k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
5.62k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
5.62k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
943k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
943k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
157k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
157k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
514
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
514
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
13.0k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
13.0k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
29.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
29.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
14.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
14.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
1.43k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.43k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
423
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
423
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.7k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.7k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
419
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
419
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
422
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
422
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
488k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
488k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
488k
    _fixed_values.insert(value);
404
488k
    _contain_null = false;
405
406
488k
    _high_value = TYPE_MIN;
407
488k
    _low_value = TYPE_MAX;
408
409
488k
    return Status::OK();
410
488k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_fixed_valueERKa
Line
Count
Source
398
121k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
121k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
121k
    _fixed_values.insert(value);
404
121k
    _contain_null = false;
405
406
121k
    _high_value = TYPE_MIN;
407
121k
    _low_value = TYPE_MAX;
408
409
121k
    return Status::OK();
410
121k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_fixed_valueERKs
Line
Count
Source
398
346
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
346
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
346
    _fixed_values.insert(value);
404
346
    _contain_null = false;
405
406
346
    _high_value = TYPE_MIN;
407
346
    _low_value = TYPE_MAX;
408
409
346
    return Status::OK();
410
346
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
42.5k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
42.5k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
42.5k
    _fixed_values.insert(value);
404
42.5k
    _contain_null = false;
405
406
42.5k
    _high_value = TYPE_MIN;
407
42.5k
    _low_value = TYPE_MAX;
408
409
42.5k
    return Status::OK();
410
42.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
15.3k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
15.3k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
15.3k
    _fixed_values.insert(value);
404
15.3k
    _contain_null = false;
405
406
15.3k
    _high_value = TYPE_MIN;
407
15.3k
    _low_value = TYPE_MAX;
408
409
15.3k
    return Status::OK();
410
15.3k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
202
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
202
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
202
    _fixed_values.insert(value);
404
202
    _contain_null = false;
405
406
202
    _high_value = TYPE_MIN;
407
202
    _low_value = TYPE_MAX;
408
409
202
    return Status::OK();
410
202
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
79
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
79
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
79
    _fixed_values.insert(value);
404
79
    _contain_null = false;
405
406
79
    _high_value = TYPE_MIN;
407
79
    _low_value = TYPE_MAX;
408
409
79
    return Status::OK();
410
79
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
188
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
188
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
188
    _fixed_values.insert(value);
404
188
    _contain_null = false;
405
406
188
    _high_value = TYPE_MIN;
407
188
    _low_value = TYPE_MAX;
408
409
188
    return Status::OK();
410
188
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_fixed_valueERKj
Line
Count
Source
398
59
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
59
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
59
    _fixed_values.insert(value);
404
59
    _contain_null = false;
405
406
59
    _high_value = TYPE_MIN;
407
59
    _low_value = TYPE_MAX;
408
409
59
    return Status::OK();
410
59
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_fixed_valueERKo
Line
Count
Source
398
59
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
59
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
59
    _fixed_values.insert(value);
404
59
    _contain_null = false;
405
406
59
    _high_value = TYPE_MIN;
407
59
    _low_value = TYPE_MAX;
408
409
59
    return Status::OK();
410
59
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
588
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
588
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
588
    _fixed_values.insert(value);
404
588
    _contain_null = false;
405
406
588
    _high_value = TYPE_MIN;
407
588
    _low_value = TYPE_MAX;
408
409
588
    return Status::OK();
410
588
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
294k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
294k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
294k
    _fixed_values.insert(value);
404
294k
    _contain_null = false;
405
406
294k
    _high_value = TYPE_MIN;
407
294k
    _low_value = TYPE_MAX;
408
409
294k
    return Status::OK();
410
294k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
1.60k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
1.60k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
1.60k
    _fixed_values.insert(value);
404
1.60k
    _contain_null = false;
405
406
1.60k
    _high_value = TYPE_MIN;
407
1.60k
    _low_value = TYPE_MAX;
408
409
1.60k
    return Status::OK();
410
1.60k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
70
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
70
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
70
    _fixed_values.insert(value);
404
70
    _contain_null = false;
405
406
70
    _high_value = TYPE_MIN;
407
70
    _low_value = TYPE_MAX;
408
409
70
    return Status::OK();
410
70
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
9.39k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
9.39k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
9.39k
    _fixed_values.insert(value);
404
9.39k
    _contain_null = false;
405
406
9.39k
    _high_value = TYPE_MIN;
407
9.39k
    _low_value = TYPE_MAX;
408
409
9.39k
    return Status::OK();
410
9.39k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
64
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
64
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
64
    _fixed_values.insert(value);
404
64
    _contain_null = false;
405
406
64
    _high_value = TYPE_MIN;
407
64
    _low_value = TYPE_MAX;
408
409
64
    return Status::OK();
410
64
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
763
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
763
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
763
    _fixed_values.insert(value);
404
763
    _contain_null = false;
405
406
763
    _high_value = TYPE_MIN;
407
763
    _low_value = TYPE_MAX;
408
409
763
    return Status::OK();
410
763
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
251
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
251
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
251
    _fixed_values.insert(value);
404
251
    _contain_null = false;
405
406
251
    _high_value = TYPE_MIN;
407
251
    _low_value = TYPE_MAX;
408
409
251
    return Status::OK();
410
251
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_fixed_valueERKNS_14DecimalV2ValueE
Line
Count
Source
398
1
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
1
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
1
    _fixed_values.insert(value);
404
1
    _contain_null = false;
405
406
1
    _high_value = TYPE_MIN;
407
1
    _low_value = TYPE_MAX;
408
409
1
    return Status::OK();
410
1
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_fixed_valueERKh
Line
Count
Source
398
395
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
395
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
395
    _fixed_values.insert(value);
404
395
    _contain_null = false;
405
406
395
    _high_value = TYPE_MIN;
407
395
    _low_value = TYPE_MAX;
408
409
395
    return Status::OK();
410
395
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
101
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
101
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
101
    _fixed_values.insert(value);
404
101
    _contain_null = false;
405
406
101
    _high_value = TYPE_MIN;
407
101
    _low_value = TYPE_MAX;
408
409
101
    return Status::OK();
410
101
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
569
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
569
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
569
    _fixed_values.insert(value);
404
569
    _contain_null = false;
405
406
569
    _high_value = TYPE_MIN;
407
569
    _low_value = TYPE_MAX;
408
409
569
    return Status::OK();
410
569
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
239
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
239
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
239
    _fixed_values.insert(value);
404
239
    _contain_null = false;
405
406
239
    _high_value = TYPE_MIN;
407
239
    _low_value = TYPE_MAX;
408
409
239
    return Status::OK();
410
239
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
40
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
40
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
40
    _fixed_values.insert(value);
404
40
    _contain_null = false;
405
406
40
    _high_value = TYPE_MIN;
407
40
    _low_value = TYPE_MAX;
408
409
40
    return Status::OK();
410
40
}
411
412
template <PrimitiveType primitive_type>
413
3
void ColumnValueRange<primitive_type>::remove_fixed_value(const CppType& value) {
414
3
    _fixed_values.erase(value);
415
3
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE18remove_fixed_valueERKa
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE18remove_fixed_valueERKs
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE18remove_fixed_valueERKi
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE18remove_fixed_valueERKl
Line
Count
Source
413
3
void ColumnValueRange<primitive_type>::remove_fixed_value(const CppType& value) {
414
3
    _fixed_values.erase(value);
415
3
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE18remove_fixed_valueERKn
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE18remove_fixed_valueERKf
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE18remove_fixed_valueERKd
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE18remove_fixed_valueERKj
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE18remove_fixed_valueERKo
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE18remove_fixed_valueERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE18remove_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE18remove_fixed_valueERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE18remove_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE18remove_fixed_valueERKNS_16TimestampTzValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE18remove_fixed_valueERKNS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE18remove_fixed_valueERKh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE18remove_fixed_valueERKNS_9StringRefE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE18remove_fixed_valueERKNS_7DecimalIiEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE18remove_fixed_valueERKNS_7DecimalIlEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE18remove_fixed_valueERKNS_12Decimal128V3E
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE18remove_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
416
417
template <PrimitiveType primitive_type>
418
7.82M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.82M
    return _fixed_values.size() != 0;
420
7.82M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_fixed_value_rangeEv
Line
Count
Source
418
1.10M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
1.10M
    return _fixed_values.size() != 0;
420
1.10M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
22.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
22.7k
    return _fixed_values.size() != 0;
420
22.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
520k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
520k
    return _fixed_values.size() != 0;
420
520k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
990k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
990k
    return _fixed_values.size() != 0;
420
990k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
30.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
30.0k
    return _fixed_values.size() != 0;
420
30.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
12.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
12.7k
    return _fixed_values.size() != 0;
420
12.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.7k
    return _fixed_values.size() != 0;
420
18.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
793
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
793
    return _fixed_values.size() != 0;
420
793
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
775
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
775
    return _fixed_values.size() != 0;
420
775
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
24.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
24.9k
    return _fixed_values.size() != 0;
420
24.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_fixed_value_rangeEv
Line
Count
Source
418
4.44M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
4.44M
    return _fixed_values.size() != 0;
420
4.44M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_fixed_value_rangeEv
Line
Count
Source
418
180k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
180k
    return _fixed_values.size() != 0;
420
180k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_fixed_value_rangeEv
Line
Count
Source
418
851
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
851
    return _fixed_values.size() != 0;
420
851
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_fixed_value_rangeEv
Line
Count
Source
418
200k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
200k
    return _fixed_values.size() != 0;
420
200k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_fixed_value_rangeEv
Line
Count
Source
418
889
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
889
    return _fixed_values.size() != 0;
420
889
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
148k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
148k
    return _fixed_values.size() != 0;
420
148k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.0k
    return _fixed_values.size() != 0;
420
18.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
756
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
756
    return _fixed_values.size() != 0;
420
756
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
19.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
19.9k
    return _fixed_values.size() != 0;
420
19.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
514
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
514
    return _fixed_values.size() != 0;
420
514
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
16.8k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
16.8k
    return _fixed_values.size() != 0;
420
16.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_fixed_value_rangeEv
Line
Count
Source
418
37.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
37.0k
    return _fixed_values.size() != 0;
420
37.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_fixed_value_rangeEv
Line
Count
Source
418
21.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
21.7k
    return _fixed_values.size() != 0;
420
21.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
3.73k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
3.73k
    return _fixed_values.size() != 0;
420
3.73k
}
421
422
template <PrimitiveType primitive_type>
423
2.72M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
2.72M
    return Compare::greater(_high_value, _low_value);
425
2.72M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
145k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
145k
    return Compare::greater(_high_value, _low_value);
425
145k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
19.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
19.1k
    return Compare::greater(_high_value, _low_value);
425
19.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
317k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
317k
    return Compare::greater(_high_value, _low_value);
425
317k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
654k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
654k
    return Compare::greater(_high_value, _low_value);
425
654k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
15.4k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
15.4k
    return Compare::greater(_high_value, _low_value);
425
15.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
12.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.0k
    return Compare::greater(_high_value, _low_value);
425
12.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
17.2k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
17.2k
    return Compare::greater(_high_value, _low_value);
425
17.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
428
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
428
    return Compare::greater(_high_value, _low_value);
425
428
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
420
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
420
    return Compare::greater(_high_value, _low_value);
425
420
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_scope_value_rangeEv
Line
Count
Source
423
19.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
19.1k
    return Compare::greater(_high_value, _low_value);
425
19.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_scope_value_rangeEv
Line
Count
Source
423
1.04M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.04M
    return Compare::greater(_high_value, _low_value);
425
1.04M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_scope_value_rangeEv
Line
Count
Source
423
161k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
161k
    return Compare::greater(_high_value, _low_value);
425
161k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
492
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
492
    return Compare::greater(_high_value, _low_value);
425
492
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
99.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
99.1k
    return Compare::greater(_high_value, _low_value);
425
99.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
509
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
509
    return Compare::greater(_high_value, _low_value);
425
509
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
132k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
132k
    return Compare::greater(_high_value, _low_value);
425
132k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
8.14k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.14k
    return Compare::greater(_high_value, _low_value);
425
8.14k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
503
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
503
    return Compare::greater(_high_value, _low_value);
425
503
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
12.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.3k
    return Compare::greater(_high_value, _low_value);
425
12.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_scope_value_rangeEv
Line
Count
Source
423
515
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
515
    return Compare::greater(_high_value, _low_value);
425
515
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
13.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.8k
    return Compare::greater(_high_value, _low_value);
425
13.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
30.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
30.5k
    return Compare::greater(_high_value, _low_value);
425
30.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
15.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
15.5k
    return Compare::greater(_high_value, _low_value);
425
15.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
1.90k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.90k
    return Compare::greater(_high_value, _low_value);
425
1.90k
}
426
427
template <PrimitiveType primitive_type>
428
3.87M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
3.87M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
3.87M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
3.87M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
386k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
386k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
386k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
386k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
19.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
19.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
19.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
19.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
331k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
331k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
331k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
331k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
658k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
658k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
658k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
658k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
16.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
16.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
16.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
16.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
12.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_empty_value_rangeEv
Line
Count
Source
428
17.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
17.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
17.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
17.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_empty_value_rangeEv
Line
Count
Source
428
507
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
507
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
507
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
507
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
510
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
510
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
510
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
510
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_empty_value_rangeEv
Line
Count
Source
428
20.1k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
20.1k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
20.1k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
20.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_empty_value_rangeEv
Line
Count
Source
428
1.91M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.91M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.91M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.91M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
164k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
164k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
164k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
164k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
579
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
579
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
579
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
579
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
117k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
117k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
117k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
117k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
583
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
583
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
583
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
583
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
133k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
133k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
133k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
133k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
8.58k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.58k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.58k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.58k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_empty_value_rangeEv
Line
Count
Source
428
508
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
508
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
508
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
508
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
13.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
13.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
13.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
13.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_empty_value_rangeEv
Line
Count
Source
428
514
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
514
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
515
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
514
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
14.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
31.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
31.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
31.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
31.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_empty_value_rangeEv
Line
Count
Source
428
16.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
16.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
16.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
16.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
1.99k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.99k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.99k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.99k
}
435
436
template <PrimitiveType primitive_type>
437
178k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
178k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
178k
    if (!is_enumeration_type(_column_type)) {
443
20.4k
        return false;
444
20.4k
    }
445
446
157k
    return true;
447
178k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.44k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.44k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.44k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.44k
    return true;
447
2.44k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
231
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
231
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
231
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
231
    return true;
447
231
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_fixed_value_convertibleEv
Line
Count
Source
437
65.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
65.7k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
65.7k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
65.7k
    return true;
447
65.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
82.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
82.3k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
82.3k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
82.3k
    return true;
447
82.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
4.18k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
4.18k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
4.18k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
4.18k
    return true;
447
4.18k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26is_fixed_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26is_fixed_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
1
    return true;
447
1
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26is_fixed_value_convertibleEv
Line
Count
Source
437
389
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
389
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
389
    if (!is_enumeration_type(_column_type)) {
443
388
        return false;
444
388
    }
445
446
1
    return true;
447
389
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
10.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
10.2k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
10.2k
    if (!is_enumeration_type(_column_type)) {
443
10.2k
        return false;
444
10.2k
    }
445
446
49
    return true;
447
10.2k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_fixed_value_convertibleEv
Line
Count
Source
437
6
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
6
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
6
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
6
    return true;
447
6
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.87k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.87k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.87k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.87k
    return true;
447
2.87k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_fixed_value_convertibleEv
Line
Count
Source
437
21
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
21
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
22
    if (!is_enumeration_type(_column_type)) {
443
22
        return false;
444
22
    }
445
446
18.4E
    return true;
447
21
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.36k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.36k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.37k
    if (!is_enumeration_type(_column_type)) {
443
2.37k
        return false;
444
2.37k
    }
445
446
18.4E
    return true;
447
2.36k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.62k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.62k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.69k
    if (!is_enumeration_type(_column_type)) {
443
2.69k
        return false;
444
2.69k
    }
445
446
18.4E
    return true;
447
2.62k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
80
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
80
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
81
    if (!is_enumeration_type(_column_type)) {
443
81
        return false;
444
81
    }
445
446
18.4E
    return true;
447
80
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.52k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.52k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.52k
    if (!is_enumeration_type(_column_type)) {
443
1.52k
        return false;
444
1.52k
    }
445
446
3
    return true;
447
1.52k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
695
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
695
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
702
    if (!is_enumeration_type(_column_type)) {
443
702
        return false;
444
702
    }
445
446
18.4E
    return true;
447
695
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
763
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
763
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
763
    if (!is_enumeration_type(_column_type)) {
443
752
        return false;
444
752
    }
445
446
11
    return true;
447
763
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.32k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.32k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.33k
    if (!is_enumeration_type(_column_type)) {
443
1.33k
        return false;
444
1.33k
    }
445
446
18.4E
    return true;
447
1.32k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
408
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
408
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
409
    if (!is_enumeration_type(_column_type)) {
443
409
        return false;
444
409
    }
445
446
18.4E
    return true;
447
408
}
448
449
template <PrimitiveType primitive_type>
450
69
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
69
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
69
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
68
    return true;
460
69
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
54
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
54
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
54
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
54
    return true;
460
54
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26is_range_value_convertibleEv
Line
Count
Source
450
2
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
2
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
2
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
2
    return true;
460
2
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_range_value_convertibleEv
Line
Count
Source
450
12
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
12
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
12
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
12
    return true;
460
12
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_range_value_convertibleEv
Line
Count
Source
450
1
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
1
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
1
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
0
    return true;
460
1
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_range_value_convertibleEv
461
462
// The return value indicates whether eos.
463
template <PrimitiveType primitive_type>
464
bool ColumnValueRange<primitive_type>::convert_to_close_range(
465
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
466
153k
        bool& begin_include, bool& end_include) {
467
153k
    if constexpr (!_is_reject_split_type) {
468
153k
        begin_include = true;
469
153k
        end_include = true;
470
471
153k
        bool is_empty = false;
472
473
153k
        if (!is_begin_include()) {
474
7.41k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
7.41k
            } else {
477
7.41k
                ++_low_value;
478
7.41k
            }
479
7.41k
        }
480
481
153k
        if (!is_end_include()) {
482
526
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
526
            } else {
485
526
                --_high_value;
486
526
            }
487
526
        }
488
489
153k
        if (Compare::less(_high_value, _low_value)) {
490
30
            is_empty = true;
491
30
        }
492
493
153k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
153k
    }
499
153k
    return false;
500
153k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.42k
        bool& begin_include, bool& end_include) {
467
2.42k
    if constexpr (!_is_reject_split_type) {
468
2.42k
        begin_include = true;
469
2.42k
        end_include = true;
470
471
2.42k
        bool is_empty = false;
472
473
2.42k
        if (!is_begin_include()) {
474
41
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
41
            } else {
477
41
                ++_low_value;
478
41
            }
479
41
        }
480
481
2.42k
        if (!is_end_include()) {
482
11
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
11
            } else {
485
11
                --_high_value;
486
11
            }
487
11
        }
488
489
2.42k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.42k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
2.42k
    }
499
2.42k
    return false;
500
2.42k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
231
        bool& begin_include, bool& end_include) {
467
231
    if constexpr (!_is_reject_split_type) {
468
231
        begin_include = true;
469
231
        end_include = true;
470
471
231
        bool is_empty = false;
472
473
231
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
231
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
231
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
231
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
231
    }
499
231
    return false;
500
231
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
65.5k
        bool& begin_include, bool& end_include) {
467
65.5k
    if constexpr (!_is_reject_split_type) {
468
65.5k
        begin_include = true;
469
65.5k
        end_include = true;
470
471
65.5k
        bool is_empty = false;
472
473
65.5k
        if (!is_begin_include()) {
474
537
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
537
            } else {
477
537
                ++_low_value;
478
537
            }
479
537
        }
480
481
65.5k
        if (!is_end_include()) {
482
423
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
423
            } else {
485
423
                --_high_value;
486
423
            }
487
423
        }
488
489
65.5k
        if (Compare::less(_high_value, _low_value)) {
490
30
            is_empty = true;
491
30
        }
492
493
65.5k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
65.5k
    }
499
65.5k
    return false;
500
65.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
82.1k
        bool& begin_include, bool& end_include) {
467
82.1k
    if constexpr (!_is_reject_split_type) {
468
82.1k
        begin_include = true;
469
82.1k
        end_include = true;
470
471
82.1k
        bool is_empty = false;
472
473
82.1k
        if (!is_begin_include()) {
474
6.81k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
6.81k
            } else {
477
6.81k
                ++_low_value;
478
6.81k
            }
479
6.81k
        }
480
481
82.1k
        if (!is_end_include()) {
482
7
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
7
            } else {
485
7
                --_high_value;
486
7
            }
487
7
        }
488
489
82.1k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
82.1k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
82.1k
    }
499
82.1k
    return false;
500
82.1k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
1
        bool& begin_include, bool& end_include) {
467
1
    if constexpr (!_is_reject_split_type) {
468
1
        begin_include = true;
469
1
        end_include = true;
470
471
1
        bool is_empty = false;
472
473
1
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
1
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
1
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
1
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
1
    }
499
1
    return false;
500
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
6
        bool& begin_include, bool& end_include) {
467
6
    if constexpr (!_is_reject_split_type) {
468
6
        begin_include = true;
469
6
        end_include = true;
470
471
6
        bool is_empty = false;
472
473
6
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
6
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
6
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
6
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
6
    }
499
6
    return false;
500
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.87k
        bool& begin_include, bool& end_include) {
467
2.87k
    if constexpr (!_is_reject_split_type) {
468
2.87k
        begin_include = true;
469
2.87k
        end_include = true;
470
471
2.87k
        bool is_empty = false;
472
473
2.87k
        if (!is_begin_include()) {
474
28
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
28
            } else {
477
28
                ++_low_value;
478
28
            }
479
28
        }
480
481
2.87k
        if (!is_end_include()) {
482
85
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
85
            } else {
485
85
                --_high_value;
486
85
            }
487
85
        }
488
489
2.87k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.87k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
2.87k
    }
499
2.87k
    return false;
500
2.87k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
501
502
// The return value indicates whether the split result is range or fixed value.
503
template <PrimitiveType primitive_type>
504
bool ColumnValueRange<primitive_type>::convert_to_avg_range_value(
505
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
506
153k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
153k
    if constexpr (!_is_reject_split_type) {
508
153k
        CppType min_value = get_range_min_value();
509
153k
        CppType max_value = get_range_max_value();
510
153k
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
6
            min_value.set_type(TimeType::TIME_DATE);
512
6
            max_value.set_type(TimeType::TIME_DATE);
513
6
        }
514
153k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
153k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
31
            DCHECK(contain_null());
518
31
        }
519
520
153k
        auto no_split = [&]() -> bool {
521
146k
            begin_scan_keys.emplace_back();
522
146k
            begin_scan_keys.back().add_value(
523
146k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
146k
                    contain_null());
525
146k
            end_scan_keys.emplace_back();
526
146k
            end_scan_keys.back().add_value(
527
146k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
146k
                    empty_range_only_null ? true : false);
529
146k
            return true;
530
146k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
64.9k
        auto no_split = [&]() -> bool {
521
64.9k
            begin_scan_keys.emplace_back();
522
64.9k
            begin_scan_keys.back().add_value(
523
64.9k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
64.9k
                    contain_null());
525
64.9k
            end_scan_keys.emplace_back();
526
64.9k
            end_scan_keys.back().add_value(
527
64.9k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
64.9k
                    empty_range_only_null ? true : false);
529
64.9k
            return true;
530
64.9k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
81.6k
        auto no_split = [&]() -> bool {
521
81.6k
            begin_scan_keys.emplace_back();
522
81.6k
            begin_scan_keys.back().add_value(
523
81.6k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
81.6k
                    contain_null());
525
81.6k
            end_scan_keys.emplace_back();
526
81.6k
            end_scan_keys.back().add_value(
527
81.6k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
81.6k
                    empty_range_only_null ? true : false);
529
81.6k
            return true;
530
81.6k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
531
153k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
31
            return no_split();
533
31
        }
534
535
416k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
138k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
138k
                return value;
539
278k
            } else {
540
278k
                return (int128_t)value;
541
278k
            }
542
416k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKaE_clESA_
Line
Count
Source
535
108k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
108k
            } else {
540
108k
                return (int128_t)value;
541
108k
            }
542
108k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKsE_clESA_
Line
Count
Source
535
11.2k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
11.2k
            } else {
540
11.2k
                return (int128_t)value;
541
11.2k
            }
542
11.2k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKiE_clESA_
Line
Count
Source
535
74.3k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
74.3k
            } else {
540
74.3k
                return (int128_t)value;
541
74.3k
            }
542
74.3k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
83.7k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
83.7k
            } else {
540
83.7k
                return (int128_t)value;
541
83.7k
            }
542
83.7k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKjE_clESA_
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKoE_clESA_
Line
Count
Source
535
1
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
1
            } else {
540
1
                return (int128_t)value;
541
1
            }
542
1
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_16VecDateTimeValueEE_clESB_
Line
Count
Source
535
294
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
294
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
294
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
294
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
138k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
138k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
138k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
138k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIiEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIlEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_12Decimal128V3EE_clESB_
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
153k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
153k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
153k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
147k
            return no_split();
552
147k
        }
553
6.61k
        int step_size = cast_set<int>(step_size_may_overflow);
554
6.61k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6.61k
        if (contain_null()) {
558
3.15k
            begin_scan_keys.emplace_back();
559
3.15k
            begin_scan_keys.back().add_null();
560
3.15k
            end_scan_keys.emplace_back();
561
3.15k
            end_scan_keys.back().add_null();
562
3.15k
        }
563
262k
        while (true) {
564
262k
            begin_scan_keys.emplace_back();
565
262k
            begin_scan_keys.back().add_value(
566
262k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
262k
            if (cast(max_value) - min_value < step_size) {
569
5.59k
                min_value = max_value;
570
256k
            } else {
571
256k
                min_value += step_size;
572
256k
            }
573
574
262k
            end_scan_keys.emplace_back();
575
262k
            end_scan_keys.back().add_value(
576
262k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
262k
            if (Compare::equal(min_value, max_value)) {
579
6.61k
                break;
580
6.61k
            }
581
255k
            ++min_value;
582
255k
            ++real_step_size;
583
255k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
255k
        }
592
593
6.61k
        return step_size != 0;
594
6.61k
    }
595
0
    return false;
596
153k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.44k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.44k
    if constexpr (!_is_reject_split_type) {
508
2.44k
        CppType min_value = get_range_min_value();
509
2.44k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
2.44k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.44k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
2.44k
        auto no_split = [&]() -> bool {
521
2.44k
            begin_scan_keys.emplace_back();
522
2.44k
            begin_scan_keys.back().add_value(
523
2.44k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.44k
                    contain_null());
525
2.44k
            end_scan_keys.emplace_back();
526
2.44k
            end_scan_keys.back().add_value(
527
2.44k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.44k
                    empty_range_only_null ? true : false);
529
2.44k
            return true;
530
2.44k
        };
531
2.44k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.44k
        auto cast = [](const CppType& value) {
536
2.44k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.44k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.44k
                return value;
539
2.44k
            } else {
540
2.44k
                return (int128_t)value;
541
2.44k
            }
542
2.44k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
2.44k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.44k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
2.44k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.44k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.44k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.44k
        if (contain_null()) {
558
1.93k
            begin_scan_keys.emplace_back();
559
1.93k
            begin_scan_keys.back().add_null();
560
1.93k
            end_scan_keys.emplace_back();
561
1.93k
            end_scan_keys.back().add_null();
562
1.93k
        }
563
105k
        while (true) {
564
105k
            begin_scan_keys.emplace_back();
565
105k
            begin_scan_keys.back().add_value(
566
105k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
105k
            if (cast(max_value) - min_value < step_size) {
569
2.46k
                min_value = max_value;
570
103k
            } else {
571
103k
                min_value += step_size;
572
103k
            }
573
574
105k
            end_scan_keys.emplace_back();
575
105k
            end_scan_keys.back().add_value(
576
105k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
105k
            if (Compare::equal(min_value, max_value)) {
579
2.50k
                break;
580
2.50k
            }
581
103k
            ++min_value;
582
103k
            ++real_step_size;
583
103k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
103k
        }
592
593
2.44k
        return step_size != 0;
594
2.44k
    }
595
0
    return false;
596
2.44k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
230
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
230
    if constexpr (!_is_reject_split_type) {
508
230
        CppType min_value = get_range_min_value();
509
230
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
230
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
230
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
230
        auto no_split = [&]() -> bool {
521
230
            begin_scan_keys.emplace_back();
522
230
            begin_scan_keys.back().add_value(
523
230
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
230
                    contain_null());
525
230
            end_scan_keys.emplace_back();
526
230
            end_scan_keys.back().add_value(
527
230
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
230
                    empty_range_only_null ? true : false);
529
230
            return true;
530
230
        };
531
230
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
230
        auto cast = [](const CppType& value) {
536
230
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
230
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
230
                return value;
539
230
            } else {
540
230
                return (int128_t)value;
541
230
            }
542
230
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
230
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
230
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
230
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
230
        int step_size = cast_set<int>(step_size_may_overflow);
554
230
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
230
        if (contain_null()) {
558
153
            begin_scan_keys.emplace_back();
559
153
            begin_scan_keys.back().add_null();
560
153
            end_scan_keys.emplace_back();
561
153
            end_scan_keys.back().add_null();
562
153
        }
563
11.0k
        while (true) {
564
11.0k
            begin_scan_keys.emplace_back();
565
11.0k
            begin_scan_keys.back().add_value(
566
11.0k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
11.0k
            if (cast(max_value) - min_value < step_size) {
569
231
                min_value = max_value;
570
10.8k
            } else {
571
10.8k
                min_value += step_size;
572
10.8k
            }
573
574
11.0k
            end_scan_keys.emplace_back();
575
11.0k
            end_scan_keys.back().add_value(
576
11.0k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
11.0k
            if (Compare::equal(min_value, max_value)) {
579
231
                break;
580
231
            }
581
10.8k
            ++min_value;
582
10.8k
            ++real_step_size;
583
10.8k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
10.8k
        }
592
593
230
        return step_size != 0;
594
230
    }
595
0
    return false;
596
230
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
66.2k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
66.2k
    if constexpr (!_is_reject_split_type) {
508
66.2k
        CppType min_value = get_range_min_value();
509
66.2k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
66.2k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
66.2k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
31
            DCHECK(contain_null());
518
31
        }
519
520
66.2k
        auto no_split = [&]() -> bool {
521
66.2k
            begin_scan_keys.emplace_back();
522
66.2k
            begin_scan_keys.back().add_value(
523
66.2k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
66.2k
                    contain_null());
525
66.2k
            end_scan_keys.emplace_back();
526
66.2k
            end_scan_keys.back().add_value(
527
66.2k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
66.2k
                    empty_range_only_null ? true : false);
529
66.2k
            return true;
530
66.2k
        };
531
66.2k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
31
            return no_split();
533
31
        }
534
535
66.1k
        auto cast = [](const CppType& value) {
536
66.1k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
66.1k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
66.1k
                return value;
539
66.1k
            } else {
540
66.1k
                return (int128_t)value;
541
66.1k
            }
542
66.1k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
66.1k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
66.1k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
66.1k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
65.3k
            return no_split();
552
65.3k
        }
553
804
        int step_size = cast_set<int>(step_size_may_overflow);
554
804
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
804
        if (contain_null()) {
558
0
            begin_scan_keys.emplace_back();
559
0
            begin_scan_keys.back().add_null();
560
0
            end_scan_keys.emplace_back();
561
0
            end_scan_keys.back().add_null();
562
0
        }
563
8.88k
        while (true) {
564
8.66k
            begin_scan_keys.emplace_back();
565
8.66k
            begin_scan_keys.back().add_value(
566
8.66k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
8.66k
            if (cast(max_value) - min_value < step_size) {
569
117
                min_value = max_value;
570
8.54k
            } else {
571
8.54k
                min_value += step_size;
572
8.54k
            }
573
574
8.66k
            end_scan_keys.emplace_back();
575
8.66k
            end_scan_keys.back().add_value(
576
8.66k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
8.66k
            if (Compare::equal(min_value, max_value)) {
579
588
                break;
580
588
            }
581
8.07k
            ++min_value;
582
8.07k
            ++real_step_size;
583
8.07k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
8.07k
        }
592
593
804
        return step_size != 0;
594
804
    }
595
0
    return false;
596
66.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
82.2k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
82.2k
    if constexpr (!_is_reject_split_type) {
508
82.2k
        CppType min_value = get_range_min_value();
509
82.2k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
82.2k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
82.2k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
82.2k
        auto no_split = [&]() -> bool {
521
82.2k
            begin_scan_keys.emplace_back();
522
82.2k
            begin_scan_keys.back().add_value(
523
82.2k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
82.2k
                    contain_null());
525
82.2k
            end_scan_keys.emplace_back();
526
82.2k
            end_scan_keys.back().add_value(
527
82.2k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
82.2k
                    empty_range_only_null ? true : false);
529
82.2k
            return true;
530
82.2k
        };
531
82.2k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
82.2k
        auto cast = [](const CppType& value) {
536
82.2k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
82.2k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
82.2k
                return value;
539
82.2k
            } else {
540
82.2k
                return (int128_t)value;
541
82.2k
            }
542
82.2k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
82.2k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
82.2k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
82.2k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
81.9k
            return no_split();
552
81.9k
        }
553
257
        int step_size = cast_set<int>(step_size_may_overflow);
554
257
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
257
        if (contain_null()) {
558
0
            begin_scan_keys.emplace_back();
559
0
            begin_scan_keys.back().add_null();
560
0
            end_scan_keys.emplace_back();
561
0
            end_scan_keys.back().add_null();
562
0
        }
563
1.62k
        while (true) {
564
1.62k
            begin_scan_keys.emplace_back();
565
1.62k
            begin_scan_keys.back().add_value(
566
1.62k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.62k
            if (cast(max_value) - min_value < step_size) {
569
3
                min_value = max_value;
570
1.62k
            } else {
571
1.62k
                min_value += step_size;
572
1.62k
            }
573
574
1.62k
            end_scan_keys.emplace_back();
575
1.62k
            end_scan_keys.back().add_value(
576
1.62k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.62k
            if (Compare::equal(min_value, max_value)) {
579
390
                break;
580
390
            }
581
1.23k
            ++min_value;
582
1.23k
            ++real_step_size;
583
1.23k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
1.23k
        }
592
593
257
        return step_size != 0;
594
257
    }
595
0
    return false;
596
82.2k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
1
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
1
    if constexpr (!_is_reject_split_type) {
508
1
        CppType min_value = get_range_min_value();
509
1
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
1
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
1
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
531
1
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
1
        auto cast = [](const CppType& value) {
536
1
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
1
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
1
                return value;
539
1
            } else {
540
1
                return (int128_t)value;
541
1
            }
542
1
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
1
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
1
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
1
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
1
            return no_split();
552
1
        }
553
0
        int step_size = cast_set<int>(step_size_may_overflow);
554
0
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
0
        if (contain_null()) {
558
0
            begin_scan_keys.emplace_back();
559
0
            begin_scan_keys.back().add_null();
560
0
            end_scan_keys.emplace_back();
561
0
            end_scan_keys.back().add_null();
562
0
        }
563
0
        while (true) {
564
0
            begin_scan_keys.emplace_back();
565
0
            begin_scan_keys.back().add_value(
566
0
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
0
            if (cast(max_value) - min_value < step_size) {
569
0
                min_value = max_value;
570
0
            } else {
571
0
                min_value += step_size;
572
0
            }
573
574
0
            end_scan_keys.emplace_back();
575
0
            end_scan_keys.back().add_value(
576
0
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
0
            if (Compare::equal(min_value, max_value)) {
579
0
                break;
580
0
            }
581
0
            ++min_value;
582
0
            ++real_step_size;
583
0
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
0
        }
592
593
0
        return step_size != 0;
594
0
    }
595
0
    return false;
596
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
6
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
6
    if constexpr (!_is_reject_split_type) {
508
6
        CppType min_value = get_range_min_value();
509
6
        CppType max_value = get_range_max_value();
510
6
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
6
            min_value.set_type(TimeType::TIME_DATE);
512
6
            max_value.set_type(TimeType::TIME_DATE);
513
6
        }
514
6
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
6
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
6
        auto no_split = [&]() -> bool {
521
6
            begin_scan_keys.emplace_back();
522
6
            begin_scan_keys.back().add_value(
523
6
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
6
                    contain_null());
525
6
            end_scan_keys.emplace_back();
526
6
            end_scan_keys.back().add_value(
527
6
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
6
                    empty_range_only_null ? true : false);
529
6
            return true;
530
6
        };
531
6
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
6
        auto cast = [](const CppType& value) {
536
6
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
6
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
6
                return value;
539
6
            } else {
540
6
                return (int128_t)value;
541
6
            }
542
6
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
6
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
6
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
6
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
6
        int step_size = cast_set<int>(step_size_may_overflow);
554
6
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6
        if (contain_null()) {
558
6
            begin_scan_keys.emplace_back();
559
6
            begin_scan_keys.back().add_null();
560
6
            end_scan_keys.emplace_back();
561
6
            end_scan_keys.back().add_null();
562
6
        }
563
288
        while (true) {
564
288
            begin_scan_keys.emplace_back();
565
288
            begin_scan_keys.back().add_value(
566
288
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
288
            if (cast(max_value) - min_value < step_size) {
569
6
                min_value = max_value;
570
282
            } else {
571
282
                min_value += step_size;
572
282
            }
573
574
288
            end_scan_keys.emplace_back();
575
288
            end_scan_keys.back().add_value(
576
288
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
288
            if (Compare::equal(min_value, max_value)) {
579
6
                break;
580
6
            }
581
282
            ++min_value;
582
282
            ++real_step_size;
583
282
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
282
        }
592
593
6
        return step_size != 0;
594
6
    }
595
0
    return false;
596
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.87k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.87k
    if constexpr (!_is_reject_split_type) {
508
2.87k
        CppType min_value = get_range_min_value();
509
2.87k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
2.87k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.87k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
2.87k
        auto no_split = [&]() -> bool {
521
2.87k
            begin_scan_keys.emplace_back();
522
2.87k
            begin_scan_keys.back().add_value(
523
2.87k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.87k
                    contain_null());
525
2.87k
            end_scan_keys.emplace_back();
526
2.87k
            end_scan_keys.back().add_value(
527
2.87k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.87k
                    empty_range_only_null ? true : false);
529
2.87k
            return true;
530
2.87k
        };
531
2.87k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.87k
        auto cast = [](const CppType& value) {
536
2.87k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.87k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.87k
                return value;
539
2.87k
            } else {
540
2.87k
                return (int128_t)value;
541
2.87k
            }
542
2.87k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
2.87k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.87k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
2.87k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.87k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.87k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.87k
        if (contain_null()) {
558
1.05k
            begin_scan_keys.emplace_back();
559
1.05k
            begin_scan_keys.back().add_null();
560
1.05k
            end_scan_keys.emplace_back();
561
1.05k
            end_scan_keys.back().add_null();
562
1.05k
        }
563
134k
        while (true) {
564
134k
            begin_scan_keys.emplace_back();
565
134k
            begin_scan_keys.back().add_value(
566
134k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
134k
            if (cast(max_value) - min_value < step_size) {
569
2.76k
                min_value = max_value;
570
132k
            } else {
571
132k
                min_value += step_size;
572
132k
            }
573
574
134k
            end_scan_keys.emplace_back();
575
134k
            end_scan_keys.back().add_value(
576
134k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
134k
            if (Compare::equal(min_value, max_value)) {
579
2.89k
                break;
580
2.89k
            }
581
131k
            ++min_value;
582
131k
            ++real_step_size;
583
131k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
131k
        }
592
593
2.87k
        return step_size != 0;
594
2.87k
    }
595
0
    return false;
596
2.87k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
597
598
template <PrimitiveType primitive_type>
599
34
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
34
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
34
    if (!_fixed_values.empty()) {
605
34
        _low_value = *_fixed_values.begin();
606
34
        _low_op = FILTER_LARGER_OR_EQUAL;
607
34
        _high_value = *_fixed_values.rbegin();
608
34
        _high_op = FILTER_LESS_OR_EQUAL;
609
34
        _fixed_values.clear();
610
34
    }
611
34
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
27
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
27
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
27
    if (!_fixed_values.empty()) {
605
27
        _low_value = *_fixed_values.begin();
606
27
        _low_op = FILTER_LARGER_OR_EQUAL;
607
27
        _high_value = *_fixed_values.rbegin();
608
27
        _high_op = FILTER_LESS_OR_EQUAL;
609
27
        _fixed_values.clear();
610
27
    }
611
27
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_range_valueEv
Line
Count
Source
599
1
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
1
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
1
    if (!_fixed_values.empty()) {
605
1
        _low_value = *_fixed_values.begin();
606
1
        _low_op = FILTER_LARGER_OR_EQUAL;
607
1
        _high_value = *_fixed_values.rbegin();
608
1
        _high_op = FILTER_LESS_OR_EQUAL;
609
1
        _fixed_values.clear();
610
1
    }
611
1
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_range_valueEv
Line
Count
Source
599
6
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
6
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
6
    if (!_fixed_values.empty()) {
605
6
        _low_value = *_fixed_values.begin();
606
6
        _low_op = FILTER_LARGER_OR_EQUAL;
607
6
        _high_value = *_fixed_values.rbegin();
608
6
        _high_op = FILTER_LESS_OR_EQUAL;
609
6
        _fixed_values.clear();
610
6
    }
611
6
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE22convert_to_range_valueEv
612
613
template <PrimitiveType primitive_type>
614
165k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
165k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
165k
    _contain_null = false;
621
622
165k
    if (is_fixed_value_range()) {
623
13.7k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
13.7k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
13.4k
        case FILTER_LARGER_OR_EQUAL: {
632
13.4k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
13.4k
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
255
        case FILTER_LESS_OR_EQUAL: {
647
255
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
255
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
13.7k
        }
655
656
13.6k
        _high_value = TYPE_MIN;
657
13.6k
        _low_value = TYPE_MAX;
658
152k
    } else {
659
152k
        if (Compare::greater(_high_value, _low_value)) {
660
84.4k
            switch (op) {
661
31.4k
            case FILTER_LARGER: {
662
31.4k
                if (Compare::greater_equal(value, _low_value)) {
663
31.4k
                    _low_value = value;
664
31.4k
                    _low_op = op;
665
31.4k
                }
666
667
31.4k
                break;
668
0
            }
669
670
19.9k
            case FILTER_LARGER_OR_EQUAL: {
671
19.9k
                if (Compare::greater(value, _low_value)) {
672
16.2k
                    _low_value = value;
673
16.2k
                    _low_op = op;
674
16.2k
                }
675
676
19.9k
                break;
677
0
            }
678
679
6.37k
            case FILTER_LESS: {
680
6.37k
                if (Compare::less_equal(value, _high_value)) {
681
6.36k
                    _high_value = value;
682
6.36k
                    _high_op = op;
683
6.36k
                }
684
685
6.37k
                break;
686
0
            }
687
688
26.6k
            case FILTER_LESS_OR_EQUAL: {
689
26.6k
                if (Compare::less(value, _high_value)) {
690
22.9k
                    _high_value = value;
691
22.9k
                    _high_op = op;
692
22.9k
                }
693
694
26.6k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
84.4k
            }
701
84.4k
        }
702
703
152k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
152k
            Compare::equal(_high_value, _low_value)) {
705
14.8k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
14.8k
            _high_value = TYPE_MIN;
707
14.8k
            _low_value = TYPE_MAX;
708
14.8k
        }
709
152k
    }
710
711
165k
    return Status::OK();
712
165k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
2.55k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2.55k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
2.55k
    _contain_null = false;
621
622
2.55k
    if (is_fixed_value_range()) {
623
258
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
258
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
250
        case FILTER_LARGER_OR_EQUAL: {
632
250
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
250
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
9
        case FILTER_LESS_OR_EQUAL: {
647
9
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
9
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
258
        }
655
656
261
        _high_value = TYPE_MIN;
657
261
        _low_value = TYPE_MAX;
658
2.29k
    } else {
659
2.29k
        if (Compare::greater(_high_value, _low_value)) {
660
2.13k
            switch (op) {
661
316
            case FILTER_LARGER: {
662
316
                if (Compare::greater_equal(value, _low_value)) {
663
314
                    _low_value = value;
664
314
                    _low_op = op;
665
314
                }
666
667
316
                break;
668
0
            }
669
670
675
            case FILTER_LARGER_OR_EQUAL: {
671
675
                if (Compare::greater(value, _low_value)) {
672
475
                    _low_value = value;
673
475
                    _low_op = op;
674
475
                }
675
676
675
                break;
677
0
            }
678
679
300
            case FILTER_LESS: {
680
301
                if (Compare::less_equal(value, _high_value)) {
681
301
                    _high_value = value;
682
301
                    _high_op = op;
683
301
                }
684
685
300
                break;
686
0
            }
687
688
851
            case FILTER_LESS_OR_EQUAL: {
689
851
                if (Compare::less(value, _high_value)) {
690
650
                    _high_value = value;
691
650
                    _high_op = op;
692
650
                }
693
694
851
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
2.13k
            }
701
2.13k
        }
702
703
2.28k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
2.28k
            Compare::equal(_high_value, _low_value)) {
705
327
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
327
            _high_value = TYPE_MIN;
707
327
            _low_value = TYPE_MAX;
708
327
        }
709
2.28k
    }
710
711
2.54k
    return Status::OK();
712
2.55k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
1.73k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.73k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
1.73k
    _contain_null = false;
621
622
1.73k
    if (is_fixed_value_range()) {
623
5
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
5
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
5
        case FILTER_LARGER_OR_EQUAL: {
632
5
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
5
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
5
        }
655
656
5
        _high_value = TYPE_MIN;
657
5
        _low_value = TYPE_MAX;
658
1.73k
    } else {
659
1.73k
        if (Compare::greater(_high_value, _low_value)) {
660
1.71k
            switch (op) {
661
1.14k
            case FILTER_LARGER: {
662
1.14k
                if (Compare::greater_equal(value, _low_value)) {
663
1.13k
                    _low_value = value;
664
1.13k
                    _low_op = op;
665
1.13k
                }
666
667
1.14k
                break;
668
0
            }
669
670
311
            case FILTER_LARGER_OR_EQUAL: {
671
311
                if (Compare::greater(value, _low_value)) {
672
272
                    _low_value = value;
673
272
                    _low_op = op;
674
272
                }
675
676
311
                break;
677
0
            }
678
679
24
            case FILTER_LESS: {
680
24
                if (Compare::less_equal(value, _high_value)) {
681
24
                    _high_value = value;
682
24
                    _high_op = op;
683
24
                }
684
685
24
                break;
686
0
            }
687
688
240
            case FILTER_LESS_OR_EQUAL: {
689
240
                if (Compare::less(value, _high_value)) {
690
180
                    _high_value = value;
691
180
                    _high_op = op;
692
180
                }
693
694
240
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.71k
            }
701
1.71k
        }
702
703
1.71k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.71k
            Compare::equal(_high_value, _low_value)) {
705
6
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
6
            _high_value = TYPE_MIN;
707
6
            _low_value = TYPE_MAX;
708
6
        }
709
1.71k
    }
710
711
1.72k
    return Status::OK();
712
1.73k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
13.8k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
13.8k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
13.8k
    _contain_null = false;
621
622
13.8k
    if (is_fixed_value_range()) {
623
259
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
259
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
171
        case FILTER_LARGER_OR_EQUAL: {
632
171
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
171
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
88
        case FILTER_LESS_OR_EQUAL: {
647
88
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
88
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
259
        }
655
656
259
        _high_value = TYPE_MIN;
657
259
        _low_value = TYPE_MAX;
658
13.6k
    } else {
659
13.6k
        if (Compare::greater(_high_value, _low_value)) {
660
12.7k
            switch (op) {
661
2.77k
            case FILTER_LARGER: {
662
2.77k
                if (Compare::greater_equal(value, _low_value)) {
663
2.76k
                    _low_value = value;
664
2.76k
                    _low_op = op;
665
2.76k
                }
666
667
2.77k
                break;
668
0
            }
669
670
4.52k
            case FILTER_LARGER_OR_EQUAL: {
671
4.52k
                if (Compare::greater(value, _low_value)) {
672
3.84k
                    _low_value = value;
673
3.84k
                    _low_op = op;
674
3.84k
                }
675
676
4.52k
                break;
677
0
            }
678
679
1.09k
            case FILTER_LESS: {
680
1.09k
                if (Compare::less_equal(value, _high_value)) {
681
1.08k
                    _high_value = value;
682
1.08k
                    _high_op = op;
683
1.08k
                }
684
685
1.09k
                break;
686
0
            }
687
688
4.39k
            case FILTER_LESS_OR_EQUAL: {
689
4.39k
                if (Compare::less(value, _high_value)) {
690
3.70k
                    _high_value = value;
691
3.70k
                    _high_op = op;
692
3.70k
                }
693
694
4.39k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
12.7k
            }
701
12.7k
        }
702
703
13.5k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
13.5k
            Compare::equal(_high_value, _low_value)) {
705
369
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
369
            _high_value = TYPE_MIN;
707
369
            _low_value = TYPE_MAX;
708
369
        }
709
13.5k
    }
710
711
13.8k
    return Status::OK();
712
13.8k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
112k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
112k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
112k
    _contain_null = false;
621
622
112k
    if (is_fixed_value_range()) {
623
13.1k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
13.1k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
12.9k
        case FILTER_LARGER_OR_EQUAL: {
632
12.9k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
12.9k
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
146
        case FILTER_LESS_OR_EQUAL: {
647
146
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
146
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
13.1k
        }
655
656
13.1k
        _high_value = TYPE_MIN;
657
13.1k
        _low_value = TYPE_MAX;
658
99.7k
    } else {
659
99.7k
        if (Compare::greater(_high_value, _low_value)) {
660
33.0k
            switch (op) {
661
11.5k
            case FILTER_LARGER: {
662
11.5k
                if (Compare::greater_equal(value, _low_value)) {
663
11.5k
                    _low_value = value;
664
11.5k
                    _low_op = op;
665
11.5k
                }
666
667
11.5k
                break;
668
0
            }
669
670
4.80k
            case FILTER_LARGER_OR_EQUAL: {
671
4.80k
                if (Compare::greater(value, _low_value)) {
672
4.78k
                    _low_value = value;
673
4.78k
                    _low_op = op;
674
4.78k
                }
675
676
4.80k
                break;
677
0
            }
678
679
121
            case FILTER_LESS: {
680
121
                if (Compare::less_equal(value, _high_value)) {
681
121
                    _high_value = value;
682
121
                    _high_op = op;
683
121
                }
684
685
121
                break;
686
0
            }
687
688
16.5k
            case FILTER_LESS_OR_EQUAL: {
689
16.5k
                if (Compare::less(value, _high_value)) {
690
16.5k
                    _high_value = value;
691
16.5k
                    _high_op = op;
692
16.5k
                }
693
694
16.5k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
33.0k
            }
701
33.0k
        }
702
703
99.7k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
99.7k
            Compare::equal(_high_value, _low_value)) {
705
13.3k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
13.3k
            _high_value = TYPE_MIN;
707
13.3k
            _low_value = TYPE_MAX;
708
13.3k
        }
709
99.7k
    }
710
711
112k
    return Status::OK();
712
112k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
159
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
159
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
159
    _contain_null = false;
621
622
159
    if (is_fixed_value_range()) {
623
10
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
10
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
5
        case FILTER_LARGER_OR_EQUAL: {
632
5
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
5
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
5
        case FILTER_LESS_OR_EQUAL: {
647
5
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
5
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
10
        }
655
656
10
        _high_value = TYPE_MIN;
657
10
        _low_value = TYPE_MAX;
658
149
    } else {
659
149
        if (Compare::greater(_high_value, _low_value)) {
660
149
            switch (op) {
661
16
            case FILTER_LARGER: {
662
16
                if (Compare::greater_equal(value, _low_value)) {
663
16
                    _low_value = value;
664
16
                    _low_op = op;
665
16
                }
666
667
16
                break;
668
0
            }
669
670
47
            case FILTER_LARGER_OR_EQUAL: {
671
47
                if (Compare::greater(value, _low_value)) {
672
44
                    _low_value = value;
673
44
                    _low_op = op;
674
44
                }
675
676
47
                break;
677
0
            }
678
679
12
            case FILTER_LESS: {
680
12
                if (Compare::less_equal(value, _high_value)) {
681
12
                    _high_value = value;
682
12
                    _high_op = op;
683
12
                }
684
685
12
                break;
686
0
            }
687
688
74
            case FILTER_LESS_OR_EQUAL: {
689
74
                if (Compare::less(value, _high_value)) {
690
69
                    _high_value = value;
691
69
                    _high_op = op;
692
69
                }
693
694
74
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
149
            }
701
149
        }
702
703
147
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
147
            Compare::equal(_high_value, _low_value)) {
705
12
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
12
            _high_value = TYPE_MIN;
707
12
            _low_value = TYPE_MAX;
708
12
        }
709
147
    }
710
711
157
    return Status::OK();
712
159
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
173
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
173
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
173
    _contain_null = false;
621
622
173
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
173
    } else {
659
173
        if (Compare::greater(_high_value, _low_value)) {
660
173
            switch (op) {
661
31
            case FILTER_LARGER: {
662
31
                if (Compare::greater_equal(value, _low_value)) {
663
31
                    _low_value = value;
664
31
                    _low_op = op;
665
31
                }
666
667
31
                break;
668
0
            }
669
670
61
            case FILTER_LARGER_OR_EQUAL: {
671
61
                if (Compare::greater(value, _low_value)) {
672
43
                    _low_value = value;
673
43
                    _low_op = op;
674
43
                }
675
676
61
                break;
677
0
            }
678
679
28
            case FILTER_LESS: {
680
28
                if (Compare::less_equal(value, _high_value)) {
681
28
                    _high_value = value;
682
28
                    _high_op = op;
683
28
                }
684
685
28
                break;
686
0
            }
687
688
53
            case FILTER_LESS_OR_EQUAL: {
689
53
                if (Compare::less(value, _high_value)) {
690
35
                    _high_value = value;
691
35
                    _high_op = op;
692
35
                }
693
694
53
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
173
            }
701
173
        }
702
703
173
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
173
            Compare::equal(_high_value, _low_value)) {
705
16
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
16
            _high_value = TYPE_MIN;
707
16
            _low_value = TYPE_MAX;
708
16
        }
709
173
    }
710
711
173
    return Status::OK();
712
173
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
396
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
396
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
396
    _contain_null = false;
621
622
396
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
396
    } else {
659
398
        if (Compare::greater(_high_value, _low_value)) {
660
398
            switch (op) {
661
185
            case FILTER_LARGER: {
662
185
                if (Compare::greater_equal(value, _low_value)) {
663
184
                    _low_value = value;
664
184
                    _low_op = op;
665
184
                }
666
667
185
                break;
668
0
            }
669
670
84
            case FILTER_LARGER_OR_EQUAL: {
671
84
                if (Compare::greater(value, _low_value)) {
672
40
                    _low_value = value;
673
40
                    _low_op = op;
674
40
                }
675
676
84
                break;
677
0
            }
678
679
49
            case FILTER_LESS: {
680
49
                if (Compare::less_equal(value, _high_value)) {
681
48
                    _high_value = value;
682
48
                    _high_op = op;
683
48
                }
684
685
49
                break;
686
0
            }
687
688
81
            case FILTER_LESS_OR_EQUAL: {
689
81
                if (Compare::less(value, _high_value)) {
690
38
                    _high_value = value;
691
38
                    _high_op = op;
692
38
                }
693
694
81
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
398
            }
701
398
        }
702
703
392
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
392
            Compare::equal(_high_value, _low_value)) {
705
13
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
13
            _high_value = TYPE_MIN;
707
13
            _low_value = TYPE_MAX;
708
13
        }
709
392
    }
710
711
392
    return Status::OK();
712
396
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
Line
Count
Source
614
26
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
26
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
26
    _contain_null = false;
621
622
26
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
26
    } else {
659
26
        if (Compare::greater(_high_value, _low_value)) {
660
26
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
13
            case FILTER_LARGER_OR_EQUAL: {
671
13
                if (Compare::greater(value, _low_value)) {
672
8
                    _low_value = value;
673
8
                    _low_op = op;
674
8
                }
675
676
13
                break;
677
0
            }
678
679
8
            case FILTER_LESS: {
680
8
                if (Compare::less_equal(value, _high_value)) {
681
7
                    _high_value = value;
682
7
                    _high_op = op;
683
7
                }
684
685
8
                break;
686
0
            }
687
688
5
            case FILTER_LESS_OR_EQUAL: {
689
5
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
5
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
26
            }
701
26
        }
702
703
25
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
25
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
25
    }
710
711
25
    return Status::OK();
712
26
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
Line
Count
Source
614
22
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
22
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
22
    _contain_null = false;
621
622
22
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
22
    } else {
659
22
        if (Compare::greater(_high_value, _low_value)) {
660
21
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
11
            case FILTER_LARGER_OR_EQUAL: {
671
11
                if (Compare::greater(value, _low_value)) {
672
8
                    _low_value = value;
673
8
                    _low_op = op;
674
8
                }
675
676
11
                break;
677
0
            }
678
679
6
            case FILTER_LESS: {
680
6
                if (Compare::less_equal(value, _high_value)) {
681
6
                    _high_value = value;
682
6
                    _high_op = op;
683
6
                }
684
685
6
                break;
686
0
            }
687
688
3
            case FILTER_LESS_OR_EQUAL: {
689
3
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
3
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
21
            }
701
21
        }
702
703
21
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
21
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
21
    }
710
711
21
    return Status::OK();
712
22
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
811
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
811
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
811
    _contain_null = false;
621
622
811
    if (is_fixed_value_range()) {
623
1
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
1
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
1
        case FILTER_LARGER_OR_EQUAL: {
632
1
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
1
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
1
        }
655
656
1
        _high_value = TYPE_MIN;
657
1
        _low_value = TYPE_MAX;
658
810
    } else {
659
810
        if (Compare::greater(_high_value, _low_value)) {
660
770
            switch (op) {
661
550
            case FILTER_LARGER: {
662
550
                if (Compare::greater_equal(value, _low_value)) {
663
548
                    _low_value = value;
664
548
                    _low_op = op;
665
548
                }
666
667
550
                break;
668
0
            }
669
670
75
            case FILTER_LARGER_OR_EQUAL: {
671
75
                if (Compare::greater(value, _low_value)) {
672
48
                    _low_value = value;
673
48
                    _low_op = op;
674
48
                }
675
676
75
                break;
677
0
            }
678
679
47
            case FILTER_LESS: {
680
47
                if (Compare::less_equal(value, _high_value)) {
681
47
                    _high_value = value;
682
47
                    _high_op = op;
683
47
                }
684
685
47
                break;
686
0
            }
687
688
101
            case FILTER_LESS_OR_EQUAL: {
689
101
                if (Compare::less(value, _high_value)) {
690
78
                    _high_value = value;
691
78
                    _high_op = op;
692
78
                }
693
694
101
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
770
            }
701
770
        }
702
703
810
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
810
            Compare::equal(_high_value, _low_value)) {
705
17
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
17
            _high_value = TYPE_MIN;
707
17
            _low_value = TYPE_MAX;
708
17
        }
709
810
    }
710
711
811
    return Status::OK();
712
811
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.86k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.86k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
1.86k
    _contain_null = false;
621
622
1.86k
    if (is_fixed_value_range()) {
623
8
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
8
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
4
        case FILTER_LARGER_OR_EQUAL: {
632
4
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
4
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
4
        case FILTER_LESS_OR_EQUAL: {
647
4
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
4
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
8
        }
655
656
8
        _high_value = TYPE_MIN;
657
8
        _low_value = TYPE_MAX;
658
1.85k
    } else {
659
1.85k
        if (Compare::greater(_high_value, _low_value)) {
660
1.84k
            switch (op) {
661
990
            case FILTER_LARGER: {
662
990
                if (Compare::greater_equal(value, _low_value)) {
663
978
                    _low_value = value;
664
978
                    _low_op = op;
665
978
                }
666
667
990
                break;
668
0
            }
669
670
335
            case FILTER_LARGER_OR_EQUAL: {
671
335
                if (Compare::greater(value, _low_value)) {
672
255
                    _low_value = value;
673
255
                    _low_op = op;
674
255
                }
675
676
335
                break;
677
0
            }
678
679
106
            case FILTER_LESS: {
680
106
                if (Compare::less_equal(value, _high_value)) {
681
105
                    _high_value = value;
682
105
                    _high_op = op;
683
105
                }
684
685
106
                break;
686
0
            }
687
688
415
            case FILTER_LESS_OR_EQUAL: {
689
415
                if (Compare::less(value, _high_value)) {
690
351
                    _high_value = value;
691
351
                    _high_op = op;
692
351
                }
693
694
415
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.84k
            }
701
1.84k
        }
702
703
1.85k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.85k
            Compare::equal(_high_value, _low_value)) {
705
213
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
213
            _high_value = TYPE_MIN;
707
213
            _low_value = TYPE_MAX;
708
213
        }
709
1.85k
    }
710
711
1.85k
    return Status::OK();
712
1.86k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
4.51k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
4.51k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
4.51k
    _contain_null = false;
621
622
4.51k
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
4.51k
    } else {
659
4.51k
        if (Compare::greater(_high_value, _low_value)) {
660
4.49k
            switch (op) {
661
72
            case FILTER_LARGER: {
662
72
                if (Compare::greater_equal(value, _low_value)) {
663
72
                    _low_value = value;
664
72
                    _low_op = op;
665
72
                }
666
667
72
                break;
668
0
            }
669
670
2.15k
            case FILTER_LARGER_OR_EQUAL: {
671
2.15k
                if (Compare::greater(value, _low_value)) {
672
93
                    _low_value = value;
673
93
                    _low_op = op;
674
93
                }
675
676
2.15k
                break;
677
0
            }
678
679
84
            case FILTER_LESS: {
680
84
                if (Compare::less_equal(value, _high_value)) {
681
82
                    _high_value = value;
682
82
                    _high_op = op;
683
82
                }
684
685
84
                break;
686
0
            }
687
688
2.20k
            case FILTER_LESS_OR_EQUAL: {
689
2.20k
                if (Compare::less(value, _high_value)) {
690
149
                    _high_value = value;
691
149
                    _high_op = op;
692
149
                }
693
694
2.20k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
4.49k
            }
701
4.49k
        }
702
703
4.50k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
4.50k
            Compare::equal(_high_value, _low_value)) {
705
67
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
67
            _high_value = TYPE_MIN;
707
67
            _low_value = TYPE_MAX;
708
67
        }
709
4.50k
    }
710
711
4.50k
    return Status::OK();
712
4.51k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
20.6k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
20.6k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
20.6k
    _contain_null = false;
621
622
20.6k
    if (is_fixed_value_range()) {
623
17
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
17
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
14
        case FILTER_LARGER_OR_EQUAL: {
632
14
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
14
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
3
        case FILTER_LESS_OR_EQUAL: {
647
3
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
3
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
17
        }
655
656
17
        _high_value = TYPE_MIN;
657
17
        _low_value = TYPE_MAX;
658
20.6k
    } else {
659
20.6k
        if (Compare::greater(_high_value, _low_value)) {
660
20.5k
            switch (op) {
661
13.1k
            case FILTER_LARGER: {
662
13.1k
                if (Compare::greater_equal(value, _low_value)) {
663
13.1k
                    _low_value = value;
664
13.1k
                    _low_op = op;
665
13.1k
                }
666
667
13.1k
                break;
668
0
            }
669
670
4.19k
            case FILTER_LARGER_OR_EQUAL: {
671
4.19k
                if (Compare::greater(value, _low_value)) {
672
4.13k
                    _low_value = value;
673
4.13k
                    _low_op = op;
674
4.13k
                }
675
676
4.19k
                break;
677
0
            }
678
679
2.75k
            case FILTER_LESS: {
680
2.75k
                if (Compare::less_equal(value, _high_value)) {
681
2.75k
                    _high_value = value;
682
2.75k
                    _high_op = op;
683
2.75k
                }
684
685
2.75k
                break;
686
0
            }
687
688
449
            case FILTER_LESS_OR_EQUAL: {
689
449
                if (Compare::less(value, _high_value)) {
690
389
                    _high_value = value;
691
389
                    _high_op = op;
692
389
                }
693
694
449
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
20.5k
            }
701
20.5k
        }
702
703
20.5k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
20.5k
            Compare::equal(_high_value, _low_value)) {
705
63
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
63
            _high_value = TYPE_MIN;
707
63
            _low_value = TYPE_MAX;
708
63
        }
709
20.5k
    }
710
711
20.5k
    return Status::OK();
712
20.6k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.86k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.86k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
3.86k
    _contain_null = false;
621
622
3.86k
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
3.86k
    } else {
659
3.86k
        if (Compare::greater(_high_value, _low_value)) {
660
3.85k
            switch (op) {
661
256
            case FILTER_LARGER: {
662
257
                if (Compare::greater_equal(value, _low_value)) {
663
257
                    _low_value = value;
664
257
                    _low_op = op;
665
257
                }
666
667
256
                break;
668
0
            }
669
670
1.75k
            case FILTER_LARGER_OR_EQUAL: {
671
1.75k
                if (Compare::greater(value, _low_value)) {
672
1.70k
                    _low_value = value;
673
1.70k
                    _low_op = op;
674
1.70k
                }
675
676
1.75k
                break;
677
0
            }
678
679
1.50k
            case FILTER_LESS: {
680
1.50k
                if (Compare::less_equal(value, _high_value)) {
681
1.50k
                    _high_value = value;
682
1.50k
                    _high_op = op;
683
1.50k
                }
684
685
1.50k
                break;
686
0
            }
687
688
341
            case FILTER_LESS_OR_EQUAL: {
689
341
                if (Compare::less(value, _high_value)) {
690
297
                    _high_value = value;
691
297
                    _high_op = op;
692
297
                }
693
694
341
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.85k
            }
701
3.85k
        }
702
703
3.85k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.85k
            Compare::equal(_high_value, _low_value)) {
705
73
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
73
            _high_value = TYPE_MIN;
707
73
            _low_value = TYPE_MAX;
708
73
        }
709
3.85k
    }
710
711
3.85k
    return Status::OK();
712
3.86k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
605
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
605
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
605
    _contain_null = false;
621
622
605
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
605
    } else {
659
605
        if (Compare::greater(_high_value, _low_value)) {
660
603
            switch (op) {
661
141
            case FILTER_LARGER: {
662
141
                if (Compare::greater_equal(value, _low_value)) {
663
140
                    _low_value = value;
664
140
                    _low_op = op;
665
140
                }
666
667
141
                break;
668
0
            }
669
670
180
            case FILTER_LARGER_OR_EQUAL: {
671
180
                if (Compare::greater(value, _low_value)) {
672
89
                    _low_value = value;
673
89
                    _low_op = op;
674
89
                }
675
676
180
                break;
677
0
            }
678
679
102
            case FILTER_LESS: {
680
102
                if (Compare::less_equal(value, _high_value)) {
681
102
                    _high_value = value;
682
102
                    _high_op = op;
683
102
                }
684
685
102
                break;
686
0
            }
687
688
176
            case FILTER_LESS_OR_EQUAL: {
689
176
                if (Compare::less(value, _high_value)) {
690
131
                    _high_value = value;
691
131
                    _high_op = op;
692
131
                }
693
694
176
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
603
            }
701
603
        }
702
703
592
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
592
            Compare::equal(_high_value, _low_value)) {
705
49
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
49
            _high_value = TYPE_MIN;
707
49
            _low_value = TYPE_MAX;
708
49
        }
709
592
    }
710
711
592
    return Status::OK();
712
605
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Line
Count
Source
614
68
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
68
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
68
    _contain_null = false;
621
622
68
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
68
    } else {
659
68
        if (Compare::greater(_high_value, _low_value)) {
660
68
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
34
            case FILTER_LARGER_OR_EQUAL: {
671
34
                if (Compare::greater(value, _low_value)) {
672
16
                    _low_value = value;
673
16
                    _low_op = op;
674
16
                }
675
676
34
                break;
677
0
            }
678
679
0
            case FILTER_LESS: {
680
0
                if (Compare::less_equal(value, _high_value)) {
681
0
                    _high_value = value;
682
0
                    _high_op = op;
683
0
                }
684
685
0
                break;
686
0
            }
687
688
34
            case FILTER_LESS_OR_EQUAL: {
689
34
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
34
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
68
            }
701
68
        }
702
703
68
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
68
            Compare::equal(_high_value, _low_value)) {
705
16
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
16
            _high_value = TYPE_MIN;
707
16
            _low_value = TYPE_MAX;
708
16
        }
709
68
    }
710
711
68
    return Status::OK();
712
68
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
233
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
233
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
233
    _contain_null = false;
621
622
233
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
233
    } else {
659
233
        if (Compare::greater(_high_value, _low_value)) {
660
233
            switch (op) {
661
12
            case FILTER_LARGER: {
662
12
                if (Compare::greater_equal(value, _low_value)) {
663
12
                    _low_value = value;
664
12
                    _low_op = op;
665
12
                }
666
667
12
                break;
668
0
            }
669
670
88
            case FILTER_LARGER_OR_EQUAL: {
671
88
                if (Compare::greater(value, _low_value)) {
672
55
                    _low_value = value;
673
55
                    _low_op = op;
674
55
                }
675
676
88
                break;
677
0
            }
678
679
45
            case FILTER_LESS: {
680
45
                if (Compare::less_equal(value, _high_value)) {
681
44
                    _high_value = value;
682
44
                    _high_op = op;
683
44
                }
684
685
45
                break;
686
0
            }
687
688
87
            case FILTER_LESS_OR_EQUAL: {
689
87
                if (Compare::less(value, _high_value)) {
690
53
                    _high_value = value;
691
53
                    _high_op = op;
692
53
                }
693
694
87
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
233
            }
701
233
        }
702
703
232
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
232
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
232
    }
710
711
232
    return Status::OK();
712
233
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
1.29k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.29k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
1.29k
    _contain_null = false;
621
622
1.29k
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
1.29k
    } else {
659
1.29k
        if (Compare::greater(_high_value, _low_value)) {
660
1.28k
            switch (op) {
661
161
            case FILTER_LARGER: {
662
161
                if (Compare::greater_equal(value, _low_value)) {
663
157
                    _low_value = value;
664
157
                    _low_op = op;
665
157
                }
666
667
161
                break;
668
0
            }
669
670
535
            case FILTER_LARGER_OR_EQUAL: {
671
535
                if (Compare::greater(value, _low_value)) {
672
285
                    _low_value = value;
673
285
                    _low_op = op;
674
285
                }
675
676
535
                break;
677
0
            }
678
679
56
            case FILTER_LESS: {
680
56
                if (Compare::less_equal(value, _high_value)) {
681
56
                    _high_value = value;
682
56
                    _high_op = op;
683
56
                }
684
685
56
                break;
686
0
            }
687
688
536
            case FILTER_LESS_OR_EQUAL: {
689
536
                if (Compare::less(value, _high_value)) {
690
283
                    _high_value = value;
691
283
                    _high_op = op;
692
283
                }
693
694
536
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.28k
            }
701
1.28k
        }
702
703
1.28k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.28k
            Compare::equal(_high_value, _low_value)) {
705
209
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
209
            _high_value = TYPE_MIN;
707
209
            _low_value = TYPE_MAX;
708
209
        }
709
1.28k
    }
710
711
1.28k
    return Status::OK();
712
1.29k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9add_rangeENS_11SQLFilterOpENS_12Decimal128V3E
Line
Count
Source
614
162
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
162
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
162
    _contain_null = false;
621
622
162
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
162
    } else {
659
162
        if (Compare::greater(_high_value, _low_value)) {
660
160
            switch (op) {
661
88
            case FILTER_LARGER: {
662
88
                if (Compare::greater_equal(value, _low_value)) {
663
87
                    _low_value = value;
664
87
                    _low_op = op;
665
87
                }
666
667
88
                break;
668
0
            }
669
670
33
            case FILTER_LARGER_OR_EQUAL: {
671
33
                if (Compare::greater(value, _low_value)) {
672
25
                    _low_value = value;
673
25
                    _low_op = op;
674
25
                }
675
676
33
                break;
677
0
            }
678
679
10
            case FILTER_LESS: {
680
10
                if (Compare::less_equal(value, _high_value)) {
681
10
                    _high_value = value;
682
10
                    _high_op = op;
683
10
                }
684
685
10
                break;
686
0
            }
687
688
29
            case FILTER_LESS_OR_EQUAL: {
689
29
                if (Compare::less(value, _high_value)) {
690
21
                    _high_value = value;
691
21
                    _high_op = op;
692
21
                }
693
694
29
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
160
            }
701
160
        }
702
703
163
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
163
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
163
    }
710
711
163
    return Status::OK();
712
162
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9add_rangeENS_11SQLFilterOpENS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
614
117
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
117
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
117
    _contain_null = false;
621
622
117
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
117
    } else {
659
117
        if (Compare::greater(_high_value, _low_value)) {
660
109
            switch (op) {
661
24
            case FILTER_LARGER: {
662
24
                if (Compare::greater_equal(value, _low_value)) {
663
24
                    _low_value = value;
664
24
                    _low_op = op;
665
24
                }
666
667
24
                break;
668
0
            }
669
670
34
            case FILTER_LARGER_OR_EQUAL: {
671
34
                if (Compare::greater(value, _low_value)) {
672
21
                    _low_value = value;
673
21
                    _low_op = op;
674
21
                }
675
676
34
                break;
677
0
            }
678
679
22
            case FILTER_LESS: {
680
24
                if (Compare::less_equal(value, _high_value)) {
681
24
                    _high_value = value;
682
24
                    _high_op = op;
683
24
                }
684
685
22
                break;
686
0
            }
687
688
32
            case FILTER_LESS_OR_EQUAL: {
689
32
                if (Compare::less(value, _high_value)) {
690
20
                    _high_value = value;
691
20
                    _high_op = op;
692
20
                }
693
694
32
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
109
            }
701
109
        }
702
703
123
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
123
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
123
    }
710
711
123
    return Status::OK();
712
117
}
713
714
template <PrimitiveType primitive_type>
715
473k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
473k
    switch (_high_op) {
717
84
    case FILTER_LESS: {
718
84
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
84
        case FILTER_LARGER_OR_EQUAL: {
724
84
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
84
        }
731
732
0
        break;
733
84
    }
734
735
473k
    case FILTER_LESS_OR_EQUAL: {
736
473k
        switch (_low_op) {
737
34
        case FILTER_LARGER: {
738
34
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
473k
        case FILTER_LARGER_OR_EQUAL: {
742
473k
            return Compare::less_equal(value, _high_value) &&
743
474k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
473k
        }
750
473k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
473k
    }
756
757
0
    return false;
758
473k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
120k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
120k
    switch (_high_op) {
717
6
    case FILTER_LESS: {
718
6
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
6
        case FILTER_LARGER_OR_EQUAL: {
724
6
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
6
        }
731
732
0
        break;
733
6
    }
734
735
120k
    case FILTER_LESS_OR_EQUAL: {
736
120k
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
120k
        case FILTER_LARGER_OR_EQUAL: {
742
120k
            return Compare::less_equal(value, _high_value) &&
743
120k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
120k
        }
750
120k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
120k
    }
756
757
0
    return false;
758
120k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
340
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
340
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
340
    case FILTER_LESS_OR_EQUAL: {
736
340
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
340
        case FILTER_LARGER_OR_EQUAL: {
742
340
            return Compare::less_equal(value, _high_value) &&
743
340
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
340
        }
750
340
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
340
    }
756
757
0
    return false;
758
340
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
42.0k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
42.0k
    switch (_high_op) {
717
70
    case FILTER_LESS: {
718
70
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
70
        case FILTER_LARGER_OR_EQUAL: {
724
70
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
70
        }
731
732
0
        break;
733
70
    }
734
735
41.9k
    case FILTER_LESS_OR_EQUAL: {
736
41.9k
        switch (_low_op) {
737
11
        case FILTER_LARGER: {
738
11
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
41.9k
        case FILTER_LARGER_OR_EQUAL: {
742
41.9k
            return Compare::less_equal(value, _high_value) &&
743
41.9k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
41.9k
        }
750
41.9k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
42.0k
    }
756
757
0
    return false;
758
42.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
1.92k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.92k
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
1.93k
    case FILTER_LESS_OR_EQUAL: {
736
1.93k
        switch (_low_op) {
737
21
        case FILTER_LARGER: {
738
21
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
1.90k
        case FILTER_LARGER_OR_EQUAL: {
742
1.90k
            return Compare::less_equal(value, _high_value) &&
743
1.90k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.93k
        }
750
1.93k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.92k
    }
756
757
0
    return false;
758
1.92k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
190
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
190
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
190
    case FILTER_LESS_OR_EQUAL: {
736
190
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
189
        case FILTER_LARGER_OR_EQUAL: {
742
189
            return Compare::less_equal(value, _high_value) &&
743
189
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
190
        }
750
190
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
190
    }
756
757
0
    return false;
758
190
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE11is_in_rangeERKf
Line
Count
Source
715
46
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
46
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
46
    case FILTER_LESS_OR_EQUAL: {
736
46
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
46
        case FILTER_LARGER_OR_EQUAL: {
742
46
            return Compare::less_equal(value, _high_value) &&
743
47
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
46
        }
750
46
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
46
    }
756
757
0
    return false;
758
46
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE11is_in_rangeERKd
Line
Count
Source
715
169
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
169
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
169
    case FILTER_LESS_OR_EQUAL: {
736
169
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
169
        case FILTER_LARGER_OR_EQUAL: {
742
169
            return Compare::less_equal(value, _high_value) &&
743
169
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
169
        }
750
169
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
169
    }
756
757
0
    return false;
758
169
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE11is_in_rangeERKj
Line
Count
Source
715
58
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
58
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
59
    case FILTER_LESS_OR_EQUAL: {
736
59
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
58
        case FILTER_LARGER_OR_EQUAL: {
742
58
            return Compare::less_equal(value, _high_value) &&
743
59
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
59
        }
750
59
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
58
    }
756
757
0
    return false;
758
58
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE11is_in_rangeERKo
Line
Count
Source
715
57
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
57
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
58
    case FILTER_LESS_OR_EQUAL: {
736
58
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
58
        case FILTER_LARGER_OR_EQUAL: {
742
58
            return Compare::less_equal(value, _high_value) &&
743
58
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
58
        }
750
58
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
57
    }
756
757
0
    return false;
758
57
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
571
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
571
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
570
    case FILTER_LESS_OR_EQUAL: {
736
570
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
568
        case FILTER_LARGER_OR_EQUAL: {
742
568
            return Compare::less_equal(value, _high_value) &&
743
571
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
570
        }
750
570
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
571
    }
756
757
0
    return false;
758
571
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
294k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
294k
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
294k
    case FILTER_LESS_OR_EQUAL: {
736
294k
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
294k
        case FILTER_LARGER_OR_EQUAL: {
742
294k
            return Compare::less_equal(value, _high_value) &&
743
295k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
294k
        }
750
294k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
294k
    }
756
757
0
    return false;
758
294k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
1.49k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.49k
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
1.49k
    case FILTER_LESS_OR_EQUAL: {
736
1.49k
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
1.49k
        case FILTER_LARGER_OR_EQUAL: {
742
1.49k
            return Compare::less_equal(value, _high_value) &&
743
1.49k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.49k
        }
750
1.49k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.49k
    }
756
757
0
    return false;
758
1.49k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
70
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
70
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
70
    case FILTER_LESS_OR_EQUAL: {
736
70
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
70
        case FILTER_LARGER_OR_EQUAL: {
742
70
            return Compare::less_equal(value, _high_value) &&
743
70
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
70
        }
750
70
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
70
    }
756
757
0
    return false;
758
70
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
9.29k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
9.29k
    switch (_high_op) {
717
8
    case FILTER_LESS: {
718
8
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
8
        case FILTER_LARGER_OR_EQUAL: {
724
8
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
8
        }
731
732
0
        break;
733
8
    }
734
735
9.29k
    case FILTER_LESS_OR_EQUAL: {
736
9.29k
        switch (_low_op) {
737
2
        case FILTER_LARGER: {
738
2
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
9.28k
        case FILTER_LARGER_OR_EQUAL: {
742
9.28k
            return Compare::less_equal(value, _high_value) &&
743
9.28k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
9.29k
        }
750
9.29k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
9.29k
    }
756
757
0
    return false;
758
9.29k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
62
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
62
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
62
    case FILTER_LESS_OR_EQUAL: {
736
62
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
62
        case FILTER_LARGER_OR_EQUAL: {
742
62
            return Compare::less_equal(value, _high_value) &&
743
62
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
62
        }
750
62
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
62
    }
756
757
0
    return false;
758
62
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
634
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
634
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
632
    case FILTER_LESS_OR_EQUAL: {
736
632
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
636
        case FILTER_LARGER_OR_EQUAL: {
742
636
            return Compare::less_equal(value, _high_value) &&
743
636
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
632
        }
750
632
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
634
    }
756
757
0
    return false;
758
634
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
201
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
201
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
200
    case FILTER_LESS_OR_EQUAL: {
736
200
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
200
        case FILTER_LARGER_OR_EQUAL: {
742
200
            return Compare::less_equal(value, _high_value) &&
743
200
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
200
        }
750
200
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
201
    }
756
757
0
    return false;
758
201
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE11is_in_rangeERKNS_14DecimalV2ValueE
Line
Count
Source
715
1
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
1
    case FILTER_LESS_OR_EQUAL: {
736
1
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
1
        case FILTER_LARGER_OR_EQUAL: {
742
1
            return Compare::less_equal(value, _high_value) &&
743
1
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1
        }
750
1
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1
    }
756
757
0
    return false;
758
1
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE11is_in_rangeERKh
Line
Count
Source
715
362
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
362
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
362
    case FILTER_LESS_OR_EQUAL: {
736
362
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
363
        case FILTER_LARGER_OR_EQUAL: {
742
363
            return Compare::less_equal(value, _high_value) &&
743
363
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
362
        }
750
362
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
362
    }
756
757
0
    return false;
758
362
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
101
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
101
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
101
    case FILTER_LESS_OR_EQUAL: {
736
101
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
101
        case FILTER_LARGER_OR_EQUAL: {
742
101
            return Compare::less_equal(value, _high_value) &&
743
101
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
101
        }
750
101
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
101
    }
756
757
0
    return false;
758
101
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE11is_in_rangeERKNS_7DecimalIlEE
Line
Count
Source
715
306
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
306
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
306
    case FILTER_LESS_OR_EQUAL: {
736
306
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
306
        case FILTER_LARGER_OR_EQUAL: {
742
306
            return Compare::less_equal(value, _high_value) &&
743
307
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
306
        }
750
306
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
306
    }
756
757
0
    return false;
758
306
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE11is_in_rangeERKNS_12Decimal128V3E
Line
Count
Source
715
241
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
241
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
241
    case FILTER_LESS_OR_EQUAL: {
736
241
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
241
        case FILTER_LARGER_OR_EQUAL: {
742
241
            return Compare::less_equal(value, _high_value) &&
743
241
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
241
        }
750
241
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
241
    }
756
757
0
    return false;
758
241
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE11is_in_rangeERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
715
39
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
39
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
39
    case FILTER_LESS_OR_EQUAL: {
736
39
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
39
        case FILTER_LARGER_OR_EQUAL: {
742
39
            return Compare::less_equal(value, _high_value) &&
743
40
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
39
        }
750
39
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
39
    }
756
757
0
    return false;
758
39
}
759
760
template <PrimitiveType primitive_type>
761
462k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
462k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
462k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
23.3k
        set_empty_value_range();
770
23.3k
    }
771
772
462k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
462k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
431k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
358
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
358
                             range._fixed_values.begin(), range._fixed_values.end(),
778
358
                             std::inserter(result_values, result_values.begin()));
779
431k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
8
            IteratorType iter = _fixed_values.begin();
781
782
30
            while (iter != _fixed_values.end()) {
783
22
                if (range.is_in_range(*iter)) {
784
22
                    result_values.insert(*iter);
785
22
                }
786
22
                ++iter;
787
22
            }
788
431k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
430k
            IteratorType iter = range._fixed_values.begin();
790
902k
            while (iter != range._fixed_values.end()) {
791
473k
                if (this->is_in_range(*iter)) {
792
473k
                    result_values.insert(*iter);
793
473k
                }
794
471k
                ++iter;
795
471k
            }
796
430k
        }
797
798
434k
        if (!result_values.empty()) {
799
434k
            _fixed_values = std::move(result_values);
800
434k
            _contain_null = false;
801
434k
            _high_value = TYPE_MIN;
802
434k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
431k
    } else {
807
30.4k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
973
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
970
                set_contain_null(true);
811
970
            }
812
29.5k
        } else {
813
29.5k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
29.5k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
29.5k
        }
816
30.4k
    }
817
462k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
121k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
121k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
121k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
77
        set_empty_value_range();
770
77
    }
771
772
121k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
121k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
119k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
4
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
4
                             range._fixed_values.begin(), range._fixed_values.end(),
778
4
                             std::inserter(result_values, result_values.begin()));
779
119k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
119k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
119k
            IteratorType iter = range._fixed_values.begin();
790
238k
            while (iter != range._fixed_values.end()) {
791
120k
                if (this->is_in_range(*iter)) {
792
120k
                    result_values.insert(*iter);
793
120k
                }
794
119k
                ++iter;
795
119k
            }
796
119k
        }
797
798
120k
        if (!result_values.empty()) {
799
120k
            _fixed_values = std::move(result_values);
800
120k
            _contain_null = false;
801
120k
            _high_value = TYPE_MIN;
802
120k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
119k
    } else {
807
1.53k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
32
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
32
                set_contain_null(true);
811
32
            }
812
1.50k
        } else {
813
1.50k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.50k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.50k
        }
816
1.53k
    }
817
121k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
Line
Count
Source
761
210
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
210
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
210
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
4
        set_empty_value_range();
770
4
    }
771
772
210
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
210
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
141
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
141
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
141
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
141
            IteratorType iter = range._fixed_values.begin();
790
481
            while (iter != range._fixed_values.end()) {
791
340
                if (this->is_in_range(*iter)) {
792
340
                    result_values.insert(*iter);
793
340
                }
794
340
                ++iter;
795
340
            }
796
141
        }
797
798
142
        if (!result_values.empty()) {
799
142
            _fixed_values = std::move(result_values);
800
142
            _contain_null = false;
801
142
            _high_value = TYPE_MIN;
802
142
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
141
    } else {
807
69
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
31
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
31
                set_contain_null(true);
811
31
            }
812
38
        } else {
813
38
            static_cast<void>(add_range(range._high_op, range._high_value));
814
38
            static_cast<void>(add_range(range._low_op, range._low_value));
815
38
        }
816
69
    }
817
210
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
7.41k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
7.41k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
7.41k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
387
        set_empty_value_range();
770
387
    }
771
772
7.41k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
7.41k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
6.10k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
108
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
108
                             range._fixed_values.begin(), range._fixed_values.end(),
778
108
                             std::inserter(result_values, result_values.begin()));
779
5.99k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
5.99k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
5.98k
            IteratorType iter = range._fixed_values.begin();
790
48.0k
            while (iter != range._fixed_values.end()) {
791
42.0k
                if (this->is_in_range(*iter)) {
792
42.0k
                    result_values.insert(*iter);
793
42.0k
                }
794
42.0k
                ++iter;
795
42.0k
            }
796
5.98k
        }
797
798
6.15k
        if (!result_values.empty()) {
799
6.15k
            _fixed_values = std::move(result_values);
800
6.15k
            _contain_null = false;
801
6.15k
            _high_value = TYPE_MIN;
802
6.15k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
6.10k
    } else {
807
1.31k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
217
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
214
                set_contain_null(true);
811
214
            }
812
1.09k
        } else {
813
1.09k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.09k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.09k
        }
816
1.31k
    }
817
7.41k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
24.0k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
24.0k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
24.0k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
22.8k
        set_empty_value_range();
770
22.8k
    }
771
772
24.0k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
24.0k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.20k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
42
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
42
                             range._fixed_values.begin(), range._fixed_values.end(),
778
42
                             std::inserter(result_values, result_values.begin()));
779
1.16k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
8
            IteratorType iter = _fixed_values.begin();
781
782
30
            while (iter != _fixed_values.end()) {
783
22
                if (range.is_in_range(*iter)) {
784
22
                    result_values.insert(*iter);
785
22
                }
786
22
                ++iter;
787
22
            }
788
1.15k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.15k
            IteratorType iter = range._fixed_values.begin();
790
3.05k
            while (iter != range._fixed_values.end()) {
791
1.90k
                if (this->is_in_range(*iter)) {
792
1.89k
                    result_values.insert(*iter);
793
1.89k
                }
794
1.90k
                ++iter;
795
1.90k
            }
796
1.15k
        }
797
798
1.21k
        if (!result_values.empty()) {
799
1.21k
            _fixed_values = std::move(result_values);
800
1.21k
            _contain_null = false;
801
1.21k
            _high_value = TYPE_MIN;
802
1.21k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
22.8k
    } else {
807
22.8k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
34
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
32
                set_contain_null(true);
811
32
            }
812
22.8k
        } else {
813
22.8k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
22.8k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
22.8k
        }
816
22.8k
    }
817
24.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
198
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
198
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
198
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
198
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
198
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
188
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
188
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
188
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
188
            IteratorType iter = range._fixed_values.begin();
790
378
            while (iter != range._fixed_values.end()) {
791
190
                if (this->is_in_range(*iter)) {
792
189
                    result_values.insert(*iter);
793
189
                }
794
190
                ++iter;
795
190
            }
796
188
        }
797
798
188
        if (!result_values.empty()) {
799
188
            _fixed_values = std::move(result_values);
800
188
            _contain_null = false;
801
188
            _high_value = TYPE_MIN;
802
188
            _low_value = TYPE_MAX;
803
188
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
188
    } else {
807
10
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
7
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
7
                set_contain_null(true);
811
7
            }
812
7
        } else {
813
3
            static_cast<void>(add_range(range._high_op, range._high_value));
814
3
            static_cast<void>(add_range(range._low_op, range._low_value));
815
3
        }
816
10
    }
817
198
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
106
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
106
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
106
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
106
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
106
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
48
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
16
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
16
                             range._fixed_values.begin(), range._fixed_values.end(),
778
16
                             std::inserter(result_values, result_values.begin()));
779
32
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
32
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
31
            IteratorType iter = range._fixed_values.begin();
790
77
            while (iter != range._fixed_values.end()) {
791
47
                if (this->is_in_range(*iter)) {
792
47
                    result_values.insert(*iter);
793
47
                }
794
46
                ++iter;
795
46
            }
796
31
        }
797
798
48
        if (!result_values.empty()) {
799
48
            _fixed_values = std::move(result_values);
800
48
            _contain_null = false;
801
48
            _high_value = TYPE_MIN;
802
48
            _low_value = TYPE_MAX;
803
48
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
58
    } else {
807
58
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
40
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
40
                set_contain_null(true);
811
40
            }
812
40
        } else {
813
18
            static_cast<void>(add_range(range._high_op, range._high_value));
814
18
            static_cast<void>(add_range(range._low_op, range._low_value));
815
18
        }
816
58
    }
817
106
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
198
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
198
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
203
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
198
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
200
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
118
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
118
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
118
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
118
            IteratorType iter = range._fixed_values.begin();
790
287
            while (iter != range._fixed_values.end()) {
791
169
                if (this->is_in_range(*iter)) {
792
169
                    result_values.insert(*iter);
793
169
                }
794
169
                ++iter;
795
169
            }
796
118
        }
797
798
119
        if (!result_values.empty()) {
799
119
            _fixed_values = std::move(result_values);
800
119
            _contain_null = false;
801
119
            _high_value = TYPE_MIN;
802
119
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
118
    } else {
807
82
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
47
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
47
                set_contain_null(true);
811
47
            }
812
46
        } else {
813
34
            static_cast<void>(add_range(range._high_op, range._high_value));
814
34
            static_cast<void>(add_range(range._low_op, range._low_value));
815
34
        }
816
80
    }
817
198
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE12intersectionERS2_
Line
Count
Source
761
45
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
45
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
45
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
45
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
45
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
41
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
41
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
41
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
41
            IteratorType iter = range._fixed_values.begin();
790
99
            while (iter != range._fixed_values.end()) {
791
58
                if (this->is_in_range(*iter)) {
792
58
                    result_values.insert(*iter);
793
58
                }
794
58
                ++iter;
795
58
            }
796
41
        }
797
798
42
        if (!result_values.empty()) {
799
42
            _fixed_values = std::move(result_values);
800
42
            _contain_null = false;
801
42
            _high_value = TYPE_MIN;
802
42
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
41
    } else {
807
4
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
4
        } else {
813
4
            static_cast<void>(add_range(range._high_op, range._high_value));
814
4
            static_cast<void>(add_range(range._low_op, range._low_value));
815
4
        }
816
4
    }
817
45
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE12intersectionERS2_
Line
Count
Source
761
42
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
42
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
42
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
42
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
42
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
40
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
40
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
40
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
40
            IteratorType iter = range._fixed_values.begin();
790
97
            while (iter != range._fixed_values.end()) {
791
58
                if (this->is_in_range(*iter)) {
792
58
                    result_values.insert(*iter);
793
58
                }
794
57
                ++iter;
795
57
            }
796
40
        }
797
798
40
        if (!result_values.empty()) {
799
40
            _fixed_values = std::move(result_values);
800
40
            _contain_null = false;
801
40
            _high_value = TYPE_MIN;
802
40
            _low_value = TYPE_MAX;
803
40
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
40
    } else {
807
2
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
2
        } else {
813
2
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2
        }
816
2
    }
817
42
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
509
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
509
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
510
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
7
        set_empty_value_range();
770
7
    }
771
772
509
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
509
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
442
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
442
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
443
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
443
            IteratorType iter = range._fixed_values.begin();
790
1.01k
            while (iter != range._fixed_values.end()) {
791
570
                if (this->is_in_range(*iter)) {
792
570
                    result_values.insert(*iter);
793
570
                }
794
568
                ++iter;
795
568
            }
796
443
        }
797
798
451
        if (!result_values.empty()) {
799
451
            _fixed_values = std::move(result_values);
800
451
            _contain_null = false;
801
451
            _high_value = TYPE_MIN;
802
451
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
442
    } else {
807
67
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
34
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
34
                set_contain_null(true);
811
34
            }
812
34
        } else {
813
33
            static_cast<void>(add_range(range._high_op, range._high_value));
814
33
            static_cast<void>(add_range(range._low_op, range._low_value));
815
33
        }
816
67
    }
817
509
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
292k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
292k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
292k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
292k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
292k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
291k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
11
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
11
                             range._fixed_values.begin(), range._fixed_values.end(),
778
11
                             std::inserter(result_values, result_values.begin()));
779
291k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
291k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
291k
            IteratorType iter = range._fixed_values.begin();
790
585k
            while (iter != range._fixed_values.end()) {
791
294k
                if (this->is_in_range(*iter)) {
792
294k
                    result_values.insert(*iter);
793
294k
                }
794
293k
                ++iter;
795
293k
            }
796
291k
        }
797
798
292k
        if (!result_values.empty()) {
799
292k
            _fixed_values = std::move(result_values);
800
292k
            _contain_null = false;
801
292k
            _high_value = TYPE_MIN;
802
292k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
291k
    } else {
807
1.53k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
186
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
186
                set_contain_null(true);
811
186
            }
812
1.34k
        } else {
813
1.34k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.34k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.34k
        }
816
1.53k
    }
817
292k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
3.52k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
3.52k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
3.52k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
3.52k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
3.52k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.32k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
40
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
40
                             range._fixed_values.begin(), range._fixed_values.end(),
778
40
                             std::inserter(result_values, result_values.begin()));
779
1.28k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
1.28k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.27k
            IteratorType iter = range._fixed_values.begin();
790
2.75k
            while (iter != range._fixed_values.end()) {
791
1.49k
                if (this->is_in_range(*iter)) {
792
1.49k
                    result_values.insert(*iter);
793
1.49k
                }
794
1.47k
                ++iter;
795
1.47k
            }
796
1.27k
        }
797
798
1.34k
        if (!result_values.empty()) {
799
1.34k
            _fixed_values = std::move(result_values);
800
1.34k
            _contain_null = false;
801
1.34k
            _high_value = TYPE_MIN;
802
1.34k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
2.20k
    } else {
807
2.20k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
133
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
133
                set_contain_null(true);
811
133
            }
812
2.07k
        } else {
813
2.07k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2.07k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2.07k
        }
816
2.20k
    }
817
3.52k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
40
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
40
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
40
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
40
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
40
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
40
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
40
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
40
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
40
            IteratorType iter = range._fixed_values.begin();
790
110
            while (iter != range._fixed_values.end()) {
791
70
                if (this->is_in_range(*iter)) {
792
70
                    result_values.insert(*iter);
793
70
                }
794
70
                ++iter;
795
70
            }
796
40
        }
797
798
40
        if (!result_values.empty()) {
799
40
            _fixed_values = std::move(result_values);
800
40
            _contain_null = false;
801
40
            _high_value = TYPE_MIN;
802
40
            _low_value = TYPE_MAX;
803
40
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
40
    } else {
807
0
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
0
        } else {
813
0
            static_cast<void>(add_range(range._high_op, range._high_value));
814
0
            static_cast<void>(add_range(range._low_op, range._low_value));
815
0
        }
816
0
    }
817
40
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
9.33k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
9.33k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
9.33k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
25
        set_empty_value_range();
770
25
    }
771
772
9.33k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
9.33k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
9.16k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
21
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
21
                             range._fixed_values.begin(), range._fixed_values.end(),
778
21
                             std::inserter(result_values, result_values.begin()));
779
9.14k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
9.15k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
9.15k
            IteratorType iter = range._fixed_values.begin();
790
18.4k
            while (iter != range._fixed_values.end()) {
791
9.30k
                if (this->is_in_range(*iter)) {
792
9.30k
                    result_values.insert(*iter);
793
9.30k
                }
794
9.28k
                ++iter;
795
9.28k
            }
796
9.15k
        }
797
798
9.21k
        if (!result_values.empty()) {
799
9.21k
            _fixed_values = std::move(result_values);
800
9.21k
            _contain_null = false;
801
9.21k
            _high_value = TYPE_MIN;
802
9.21k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
9.16k
    } else {
807
165
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
61
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
60
                set_contain_null(true);
811
60
            }
812
105
        } else {
813
105
            static_cast<void>(add_range(range._high_op, range._high_value));
814
105
            static_cast<void>(add_range(range._low_op, range._low_value));
815
105
        }
816
165
    }
817
9.33k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12intersectionERS2_
Line
Count
Source
761
36
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
36
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
36
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
36
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
36
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
35
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
35
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
35
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
35
            IteratorType iter = range._fixed_values.begin();
790
98
            while (iter != range._fixed_values.end()) {
791
63
                if (this->is_in_range(*iter)) {
792
62
                    result_values.insert(*iter);
793
62
                }
794
63
                ++iter;
795
63
            }
796
35
        }
797
798
35
        if (!result_values.empty()) {
799
35
            _fixed_values = std::move(result_values);
800
35
            _contain_null = false;
801
35
            _high_value = TYPE_MIN;
802
35
            _low_value = TYPE_MAX;
803
35
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
35
    } else {
807
1
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
1
        } else {
813
1
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1
        }
816
1
    }
817
36
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12intersectionERS2_
Line
Count
Source
761
688
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
688
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
688
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
688
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
688
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
597
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
48
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
48
                             range._fixed_values.begin(), range._fixed_values.end(),
778
48
                             std::inserter(result_values, result_values.begin()));
779
549
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
555
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
555
            IteratorType iter = range._fixed_values.begin();
790
1.18k
            while (iter != range._fixed_values.end()) {
791
631
                if (this->is_in_range(*iter)) {
792
629
                    result_values.insert(*iter);
793
629
                }
794
631
                ++iter;
795
631
            }
796
555
        }
797
798
613
        if (!result_values.empty()) {
799
613
            _fixed_values = std::move(result_values);
800
613
            _contain_null = false;
801
613
            _high_value = TYPE_MIN;
802
613
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
597
    } else {
807
91
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
35
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
35
                set_contain_null(true);
811
35
            }
812
56
        } else {
813
56
            static_cast<void>(add_range(range._high_op, range._high_value));
814
56
            static_cast<void>(add_range(range._low_op, range._low_value));
815
56
        }
816
91
    }
817
688
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
145
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
145
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
145
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
145
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
145
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
93
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
93
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
93
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
93
            IteratorType iter = range._fixed_values.begin();
790
294
            while (iter != range._fixed_values.end()) {
791
201
                if (this->is_in_range(*iter)) {
792
200
                    result_values.insert(*iter);
793
200
                }
794
201
                ++iter;
795
201
            }
796
93
        }
797
798
95
        if (!result_values.empty()) {
799
95
            _fixed_values = std::move(result_values);
800
95
            _contain_null = false;
801
95
            _high_value = TYPE_MIN;
802
95
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
93
    } else {
807
52
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
9
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
9
                set_contain_null(true);
811
9
            }
812
43
        } else {
813
43
            static_cast<void>(add_range(range._high_op, range._high_value));
814
43
            static_cast<void>(add_range(range._low_op, range._low_value));
815
43
        }
816
52
    }
817
145
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12intersectionERS2_
Line
Count
Source
761
1
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
1
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
1
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
1
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
1
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
1
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
1
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1
            IteratorType iter = range._fixed_values.begin();
790
2
            while (iter != range._fixed_values.end()) {
791
1
                if (this->is_in_range(*iter)) {
792
1
                    result_values.insert(*iter);
793
1
                }
794
1
                ++iter;
795
1
            }
796
1
        }
797
798
1
        if (!result_values.empty()) {
799
1
            _fixed_values = std::move(result_values);
800
1
            _contain_null = false;
801
1
            _high_value = TYPE_MIN;
802
1
            _low_value = TYPE_MAX;
803
1
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
1
    } else {
807
0
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
0
        } else {
813
0
            static_cast<void>(add_range(range._high_op, range._high_value));
814
0
            static_cast<void>(add_range(range._low_op, range._low_value));
815
0
        }
816
0
    }
817
1
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12intersectionERS2_
Line
Count
Source
761
412
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
412
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
412
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
412
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
412
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
365
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
16
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
16
                             range._fixed_values.begin(), range._fixed_values.end(),
778
16
                             std::inserter(result_values, result_values.begin()));
779
349
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
349
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
349
            IteratorType iter = range._fixed_values.begin();
790
712
            while (iter != range._fixed_values.end()) {
791
363
                if (this->is_in_range(*iter)) {
792
362
                    result_values.insert(*iter);
793
362
                }
794
363
                ++iter;
795
363
            }
796
349
        }
797
798
365
        if (!result_values.empty()) {
799
365
            _fixed_values = std::move(result_values);
800
365
            _contain_null = false;
801
365
            _high_value = TYPE_MIN;
802
365
            _low_value = TYPE_MAX;
803
365
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
365
    } else {
807
47
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
37
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
37
                set_contain_null(true);
811
37
            }
812
37
        } else {
813
10
            static_cast<void>(add_range(range._high_op, range._high_value));
814
10
            static_cast<void>(add_range(range._low_op, range._low_value));
815
10
        }
816
47
    }
817
412
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12intersectionERS2_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12intersectionERS2_
Line
Count
Source
761
111
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
111
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
111
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
111
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
111
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
72
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
72
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
72
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
72
            IteratorType iter = range._fixed_values.begin();
790
173
            while (iter != range._fixed_values.end()) {
791
101
                if (this->is_in_range(*iter)) {
792
101
                    result_values.insert(*iter);
793
101
                }
794
101
                ++iter;
795
101
            }
796
72
        }
797
798
72
        if (!result_values.empty()) {
799
72
            _fixed_values = std::move(result_values);
800
72
            _contain_null = false;
801
72
            _high_value = TYPE_MIN;
802
72
            _low_value = TYPE_MAX;
803
72
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
72
    } else {
807
39
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
4
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
4
                set_contain_null(true);
811
4
            }
812
35
        } else {
813
35
            static_cast<void>(add_range(range._high_op, range._high_value));
814
35
            static_cast<void>(add_range(range._low_op, range._low_value));
815
35
        }
816
39
    }
817
111
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
607
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
607
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
607
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
607
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
607
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
280
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
52
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
52
                             range._fixed_values.begin(), range._fixed_values.end(),
778
52
                             std::inserter(result_values, result_values.begin()));
779
228
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
228
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
227
            IteratorType iter = range._fixed_values.begin();
790
531
            while (iter != range._fixed_values.end()) {
791
307
                if (this->is_in_range(*iter)) {
792
307
                    result_values.insert(*iter);
793
307
                }
794
304
                ++iter;
795
304
            }
796
227
        }
797
798
283
        if (!result_values.empty()) {
799
283
            _fixed_values = std::move(result_values);
800
283
            _contain_null = false;
801
283
            _high_value = TYPE_MIN;
802
283
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
327
    } else {
807
327
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
68
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
68
                set_contain_null(true);
811
68
            }
812
259
        } else {
813
259
            static_cast<void>(add_range(range._high_op, range._high_value));
814
259
            static_cast<void>(add_range(range._low_op, range._low_value));
815
259
        }
816
327
    }
817
607
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
229
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
229
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
229
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
229
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
229
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
216
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
216
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
216
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
216
            IteratorType iter = range._fixed_values.begin();
790
452
            while (iter != range._fixed_values.end()) {
791
241
                if (this->is_in_range(*iter)) {
792
241
                    result_values.insert(*iter);
793
241
                }
794
236
                ++iter;
795
236
            }
796
216
        }
797
798
222
        if (!result_values.empty()) {
799
222
            _fixed_values = std::move(result_values);
800
222
            _contain_null = false;
801
222
            _high_value = TYPE_MIN;
802
222
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
216
    } else {
807
13
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
13
        } else {
813
13
            static_cast<void>(add_range(range._high_op, range._high_value));
814
13
            static_cast<void>(add_range(range._low_op, range._low_value));
815
13
        }
816
13
    }
817
229
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
46
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
46
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
46
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
46
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
46
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
32
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
32
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
32
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
31
            IteratorType iter = range._fixed_values.begin();
790
68
            while (iter != range._fixed_values.end()) {
791
40
                if (this->is_in_range(*iter)) {
792
40
                    result_values.insert(*iter);
793
40
                }
794
37
                ++iter;
795
37
            }
796
31
        }
797
798
34
        if (!result_values.empty()) {
799
34
            _fixed_values = std::move(result_values);
800
34
            _contain_null = false;
801
34
            _high_value = TYPE_MIN;
802
34
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
32
    } else {
807
14
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
1
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
1
                set_contain_null(true);
811
1
            }
812
13
        } else {
813
13
            static_cast<void>(add_range(range._high_op, range._high_value));
814
13
            static_cast<void>(add_range(range._low_op, range._low_value));
815
13
        }
816
14
    }
817
46
}
818
819
template <PrimitiveType primitive_type>
820
Status OlapScanKeys::extend_scan_key(ColumnValueRange<primitive_type>& range,
821
                                     int32_t max_scan_key_num, bool* exact_value, bool* eos,
822
564k
                                     bool* should_break) {
823
564k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
564k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
564k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
564k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
564k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
564k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
564k
    if (range.is_fixed_value_range()) {
842
288k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
35
            if (range.is_range_value_convertible()) {
844
34
                range.convert_to_range_value();
845
34
                *exact_value = false;
846
34
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
35
        }
851
288k
    } else {
852
275k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
275k
            !range.is_reject_split_type()) {
854
153k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
153k
                                                 _end_include);
856
857
153k
            if (!(*eos) &&
858
153k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
153k
                                                 _end_include, max_scan_key_num)) {
860
153k
                _has_range_value = true;
861
153k
            }
862
153k
            return Status::OK();
863
153k
        }
864
275k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
410k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
288k
        if (_begin_scan_keys.empty()) {
870
98.4k
            auto fixed_value_set = range.get_fixed_value_set();
871
98.4k
            ConstIterator iter = fixed_value_set.begin();
872
873
198k
            for (; iter != fixed_value_set.end(); ++iter) {
874
100k
                _begin_scan_keys.emplace_back();
875
100k
                _begin_scan_keys.back().add_value(
876
100k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
100k
                _end_scan_keys.emplace_back();
878
100k
                _end_scan_keys.back().add_value(
879
100k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
100k
            }
881
882
98.4k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
98.4k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
189k
        else {
890
189k
            auto fixed_value_set = range.get_fixed_value_set();
891
189k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
379k
            for (int i = 0; i < original_key_range_size; ++i) {
894
190k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
190k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
190k
                ConstIterator iter = fixed_value_set.begin();
898
899
380k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
189k
                        _begin_scan_keys[i].add_value(
903
189k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
189k
                        _end_scan_keys[i].add_value(
905
189k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
189k
                    } // append follow ScanKey
907
200
                    else {
908
200
                        _begin_scan_keys.push_back(start_base_key_range);
909
200
                        _begin_scan_keys.back().add_value(
910
200
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
200
                        _end_scan_keys.push_back(end_base_key_range);
912
200
                        _end_scan_keys.back().add_value(
913
200
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
200
                    }
915
190k
                }
916
917
190k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
190k
            }
924
189k
        }
925
926
288k
        _begin_include = true;
927
288k
        _end_include = true;
928
288k
    } // Extend ScanKey with range value
929
122k
    else {
930
122k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
122k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
18
            CHECK(range.contain_null());
935
18
            if (_begin_scan_keys.empty()) {
936
18
                _begin_scan_keys.emplace_back();
937
18
                _begin_scan_keys.back().add_null();
938
18
                _end_scan_keys.emplace_back();
939
18
                _end_scan_keys.back().add_null();
940
18
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
122k
        } else if (_begin_scan_keys.empty()) {
947
24.8k
            _begin_scan_keys.emplace_back();
948
24.8k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
24.8k
                                                      range.get_range_min_value(), range.scale()),
950
24.8k
                                              range.contain_null());
951
24.8k
            _end_scan_keys.emplace_back();
952
24.8k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
24.8k
                    range.get_range_max_value(), range.scale()));
954
97.6k
        } else {
955
199k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
101k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
101k
                                                      range.get_range_min_value(), range.scale()),
958
101k
                                              range.contain_null());
959
101k
            }
960
961
199k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
102k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
102k
                        range.get_range_max_value(), range.scale()));
964
102k
            }
965
97.6k
        }
966
122k
        _begin_include = range.is_begin_include();
967
122k
        _end_include = range.is_end_include();
968
122k
    }
969
970
410k
    return Status::OK();
971
564k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.48k
                                     bool* should_break) {
823
2.48k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.48k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.48k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.48k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2.48k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
2.48k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.48k
    if (range.is_fixed_value_range()) {
842
7
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.47k
    } else {
852
2.47k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.47k
            !range.is_reject_split_type()) {
854
2.42k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.42k
                                                 _end_include);
856
857
2.42k
            if (!(*eos) &&
858
2.44k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.48k
                                                 _end_include, max_scan_key_num)) {
860
2.48k
                _has_range_value = true;
861
2.48k
            }
862
2.42k
            return Status::OK();
863
2.42k
        }
864
2.47k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
55
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
7
        if (_begin_scan_keys.empty()) {
870
7
            auto fixed_value_set = range.get_fixed_value_set();
871
7
            ConstIterator iter = fixed_value_set.begin();
872
873
16
            for (; iter != fixed_value_set.end(); ++iter) {
874
9
                _begin_scan_keys.emplace_back();
875
9
                _begin_scan_keys.back().add_value(
876
9
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
9
                _end_scan_keys.emplace_back();
878
9
                _end_scan_keys.back().add_value(
879
9
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
9
            }
881
882
7
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
7
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
7
        _begin_include = true;
927
7
        _end_include = true;
928
7
    } // Extend ScanKey with range value
929
48
    else {
930
48
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
48
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
48
        } else if (_begin_scan_keys.empty()) {
947
2
            _begin_scan_keys.emplace_back();
948
2
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2
                                                      range.get_range_min_value(), range.scale()),
950
2
                                              range.contain_null());
951
2
            _end_scan_keys.emplace_back();
952
2
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2
                    range.get_range_max_value(), range.scale()));
954
46
        } else {
955
83
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
37
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
37
                                                      range.get_range_min_value(), range.scale()),
958
37
                                              range.contain_null());
959
37
            }
960
961
84
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
38
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
38
                        range.get_range_max_value(), range.scale()));
964
38
            }
965
46
        }
966
48
        _begin_include = range.is_begin_include();
967
48
        _end_include = range.is_end_include();
968
48
    }
969
970
55
    return Status::OK();
971
2.48k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
290
                                     bool* should_break) {
823
290
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
290
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
290
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
290
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
290
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
290
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
290
    if (range.is_fixed_value_range()) {
842
3
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
287
    } else {
852
287
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
287
            !range.is_reject_split_type()) {
854
229
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
229
                                                 _end_include);
856
857
229
            if (!(*eos) &&
858
231
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
231
                                                 _end_include, max_scan_key_num)) {
860
231
                _has_range_value = true;
861
231
            }
862
229
            return Status::OK();
863
229
        }
864
287
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
61
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
3
        if (_begin_scan_keys.empty()) {
870
2
            auto fixed_value_set = range.get_fixed_value_set();
871
2
            ConstIterator iter = fixed_value_set.begin();
872
873
5
            for (; iter != fixed_value_set.end(); ++iter) {
874
3
                _begin_scan_keys.emplace_back();
875
3
                _begin_scan_keys.back().add_value(
876
3
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
3
                _end_scan_keys.emplace_back();
878
3
                _end_scan_keys.back().add_value(
879
3
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
3
            }
881
882
2
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
2
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
1
        else {
890
1
            auto fixed_value_set = range.get_fixed_value_set();
891
1
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
3
            for (int i = 0; i < original_key_range_size; ++i) {
894
2
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
2
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
2
                ConstIterator iter = fixed_value_set.begin();
898
899
4
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
2
                    if (iter == fixed_value_set.begin()) {
902
2
                        _begin_scan_keys[i].add_value(
903
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
2
                        _end_scan_keys[i].add_value(
905
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
2
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
2
                }
916
917
2
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
2
            }
924
1
        }
925
926
3
        _begin_include = true;
927
3
        _end_include = true;
928
3
    } // Extend ScanKey with range value
929
58
    else {
930
58
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
58
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
58
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
58
        } else {
955
352
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
294
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
294
                                                      range.get_range_min_value(), range.scale()),
958
294
                                              range.contain_null());
959
294
            }
960
961
352
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
294
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
294
                        range.get_range_max_value(), range.scale()));
964
294
            }
965
58
        }
966
58
        _begin_include = range.is_begin_include();
967
58
        _end_include = range.is_end_include();
968
58
    }
969
970
61
    return Status::OK();
971
290
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
68.5k
                                     bool* should_break) {
823
68.5k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
68.5k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
68.5k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
68.5k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
68.5k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
68.5k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
68.5k
    if (range.is_fixed_value_range()) {
842
2.21k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
27
            if (range.is_range_value_convertible()) {
844
27
                range.convert_to_range_value();
845
27
                *exact_value = false;
846
27
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
27
        }
851
66.3k
    } else {
852
66.3k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
66.3k
            !range.is_reject_split_type()) {
854
65.6k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
65.6k
                                                 _end_include);
856
857
65.6k
            if (!(*eos) &&
858
65.6k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
65.8k
                                                 _end_include, max_scan_key_num)) {
860
65.8k
                _has_range_value = true;
861
65.8k
            }
862
65.6k
            return Status::OK();
863
65.6k
        }
864
66.3k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.97k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.18k
        if (_begin_scan_keys.empty()) {
870
2.12k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.12k
            ConstIterator iter = fixed_value_set.begin();
872
873
5.22k
            for (; iter != fixed_value_set.end(); ++iter) {
874
3.10k
                _begin_scan_keys.emplace_back();
875
3.10k
                _begin_scan_keys.back().add_value(
876
3.10k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
3.10k
                _end_scan_keys.emplace_back();
878
3.10k
                _end_scan_keys.back().add_value(
879
3.10k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
3.10k
            }
881
882
2.12k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
2.12k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
67
        else {
890
67
            auto fixed_value_set = range.get_fixed_value_set();
891
67
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
150
            for (int i = 0; i < original_key_range_size; ++i) {
894
83
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
83
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
83
                ConstIterator iter = fixed_value_set.begin();
898
899
162
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
82
                    if (iter == fixed_value_set.begin()) {
902
82
                        _begin_scan_keys[i].add_value(
903
82
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
82
                        _end_scan_keys[i].add_value(
905
82
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
82
                    } // append follow ScanKey
907
18.4E
                    else {
908
18.4E
                        _begin_scan_keys.push_back(start_base_key_range);
909
18.4E
                        _begin_scan_keys.back().add_value(
910
18.4E
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
18.4E
                        _end_scan_keys.push_back(end_base_key_range);
912
18.4E
                        _end_scan_keys.back().add_value(
913
18.4E
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
18.4E
                    }
915
79
                }
916
917
83
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
83
            }
924
67
        }
925
926
2.18k
        _begin_include = true;
927
2.18k
        _end_include = true;
928
2.18k
    } // Extend ScanKey with range value
929
789
    else {
930
789
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
789
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
789
        } else if (_begin_scan_keys.empty()) {
947
124
            _begin_scan_keys.emplace_back();
948
124
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
124
                                                      range.get_range_min_value(), range.scale()),
950
124
                                              range.contain_null());
951
124
            _end_scan_keys.emplace_back();
952
124
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
124
                    range.get_range_max_value(), range.scale()));
954
665
        } else {
955
4.72k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
4.06k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
4.06k
                                                      range.get_range_min_value(), range.scale()),
958
4.06k
                                              range.contain_null());
959
4.06k
            }
960
961
4.73k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
4.06k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
4.06k
                        range.get_range_max_value(), range.scale()));
964
4.06k
            }
965
665
        }
966
789
        _begin_include = range.is_begin_include();
967
789
        _end_include = range.is_end_include();
968
789
    }
969
970
2.97k
    return Status::OK();
971
68.5k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
83.5k
                                     bool* should_break) {
823
83.5k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
83.5k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
83.5k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
83.5k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
83.5k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
83.5k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
83.5k
    if (range.is_fixed_value_range()) {
842
857
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
82.6k
    } else {
852
82.6k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
82.6k
            !range.is_reject_split_type()) {
854
82.1k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
82.1k
                                                 _end_include);
856
857
82.1k
            if (!(*eos) &&
858
82.2k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
82.2k
                                                 _end_include, max_scan_key_num)) {
860
81.8k
                _has_range_value = true;
861
81.8k
            }
862
82.1k
            return Status::OK();
863
82.1k
        }
864
82.6k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.32k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
855
        if (_begin_scan_keys.empty()) {
870
855
            auto fixed_value_set = range.get_fixed_value_set();
871
855
            ConstIterator iter = fixed_value_set.begin();
872
873
1.80k
            for (; iter != fixed_value_set.end(); ++iter) {
874
953
                _begin_scan_keys.emplace_back();
875
953
                _begin_scan_keys.back().add_value(
876
953
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
953
                _end_scan_keys.emplace_back();
878
953
                _end_scan_keys.back().add_value(
879
953
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
953
            }
881
882
855
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
855
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
18.4E
        else {
890
18.4E
            auto fixed_value_set = range.get_fixed_value_set();
891
18.4E
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
18.4E
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
18.4E
        }
925
926
854
        _begin_include = true;
927
854
        _end_include = true;
928
854
    } // Extend ScanKey with range value
929
474
    else {
930
474
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
474
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
474
        } else if (_begin_scan_keys.empty()) {
947
24
            _begin_scan_keys.emplace_back();
948
24
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
24
                                                      range.get_range_min_value(), range.scale()),
950
24
                                              range.contain_null());
951
24
            _end_scan_keys.emplace_back();
952
24
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
24
                    range.get_range_max_value(), range.scale()));
954
450
        } else {
955
1.26k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
815
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
815
                                                      range.get_range_min_value(), range.scale()),
958
815
                                              range.contain_null());
959
815
            }
960
961
1.26k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
812
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
812
                        range.get_range_max_value(), range.scale()));
964
812
            }
965
450
        }
966
474
        _begin_include = range.is_begin_include();
967
474
        _end_include = range.is_end_include();
968
474
    }
969
970
1.32k
    return Status::OK();
971
83.5k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.37k
                                     bool* should_break) {
823
4.37k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.37k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.37k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.37k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
4.37k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
4.37k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.37k
    if (range.is_fixed_value_range()) {
842
142
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
4.22k
    } else {
852
4.22k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
4.22k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
4.22k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.37k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
142
        if (_begin_scan_keys.empty()) {
870
142
            auto fixed_value_set = range.get_fixed_value_set();
871
142
            ConstIterator iter = fixed_value_set.begin();
872
873
284
            for (; iter != fixed_value_set.end(); ++iter) {
874
142
                _begin_scan_keys.emplace_back();
875
142
                _begin_scan_keys.back().add_value(
876
142
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
142
                _end_scan_keys.emplace_back();
878
142
                _end_scan_keys.back().add_value(
879
142
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
142
            }
881
882
142
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
142
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
142
        _begin_include = true;
927
142
        _end_include = true;
928
142
    } // Extend ScanKey with range value
929
4.22k
    else {
930
4.22k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
4.22k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
4.22k
        } else if (_begin_scan_keys.empty()) {
947
4.19k
            _begin_scan_keys.emplace_back();
948
4.19k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
4.19k
                                                      range.get_range_min_value(), range.scale()),
950
4.19k
                                              range.contain_null());
951
4.19k
            _end_scan_keys.emplace_back();
952
4.19k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
4.19k
                    range.get_range_max_value(), range.scale()));
954
4.19k
        } else {
955
84
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
56
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
56
                                                      range.get_range_min_value(), range.scale()),
958
56
                                              range.contain_null());
959
56
            }
960
961
84
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
56
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
56
                        range.get_range_max_value(), range.scale()));
964
56
            }
965
28
        }
966
4.22k
        _begin_include = range.is_begin_include();
967
4.22k
        _end_include = range.is_end_include();
968
4.22k
    }
969
970
4.37k
    return Status::OK();
971
4.37k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE8EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE9EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE36EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE37EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2
                                     bool* should_break) {
823
2
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
2
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2
    if (range.is_fixed_value_range()) {
842
0
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2
    } else {
852
2
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2
            !range.is_reject_split_type()) {
854
1
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
1
                                                 _end_include);
856
857
1
            if (!(*eos) &&
858
1
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
1
                                                 _end_include, max_scan_key_num)) {
860
1
                _has_range_value = true;
861
1
            }
862
1
            return Status::OK();
863
1
        }
864
2
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
0
        if (_begin_scan_keys.empty()) {
870
0
            auto fixed_value_set = range.get_fixed_value_set();
871
0
            ConstIterator iter = fixed_value_set.begin();
872
873
0
            for (; iter != fixed_value_set.end(); ++iter) {
874
0
                _begin_scan_keys.emplace_back();
875
0
                _begin_scan_keys.back().add_value(
876
0
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
0
                _end_scan_keys.emplace_back();
878
0
                _end_scan_keys.back().add_value(
879
0
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
0
            }
881
882
0
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
0
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
0
        _begin_include = true;
927
0
        _end_include = true;
928
0
    } // Extend ScanKey with range value
929
1
    else {
930
1
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
1
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
1
        } else {
955
2
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
1
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
1
                                                      range.get_range_min_value(), range.scale()),
958
1
                                              range.contain_null());
959
1
            }
960
961
2
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
1
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
1
                        range.get_range_max_value(), range.scale()));
964
1
            }
965
1
        }
966
1
        _begin_include = range.is_begin_include();
967
1
        _end_include = range.is_end_include();
968
1
    }
969
970
1
    return Status::OK();
971
2
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE15EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
409
                                     bool* should_break) {
823
409
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
409
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
409
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
409
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
409
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
409
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
409
    if (range.is_fixed_value_range()) {
842
15
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
1
                range.convert_to_range_value();
845
1
                *exact_value = false;
846
1
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
1
        }
851
394
    } else {
852
394
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
394
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
394
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
409
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
14
        if (_begin_scan_keys.empty()) {
870
13
            auto fixed_value_set = range.get_fixed_value_set();
871
13
            ConstIterator iter = fixed_value_set.begin();
872
873
34
            for (; iter != fixed_value_set.end(); ++iter) {
874
21
                _begin_scan_keys.emplace_back();
875
21
                _begin_scan_keys.back().add_value(
876
21
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
21
                _end_scan_keys.emplace_back();
878
21
                _end_scan_keys.back().add_value(
879
21
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
21
            }
881
882
13
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
13
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
1
        else {
890
1
            auto fixed_value_set = range.get_fixed_value_set();
891
1
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
2
            for (int i = 0; i < original_key_range_size; ++i) {
894
1
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
1
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
1
                ConstIterator iter = fixed_value_set.begin();
898
899
2
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
1
                    if (iter == fixed_value_set.begin()) {
902
1
                        _begin_scan_keys[i].add_value(
903
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
1
                        _end_scan_keys[i].add_value(
905
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
1
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
1
                }
916
917
1
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
1
            }
924
1
        }
925
926
14
        _begin_include = true;
927
14
        _end_include = true;
928
14
    } // Extend ScanKey with range value
929
395
    else {
930
395
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
395
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
394
        } else if (_begin_scan_keys.empty()) {
947
388
            _begin_scan_keys.emplace_back();
948
388
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
388
                                                      range.get_range_min_value(), range.scale()),
950
388
                                              range.contain_null());
951
388
            _end_scan_keys.emplace_back();
952
388
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
388
                    range.get_range_max_value(), range.scale()));
954
388
        } else {
955
87
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
81
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
81
                                                      range.get_range_min_value(), range.scale()),
958
81
                                              range.contain_null());
959
81
            }
960
961
87
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
81
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
81
                        range.get_range_max_value(), range.scale()));
964
81
            }
965
6
        }
966
395
        _begin_include = range.is_begin_include();
967
395
        _end_include = range.is_end_include();
968
395
    }
969
970
409
    return Status::OK();
971
409
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
391k
                                     bool* should_break) {
823
391k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
391k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
391k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
391k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
391k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
391k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
391k
    if (range.is_fixed_value_range()) {
842
284k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
6
            if (range.is_range_value_convertible()) {
844
6
                range.convert_to_range_value();
845
6
                *exact_value = false;
846
6
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
6
        }
851
284k
    } else {
852
106k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
106k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
106k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
391k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
284k
        if (_begin_scan_keys.empty()) {
870
94.7k
            auto fixed_value_set = range.get_fixed_value_set();
871
94.7k
            ConstIterator iter = fixed_value_set.begin();
872
873
189k
            for (; iter != fixed_value_set.end(); ++iter) {
874
95.0k
                _begin_scan_keys.emplace_back();
875
95.0k
                _begin_scan_keys.back().add_value(
876
95.0k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
95.0k
                _end_scan_keys.emplace_back();
878
95.0k
                _end_scan_keys.back().add_value(
879
95.0k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
95.0k
            }
881
882
94.7k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
94.7k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
189k
        else {
890
189k
            auto fixed_value_set = range.get_fixed_value_set();
891
189k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
379k
            for (int i = 0; i < original_key_range_size; ++i) {
894
189k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
189k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
189k
                ConstIterator iter = fixed_value_set.begin();
898
899
379k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
189k
                        _begin_scan_keys[i].add_value(
903
189k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
189k
                        _end_scan_keys[i].add_value(
905
189k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
189k
                    } // append follow ScanKey
907
203
                    else {
908
203
                        _begin_scan_keys.push_back(start_base_key_range);
909
203
                        _begin_scan_keys.back().add_value(
910
203
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
203
                        _end_scan_keys.push_back(end_base_key_range);
912
203
                        _end_scan_keys.back().add_value(
913
203
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
203
                    }
915
190k
                }
916
917
189k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
189k
            }
924
189k
        }
925
926
284k
        _begin_include = true;
927
284k
        _end_include = true;
928
284k
    } // Extend ScanKey with range value
929
106k
    else {
930
106k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
106k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
106k
        } else if (_begin_scan_keys.empty()) {
947
10.2k
            _begin_scan_keys.emplace_back();
948
10.2k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
10.2k
                                                      range.get_range_min_value(), range.scale()),
950
10.2k
                                              range.contain_null());
951
10.2k
            _end_scan_keys.emplace_back();
952
10.2k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
10.2k
                    range.get_range_max_value(), range.scale()));
954
96.1k
        } else {
955
192k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
96.2k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
96.2k
                                                      range.get_range_min_value(), range.scale()),
958
96.2k
                                              range.contain_null());
959
96.2k
            }
960
961
192k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
96.4k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
96.4k
                        range.get_range_max_value(), range.scale()));
964
96.4k
            }
965
96.1k
        }
966
106k
        _begin_include = range.is_begin_include();
967
106k
        _end_include = range.is_end_include();
968
106k
    }
969
970
391k
    return Status::OK();
971
391k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE23EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE11EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
9
                                     bool* should_break) {
823
9
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
9
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
9
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
9
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
9
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
9
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
9
    if (range.is_fixed_value_range()) {
842
3
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
6
    } else {
852
6
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
6
            !range.is_reject_split_type()) {
854
6
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
6
                                                 _end_include);
856
857
6
            if (!(*eos) &&
858
6
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
6
                                                 _end_include, max_scan_key_num)) {
860
6
                _has_range_value = true;
861
6
            }
862
6
            return Status::OK();
863
6
        }
864
6
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
3
        if (_begin_scan_keys.empty()) {
870
3
            auto fixed_value_set = range.get_fixed_value_set();
871
3
            ConstIterator iter = fixed_value_set.begin();
872
873
10
            for (; iter != fixed_value_set.end(); ++iter) {
874
7
                _begin_scan_keys.emplace_back();
875
7
                _begin_scan_keys.back().add_value(
876
7
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
7
                _end_scan_keys.emplace_back();
878
7
                _end_scan_keys.back().add_value(
879
7
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
7
            }
881
882
3
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
3
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
3
        _begin_include = true;
927
3
        _end_include = true;
928
3
    } // Extend ScanKey with range value
929
0
    else {
930
0
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
0
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
0
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
0
        } else {
955
0
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
0
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
0
                                                      range.get_range_min_value(), range.scale()),
958
0
                                              range.contain_null());
959
0
            }
960
961
0
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
0
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
0
                        range.get_range_max_value(), range.scale()));
964
0
            }
965
0
        }
966
0
        _begin_include = range.is_begin_include();
967
0
        _end_include = range.is_end_include();
968
0
    }
969
970
3
    return Status::OK();
971
9
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE25EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.26k
                                     bool* should_break) {
823
3.26k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.26k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.26k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.26k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
3.26k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
3.26k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.26k
    if (range.is_fixed_value_range()) {
842
306
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.95k
    } else {
852
2.95k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.95k
            !range.is_reject_split_type()) {
854
2.87k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.87k
                                                 _end_include);
856
857
2.87k
            if (!(*eos) &&
858
2.87k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.87k
                                                 _end_include, max_scan_key_num)) {
860
2.76k
                _has_range_value = true;
861
2.76k
            }
862
2.87k
            return Status::OK();
863
2.87k
        }
864
2.95k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
390
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
304
        if (_begin_scan_keys.empty()) {
870
302
            auto fixed_value_set = range.get_fixed_value_set();
871
302
            ConstIterator iter = fixed_value_set.begin();
872
873
639
            for (; iter != fixed_value_set.end(); ++iter) {
874
337
                _begin_scan_keys.emplace_back();
875
337
                _begin_scan_keys.back().add_value(
876
337
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
337
                _end_scan_keys.emplace_back();
878
337
                _end_scan_keys.back().add_value(
879
337
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
337
            }
881
882
302
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
302
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
2
        else {
890
2
            auto fixed_value_set = range.get_fixed_value_set();
891
2
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
4
            for (int i = 0; i < original_key_range_size; ++i) {
894
2
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
2
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
2
                ConstIterator iter = fixed_value_set.begin();
898
899
4
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
2
                    if (iter == fixed_value_set.begin()) {
902
2
                        _begin_scan_keys[i].add_value(
903
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
2
                        _end_scan_keys[i].add_value(
905
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
2
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
2
                }
916
917
2
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
2
            }
924
2
        }
925
926
304
        _begin_include = true;
927
304
        _end_include = true;
928
304
    } // Extend ScanKey with range value
929
86
    else {
930
86
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
86
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
86
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
86
        } else {
955
184
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
98
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
98
                                                      range.get_range_min_value(), range.scale()),
958
98
                                              range.contain_null());
959
98
            }
960
961
184
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
98
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
98
                        range.get_range_max_value(), range.scale()));
964
98
            }
965
86
        }
966
86
        _begin_include = range.is_begin_include();
967
86
        _end_include = range.is_end_include();
968
86
    }
969
970
390
    return Status::OK();
971
3.26k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE12EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
27
                                     bool* should_break) {
823
27
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
27
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
27
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
27
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
27
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
27
    if (range.is_fixed_value_range()) {
842
9
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
18
    } else {
852
21
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
18
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
18
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
27
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
8
        if (_begin_scan_keys.empty()) {
870
8
            auto fixed_value_set = range.get_fixed_value_set();
871
8
            ConstIterator iter = fixed_value_set.begin();
872
873
28
            for (; iter != fixed_value_set.end(); ++iter) {
874
20
                _begin_scan_keys.emplace_back();
875
20
                _begin_scan_keys.back().add_value(
876
20
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
20
                _end_scan_keys.emplace_back();
878
20
                _end_scan_keys.back().add_value(
879
20
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
20
            }
881
882
8
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
8
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
8
        _begin_include = true;
927
8
        _end_include = true;
928
8
    } // Extend ScanKey with range value
929
19
    else {
930
19
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
19
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
22
        } else if (_begin_scan_keys.empty()) {
947
22
            _begin_scan_keys.emplace_back();
948
22
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
22
                                                      range.get_range_min_value(), range.scale()),
950
22
                                              range.contain_null());
951
22
            _end_scan_keys.emplace_back();
952
22
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
22
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
0
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
0
                                                      range.get_range_min_value(), range.scale()),
958
0
                                              range.contain_null());
959
0
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
0
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
0
                        range.get_range_max_value(), range.scale()));
964
0
            }
965
18.4E
        }
966
19
        _begin_include = range.is_begin_include();
967
19
        _end_include = range.is_end_include();
968
19
    }
969
970
27
    return Status::OK();
971
27
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE26EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.44k
                                     bool* should_break) {
823
2.44k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.44k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.44k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.44k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2.44k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.44k
    if (range.is_fixed_value_range()) {
842
73
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.36k
    } else {
852
2.36k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.36k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
2.36k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.44k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
73
        if (_begin_scan_keys.empty()) {
870
71
            auto fixed_value_set = range.get_fixed_value_set();
871
71
            ConstIterator iter = fixed_value_set.begin();
872
873
146
            for (; iter != fixed_value_set.end(); ++iter) {
874
75
                _begin_scan_keys.emplace_back();
875
75
                _begin_scan_keys.back().add_value(
876
75
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
75
                _end_scan_keys.emplace_back();
878
75
                _end_scan_keys.back().add_value(
879
75
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
75
            }
881
882
71
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
71
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
2
        else {
890
2
            auto fixed_value_set = range.get_fixed_value_set();
891
2
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
6
            for (int i = 0; i < original_key_range_size; ++i) {
894
4
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
4
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
4
                ConstIterator iter = fixed_value_set.begin();
898
899
8
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
4
                    if (iter == fixed_value_set.begin()) {
902
4
                        _begin_scan_keys[i].add_value(
903
4
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
4
                        _end_scan_keys[i].add_value(
905
4
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
4
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
4
                }
916
917
4
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
4
            }
924
2
        }
925
926
73
        _begin_include = true;
927
73
        _end_include = true;
928
73
    } // Extend ScanKey with range value
929
2.36k
    else {
930
2.36k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.36k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
2.37k
        } else if (_begin_scan_keys.empty()) {
947
2.37k
            _begin_scan_keys.emplace_back();
948
2.37k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.37k
                                                      range.get_range_min_value(), range.scale()),
950
2.37k
                                              range.contain_null());
951
2.37k
            _end_scan_keys.emplace_back();
952
2.37k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.37k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
2
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
2
                                                      range.get_range_min_value(), range.scale()),
958
2
                                              range.contain_null());
959
2
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
2
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
2
                        range.get_range_max_value(), range.scale()));
964
2
            }
965
18.4E
        }
966
2.36k
        _begin_include = range.is_begin_include();
967
2.36k
        _end_include = range.is_end_include();
968
2.36k
    }
969
970
2.44k
    return Status::OK();
971
2.44k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.78k
                                     bool* should_break) {
823
2.78k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.78k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.78k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.78k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2.78k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
2.78k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.78k
    if (range.is_fixed_value_range()) {
842
121
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.66k
    } else {
852
2.66k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.66k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
2.66k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.78k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
124
        if (_begin_scan_keys.empty()) {
870
124
            auto fixed_value_set = range.get_fixed_value_set();
871
124
            ConstIterator iter = fixed_value_set.begin();
872
873
343
            for (; iter != fixed_value_set.end(); ++iter) {
874
219
                _begin_scan_keys.emplace_back();
875
219
                _begin_scan_keys.back().add_value(
876
219
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
219
                _end_scan_keys.emplace_back();
878
219
                _end_scan_keys.back().add_value(
879
219
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
219
            }
881
882
124
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
124
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
18.4E
        else {
890
18.4E
            auto fixed_value_set = range.get_fixed_value_set();
891
18.4E
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
18.4E
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
18.4E
        }
925
926
122
        _begin_include = true;
927
122
        _end_include = true;
928
122
    } // Extend ScanKey with range value
929
2.66k
    else {
930
2.66k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.66k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
9
            CHECK(range.contain_null());
935
9
            if (_begin_scan_keys.empty()) {
936
9
                _begin_scan_keys.emplace_back();
937
9
                _begin_scan_keys.back().add_null();
938
9
                _end_scan_keys.emplace_back();
939
9
                _end_scan_keys.back().add_null();
940
9
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
2.65k
        } else if (_begin_scan_keys.empty()) {
947
2.65k
            _begin_scan_keys.emplace_back();
948
2.65k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.65k
                                                      range.get_range_min_value(), range.scale()),
950
2.65k
                                              range.contain_null());
951
2.65k
            _end_scan_keys.emplace_back();
952
2.65k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.65k
                    range.get_range_max_value(), range.scale()));
954
2.65k
        } else {
955
4
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
0
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
0
                                                      range.get_range_min_value(), range.scale()),
958
0
                                              range.contain_null());
959
0
            }
960
961
4
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
0
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
0
                        range.get_range_max_value(), range.scale()));
964
0
            }
965
4
        }
966
2.66k
        _begin_include = range.is_begin_include();
967
2.66k
        _end_include = range.is_end_include();
968
2.66k
    }
969
970
2.78k
    return Status::OK();
971
2.78k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
83
                                     bool* should_break) {
823
83
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
83
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
83
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
83
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
83
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
83
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
83
    if (range.is_fixed_value_range()) {
842
1
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
82
    } else {
852
82
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
82
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
82
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
83
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
1
        if (_begin_scan_keys.empty()) {
870
1
            auto fixed_value_set = range.get_fixed_value_set();
871
1
            ConstIterator iter = fixed_value_set.begin();
872
873
2
            for (; iter != fixed_value_set.end(); ++iter) {
874
1
                _begin_scan_keys.emplace_back();
875
1
                _begin_scan_keys.back().add_value(
876
1
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
1
                _end_scan_keys.emplace_back();
878
1
                _end_scan_keys.back().add_value(
879
1
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
1
            }
881
882
1
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
1
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
1
        _begin_include = true;
927
1
        _end_include = true;
928
1
    } // Extend ScanKey with range value
929
82
    else {
930
82
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
82
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
82
        } else if (_begin_scan_keys.empty()) {
947
81
            _begin_scan_keys.emplace_back();
948
81
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
81
                                                      range.get_range_min_value(), range.scale()),
950
81
                                              range.contain_null());
951
81
            _end_scan_keys.emplace_back();
952
81
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
81
                    range.get_range_max_value(), range.scale()));
954
81
        } else {
955
2
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
1
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
1
                                                      range.get_range_min_value(), range.scale()),
958
1
                                              range.contain_null());
959
1
            }
960
961
2
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
1
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
1
                        range.get_range_max_value(), range.scale()));
964
1
            }
965
1
        }
966
82
        _begin_include = range.is_begin_include();
967
82
        _end_include = range.is_end_include();
968
82
    }
969
970
83
    return Status::OK();
971
83
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.53k
                                     bool* should_break) {
823
1.53k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.53k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.53k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.53k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
1.53k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.53k
    if (range.is_fixed_value_range()) {
842
8
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
1
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
1
        }
851
1.52k
    } else {
852
1.52k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.52k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
1.52k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.52k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
7
        if (_begin_scan_keys.empty()) {
870
7
            auto fixed_value_set = range.get_fixed_value_set();
871
7
            ConstIterator iter = fixed_value_set.begin();
872
873
19
            for (; iter != fixed_value_set.end(); ++iter) {
874
12
                _begin_scan_keys.emplace_back();
875
12
                _begin_scan_keys.back().add_value(
876
12
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
12
                _end_scan_keys.emplace_back();
878
12
                _end_scan_keys.back().add_value(
879
12
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
12
            }
881
882
7
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
7
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
7
        _begin_include = true;
927
7
        _end_include = true;
928
7
    } // Extend ScanKey with range value
929
1.52k
    else {
930
1.52k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.52k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
5
            CHECK(range.contain_null());
935
5
            if (_begin_scan_keys.empty()) {
936
5
                _begin_scan_keys.emplace_back();
937
5
                _begin_scan_keys.back().add_null();
938
5
                _end_scan_keys.emplace_back();
939
5
                _end_scan_keys.back().add_null();
940
5
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
1.52k
        } else if (_begin_scan_keys.empty()) {
947
1.52k
            _begin_scan_keys.emplace_back();
948
1.52k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.52k
                                                      range.get_range_min_value(), range.scale()),
950
1.52k
                                              range.contain_null());
951
1.52k
            _end_scan_keys.emplace_back();
952
1.52k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.52k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
30
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
30
                                                      range.get_range_min_value(), range.scale()),
958
30
                                              range.contain_null());
959
30
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
30
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
30
                        range.get_range_max_value(), range.scale()));
964
30
            }
965
18.4E
        }
966
1.52k
        _begin_include = range.is_begin_include();
967
1.52k
        _end_include = range.is_end_include();
968
1.52k
    }
969
970
1.52k
    return Status::OK();
971
1.53k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
730
                                     bool* should_break) {
823
730
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
730
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
730
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
730
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
730
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
730
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
730
    if (range.is_fixed_value_range()) {
842
30
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
700
    } else {
852
700
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
700
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
700
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
730
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
30
        if (_begin_scan_keys.empty()) {
870
29
            auto fixed_value_set = range.get_fixed_value_set();
871
29
            ConstIterator iter = fixed_value_set.begin();
872
873
77
            for (; iter != fixed_value_set.end(); ++iter) {
874
48
                _begin_scan_keys.emplace_back();
875
48
                _begin_scan_keys.back().add_value(
876
48
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
48
                _end_scan_keys.emplace_back();
878
48
                _end_scan_keys.back().add_value(
879
48
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
48
            }
881
882
29
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
29
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
1
        else {
890
1
            auto fixed_value_set = range.get_fixed_value_set();
891
1
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
3
            for (int i = 0; i < original_key_range_size; ++i) {
894
2
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
2
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
2
                ConstIterator iter = fixed_value_set.begin();
898
899
4
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
2
                    if (iter == fixed_value_set.begin()) {
902
2
                        _begin_scan_keys[i].add_value(
903
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
2
                        _end_scan_keys[i].add_value(
905
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
2
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
2
                }
916
917
2
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
2
            }
924
1
        }
925
926
30
        _begin_include = true;
927
30
        _end_include = true;
928
30
    } // Extend ScanKey with range value
929
700
    else {
930
700
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
700
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
700
        } else if (_begin_scan_keys.empty()) {
947
697
            _begin_scan_keys.emplace_back();
948
697
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
697
                                                      range.get_range_min_value(), range.scale()),
950
697
                                              range.contain_null());
951
697
            _end_scan_keys.emplace_back();
952
697
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
697
                    range.get_range_max_value(), range.scale()));
954
697
        } else {
955
4
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
1
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
1
                                                      range.get_range_min_value(), range.scale()),
958
1
                                              range.contain_null());
959
1
            }
960
961
4
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
1
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
1
                        range.get_range_max_value(), range.scale()));
964
1
            }
965
3
        }
966
700
        _begin_include = range.is_begin_include();
967
700
        _end_include = range.is_end_include();
968
700
    }
969
970
730
    return Status::OK();
971
730
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
800
                                     bool* should_break) {
823
800
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
800
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
800
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
800
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
800
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
800
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
800
    if (range.is_fixed_value_range()) {
842
20
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
780
    } else {
852
780
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
780
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
780
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
800
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
20
        if (_begin_scan_keys.empty()) {
870
19
            auto fixed_value_set = range.get_fixed_value_set();
871
19
            ConstIterator iter = fixed_value_set.begin();
872
873
38
            for (; iter != fixed_value_set.end(); ++iter) {
874
19
                _begin_scan_keys.emplace_back();
875
19
                _begin_scan_keys.back().add_value(
876
19
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
19
                _end_scan_keys.emplace_back();
878
19
                _end_scan_keys.back().add_value(
879
19
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
19
            }
881
882
19
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
19
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
1
        else {
890
1
            auto fixed_value_set = range.get_fixed_value_set();
891
1
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
2
            for (int i = 0; i < original_key_range_size; ++i) {
894
1
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
1
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
1
                ConstIterator iter = fixed_value_set.begin();
898
899
2
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
1
                    if (iter == fixed_value_set.begin()) {
902
1
                        _begin_scan_keys[i].add_value(
903
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
1
                        _end_scan_keys[i].add_value(
905
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
1
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
1
                }
916
917
1
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
1
            }
924
1
        }
925
926
20
        _begin_include = true;
927
20
        _end_include = true;
928
20
    } // Extend ScanKey with range value
929
780
    else {
930
780
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
780
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
780
        } else if (_begin_scan_keys.empty()) {
947
762
            _begin_scan_keys.emplace_back();
948
762
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
762
                                                      range.get_range_min_value(), range.scale()),
950
762
                                              range.contain_null());
951
762
            _end_scan_keys.emplace_back();
952
762
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
762
                    range.get_range_max_value(), range.scale()));
954
762
        } else {
955
69
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
51
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
51
                                                      range.get_range_min_value(), range.scale()),
958
51
                                              range.contain_null());
959
51
            }
960
961
70
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
52
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
52
                        range.get_range_max_value(), range.scale()));
964
52
            }
965
18
        }
966
780
        _begin_include = range.is_begin_include();
967
780
        _end_include = range.is_end_include();
968
780
    }
969
970
800
    return Status::OK();
971
800
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.45k
                                     bool* should_break) {
823
1.45k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.45k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.45k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.45k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
1.45k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
1.45k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.45k
    if (range.is_fixed_value_range()) {
842
6
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
1.44k
    } else {
852
1.44k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.44k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
1.44k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.45k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
6
        if (_begin_scan_keys.empty()) {
870
6
            auto fixed_value_set = range.get_fixed_value_set();
871
6
            ConstIterator iter = fixed_value_set.begin();
872
873
12
            for (; iter != fixed_value_set.end(); ++iter) {
874
6
                _begin_scan_keys.emplace_back();
875
6
                _begin_scan_keys.back().add_value(
876
6
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
6
                _end_scan_keys.emplace_back();
878
6
                _end_scan_keys.back().add_value(
879
6
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
6
            }
881
882
6
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
6
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
6
        _begin_include = true;
927
6
        _end_include = true;
928
6
    } // Extend ScanKey with range value
929
1.44k
    else {
930
1.44k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.44k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
1.44k
        } else if (_begin_scan_keys.empty()) {
947
1.33k
            _begin_scan_keys.emplace_back();
948
1.33k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.33k
                                                      range.get_range_min_value(), range.scale()),
950
1.33k
                                              range.contain_null());
951
1.33k
            _end_scan_keys.emplace_back();
952
1.33k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.33k
                    range.get_range_max_value(), range.scale()));
954
1.33k
        } else {
955
221
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
108
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
108
                                                      range.get_range_min_value(), range.scale()),
958
108
                                              range.contain_null());
959
108
            }
960
961
221
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
108
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
108
                        range.get_range_max_value(), range.scale()));
964
108
            }
965
113
        }
966
1.44k
        _begin_include = range.is_begin_include();
967
1.44k
        _end_include = range.is_end_include();
968
1.44k
    }
969
970
1.45k
    return Status::OK();
971
1.45k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
484
                                     bool* should_break) {
823
484
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
484
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
484
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
484
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
484
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
484
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
484
    if (range.is_fixed_value_range()) {
842
16
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
468
    } else {
852
468
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
468
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
468
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
484
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
16
        if (_begin_scan_keys.empty()) {
870
16
            auto fixed_value_set = range.get_fixed_value_set();
871
16
            ConstIterator iter = fixed_value_set.begin();
872
873
36
            for (; iter != fixed_value_set.end(); ++iter) {
874
20
                _begin_scan_keys.emplace_back();
875
20
                _begin_scan_keys.back().add_value(
876
20
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
20
                _end_scan_keys.emplace_back();
878
20
                _end_scan_keys.back().add_value(
879
20
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
20
            }
881
882
16
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
16
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
16
        _begin_include = true;
927
16
        _end_include = true;
928
16
    } // Extend ScanKey with range value
929
468
    else {
930
468
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
468
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
467
        } else if (_begin_scan_keys.empty()) {
947
404
            _begin_scan_keys.emplace_back();
948
404
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
404
                                                      range.get_range_min_value(), range.scale()),
950
404
                                              range.contain_null());
951
404
            _end_scan_keys.emplace_back();
952
404
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
404
                    range.get_range_max_value(), range.scale()));
954
404
        } else {
955
123
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
60
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
60
                                                      range.get_range_min_value(), range.scale()),
958
60
                                              range.contain_null());
959
60
            }
960
961
123
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
60
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
60
                        range.get_range_max_value(), range.scale()));
964
60
            }
965
63
        }
966
468
        _begin_include = range.is_begin_include();
967
468
        _end_include = range.is_end_include();
968
468
    }
969
970
484
    return Status::OK();
971
484
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris