Coverage Report

Created: 2026-03-23 09:24

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.62M
std::string cast_to_string(T value, int scale) {
61
1.62M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.19k
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.74k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.74k
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.54k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.54k
        return ((Decimal<int128_t>)value).to_string(scale);
67
2.54k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
776
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
202k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
202k
        return std::to_string(static_cast<int>(value));
71
202k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.19k
        return int128_to_string(value);
73
8.19k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.87k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.87k
        char buf[30];
76
4.87k
        datetimev2_val.to_string(buf);
77
4.87k
        std::stringstream ss;
78
4.87k
        ss << buf;
79
4.87k
        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
4.17k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
4.17k
        return CastToString::from_number(value);
91
1.38M
    } else {
92
1.38M
        return boost::lexical_cast<std::string>(value);
93
1.38M
    }
94
1.62M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
202k
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
202k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
202k
        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
202k
}
_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
159k
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
159k
    } else {
92
159k
        return boost::lexical_cast<std::string>(value);
93
159k
    }
94
159k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
165k
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
165k
    } else {
92
165k
        return boost::lexical_cast<std::string>(value);
93
165k
    }
94
165k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
8.19k
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.19k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.19k
        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.19k
}
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
985
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
985
    } else {
92
985
        return boost::lexical_cast<std::string>(value);
93
985
    }
94
985
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
777k
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
777k
    } else {
92
777k
        return boost::lexical_cast<std::string>(value);
93
777k
    }
94
777k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE23ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE11ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
554
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
554
    } else {
92
554
        return boost::lexical_cast<std::string>(value);
93
554
    }
94
554
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
263k
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
263k
    } else {
92
263k
        return boost::lexical_cast<std::string>(value);
93
263k
    }
94
263k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE12ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
34
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
34
    } else {
92
34
        return boost::lexical_cast<std::string>(value);
93
34
    }
94
34
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE26ENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4.87k
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.87k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.87k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.87k
        char buf[30];
76
4.87k
        datetimev2_val.to_string(buf);
77
4.87k
        std::stringstream ss;
78
4.87k
        ss << buf;
79
4.87k
        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.87k
}
_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
92
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
92
    } else {
92
92
        return boost::lexical_cast<std::string>(value);
93
92
    }
94
92
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4.17k
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
4.17k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
4.17k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
4.17k
}
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.19k
std::string cast_to_string(T value, int scale) {
61
1.19k
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.19k
        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.19k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.74k
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.74k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.74k
        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.74k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
2.54k
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.54k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.54k
        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.54k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
776
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
776
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
776
        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
776
}
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
155k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
2.36k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_reject_split_typeEv
Line
Count
Source
139
227
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_reject_split_typeEv
Line
Count
Source
139
66.9k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
79.5k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
3.88k
    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.80k
    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
27.4k
    void set_empty_value_range() {
144
27.4k
        _fixed_values.clear();
145
27.4k
        _low_value = TYPE_MAX;
146
27.4k
        _high_value = TYPE_MIN;
147
27.4k
        _contain_null = false;
148
27.4k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
336
    void set_empty_value_range() {
144
336
        _fixed_values.clear();
145
336
        _low_value = TYPE_MAX;
146
336
        _high_value = TYPE_MIN;
147
336
        _contain_null = false;
148
336
    }
_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
611
    void set_empty_value_range() {
144
611
        _fixed_values.clear();
145
611
        _low_value = TYPE_MAX;
146
611
        _high_value = TYPE_MIN;
147
611
        _contain_null = false;
148
611
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
25.1k
    void set_empty_value_range() {
144
25.1k
        _fixed_values.clear();
145
25.1k
        _low_value = TYPE_MAX;
146
25.1k
        _high_value = TYPE_MIN;
147
25.1k
        _contain_null = false;
148
25.1k
    }
_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
82
    void set_empty_value_range() {
144
82
        _fixed_values.clear();
145
82
        _low_value = TYPE_MAX;
146
82
        _high_value = TYPE_MIN;
147
82
        _contain_null = false;
148
82
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_empty_value_rangeEv
Line
Count
Source
143
84
    void set_empty_value_range() {
144
84
        _fixed_values.clear();
145
84
        _low_value = TYPE_MAX;
146
84
        _high_value = TYPE_MIN;
147
84
        _contain_null = false;
148
84
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_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_13PrimitiveTypeE10EE21set_empty_value_rangeEv
Line
Count
Source
143
371
    void set_empty_value_range() {
144
371
        _fixed_values.clear();
145
371
        _low_value = TYPE_MAX;
146
371
        _high_value = TYPE_MIN;
147
371
        _contain_null = false;
148
371
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_empty_value_rangeEv
Line
Count
Source
143
284
    void set_empty_value_range() {
144
284
        _fixed_values.clear();
145
284
        _low_value = TYPE_MAX;
146
284
        _high_value = TYPE_MIN;
147
284
        _contain_null = false;
148
284
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_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_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
68
    void set_empty_value_range() {
144
68
        _fixed_values.clear();
145
68
        _low_value = TYPE_MAX;
146
68
        _high_value = TYPE_MIN;
147
68
        _contain_null = false;
148
68
    }
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
134
    void set_empty_value_range() {
144
134
        _fixed_values.clear();
145
134
        _low_value = TYPE_MAX;
146
134
        _high_value = TYPE_MIN;
147
134
        _contain_null = false;
148
134
    }
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
9
    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.27k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_fixed_value_setEv
Line
Count
Source
150
1.02k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
133
    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
277
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_fixed_value_setEv
Line
Count
Source
150
3
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_fixed_value_setEv
Line
Count
Source
150
58
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_fixed_value_setEv
Line
Count
Source
150
89
    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
5
    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
26
    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
544k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
2.44k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
678
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
138k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
160k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
7.88k
    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
859
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
209k
    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.05k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_max_valueEv
Line
Count
Source
152
20
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_max_valueEv
Line
Count
Source
152
4.78k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
5.52k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
90
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
4.10k
    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.10k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.68k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
2.53k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
735
    CppType get_range_max_value() const { return _high_value; }
153
154
544k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.44k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
678
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
138k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
160k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
7.91k
    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
858
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
210k
    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.05k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_min_valueEv
Line
Count
Source
154
20
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_min_valueEv
Line
Count
Source
154
4.78k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
5.52k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
90
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
4.12k
    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.11k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.69k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
2.53k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
731
    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
272k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
2.40k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
293
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
67.5k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
79.9k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
3.91k
    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
393
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
104k
    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.92k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16is_begin_includeEv
Line
Count
Source
168
10
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16is_begin_includeEv
Line
Count
Source
168
2.38k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
2.77k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
45
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
2.05k
    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
551
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
825
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.25k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
370
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
169
170
272k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14is_end_includeEv
Line
Count
Source
170
2.40k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14is_end_includeEv
Line
Count
Source
170
293
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
67.6k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
80.0k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
3.94k
    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
394
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
104k
    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.92k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14is_end_includeEv
Line
Count
Source
170
10
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14is_end_includeEv
Line
Count
Source
170
2.38k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
2.77k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
45
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
2.04k
    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
551
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
828
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.26k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
370
    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
662k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
3.90k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
852
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
76.1k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12contain_nullEv
Line
Count
Source
176
165k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12contain_nullEv
Line
Count
Source
176
4.15k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
231
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
325
    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
701
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
390k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
4.78k
    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.59k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12contain_nullEv
Line
Count
Source
176
13
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12contain_nullEv
Line
Count
Source
176
2.71k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
2.98k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
46
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
2.27k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
652
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
1.71k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.28k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
406
    bool contain_null() const { return _contain_null; }
177
178
851k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.43k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
299
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
73.4k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
82.1k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.25k
    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
422
    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.49k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20get_fixed_value_sizeEv
Line
Count
Source
178
16
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.51k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.94k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
47
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.07k
    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
610
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
876
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.27k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
397
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
3.67k
    void set_whole_value_range() {
181
3.67k
        _fixed_values.clear();
182
3.67k
        _low_value = TYPE_MIN;
183
3.67k
        _high_value = TYPE_MAX;
184
3.67k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3.67k
        _high_op = FILTER_LESS_OR_EQUAL;
186
3.67k
        _contain_null = _is_nullable_col;
187
3.67k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
262
    void set_whole_value_range() {
181
262
        _fixed_values.clear();
182
262
        _low_value = TYPE_MIN;
183
262
        _high_value = TYPE_MAX;
184
262
        _low_op = FILTER_LARGER_OR_EQUAL;
185
262
        _high_op = FILTER_LESS_OR_EQUAL;
186
262
        _contain_null = _is_nullable_col;
187
262
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_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_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
713
    void set_whole_value_range() {
181
713
        _fixed_values.clear();
182
713
        _low_value = TYPE_MIN;
183
713
        _high_value = TYPE_MAX;
184
713
        _low_op = FILTER_LARGER_OR_EQUAL;
185
713
        _high_op = FILTER_LESS_OR_EQUAL;
186
713
        _contain_null = _is_nullable_col;
187
713
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_whole_value_rangeEv
Line
Count
Source
180
44
    void set_whole_value_range() {
181
44
        _fixed_values.clear();
182
44
        _low_value = TYPE_MIN;
183
44
        _high_value = TYPE_MAX;
184
44
        _low_op = FILTER_LARGER_OR_EQUAL;
185
44
        _high_op = FILTER_LESS_OR_EQUAL;
186
44
        _contain_null = _is_nullable_col;
187
44
    }
_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
17
    void set_whole_value_range() {
181
17
        _fixed_values.clear();
182
17
        _low_value = TYPE_MIN;
183
17
        _high_value = TYPE_MAX;
184
17
        _low_op = FILTER_LARGER_OR_EQUAL;
185
17
        _high_op = FILTER_LESS_OR_EQUAL;
186
17
        _contain_null = _is_nullable_col;
187
17
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_whole_value_rangeEv
Line
Count
Source
180
45
    void set_whole_value_range() {
181
45
        _fixed_values.clear();
182
45
        _low_value = TYPE_MIN;
183
45
        _high_value = TYPE_MAX;
184
45
        _low_op = FILTER_LARGER_OR_EQUAL;
185
45
        _high_op = FILTER_LESS_OR_EQUAL;
186
45
        _contain_null = _is_nullable_col;
187
45
    }
_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
19
    void set_whole_value_range() {
181
19
        _fixed_values.clear();
182
19
        _low_value = TYPE_MIN;
183
19
        _high_value = TYPE_MAX;
184
19
        _low_op = FILTER_LARGER_OR_EQUAL;
185
19
        _high_op = FILTER_LESS_OR_EQUAL;
186
19
        _contain_null = _is_nullable_col;
187
19
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_whole_value_rangeEv
Line
Count
Source
180
62
    void set_whole_value_range() {
181
62
        _fixed_values.clear();
182
62
        _low_value = TYPE_MIN;
183
62
        _high_value = TYPE_MAX;
184
62
        _low_op = FILTER_LARGER_OR_EQUAL;
185
62
        _high_op = FILTER_LESS_OR_EQUAL;
186
62
        _contain_null = _is_nullable_col;
187
62
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_whole_value_rangeEv
Line
Count
Source
180
2.06k
    void set_whole_value_range() {
181
2.06k
        _fixed_values.clear();
182
2.06k
        _low_value = TYPE_MIN;
183
2.06k
        _high_value = TYPE_MAX;
184
2.06k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
2.06k
        _high_op = FILTER_LESS_OR_EQUAL;
186
2.06k
        _contain_null = _is_nullable_col;
187
2.06k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
24
    void set_whole_value_range() {
181
24
        _fixed_values.clear();
182
24
        _low_value = TYPE_MIN;
183
24
        _high_value = TYPE_MAX;
184
24
        _low_op = FILTER_LARGER_OR_EQUAL;
185
24
        _high_op = FILTER_LESS_OR_EQUAL;
186
24
        _contain_null = _is_nullable_col;
187
24
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_whole_value_rangeEv
Line
Count
Source
180
45
    void set_whole_value_range() {
181
45
        _fixed_values.clear();
182
45
        _low_value = TYPE_MIN;
183
45
        _high_value = TYPE_MAX;
184
45
        _low_op = FILTER_LARGER_OR_EQUAL;
185
45
        _high_op = FILTER_LESS_OR_EQUAL;
186
45
        _contain_null = _is_nullable_col;
187
45
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
22
    void set_whole_value_range() {
181
22
        _fixed_values.clear();
182
22
        _low_value = TYPE_MIN;
183
22
        _high_value = TYPE_MAX;
184
22
        _low_op = FILTER_LARGER_OR_EQUAL;
185
22
        _high_op = FILTER_LESS_OR_EQUAL;
186
22
        _contain_null = _is_nullable_col;
187
22
    }
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
25
    void set_whole_value_range() {
181
25
        _fixed_values.clear();
182
25
        _low_value = TYPE_MIN;
183
25
        _high_value = TYPE_MAX;
184
25
        _low_op = FILTER_LARGER_OR_EQUAL;
185
25
        _high_op = FILTER_LESS_OR_EQUAL;
186
25
        _contain_null = _is_nullable_col;
187
25
    }
_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
7
    void set_whole_value_range() {
181
7
        _fixed_values.clear();
182
7
        _low_value = TYPE_MIN;
183
7
        _high_value = TYPE_MAX;
184
7
        _low_op = FILTER_LARGER_OR_EQUAL;
185
7
        _high_op = FILTER_LESS_OR_EQUAL;
186
7
        _contain_null = _is_nullable_col;
187
7
    }
188
189
1.95k
    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.95k
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
1.95k
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
1.95k
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
1.95k
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_whole_value_rangeEv
Line
Count
Source
189
54
    bool is_whole_value_range() const {
190
54
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
54
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
54
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
54
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
54
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_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_13PrimitiveTypeE5EE20is_whole_value_rangeEv
Line
Count
Source
189
450
    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
451
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
450
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
450
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
450
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_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_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
87
    bool is_whole_value_range() const {
190
87
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
87
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
87
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
87
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
87
    }
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
362
    bool is_whole_value_range() const {
190
362
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
362
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
362
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
362
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
362
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_whole_value_rangeEv
Line
Count
Source
189
285
    bool is_whole_value_range() const {
190
285
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
285
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
285
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
285
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
285
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
120
    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
121
        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
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
    }
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.63k
    void set_contain_null(bool contain_null) {
205
5.63k
        if (contain_null) {
206
1.96k
            set_empty_value_range();
207
3.66k
        } else {
208
3.66k
            set_whole_value_range();
209
3.66k
        }
210
5.63k
        _contain_null = _is_nullable_col && contain_null;
211
5.63k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
321
    void set_contain_null(bool contain_null) {
205
321
        if (contain_null) {
206
60
            set_empty_value_range();
207
261
        } else {
208
261
            set_whole_value_range();
209
261
        }
210
321
        _contain_null = _is_nullable_col && contain_null;
211
321
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
102
    void set_contain_null(bool contain_null) {
205
102
        if (contain_null) {
206
66
            set_empty_value_range();
207
66
        } else {
208
36
            set_whole_value_range();
209
36
        }
210
102
        _contain_null = _is_nullable_col && contain_null;
211
102
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
1.16k
    void set_contain_null(bool contain_null) {
205
1.16k
        if (contain_null) {
206
457
            set_empty_value_range();
207
711
        } else {
208
711
            set_whole_value_range();
209
711
        }
210
1.16k
        _contain_null = _is_nullable_col && contain_null;
211
1.16k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
113
    void set_contain_null(bool contain_null) {
205
113
        if (contain_null) {
206
69
            set_empty_value_range();
207
69
        } else {
208
44
            set_whole_value_range();
209
44
        }
210
113
        _contain_null = _is_nullable_col && contain_null;
211
113
    }
_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
100
    void set_contain_null(bool contain_null) {
205
100
        if (contain_null) {
206
82
            set_empty_value_range();
207
82
        } else {
208
18
            set_whole_value_range();
209
18
        }
210
100
        _contain_null = _is_nullable_col && contain_null;
211
100
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
129
    void set_contain_null(bool contain_null) {
205
129
        if (contain_null) {
206
84
            set_empty_value_range();
207
84
        } else {
208
45
            set_whole_value_range();
209
45
        }
210
131
        _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
88
    void set_contain_null(bool contain_null) {
205
88
        if (contain_null) {
206
68
            set_empty_value_range();
207
68
        } else {
208
20
            set_whole_value_range();
209
20
        }
210
88
        _contain_null = _is_nullable_col && contain_null;
211
88
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16set_contain_nullEb
Line
Count
Source
204
425
    void set_contain_null(bool contain_null) {
205
425
        if (contain_null) {
206
362
            set_empty_value_range();
207
362
        } else {
208
63
            set_whole_value_range();
209
63
        }
210
425
        _contain_null = _is_nullable_col && contain_null;
211
425
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
2.34k
    void set_contain_null(bool contain_null) {
205
2.34k
        if (contain_null) {
206
283
            set_empty_value_range();
207
2.06k
        } else {
208
2.06k
            set_whole_value_range();
209
2.06k
        }
210
2.35k
        _contain_null = _is_nullable_col && contain_null;
211
2.34k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
147
    void set_contain_null(bool contain_null) {
205
147
        if (contain_null) {
206
120
            set_empty_value_range();
207
120
        } else {
208
27
            set_whole_value_range();
209
27
        }
210
147
        _contain_null = _is_nullable_col && contain_null;
211
147
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
115
    void set_contain_null(bool contain_null) {
205
115
        if (contain_null) {
206
70
            set_empty_value_range();
207
70
        } else {
208
45
            set_whole_value_range();
209
45
        }
210
115
        _contain_null = _is_nullable_col && contain_null;
211
115
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
40
    void set_contain_null(bool contain_null) {
205
40
        if (contain_null) {
206
18
            set_empty_value_range();
207
22
        } else {
208
22
            set_whole_value_range();
209
22
        }
210
40
        _contain_null = _is_nullable_col && contain_null;
211
40
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16set_contain_nullEb
Line
Count
Source
204
78
    void set_contain_null(bool contain_null) {
205
78
        if (contain_null) {
206
68
            set_empty_value_range();
207
68
        } else {
208
10
            set_whole_value_range();
209
10
        }
210
78
        _contain_null = _is_nullable_col && contain_null;
211
78
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16set_contain_nullEb
Line
Count
Source
204
33
    void set_contain_null(bool contain_null) {
205
33
        if (contain_null) {
206
8
            set_empty_value_range();
207
25
        } else {
208
25
            set_whole_value_range();
209
25
        }
210
33
        _contain_null = _is_nullable_col && contain_null;
211
33
    }
_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
9
    void set_contain_null(bool contain_null) {
205
9
        if (contain_null) {
206
2
            set_empty_value_range();
207
7
        } else {
208
7
            set_whole_value_range();
209
7
        }
210
9
        _contain_null = _is_nullable_col && contain_null;
211
9
    }
212
213
570k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
125k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
2.05k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
19.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
84.3k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
337
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
313
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
655
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
32
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
31
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.55k
    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
63
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
29.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
47
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
4.23k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
536
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
487
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
265
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
1.05k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
373
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
129
    int precision() const { return _precision; }
214
215
2.19M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
327k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
24.4k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
181k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
250k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
8.54k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
313
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
657
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
32
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
35
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.53k
    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.21k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
618
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
293k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
81
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
9.15k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
6.36k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
93
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
4.67k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.45k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
2.80k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
2.91k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
906
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
500k
                                      const CppType& value) {
219
500k
        static_cast<void>(range.add_fixed_value(value));
220
500k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
121k
                                      const CppType& value) {
219
121k
        static_cast<void>(range.add_fixed_value(value));
220
121k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
145
                                      const CppType& value) {
219
145
        static_cast<void>(range.add_fixed_value(value));
220
145
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
67.5k
                                      const CppType& value) {
219
67.5k
        static_cast<void>(range.add_fixed_value(value));
220
67.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
3.01k
                                      const CppType& value) {
219
3.01k
        static_cast<void>(range.add_fixed_value(value));
220
3.01k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
186
                                      const CppType& value) {
219
186
        static_cast<void>(range.add_fixed_value(value));
220
186
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
60
                                      const CppType& value) {
219
60
        static_cast<void>(range.add_fixed_value(value));
220
60
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
171
                                      const CppType& value) {
219
171
        static_cast<void>(range.add_fixed_value(value));
220
171
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
218
23
                                      const CppType& value) {
219
23
        static_cast<void>(range.add_fixed_value(value));
220
23
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
218
24
                                      const CppType& value) {
219
24
        static_cast<void>(range.add_fixed_value(value));
220
24
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
649
                                      const CppType& value) {
219
649
        static_cast<void>(range.add_fixed_value(value));
220
649
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
293k
                                      const CppType& value) {
219
293k
        static_cast<void>(range.add_fixed_value(value));
220
293k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
1.58k
                                      const CppType& value) {
219
1.58k
        static_cast<void>(range.add_fixed_value(value));
220
1.58k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
63
                                      const CppType& value) {
219
63
        static_cast<void>(range.add_fixed_value(value));
220
63
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
9.40k
                                      const CppType& value) {
219
9.40k
        static_cast<void>(range.add_fixed_value(value));
220
9.40k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
57
                                      const CppType& value) {
219
57
        static_cast<void>(range.add_fixed_value(value));
220
57
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
589
                                      const CppType& value) {
219
589
        static_cast<void>(range.add_fixed_value(value));
220
589
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
154
                                      const CppType& value) {
219
154
        static_cast<void>(range.add_fixed_value(value));
220
154
    }
_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
401
                                      const CppType& value) {
219
401
        static_cast<void>(range.add_fixed_value(value));
220
401
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
218
71
                                      const CppType& value) {
219
71
        static_cast<void>(range.add_fixed_value(value));
220
71
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
218
407
                                      const CppType& value) {
219
407
        static_cast<void>(range.add_fixed_value(value));
220
407
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
219
                                      const CppType& value) {
219
219
        static_cast<void>(range.add_fixed_value(value));
220
219
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
42
                                      const CppType& value) {
219
42
        static_cast<void>(range.add_fixed_value(value));
220
42
    }
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.95k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
57
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
31
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
1.32k
                               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
49
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
143
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14empty_functionERS2_NS_11SQLFilterOpERKj
Line
Count
Source
228
6
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14empty_functionERS2_NS_11SQLFilterOpERKo
Line
Count
Source
228
6
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
124
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
446
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
299
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
45
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
32
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
35
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
228
59
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
183
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
6
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
31
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
228
9
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14empty_functionERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
228
14
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
32
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
100k
                                const CppType& value) {
232
100k
        static_cast<void>(range.add_range(op, value));
233
100k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
2.49k
                                const CppType& value) {
232
2.49k
        static_cast<void>(range.add_range(op, value));
233
2.49k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.85k
                                const CppType& value) {
232
1.85k
        static_cast<void>(range.add_range(op, value));
233
1.85k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
10.5k
                                const CppType& value) {
232
10.5k
        static_cast<void>(range.add_range(op, value));
233
10.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
57.7k
                                const CppType& value) {
232
57.7k
        static_cast<void>(range.add_range(op, value));
233
57.7k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
139
                                const CppType& value) {
232
139
        static_cast<void>(range.add_range(op, value));
233
139
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
157
                                const CppType& value) {
232
157
        static_cast<void>(range.add_range(op, value));
233
157
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
354
                                const CppType& value) {
232
354
        static_cast<void>(range.add_range(op, value));
233
354
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
8
                                const CppType& value) {
232
8
        static_cast<void>(range.add_range(op, value));
233
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
8
                                const CppType& value) {
232
8
        static_cast<void>(range.add_range(op, value));
233
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
913
                                const CppType& value) {
232
913
        static_cast<void>(range.add_range(op, value));
233
913
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.45k
                                const CppType& value) {
232
1.45k
        static_cast<void>(range.add_range(op, value));
233
1.45k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
358
                                const CppType& value) {
232
358
        static_cast<void>(range.add_range(op, value));
233
358
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
231
6
                                const CppType& value) {
232
6
        static_cast<void>(range.add_range(op, value));
233
6
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
20.1k
                                const CppType& value) {
232
20.1k
        static_cast<void>(range.add_range(op, value));
233
20.1k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
3.57k
                                const CppType& value) {
232
3.57k
        static_cast<void>(range.add_range(op, value));
233
3.57k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
306
                                const CppType& value) {
232
306
        static_cast<void>(range.add_range(op, value));
233
306
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
231
50
                                const CppType& value) {
232
50
        static_cast<void>(range.add_range(op, value));
233
50
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
147
                                const CppType& value) {
232
147
        static_cast<void>(range.add_range(op, value));
233
147
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
458
                                const CppType& value) {
232
458
        static_cast<void>(range.add_range(op, value));
233
458
    }
_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
58
                                const CppType& value) {
232
58
        static_cast<void>(range.add_range(op, value));
233
58
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
568k
                                                                            int scale) {
238
568k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
568k
                                                precision, scale);
240
568k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
124k
                                                                            int scale) {
238
124k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
124k
                                                precision, scale);
240
124k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
2.04k
                                                                            int scale) {
238
2.04k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
2.04k
                                                precision, scale);
240
2.04k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
19.5k
                                                                            int scale) {
238
19.5k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
19.5k
                                                precision, scale);
240
19.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
84.2k
                                                                            int scale) {
238
84.2k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
84.2k
                                                precision, scale);
240
84.2k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
332
                                                                            int scale) {
238
332
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
332
                                                precision, scale);
240
332
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
310
                                                                            int scale) {
238
310
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
310
                                                precision, scale);
240
310
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
650
                                                                            int scale) {
238
650
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
650
                                                precision, scale);
240
650
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
32
                                                                            int scale) {
238
32
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
32
                                                precision, scale);
240
32
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
31
                                                                            int scale) {
238
31
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
31
                                                precision, scale);
240
31
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.51k
                                                                            int scale) {
238
1.51k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.51k
                                                precision, scale);
240
1.51k
    }
_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.16k
                                                                            int scale) {
238
4.16k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.16k
                                                precision, scale);
240
4.16k
    }
_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.4k
                                                                            int scale) {
238
29.4k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
29.4k
                                                precision, scale);
240
29.4k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
47
                                                                            int scale) {
238
47
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
47
                                                precision, scale);
240
47
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.21k
                                                                            int scale) {
238
4.21k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.21k
                                                precision, scale);
240
4.21k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
534
                                                                            int scale) {
238
534
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
534
                                                precision, scale);
240
534
    }
_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
487
                                                                            int scale) {
238
487
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
487
                                                precision, scale);
240
487
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
264
                                                                            int scale) {
238
264
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
264
                                                precision, scale);
240
264
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.05k
                                                                            int scale) {
238
1.05k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.05k
                                                precision, scale);
240
1.05k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
365
                                                                            int scale) {
238
365
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
365
                                                precision, scale);
240
365
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
128
                                                                            int scale) {
238
128
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
128
                                                precision, scale);
240
128
    }
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
826k
    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.76k
    std::string debug_string() {
310
1.76k
        std::stringstream ss;
311
1.76k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
1.76k
        ss << "ScanKeys:";
313
314
10.1k
        for (int i = 0; i < _begin_scan_keys.size(); ++i) {
315
18.4E
            ss << "ScanKey=" << (_begin_include ? "[" : "(") << _begin_scan_keys[i] << " : "
316
18.4E
               << _end_scan_keys[i] << (_end_include ? "]" : ")");
317
8.42k
        }
318
1.76k
        return ss.str();
319
1.76k
    }
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.42M
        : _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.74M
          _low_value(min),
383
1.74M
          _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
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_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
23.5k
        : _column_name(std::move(col_name)),
381
23.5k
          _column_type(primitive_type),
382
23.5k
          _low_value(min),
383
23.5k
          _high_value(max),
384
23.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
23.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
23.5k
          _is_nullable_col(is_nullable_col),
387
23.5k
          _contain_null(is_nullable_col && contain_null),
388
23.5k
          _precision(precision),
389
23.5k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
274k
        : _column_name(std::move(col_name)),
381
274k
          _column_type(primitive_type),
382
274k
          _low_value(min),
383
274k
          _high_value(max),
384
274k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
274k
          _high_op(FILTER_LESS_OR_EQUAL),
386
274k
          _is_nullable_col(is_nullable_col),
387
274k
          _contain_null(is_nullable_col && contain_null),
388
274k
          _precision(precision),
389
274k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
620k
        : _column_name(std::move(col_name)),
381
620k
          _column_type(primitive_type),
382
620k
          _low_value(min),
383
620k
          _high_value(max),
384
620k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
620k
          _high_op(FILTER_LESS_OR_EQUAL),
386
620k
          _is_nullable_col(is_nullable_col),
387
620k
          _contain_null(is_nullable_col && contain_null),
388
620k
          _precision(precision),
389
620k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_bbii
Line
Count
Source
380
11.8k
        : _column_name(std::move(col_name)),
381
11.8k
          _column_type(primitive_type),
382
11.8k
          _low_value(min),
383
11.8k
          _high_value(max),
384
11.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.8k
          _is_nullable_col(is_nullable_col),
387
11.8k
          _contain_null(is_nullable_col && contain_null),
388
11.8k
          _precision(precision),
389
11.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
13.1k
        : _column_name(std::move(col_name)),
381
13.1k
          _column_type(primitive_type),
382
13.1k
          _low_value(min),
383
13.1k
          _high_value(max),
384
13.1k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.1k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.1k
          _is_nullable_col(is_nullable_col),
387
13.1k
          _contain_null(is_nullable_col && contain_null),
388
13.1k
          _precision(precision),
389
13.1k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
18.2k
        : _column_name(std::move(col_name)),
381
18.2k
          _column_type(primitive_type),
382
18.2k
          _low_value(min),
383
18.2k
          _high_value(max),
384
18.2k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
18.2k
          _high_op(FILTER_LESS_OR_EQUAL),
386
18.2k
          _is_nullable_col(is_nullable_col),
387
18.2k
          _contain_null(is_nullable_col && contain_null),
388
18.2k
          _precision(precision),
389
18.2k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
341
        : _column_name(std::move(col_name)),
381
341
          _column_type(primitive_type),
382
341
          _low_value(min),
383
341
          _high_value(max),
384
341
          _low_op(FILTER_LARGER_OR_EQUAL),
385
341
          _high_op(FILTER_LESS_OR_EQUAL),
386
341
          _is_nullable_col(is_nullable_col),
387
341
          _contain_null(is_nullable_col && contain_null),
388
341
          _precision(precision),
389
341
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
382
        : _column_name(std::move(col_name)),
381
382
          _column_type(primitive_type),
382
382
          _low_value(min),
383
382
          _high_value(max),
384
382
          _low_op(FILTER_LARGER_OR_EQUAL),
385
382
          _high_op(FILTER_LESS_OR_EQUAL),
386
382
          _is_nullable_col(is_nullable_col),
387
382
          _contain_null(is_nullable_col && contain_null),
388
382
          _precision(precision),
389
382
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
20.6k
        : _column_name(std::move(col_name)),
381
20.6k
          _column_type(primitive_type),
382
20.6k
          _low_value(min),
383
20.6k
          _high_value(max),
384
20.6k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
20.6k
          _high_op(FILTER_LESS_OR_EQUAL),
386
20.6k
          _is_nullable_col(is_nullable_col),
387
20.6k
          _contain_null(is_nullable_col && contain_null),
388
20.6k
          _precision(precision),
389
20.6k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
1.23M
        : _column_name(std::move(col_name)),
381
1.23M
          _column_type(primitive_type),
382
1.23M
          _low_value(min),
383
1.23M
          _high_value(max),
384
1.23M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.23M
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.23M
          _is_nullable_col(is_nullable_col),
387
1.23M
          _contain_null(is_nullable_col && contain_null),
388
1.23M
          _precision(precision),
389
1.23M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
161k
        : _column_name(std::move(col_name)),
381
161k
          _column_type(primitive_type),
382
161k
          _low_value(min),
383
161k
          _high_value(max),
384
161k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
161k
          _high_op(FILTER_LESS_OR_EQUAL),
386
161k
          _is_nullable_col(is_nullable_col),
387
161k
          _contain_null(is_nullable_col && contain_null),
388
161k
          _precision(precision),
389
161k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
530
        : _column_name(std::move(col_name)),
381
530
          _column_type(primitive_type),
382
530
          _low_value(min),
383
530
          _high_value(max),
384
530
          _low_op(FILTER_LARGER_OR_EQUAL),
385
530
          _high_op(FILTER_LESS_OR_EQUAL),
386
530
          _is_nullable_col(is_nullable_col),
387
530
          _contain_null(is_nullable_col && contain_null),
388
530
          _precision(precision),
389
530
          _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
501
        : _column_name(std::move(col_name)),
381
501
          _column_type(primitive_type),
382
501
          _low_value(min),
383
501
          _high_value(max),
384
501
          _low_op(FILTER_LARGER_OR_EQUAL),
385
501
          _high_op(FILTER_LESS_OR_EQUAL),
386
501
          _is_nullable_col(is_nullable_col),
387
501
          _contain_null(is_nullable_col && contain_null),
388
501
          _precision(precision),
389
501
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
134k
        : _column_name(std::move(col_name)),
381
134k
          _column_type(primitive_type),
382
134k
          _low_value(min),
383
134k
          _high_value(max),
384
134k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
134k
          _high_op(FILTER_LESS_OR_EQUAL),
386
134k
          _is_nullable_col(is_nullable_col),
387
134k
          _contain_null(is_nullable_col && contain_null),
388
134k
          _precision(precision),
389
134k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
5.50k
        : _column_name(std::move(col_name)),
381
5.50k
          _column_type(primitive_type),
382
5.50k
          _low_value(min),
383
5.50k
          _high_value(max),
384
5.50k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
5.50k
          _high_op(FILTER_LESS_OR_EQUAL),
386
5.50k
          _is_nullable_col(is_nullable_col),
387
5.50k
          _contain_null(is_nullable_col && contain_null),
388
5.50k
          _precision(precision),
389
5.50k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
468
        : _column_name(std::move(col_name)),
381
468
          _column_type(primitive_type),
382
468
          _low_value(min),
383
468
          _high_value(max),
384
468
          _low_op(FILTER_LARGER_OR_EQUAL),
385
468
          _high_op(FILTER_LESS_OR_EQUAL),
386
468
          _is_nullable_col(is_nullable_col),
387
468
          _contain_null(is_nullable_col && contain_null),
388
468
          _precision(precision),
389
468
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
12.0k
        : _column_name(std::move(col_name)),
381
12.0k
          _column_type(primitive_type),
382
12.0k
          _low_value(min),
383
12.0k
          _high_value(max),
384
12.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.0k
          _is_nullable_col(is_nullable_col),
387
12.0k
          _contain_null(is_nullable_col && contain_null),
388
12.0k
          _precision(precision),
389
12.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
550
        : _column_name(std::move(col_name)),
381
550
          _column_type(primitive_type),
382
550
          _low_value(min),
383
550
          _high_value(max),
384
550
          _low_op(FILTER_LARGER_OR_EQUAL),
385
550
          _high_op(FILTER_LESS_OR_EQUAL),
386
550
          _is_nullable_col(is_nullable_col),
387
550
          _contain_null(is_nullable_col && contain_null),
388
550
          _precision(precision),
389
550
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
13.9k
        : _column_name(std::move(col_name)),
381
13.9k
          _column_type(primitive_type),
382
13.9k
          _low_value(min),
383
13.9k
          _high_value(max),
384
13.9k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.9k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.9k
          _is_nullable_col(is_nullable_col),
387
13.9k
          _contain_null(is_nullable_col && contain_null),
388
13.9k
          _precision(precision),
389
13.9k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
31.0k
        : _column_name(std::move(col_name)),
381
31.0k
          _column_type(primitive_type),
382
31.0k
          _low_value(min),
383
31.0k
          _high_value(max),
384
31.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
31.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
31.0k
          _is_nullable_col(is_nullable_col),
387
31.0k
          _contain_null(is_nullable_col && contain_null),
388
31.0k
          _precision(precision),
389
31.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
13.7k
        : _column_name(std::move(col_name)),
381
13.7k
          _column_type(primitive_type),
382
13.7k
          _low_value(min),
383
13.7k
          _high_value(max),
384
13.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.7k
          _is_nullable_col(is_nullable_col),
387
13.7k
          _contain_null(is_nullable_col && contain_null),
388
13.7k
          _precision(precision),
389
13.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
1.11k
        : _column_name(std::move(col_name)),
381
1.11k
          _column_type(primitive_type),
382
1.11k
          _low_value(min),
383
1.11k
          _high_value(max),
384
1.11k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.11k
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.11k
          _is_nullable_col(is_nullable_col),
387
1.11k
          _contain_null(is_nullable_col && contain_null),
388
1.11k
          _precision(precision),
389
1.11k
          _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
146k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
146k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
21.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
21.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
253k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
253k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
535k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
535k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.8k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.8k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
17.5k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
17.5k
                           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
465
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
465
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
450
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
450
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
97.0k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
97.0k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
129k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
129k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
4.95k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
4.95k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
940k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
940k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
156k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
156k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
546
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
546
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
13.6k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
13.6k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
29.9k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
29.9k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
13.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
13.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
984
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
984
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
467
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
467
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
306
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
306
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
351
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
351
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
513k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
513k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
513k
    _fixed_values.insert(value);
404
513k
    _contain_null = false;
405
406
513k
    _high_value = TYPE_MIN;
407
513k
    _low_value = TYPE_MAX;
408
409
513k
    return Status::OK();
410
513k
}
_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
147
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
147
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
147
    _fixed_values.insert(value);
404
147
    _contain_null = false;
405
406
147
    _high_value = TYPE_MIN;
407
147
    _low_value = TYPE_MAX;
408
409
147
    return Status::OK();
410
147
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
68.0k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
68.0k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
68.0k
    _fixed_values.insert(value);
404
68.0k
    _contain_null = false;
405
406
68.0k
    _high_value = TYPE_MIN;
407
68.0k
    _low_value = TYPE_MAX;
408
409
68.0k
    return Status::OK();
410
68.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
14.9k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
14.9k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
14.9k
    _fixed_values.insert(value);
404
14.9k
    _contain_null = false;
405
406
14.9k
    _high_value = TYPE_MIN;
407
14.9k
    _low_value = TYPE_MAX;
408
409
14.9k
    return Status::OK();
410
14.9k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
194
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
194
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
194
    _fixed_values.insert(value);
404
194
    _contain_null = false;
405
406
194
    _high_value = TYPE_MIN;
407
194
    _low_value = TYPE_MAX;
408
409
194
    return Status::OK();
410
194
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
76
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
76
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
76
    _fixed_values.insert(value);
404
76
    _contain_null = false;
405
406
76
    _high_value = TYPE_MIN;
407
76
    _low_value = TYPE_MAX;
408
409
76
    return Status::OK();
410
76
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
187
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
187
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
187
    _fixed_values.insert(value);
404
187
    _contain_null = false;
405
406
187
    _high_value = TYPE_MIN;
407
187
    _low_value = TYPE_MAX;
408
409
187
    return Status::OK();
410
187
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_fixed_valueERKj
Line
Count
Source
398
23
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
23
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
23
    _fixed_values.insert(value);
404
23
    _contain_null = false;
405
406
23
    _high_value = TYPE_MIN;
407
23
    _low_value = TYPE_MAX;
408
409
23
    return Status::OK();
410
23
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_fixed_valueERKo
Line
Count
Source
398
24
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
24
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
24
    _fixed_values.insert(value);
404
24
    _contain_null = false;
405
406
24
    _high_value = TYPE_MIN;
407
24
    _low_value = TYPE_MAX;
408
409
24
    return Status::OK();
410
24
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
652
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
652
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
652
    _fixed_values.insert(value);
404
652
    _contain_null = false;
405
406
652
    _high_value = TYPE_MIN;
407
652
    _low_value = TYPE_MAX;
408
409
652
    return Status::OK();
410
652
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
293k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
293k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
293k
    _fixed_values.insert(value);
404
293k
    _contain_null = false;
405
406
293k
    _high_value = TYPE_MIN;
407
293k
    _low_value = TYPE_MAX;
408
409
293k
    return Status::OK();
410
293k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
1.63k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
1.63k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
1.63k
    _fixed_values.insert(value);
404
1.63k
    _contain_null = false;
405
406
1.63k
    _high_value = TYPE_MIN;
407
1.63k
    _low_value = TYPE_MAX;
408
409
1.63k
    return Status::OK();
410
1.63k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_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_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
9.48k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
9.48k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
9.48k
    _fixed_values.insert(value);
404
9.48k
    _contain_null = false;
405
406
9.48k
    _high_value = TYPE_MIN;
407
9.48k
    _low_value = TYPE_MAX;
408
409
9.48k
    return Status::OK();
410
9.48k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
57
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
57
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
57
    _fixed_values.insert(value);
404
57
    _contain_null = false;
405
406
57
    _high_value = TYPE_MIN;
407
57
    _low_value = TYPE_MAX;
408
409
57
    return Status::OK();
410
57
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
655
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
655
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
655
    _fixed_values.insert(value);
404
655
    _contain_null = false;
405
406
655
    _high_value = TYPE_MIN;
407
655
    _low_value = TYPE_MAX;
408
409
655
    return Status::OK();
410
655
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
182
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
182
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
182
    _fixed_values.insert(value);
404
182
    _contain_null = false;
405
406
182
    _high_value = TYPE_MIN;
407
182
    _low_value = TYPE_MAX;
408
409
182
    return Status::OK();
410
182
}
_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
418
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
418
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
418
    _fixed_values.insert(value);
404
418
    _contain_null = false;
405
406
418
    _high_value = TYPE_MIN;
407
418
    _low_value = TYPE_MAX;
408
409
418
    return Status::OK();
410
418
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
71
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
71
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
71
    _fixed_values.insert(value);
404
71
    _contain_null = false;
405
406
71
    _high_value = TYPE_MIN;
407
71
    _low_value = TYPE_MAX;
408
409
71
    return Status::OK();
410
71
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
459
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
459
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
459
    _fixed_values.insert(value);
404
459
    _contain_null = false;
405
406
459
    _high_value = TYPE_MIN;
407
459
    _low_value = TYPE_MAX;
408
409
459
    return Status::OK();
410
459
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
219
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
219
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
219
    _fixed_values.insert(value);
404
219
    _contain_null = false;
405
406
219
    _high_value = TYPE_MIN;
407
219
    _low_value = TYPE_MAX;
408
409
219
    return Status::OK();
410
219
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
42
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
42
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
42
    _fixed_values.insert(value);
404
42
    _contain_null = false;
405
406
42
    _high_value = TYPE_MIN;
407
42
    _low_value = TYPE_MAX;
408
409
42
    return Status::OK();
410
42
}
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.84M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.84M
    return _fixed_values.size() != 0;
420
7.84M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_fixed_value_rangeEv
Line
Count
Source
418
1.11M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
1.11M
    return _fixed_values.size() != 0;
420
1.11M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
25.1k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
25.1k
    return _fixed_values.size() != 0;
420
25.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
531k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
531k
    return _fixed_values.size() != 0;
420
531k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
991k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
991k
    return _fixed_values.size() != 0;
420
991k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
28.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
28.9k
    return _fixed_values.size() != 0;
420
28.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
13.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
13.5k
    return _fixed_values.size() != 0;
420
13.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
19.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
19.2k
    return _fixed_values.size() != 0;
420
19.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
474
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
474
    return _fixed_values.size() != 0;
420
474
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
523
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
523
    return _fixed_values.size() != 0;
420
523
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
25.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
25.3k
    return _fixed_values.size() != 0;
420
25.3k
}
_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
807
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
807
    return _fixed_values.size() != 0;
420
807
}
_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
776
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
776
    return _fixed_values.size() != 0;
420
776
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
146k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
146k
    return _fixed_values.size() != 0;
420
146k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_fixed_value_rangeEv
Line
Count
Source
418
17.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
17.4k
    return _fixed_values.size() != 0;
420
17.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
652
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
652
    return _fixed_values.size() != 0;
420
652
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
22.8k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
22.8k
    return _fixed_values.size() != 0;
420
22.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
547
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
547
    return _fixed_values.size() != 0;
420
547
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
16.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
16.5k
    return _fixed_values.size() != 0;
420
16.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_fixed_value_rangeEv
Line
Count
Source
418
37.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
37.3k
    return _fixed_values.size() != 0;
420
37.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_fixed_value_rangeEv
Line
Count
Source
418
20.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
20.0k
    return _fixed_values.size() != 0;
420
20.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
2.83k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
2.83k
    return _fixed_values.size() != 0;
420
2.83k
}
421
422
template <PrimitiveType primitive_type>
423
2.73M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
2.73M
    return Compare::greater(_high_value, _low_value);
425
2.73M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
149k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
149k
    return Compare::greater(_high_value, _low_value);
425
149k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
21.6k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
21.6k
    return Compare::greater(_high_value, _low_value);
425
21.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
320k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
320k
    return Compare::greater(_high_value, _low_value);
425
320k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
659k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
659k
    return Compare::greater(_high_value, _low_value);
425
659k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
15.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
15.3k
    return Compare::greater(_high_value, _low_value);
425
15.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
12.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.8k
    return Compare::greater(_high_value, _low_value);
425
12.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
17.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
17.5k
    return Compare::greater(_high_value, _low_value);
425
17.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
306
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
306
    return Compare::greater(_high_value, _low_value);
425
306
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
351
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
351
    return Compare::greater(_high_value, _low_value);
425
351
}
_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
160k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
160k
    return Compare::greater(_high_value, _low_value);
425
160k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
472
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
472
    return Compare::greater(_high_value, _low_value);
425
472
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
99.7k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
99.7k
    return Compare::greater(_high_value, _low_value);
425
99.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
459
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
459
    return Compare::greater(_high_value, _low_value);
425
459
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
131k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
131k
    return Compare::greater(_high_value, _low_value);
425
131k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
7.71k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
7.71k
    return Compare::greater(_high_value, _low_value);
425
7.71k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
508
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
508
    return Compare::greater(_high_value, _low_value);
425
508
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
13.4k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.4k
    return Compare::greater(_high_value, _low_value);
425
13.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_scope_value_rangeEv
Line
Count
Source
423
548
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
548
    return Compare::greater(_high_value, _low_value);
425
548
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
14.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.1k
    return Compare::greater(_high_value, _low_value);
425
14.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
31.2k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
31.2k
    return Compare::greater(_high_value, _low_value);
425
31.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
14.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.5k
    return Compare::greater(_high_value, _low_value);
425
14.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
1.35k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.35k
    return Compare::greater(_high_value, _low_value);
425
1.35k
}
426
427
template <PrimitiveType primitive_type>
428
3.89M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
3.89M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
3.89M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
3.89M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
391k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
391k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
391k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
391k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
21.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
21.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
21.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
21.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
338k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
338k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
338k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
338k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
663k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
663k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
663k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
663k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
15.7k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
15.7k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
15.7k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
15.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
12.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_empty_value_rangeEv
Line
Count
Source
428
17.7k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
17.7k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
17.7k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
17.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_empty_value_rangeEv
Line
Count
Source
428
342
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
342
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
342
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
342
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
390
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
390
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
390
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
390
}
_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.90M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.90M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.90M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.90M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
163k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
163k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
163k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
163k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
546
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
546
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
546
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
546
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
118k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
118k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
118k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
118k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
527
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
527
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
527
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
527
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
132k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
132k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
132k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
132k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
7.97k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
7.97k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
7.97k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
7.97k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_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_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
14.3k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.3k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.3k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_empty_value_rangeEv
Line
Count
Source
428
551
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
551
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
551
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
551
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
14.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
31.7k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
31.7k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
31.7k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
31.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_empty_value_rangeEv
Line
Count
Source
428
14.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
1.44k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.44k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.44k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.44k
}
435
436
template <PrimitiveType primitive_type>
437
175k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
175k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
175k
    if (!is_enumeration_type(_column_type)) {
443
19.7k
        return false;
444
19.7k
    }
445
446
156k
    return true;
447
175k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.37k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.37k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.37k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.37k
    return true;
447
2.37k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
228
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
228
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
228
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
228
    return true;
447
228
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_fixed_value_convertibleEv
Line
Count
Source
437
67.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
67.2k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
67.2k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
67.2k
    return true;
447
67.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
79.6k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
79.6k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
79.6k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
79.6k
    return true;
447
79.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
3.90k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
3.90k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
3.90k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
3.90k
    return true;
447
3.90k
}
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
384
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
384
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
386
    if (!is_enumeration_type(_column_type)) {
443
386
        return false;
444
386
    }
445
446
18.4E
    return true;
447
384
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
9.20k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
9.20k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
9.23k
    if (!is_enumeration_type(_column_type)) {
443
9.23k
        return false;
444
9.23k
    }
445
446
18.4E
    return true;
447
9.20k
}
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.80k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.80k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.80k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.80k
    return true;
447
2.80k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_fixed_value_convertibleEv
Line
Count
Source
437
10
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
10
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
10
    if (!is_enumeration_type(_column_type)) {
443
10
        return false;
444
10
    }
445
446
0
    return true;
447
10
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.39k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.39k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.39k
    if (!is_enumeration_type(_column_type)) {
443
2.39k
        return false;
444
2.39k
    }
445
446
18.4E
    return true;
447
2.39k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.75k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.75k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.76k
    if (!is_enumeration_type(_column_type)) {
443
2.76k
        return false;
444
2.76k
    }
445
446
18.4E
    return true;
447
2.75k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
44
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
44
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
44
    if (!is_enumeration_type(_column_type)) {
443
44
        return false;
444
44
    }
445
446
0
    return true;
447
44
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.02k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.02k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.05k
    if (!is_enumeration_type(_column_type)) {
443
2.05k
        return false;
444
2.05k
    }
445
446
18.4E
    return true;
447
2.02k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
554
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
554
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
554
    if (!is_enumeration_type(_column_type)) {
443
554
        return false;
444
554
    }
445
446
0
    return true;
447
554
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
806
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
806
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
806
    if (!is_enumeration_type(_column_type)) {
443
803
        return false;
444
803
    }
445
446
3
    return true;
447
806
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.15k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.15k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.15k
    if (!is_enumeration_type(_column_type)) {
443
1.15k
        return false;
444
1.15k
    }
445
446
18.4E
    return true;
447
1.15k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
306
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
306
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
308
    if (!is_enumeration_type(_column_type)) {
443
308
        return false;
444
308
    }
445
446
18.4E
    return true;
447
306
}
448
449
template <PrimitiveType primitive_type>
450
113
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
113
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
113
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
112
    return true;
460
113
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
106
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
106
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
106
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
106
    return true;
460
106
}
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
4
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
4
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
4
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
4
    return true;
460
4
}
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
151k
        bool& begin_include, bool& end_include) {
467
151k
    if constexpr (!_is_reject_split_type) {
468
151k
        begin_include = true;
469
151k
        end_include = true;
470
471
151k
        bool is_empty = false;
472
473
151k
        if (!is_begin_include()) {
474
8.43k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
8.43k
            } else {
477
8.43k
                ++_low_value;
478
8.43k
            }
479
8.43k
        }
480
481
151k
        if (!is_end_include()) {
482
524
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
524
            } else {
485
524
                --_high_value;
486
524
            }
487
524
        }
488
489
151k
        if (Compare::less(_high_value, _low_value)) {
490
30
            is_empty = true;
491
30
        }
492
493
151k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
151k
    }
499
151k
    return false;
500
151k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.37k
        bool& begin_include, bool& end_include) {
467
2.37k
    if constexpr (!_is_reject_split_type) {
468
2.37k
        begin_include = true;
469
2.37k
        end_include = true;
470
471
2.37k
        bool is_empty = false;
472
473
2.37k
        if (!is_begin_include()) {
474
50
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
50
            } else {
477
50
                ++_low_value;
478
50
            }
479
50
        }
480
481
2.37k
        if (!is_end_include()) {
482
20
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
20
            } else {
485
20
                --_high_value;
486
20
            }
487
20
        }
488
489
2.37k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.37k
        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.37k
    }
499
2.37k
    return false;
500
2.37k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
227
        bool& begin_include, bool& end_include) {
467
227
    if constexpr (!_is_reject_split_type) {
468
227
        begin_include = true;
469
227
        end_include = true;
470
471
227
        bool is_empty = false;
472
473
227
        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
227
        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
227
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
227
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
227
    }
499
227
    return false;
500
227
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
66.8k
        bool& begin_include, bool& end_include) {
467
66.8k
    if constexpr (!_is_reject_split_type) {
468
66.8k
        begin_include = true;
469
66.8k
        end_include = true;
470
471
66.8k
        bool is_empty = false;
472
473
66.8k
        if (!is_begin_include()) {
474
506
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
506
            } else {
477
506
                ++_low_value;
478
506
            }
479
506
        }
480
481
66.8k
        if (!is_end_include()) {
482
401
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
401
            } else {
485
401
                --_high_value;
486
401
            }
487
401
        }
488
489
66.8k
        if (Compare::less(_high_value, _low_value)) {
490
30
            is_empty = true;
491
30
        }
492
493
66.8k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
66.8k
    }
499
66.8k
    return false;
500
66.8k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
79.5k
        bool& begin_include, bool& end_include) {
467
79.5k
    if constexpr (!_is_reject_split_type) {
468
79.5k
        begin_include = true;
469
79.5k
        end_include = true;
470
471
79.5k
        bool is_empty = false;
472
473
79.5k
        if (!is_begin_include()) {
474
7.86k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
7.86k
            } else {
477
7.86k
                ++_low_value;
478
7.86k
            }
479
7.86k
        }
480
481
79.5k
        if (!is_end_include()) {
482
6
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
6
            } else {
485
6
                --_high_value;
486
6
            }
487
6
        }
488
489
79.5k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
79.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
79.5k
    }
499
79.5k
    return false;
500
79.5k
}
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.80k
        bool& begin_include, bool& end_include) {
467
2.80k
    if constexpr (!_is_reject_split_type) {
468
2.80k
        begin_include = true;
469
2.80k
        end_include = true;
470
471
2.80k
        bool is_empty = false;
472
473
2.80k
        if (!is_begin_include()) {
474
14
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
14
            } else {
477
14
                ++_low_value;
478
14
            }
479
14
        }
480
481
2.80k
        if (!is_end_include()) {
482
97
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
97
            } else {
485
97
                --_high_value;
486
97
            }
487
97
        }
488
489
2.80k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.80k
        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.80k
    }
499
2.80k
    return false;
500
2.80k
}
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
152k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
152k
    if constexpr (!_is_reject_split_type) {
508
152k
        CppType min_value = get_range_min_value();
509
152k
        CppType max_value = get_range_max_value();
510
152k
        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
152k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
152k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
30
            DCHECK(contain_null());
518
30
        }
519
520
152k
        auto no_split = [&]() -> bool {
521
144k
            begin_scan_keys.emplace_back();
522
144k
            begin_scan_keys.back().add_value(
523
144k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
144k
                    contain_null());
525
144k
            end_scan_keys.emplace_back();
526
144k
            end_scan_keys.back().add_value(
527
144k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
144k
                    empty_range_only_null ? true : false);
529
144k
            return true;
530
144k
        };
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
65.6k
        auto no_split = [&]() -> bool {
521
65.6k
            begin_scan_keys.emplace_back();
522
65.6k
            begin_scan_keys.back().add_value(
523
65.6k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
65.6k
                    contain_null());
525
65.6k
            end_scan_keys.emplace_back();
526
65.6k
            end_scan_keys.back().add_value(
527
65.6k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
65.6k
                    empty_range_only_null ? true : false);
529
65.6k
            return true;
530
65.6k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
79.2k
        auto no_split = [&]() -> bool {
521
79.2k
            begin_scan_keys.emplace_back();
522
79.2k
            begin_scan_keys.back().add_value(
523
79.2k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
79.2k
                    contain_null());
525
79.2k
            end_scan_keys.emplace_back();
526
79.2k
            end_scan_keys.back().add_value(
527
79.2k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
79.2k
                    empty_range_only_null ? true : false);
529
79.2k
            return true;
530
79.2k
        };
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
152k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
30
            return no_split();
533
30
        }
534
535
407k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
135k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
135k
                return value;
539
272k
            } else {
540
272k
                return (int128_t)value;
541
272k
            }
542
407k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKaE_clESA_
Line
Count
Source
535
105k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
105k
            } else {
540
105k
                return (int128_t)value;
541
105k
            }
542
105k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKsE_clESA_
Line
Count
Source
535
11.1k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
11.1k
            } else {
540
11.1k
                return (int128_t)value;
541
11.1k
            }
542
11.1k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKiE_clESA_
Line
Count
Source
535
75.0k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
75.0k
            } else {
540
75.0k
                return (int128_t)value;
541
75.0k
            }
542
75.0k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
80.6k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
80.6k
            } else {
540
80.6k
                return (int128_t)value;
541
80.6k
            }
542
80.6k
        };
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
276
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
276
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
276
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
276
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
135k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
135k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
135k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
135k
        };
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
152k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
152k
        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
152k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
145k
            return no_split();
552
145k
        }
553
6.56k
        int step_size = cast_set<int>(step_size_may_overflow);
554
6.56k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6.56k
        if (contain_null()) {
558
3.28k
            begin_scan_keys.emplace_back();
559
3.28k
            begin_scan_keys.back().add_null();
560
3.28k
            end_scan_keys.emplace_back();
561
3.28k
            end_scan_keys.back().add_null();
562
3.28k
        }
563
254k
        while (true) {
564
254k
            begin_scan_keys.emplace_back();
565
254k
            begin_scan_keys.back().add_value(
566
254k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
254k
            if (cast(max_value) - min_value < step_size) {
569
5.44k
                min_value = max_value;
570
249k
            } else {
571
249k
                min_value += step_size;
572
249k
            }
573
574
254k
            end_scan_keys.emplace_back();
575
254k
            end_scan_keys.back().add_value(
576
254k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
254k
            if (Compare::equal(min_value, max_value)) {
579
6.55k
                break;
580
6.55k
            }
581
248k
            ++min_value;
582
248k
            ++real_step_size;
583
248k
            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
248k
        }
592
593
6.56k
        return step_size != 0;
594
6.56k
    }
595
0
    return false;
596
152k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.38k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.38k
    if constexpr (!_is_reject_split_type) {
508
2.38k
        CppType min_value = get_range_min_value();
509
2.38k
        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.38k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.38k
        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.38k
        auto no_split = [&]() -> bool {
521
2.38k
            begin_scan_keys.emplace_back();
522
2.38k
            begin_scan_keys.back().add_value(
523
2.38k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.38k
                    contain_null());
525
2.38k
            end_scan_keys.emplace_back();
526
2.38k
            end_scan_keys.back().add_value(
527
2.38k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.38k
                    empty_range_only_null ? true : false);
529
2.38k
            return true;
530
2.38k
        };
531
2.38k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.38k
        auto cast = [](const CppType& value) {
536
2.38k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.38k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.38k
                return value;
539
2.38k
            } else {
540
2.38k
                return (int128_t)value;
541
2.38k
            }
542
2.38k
        };
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.38k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.38k
        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.38k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.38k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.38k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.38k
        if (contain_null()) {
558
2.07k
            begin_scan_keys.emplace_back();
559
2.07k
            begin_scan_keys.back().add_null();
560
2.07k
            end_scan_keys.emplace_back();
561
2.07k
            end_scan_keys.back().add_null();
562
2.07k
        }
563
102k
        while (true) {
564
102k
            begin_scan_keys.emplace_back();
565
102k
            begin_scan_keys.back().add_value(
566
102k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
102k
            if (cast(max_value) - min_value < step_size) {
569
2.39k
                min_value = max_value;
570
100k
            } else {
571
100k
                min_value += step_size;
572
100k
            }
573
574
102k
            end_scan_keys.emplace_back();
575
102k
            end_scan_keys.back().add_value(
576
102k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
102k
            if (Compare::equal(min_value, max_value)) {
579
2.42k
                break;
580
2.42k
            }
581
100k
            ++min_value;
582
100k
            ++real_step_size;
583
100k
            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
100k
        }
592
593
2.38k
        return step_size != 0;
594
2.38k
    }
595
0
    return false;
596
2.38k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
226
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
226
    if constexpr (!_is_reject_split_type) {
508
226
        CppType min_value = get_range_min_value();
509
226
        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
226
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
226
        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
226
        auto no_split = [&]() -> bool {
521
226
            begin_scan_keys.emplace_back();
522
226
            begin_scan_keys.back().add_value(
523
226
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
226
                    contain_null());
525
226
            end_scan_keys.emplace_back();
526
226
            end_scan_keys.back().add_value(
527
226
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
226
                    empty_range_only_null ? true : false);
529
226
            return true;
530
226
        };
531
226
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
226
        auto cast = [](const CppType& value) {
536
226
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
226
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
226
                return value;
539
226
            } else {
540
226
                return (int128_t)value;
541
226
            }
542
226
        };
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
226
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
226
        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
226
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
226
        int step_size = cast_set<int>(step_size_may_overflow);
554
226
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
226
        if (contain_null()) {
558
149
            begin_scan_keys.emplace_back();
559
149
            begin_scan_keys.back().add_null();
560
149
            end_scan_keys.emplace_back();
561
149
            end_scan_keys.back().add_null();
562
149
        }
563
10.9k
        while (true) {
564
10.9k
            begin_scan_keys.emplace_back();
565
10.9k
            begin_scan_keys.back().add_value(
566
10.9k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
10.9k
            if (cast(max_value) - min_value < step_size) {
569
228
                min_value = max_value;
570
10.6k
            } else {
571
10.6k
                min_value += step_size;
572
10.6k
            }
573
574
10.9k
            end_scan_keys.emplace_back();
575
10.9k
            end_scan_keys.back().add_value(
576
10.9k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
10.9k
            if (Compare::equal(min_value, max_value)) {
579
228
                break;
580
228
            }
581
10.6k
            ++min_value;
582
10.6k
            ++real_step_size;
583
10.6k
            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.6k
        }
592
593
226
        return step_size != 0;
594
226
    }
595
0
    return false;
596
226
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
67.3k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
67.3k
    if constexpr (!_is_reject_split_type) {
508
67.3k
        CppType min_value = get_range_min_value();
509
67.3k
        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
67.3k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
67.3k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
30
            DCHECK(contain_null());
518
30
        }
519
520
67.3k
        auto no_split = [&]() -> bool {
521
67.3k
            begin_scan_keys.emplace_back();
522
67.3k
            begin_scan_keys.back().add_value(
523
67.3k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
67.3k
                    contain_null());
525
67.3k
            end_scan_keys.emplace_back();
526
67.3k
            end_scan_keys.back().add_value(
527
67.3k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
67.3k
                    empty_range_only_null ? true : false);
529
67.3k
            return true;
530
67.3k
        };
531
67.3k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
30
            return no_split();
533
30
        }
534
535
67.3k
        auto cast = [](const CppType& value) {
536
67.3k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
67.3k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
67.3k
                return value;
539
67.3k
            } else {
540
67.3k
                return (int128_t)value;
541
67.3k
            }
542
67.3k
        };
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
67.3k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
67.3k
        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
67.3k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
66.2k
            return no_split();
552
66.2k
        }
553
1.09k
        int step_size = cast_set<int>(step_size_may_overflow);
554
1.09k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
1.09k
        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.41k
        while (true) {
564
8.17k
            begin_scan_keys.emplace_back();
565
8.17k
            begin_scan_keys.back().add_value(
566
8.17k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
8.17k
            if (cast(max_value) - min_value < step_size) {
569
90
                min_value = max_value;
570
8.08k
            } else {
571
8.08k
                min_value += step_size;
572
8.08k
            }
573
574
8.17k
            end_scan_keys.emplace_back();
575
8.17k
            end_scan_keys.back().add_value(
576
8.17k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
8.17k
            if (Compare::equal(min_value, max_value)) {
579
846
                break;
580
846
            }
581
7.32k
            ++min_value;
582
7.32k
            ++real_step_size;
583
7.32k
            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
7.32k
        }
592
593
1.09k
        return step_size != 0;
594
1.09k
    }
595
0
    return false;
596
67.3k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
79.5k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
79.5k
    if constexpr (!_is_reject_split_type) {
508
79.5k
        CppType min_value = get_range_min_value();
509
79.5k
        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
79.5k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
79.5k
        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
79.5k
        auto no_split = [&]() -> bool {
521
79.5k
            begin_scan_keys.emplace_back();
522
79.5k
            begin_scan_keys.back().add_value(
523
79.5k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
79.5k
                    contain_null());
525
79.5k
            end_scan_keys.emplace_back();
526
79.5k
            end_scan_keys.back().add_value(
527
79.5k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
79.5k
                    empty_range_only_null ? true : false);
529
79.5k
            return true;
530
79.5k
        };
531
79.5k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
79.5k
        auto cast = [](const CppType& value) {
536
79.5k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
79.5k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
79.5k
                return value;
539
79.5k
            } else {
540
79.5k
                return (int128_t)value;
541
79.5k
            }
542
79.5k
        };
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
79.5k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
79.5k
        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
79.5k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
79.5k
            return no_split();
552
79.5k
        }
553
59
        int step_size = cast_set<int>(step_size_may_overflow);
554
59
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
59
        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.14k
        while (true) {
564
1.14k
            begin_scan_keys.emplace_back();
565
1.14k
            begin_scan_keys.back().add_value(
566
1.14k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.14k
            if (cast(max_value) - min_value < step_size) {
569
2
                min_value = max_value;
570
1.14k
            } else {
571
1.14k
                min_value += step_size;
572
1.14k
            }
573
574
1.14k
            end_scan_keys.emplace_back();
575
1.14k
            end_scan_keys.back().add_value(
576
1.14k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.14k
            if (Compare::equal(min_value, max_value)) {
579
217
                break;
580
217
            }
581
931
            ++min_value;
582
931
            ++real_step_size;
583
931
            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
931
        }
592
593
59
        return step_size != 0;
594
59
    }
595
0
    return false;
596
79.5k
}
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
3
            begin_scan_keys.emplace_back();
559
3
            begin_scan_keys.back().add_null();
560
3
            end_scan_keys.emplace_back();
561
3
            end_scan_keys.back().add_null();
562
3
        }
563
270
        while (true) {
564
270
            begin_scan_keys.emplace_back();
565
270
            begin_scan_keys.back().add_value(
566
270
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
270
            if (cast(max_value) - min_value < step_size) {
569
6
                min_value = max_value;
570
264
            } else {
571
264
                min_value += step_size;
572
264
            }
573
574
270
            end_scan_keys.emplace_back();
575
270
            end_scan_keys.back().add_value(
576
270
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
270
            if (Compare::equal(min_value, max_value)) {
579
6
                break;
580
6
            }
581
264
            ++min_value;
582
264
            ++real_step_size;
583
264
            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
264
        }
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.80k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.80k
    if constexpr (!_is_reject_split_type) {
508
2.80k
        CppType min_value = get_range_min_value();
509
2.80k
        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.80k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.80k
        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.80k
        auto no_split = [&]() -> bool {
521
2.80k
            begin_scan_keys.emplace_back();
522
2.80k
            begin_scan_keys.back().add_value(
523
2.80k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.80k
                    contain_null());
525
2.80k
            end_scan_keys.emplace_back();
526
2.80k
            end_scan_keys.back().add_value(
527
2.80k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.80k
                    empty_range_only_null ? true : false);
529
2.80k
            return true;
530
2.80k
        };
531
2.80k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.80k
        auto cast = [](const CppType& value) {
536
2.80k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.80k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.80k
                return value;
539
2.80k
            } else {
540
2.80k
                return (int128_t)value;
541
2.80k
            }
542
2.80k
        };
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.80k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.80k
        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.80k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.80k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.80k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.80k
        if (contain_null()) {
558
1.06k
            begin_scan_keys.emplace_back();
559
1.06k
            begin_scan_keys.back().add_null();
560
1.06k
            end_scan_keys.emplace_back();
561
1.06k
            end_scan_keys.back().add_null();
562
1.06k
        }
563
131k
        while (true) {
564
131k
            begin_scan_keys.emplace_back();
565
131k
            begin_scan_keys.back().add_value(
566
131k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
131k
            if (cast(max_value) - min_value < step_size) {
569
2.72k
                min_value = max_value;
570
128k
            } else {
571
128k
                min_value += step_size;
572
128k
            }
573
574
131k
            end_scan_keys.emplace_back();
575
131k
            end_scan_keys.back().add_value(
576
131k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
131k
            if (Compare::equal(min_value, max_value)) {
579
2.82k
                break;
580
2.82k
            }
581
128k
            ++min_value;
582
128k
            ++real_step_size;
583
128k
            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
128k
        }
592
593
2.80k
        return step_size != 0;
594
2.80k
    }
595
0
    return false;
596
2.80k
}
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
56
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
56
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
56
    if (!_fixed_values.empty()) {
605
56
        _low_value = *_fixed_values.begin();
606
56
        _low_op = FILTER_LARGER_OR_EQUAL;
607
56
        _high_value = *_fixed_values.rbegin();
608
56
        _high_op = FILTER_LESS_OR_EQUAL;
609
56
        _fixed_values.clear();
610
56
    }
611
56
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
53
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
53
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
53
    if (!_fixed_values.empty()) {
605
53
        _low_value = *_fixed_values.begin();
606
53
        _low_op = FILTER_LARGER_OR_EQUAL;
607
53
        _high_value = *_fixed_values.rbegin();
608
53
        _high_op = FILTER_LESS_OR_EQUAL;
609
53
        _fixed_values.clear();
610
53
    }
611
53
}
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
2
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
2
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
2
    if (!_fixed_values.empty()) {
605
2
        _low_value = *_fixed_values.begin();
606
2
        _low_op = FILTER_LARGER_OR_EQUAL;
607
2
        _high_value = *_fixed_values.rbegin();
608
2
        _high_op = FILTER_LESS_OR_EQUAL;
609
2
        _fixed_values.clear();
610
2
    }
611
2
}
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
159k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
159k
    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
159k
    _contain_null = false;
621
622
159k
    if (is_fixed_value_range()) {
623
12.3k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
12.3k
        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.0k
        case FILTER_LARGER_OR_EQUAL: {
632
12.0k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
12.0k
            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
208
        case FILTER_LESS_OR_EQUAL: {
647
208
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
208
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
12.3k
        }
655
656
12.3k
        _high_value = TYPE_MIN;
657
12.3k
        _low_value = TYPE_MAX;
658
146k
    } else {
659
146k
        if (Compare::greater(_high_value, _low_value)) {
660
79.7k
            switch (op) {
661
31.7k
            case FILTER_LARGER: {
662
31.7k
                if (Compare::greater_equal(value, _low_value)) {
663
31.7k
                    _low_value = value;
664
31.7k
                    _low_op = op;
665
31.7k
                }
666
667
31.7k
                break;
668
0
            }
669
670
18.6k
            case FILTER_LARGER_OR_EQUAL: {
671
18.6k
                if (Compare::greater(value, _low_value)) {
672
14.8k
                    _low_value = value;
673
14.8k
                    _low_op = op;
674
14.8k
                }
675
676
18.6k
                break;
677
0
            }
678
679
6.25k
            case FILTER_LESS: {
680
6.25k
                if (Compare::less_equal(value, _high_value)) {
681
6.25k
                    _high_value = value;
682
6.25k
                    _high_op = op;
683
6.25k
                }
684
685
6.25k
                break;
686
0
            }
687
688
23.1k
            case FILTER_LESS_OR_EQUAL: {
689
23.1k
                if (Compare::less(value, _high_value)) {
690
19.3k
                    _high_value = value;
691
19.3k
                    _high_op = op;
692
19.3k
                }
693
694
23.1k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
79.7k
            }
701
79.7k
        }
702
703
146k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
146k
            Compare::equal(_high_value, _low_value)) {
705
13.2k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
13.2k
            _high_value = TYPE_MIN;
707
13.2k
            _low_value = TYPE_MAX;
708
13.2k
        }
709
146k
    }
710
711
159k
    return Status::OK();
712
159k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
3.56k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.56k
    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.56k
    _contain_null = false;
621
622
3.56k
    if (is_fixed_value_range()) {
623
320
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
320
        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
292
        case FILTER_LARGER_OR_EQUAL: {
632
292
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
292
            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
27
        case FILTER_LESS_OR_EQUAL: {
647
27
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
27
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
320
        }
655
656
317
        _high_value = TYPE_MIN;
657
317
        _low_value = TYPE_MAX;
658
3.24k
    } else {
659
3.24k
        if (Compare::greater(_high_value, _low_value)) {
660
2.66k
            switch (op) {
661
424
            case FILTER_LARGER: {
662
424
                if (Compare::greater_equal(value, _low_value)) {
663
422
                    _low_value = value;
664
422
                    _low_op = op;
665
422
                }
666
667
424
                break;
668
0
            }
669
670
773
            case FILTER_LARGER_OR_EQUAL: {
671
773
                if (Compare::greater(value, _low_value)) {
672
512
                    _low_value = value;
673
512
                    _low_op = op;
674
512
                }
675
676
773
                break;
677
0
            }
678
679
434
            case FILTER_LESS: {
680
434
                if (Compare::less_equal(value, _high_value)) {
681
433
                    _high_value = value;
682
433
                    _high_op = op;
683
433
                }
684
685
434
                break;
686
0
            }
687
688
1.03k
            case FILTER_LESS_OR_EQUAL: {
689
1.03k
                if (Compare::less(value, _high_value)) {
690
775
                    _high_value = value;
691
775
                    _high_op = op;
692
775
                }
693
694
1.03k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
2.66k
            }
701
2.66k
        }
702
703
3.23k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.23k
            Compare::equal(_high_value, _low_value)) {
705
356
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
356
            _high_value = TYPE_MIN;
707
356
            _low_value = TYPE_MAX;
708
356
        }
709
3.23k
    }
710
711
3.55k
    return Status::OK();
712
3.56k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
1.93k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.93k
    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.93k
    _contain_null = false;
621
622
1.93k
    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
9
        case FILTER_LARGER_OR_EQUAL: {
632
9
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
9
            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
8
        case FILTER_LESS_OR_EQUAL: {
647
8
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
8
            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
1.91k
    } else {
659
1.91k
        if (Compare::greater(_high_value, _low_value)) {
660
1.91k
            switch (op) {
661
1.43k
            case FILTER_LARGER: {
662
1.43k
                if (Compare::greater_equal(value, _low_value)) {
663
1.43k
                    _low_value = value;
664
1.43k
                    _low_op = op;
665
1.43k
                }
666
667
1.43k
                break;
668
0
            }
669
670
245
            case FILTER_LARGER_OR_EQUAL: {
671
245
                if (Compare::greater(value, _low_value)) {
672
209
                    _low_value = value;
673
209
                    _low_op = op;
674
209
                }
675
676
245
                break;
677
0
            }
678
679
22
            case FILTER_LESS: {
680
22
                if (Compare::less_equal(value, _high_value)) {
681
22
                    _high_value = value;
682
22
                    _high_op = op;
683
22
                }
684
685
22
                break;
686
0
            }
687
688
204
            case FILTER_LESS_OR_EQUAL: {
689
204
                if (Compare::less(value, _high_value)) {
690
156
                    _high_value = value;
691
156
                    _high_op = op;
692
156
                }
693
694
204
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.91k
            }
701
1.91k
        }
702
703
1.91k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.91k
            Compare::equal(_high_value, _low_value)) {
705
2
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
2
            _high_value = TYPE_MIN;
707
2
            _low_value = TYPE_MAX;
708
2
        }
709
1.91k
    }
710
711
1.92k
    return Status::OK();
712
1.93k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
12.2k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
12.2k
    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
12.2k
    _contain_null = false;
621
622
12.2k
    if (is_fixed_value_range()) {
623
418
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
418
        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
291
        case FILTER_LARGER_OR_EQUAL: {
632
291
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
291
            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
127
        case FILTER_LESS_OR_EQUAL: {
647
127
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
127
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
418
        }
655
656
418
        _high_value = TYPE_MIN;
657
418
        _low_value = TYPE_MAX;
658
11.8k
    } else {
659
11.8k
        if (Compare::greater(_high_value, _low_value)) {
660
11.3k
            switch (op) {
661
2.75k
            case FILTER_LARGER: {
662
2.75k
                if (Compare::greater_equal(value, _low_value)) {
663
2.74k
                    _low_value = value;
664
2.74k
                    _low_op = op;
665
2.74k
                }
666
667
2.75k
                break;
668
0
            }
669
670
3.86k
            case FILTER_LARGER_OR_EQUAL: {
671
3.86k
                if (Compare::greater(value, _low_value)) {
672
3.11k
                    _low_value = value;
673
3.11k
                    _low_op = op;
674
3.11k
                }
675
676
3.86k
                break;
677
0
            }
678
679
1.01k
            case FILTER_LESS: {
680
1.01k
                if (Compare::less_equal(value, _high_value)) {
681
1.01k
                    _high_value = value;
682
1.01k
                    _high_op = op;
683
1.01k
                }
684
685
1.01k
                break;
686
0
            }
687
688
3.77k
            case FILTER_LESS_OR_EQUAL: {
689
3.77k
                if (Compare::less(value, _high_value)) {
690
3.03k
                    _high_value = value;
691
3.03k
                    _high_op = op;
692
3.03k
                }
693
694
3.77k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
11.3k
            }
701
11.3k
        }
702
703
11.7k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
11.7k
            Compare::equal(_high_value, _low_value)) {
705
588
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
588
            _high_value = TYPE_MIN;
707
588
            _low_value = TYPE_MAX;
708
588
        }
709
11.7k
    }
710
711
12.2k
    return Status::OK();
712
12.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
107k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
107k
    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
107k
    _contain_null = false;
621
622
107k
    if (is_fixed_value_range()) {
623
11.4k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
11.4k
        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
11.4k
        case FILTER_LARGER_OR_EQUAL: {
632
11.4k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
11.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
23
        case FILTER_LESS_OR_EQUAL: {
647
23
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
23
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
11.4k
        }
655
656
11.4k
        _high_value = TYPE_MIN;
657
11.4k
        _low_value = TYPE_MAX;
658
96.3k
    } else {
659
96.3k
        if (Compare::greater(_high_value, _low_value)) {
660
30.3k
            switch (op) {
661
11.6k
            case FILTER_LARGER: {
662
11.6k
                if (Compare::greater_equal(value, _low_value)) {
663
11.6k
                    _low_value = value;
664
11.6k
                    _low_op = op;
665
11.6k
                }
666
667
11.6k
                break;
668
0
            }
669
670
4.57k
            case FILTER_LARGER_OR_EQUAL: {
671
4.57k
                if (Compare::greater(value, _low_value)) {
672
4.53k
                    _low_value = value;
673
4.53k
                    _low_op = op;
674
4.53k
                }
675
676
4.57k
                break;
677
0
            }
678
679
114
            case FILTER_LESS: {
680
114
                if (Compare::less_equal(value, _high_value)) {
681
114
                    _high_value = value;
682
114
                    _high_op = op;
683
114
                }
684
685
114
                break;
686
0
            }
687
688
14.0k
            case FILTER_LESS_OR_EQUAL: {
689
14.0k
                if (Compare::less(value, _high_value)) {
690
14.0k
                    _high_value = value;
691
14.0k
                    _high_op = op;
692
14.0k
                }
693
694
14.0k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
30.3k
            }
701
30.3k
        }
702
703
96.3k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
96.3k
            Compare::equal(_high_value, _low_value)) {
705
11.9k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
11.9k
            _high_value = TYPE_MIN;
707
11.9k
            _low_value = TYPE_MAX;
708
11.9k
        }
709
96.3k
    }
710
711
107k
    return Status::OK();
712
107k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
144
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
144
    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
144
    _contain_null = false;
621
622
144
    if (is_fixed_value_range()) {
623
2
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
2
        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
1
        case FILTER_LESS_OR_EQUAL: {
647
1
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
1
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
2
        }
655
656
2
        _high_value = TYPE_MIN;
657
2
        _low_value = TYPE_MAX;
658
142
    } else {
659
146
        if (Compare::greater(_high_value, _low_value)) {
660
146
            switch (op) {
661
47
            case FILTER_LARGER: {
662
47
                if (Compare::greater_equal(value, _low_value)) {
663
44
                    _low_value = value;
664
44
                    _low_op = op;
665
44
                }
666
667
47
                break;
668
0
            }
669
670
28
            case FILTER_LARGER_OR_EQUAL: {
671
28
                if (Compare::greater(value, _low_value)) {
672
25
                    _low_value = value;
673
25
                    _low_op = op;
674
25
                }
675
676
28
                break;
677
0
            }
678
679
23
            case FILTER_LESS: {
680
23
                if (Compare::less_equal(value, _high_value)) {
681
22
                    _high_value = value;
682
22
                    _high_op = op;
683
22
                }
684
685
23
                break;
686
0
            }
687
688
48
            case FILTER_LESS_OR_EQUAL: {
689
48
                if (Compare::less(value, _high_value)) {
690
45
                    _high_value = value;
691
45
                    _high_op = op;
692
45
                }
693
694
48
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
146
            }
701
146
        }
702
703
138
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
138
            Compare::equal(_high_value, _low_value)) {
705
8
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
8
            _high_value = TYPE_MIN;
707
8
            _low_value = TYPE_MAX;
708
8
        }
709
138
    }
710
711
140
    return Status::OK();
712
144
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
190
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
190
    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
190
    _contain_null = false;
621
622
190
    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
190
    } else {
659
190
        if (Compare::greater(_high_value, _low_value)) {
660
187
            switch (op) {
661
43
            case FILTER_LARGER: {
662
43
                if (Compare::greater_equal(value, _low_value)) {
663
41
                    _low_value = value;
664
41
                    _low_op = op;
665
41
                }
666
667
43
                break;
668
0
            }
669
670
60
            case FILTER_LARGER_OR_EQUAL: {
671
60
                if (Compare::greater(value, _low_value)) {
672
44
                    _low_value = value;
673
44
                    _low_op = op;
674
44
                }
675
676
60
                break;
677
0
            }
678
679
30
            case FILTER_LESS: {
680
30
                if (Compare::less_equal(value, _high_value)) {
681
30
                    _high_value = value;
682
30
                    _high_op = op;
683
30
                }
684
685
30
                break;
686
0
            }
687
688
55
            case FILTER_LESS_OR_EQUAL: {
689
55
                if (Compare::less(value, _high_value)) {
690
38
                    _high_value = value;
691
38
                    _high_op = op;
692
38
                }
693
694
55
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
187
            }
701
187
        }
702
703
188
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
188
            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
188
    }
710
711
188
    return Status::OK();
712
190
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
442
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
442
    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
442
    _contain_null = false;
621
622
442
    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
442
    } else {
659
443
        if (Compare::greater(_high_value, _low_value)) {
660
443
            switch (op) {
661
187
            case FILTER_LARGER: {
662
187
                if (Compare::greater_equal(value, _low_value)) {
663
187
                    _low_value = value;
664
187
                    _low_op = op;
665
187
                }
666
667
187
                break;
668
0
            }
669
670
102
            case FILTER_LARGER_OR_EQUAL: {
671
102
                if (Compare::greater(value, _low_value)) {
672
50
                    _low_value = value;
673
50
                    _low_op = op;
674
50
                }
675
676
102
                break;
677
0
            }
678
679
57
            case FILTER_LESS: {
680
58
                if (Compare::less_equal(value, _high_value)) {
681
58
                    _high_value = value;
682
58
                    _high_op = op;
683
58
                }
684
685
57
                break;
686
0
            }
687
688
96
            case FILTER_LESS_OR_EQUAL: {
689
96
                if (Compare::less(value, _high_value)) {
690
44
                    _high_value = value;
691
44
                    _high_op = op;
692
44
                }
693
694
96
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
443
            }
701
443
        }
702
703
441
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
441
            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
441
    }
710
711
441
    return Status::OK();
712
442
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
Line
Count
Source
614
14
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
14
    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
14
    _contain_null = false;
621
622
14
    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
14
    } else {
659
14
        if (Compare::greater(_high_value, _low_value)) {
660
14
            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
7
            case FILTER_LARGER_OR_EQUAL: {
671
7
                if (Compare::greater(value, _low_value)) {
672
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
7
                break;
677
0
            }
678
679
2
            case FILTER_LESS: {
680
2
                if (Compare::less_equal(value, _high_value)) {
681
2
                    _high_value = value;
682
2
                    _high_op = op;
683
2
                }
684
685
2
                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
14
            }
701
14
        }
702
703
14
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
14
            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
14
    }
710
711
14
    return Status::OK();
712
14
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
Line
Count
Source
614
10
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
10
    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
10
    _contain_null = false;
621
622
10
    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
10
    } else {
659
10
        if (Compare::greater(_high_value, _low_value)) {
660
10
            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
5
            case FILTER_LARGER_OR_EQUAL: {
671
5
                if (Compare::greater(value, _low_value)) {
672
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
5
                break;
677
0
            }
678
679
2
            case FILTER_LESS: {
680
2
                if (Compare::less_equal(value, _high_value)) {
681
2
                    _high_value = value;
682
2
                    _high_op = op;
683
2
                }
684
685
2
                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
10
            }
701
10
        }
702
703
10
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
10
            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
10
    }
710
711
10
    return Status::OK();
712
10
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
961
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
961
    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
961
    _contain_null = false;
621
622
961
    if (is_fixed_value_range()) {
623
19
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
19
        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
9
        case FILTER_LARGER_OR_EQUAL: {
632
9
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
9
            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
10
        case FILTER_LESS_OR_EQUAL: {
647
10
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
10
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
19
        }
655
656
19
        _high_value = TYPE_MIN;
657
19
        _low_value = TYPE_MAX;
658
942
    } else {
659
945
        if (Compare::greater(_high_value, _low_value)) {
660
945
            switch (op) {
661
787
            case FILTER_LARGER: {
662
787
                if (Compare::greater_equal(value, _low_value)) {
663
777
                    _low_value = value;
664
777
                    _low_op = op;
665
777
                }
666
667
787
                break;
668
0
            }
669
670
54
            case FILTER_LARGER_OR_EQUAL: {
671
54
                if (Compare::greater(value, _low_value)) {
672
31
                    _low_value = value;
673
31
                    _low_op = op;
674
31
                }
675
676
54
                break;
677
0
            }
678
679
40
            case FILTER_LESS: {
680
40
                if (Compare::less_equal(value, _high_value)) {
681
40
                    _high_value = value;
682
40
                    _high_op = op;
683
40
                }
684
685
40
                break;
686
0
            }
687
688
55
            case FILTER_LESS_OR_EQUAL: {
689
55
                if (Compare::less(value, _high_value)) {
690
38
                    _high_value = value;
691
38
                    _high_op = op;
692
38
                }
693
694
55
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
945
            }
701
945
        }
702
703
923
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
923
            Compare::equal(_high_value, _low_value)) {
705
4
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
4
            _high_value = TYPE_MIN;
707
4
            _low_value = TYPE_MAX;
708
4
        }
709
923
    }
710
711
942
    return Status::OK();
712
961
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.60k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.60k
    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.60k
    _contain_null = false;
621
622
1.60k
    if (is_fixed_value_range()) {
623
33
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
33
        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
30
        case FILTER_LARGER_OR_EQUAL: {
632
30
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
30
            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
33
        }
655
656
33
        _high_value = TYPE_MIN;
657
33
        _low_value = TYPE_MAX;
658
1.57k
    } else {
659
1.57k
        if (Compare::greater(_high_value, _low_value)) {
660
1.53k
            switch (op) {
661
937
            case FILTER_LARGER: {
662
937
                if (Compare::greater_equal(value, _low_value)) {
663
937
                    _low_value = value;
664
937
                    _low_op = op;
665
937
                }
666
667
937
                break;
668
0
            }
669
670
242
            case FILTER_LARGER_OR_EQUAL: {
671
242
                if (Compare::greater(value, _low_value)) {
672
163
                    _low_value = value;
673
163
                    _low_op = op;
674
163
                }
675
676
242
                break;
677
0
            }
678
679
94
            case FILTER_LESS: {
680
94
                if (Compare::less_equal(value, _high_value)) {
681
92
                    _high_value = value;
682
92
                    _high_op = op;
683
92
                }
684
685
94
                break;
686
0
            }
687
688
266
            case FILTER_LESS_OR_EQUAL: {
689
266
                if (Compare::less(value, _high_value)) {
690
198
                    _high_value = value;
691
198
                    _high_op = op;
692
198
                }
693
694
266
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.53k
            }
701
1.53k
        }
702
703
1.56k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.56k
            Compare::equal(_high_value, _low_value)) {
705
65
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
65
            _high_value = TYPE_MIN;
707
65
            _low_value = TYPE_MAX;
708
65
        }
709
1.56k
    }
710
711
1.60k
    return Status::OK();
712
1.60k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
4.45k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
4.45k
    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.45k
    _contain_null = false;
621
622
4.45k
    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.45k
    } else {
659
4.45k
        if (Compare::greater(_high_value, _low_value)) {
660
4.44k
            switch (op) {
661
55
            case FILTER_LARGER: {
662
55
                if (Compare::greater_equal(value, _low_value)) {
663
54
                    _low_value = value;
664
54
                    _low_op = op;
665
54
                }
666
667
55
                break;
668
0
            }
669
670
2.16k
            case FILTER_LARGER_OR_EQUAL: {
671
2.16k
                if (Compare::greater(value, _low_value)) {
672
104
                    _low_value = value;
673
104
                    _low_op = op;
674
104
                }
675
676
2.16k
                break;
677
0
            }
678
679
74
            case FILTER_LESS: {
680
76
                if (Compare::less_equal(value, _high_value)) {
681
76
                    _high_value = value;
682
76
                    _high_op = op;
683
76
                }
684
685
74
                break;
686
0
            }
687
688
2.17k
            case FILTER_LESS_OR_EQUAL: {
689
2.17k
                if (Compare::less(value, _high_value)) {
690
111
                    _high_value = value;
691
111
                    _high_op = op;
692
111
                }
693
694
2.17k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
4.44k
            }
701
4.44k
        }
702
703
4.46k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
4.46k
            Compare::equal(_high_value, _low_value)) {
705
48
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
48
            _high_value = TYPE_MIN;
707
48
            _low_value = TYPE_MAX;
708
48
        }
709
4.46k
    }
710
711
4.46k
    return Status::OK();
712
4.45k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
Line
Count
Source
614
6
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
6
    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
6
    _contain_null = false;
621
622
6
    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
6
    } else {
659
6
        if (Compare::greater(_high_value, _low_value)) {
660
6
            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
3
            case FILTER_LARGER_OR_EQUAL: {
671
3
                if (Compare::greater(value, _low_value)) {
672
3
                    _low_value = value;
673
3
                    _low_op = op;
674
3
                }
675
676
3
                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
3
            case FILTER_LESS_OR_EQUAL: {
689
3
                if (Compare::less(value, _high_value)) {
690
3
                    _high_value = value;
691
3
                    _high_op = op;
692
3
                }
693
694
3
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
6
            }
701
6
        }
702
703
6
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
6
            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
6
    }
710
711
6
    return Status::OK();
712
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
20.1k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
20.1k
    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.1k
    _contain_null = false;
621
622
20.1k
    if (is_fixed_value_range()) {
623
24
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
24
        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
17
        case FILTER_LARGER_OR_EQUAL: {
632
17
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
17
            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
7
        case FILTER_LESS_OR_EQUAL: {
647
7
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
7
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
24
        }
655
656
24
        _high_value = TYPE_MIN;
657
24
        _low_value = TYPE_MAX;
658
20.1k
    } else {
659
20.1k
        if (Compare::greater(_high_value, _low_value)) {
660
20.1k
            switch (op) {
661
12.8k
            case FILTER_LARGER: {
662
12.8k
                if (Compare::greater_equal(value, _low_value)) {
663
12.8k
                    _low_value = value;
664
12.8k
                    _low_op = op;
665
12.8k
                }
666
667
12.8k
                break;
668
0
            }
669
670
4.15k
            case FILTER_LARGER_OR_EQUAL: {
671
4.15k
                if (Compare::greater(value, _low_value)) {
672
4.12k
                    _low_value = value;
673
4.12k
                    _low_op = op;
674
4.12k
                }
675
676
4.15k
                break;
677
0
            }
678
679
2.68k
            case FILTER_LESS: {
680
2.68k
                if (Compare::less_equal(value, _high_value)) {
681
2.68k
                    _high_value = value;
682
2.68k
                    _high_op = op;
683
2.68k
                }
684
685
2.68k
                break;
686
0
            }
687
688
432
            case FILTER_LESS_OR_EQUAL: {
689
432
                if (Compare::less(value, _high_value)) {
690
399
                    _high_value = value;
691
399
                    _high_op = op;
692
399
                }
693
694
432
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
20.1k
            }
701
20.1k
        }
702
703
20.1k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
20.1k
            Compare::equal(_high_value, _low_value)) {
705
69
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
69
            _high_value = TYPE_MIN;
707
69
            _low_value = TYPE_MAX;
708
69
        }
709
20.1k
    }
710
711
20.1k
    return Status::OK();
712
20.1k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.67k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.67k
    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.67k
    _contain_null = false;
621
622
3.67k
    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.67k
    } else {
659
3.67k
        if (Compare::greater(_high_value, _low_value)) {
660
3.66k
            switch (op) {
661
241
            case FILTER_LARGER: {
662
241
                if (Compare::greater_equal(value, _low_value)) {
663
238
                    _low_value = value;
664
238
                    _low_op = op;
665
238
                }
666
667
241
                break;
668
0
            }
669
670
1.68k
            case FILTER_LARGER_OR_EQUAL: {
671
1.68k
                if (Compare::greater(value, _low_value)) {
672
1.63k
                    _low_value = value;
673
1.63k
                    _low_op = op;
674
1.63k
                }
675
676
1.68k
                break;
677
0
            }
678
679
1.49k
            case FILTER_LESS: {
680
1.49k
                if (Compare::less_equal(value, _high_value)) {
681
1.49k
                    _high_value = value;
682
1.49k
                    _high_op = op;
683
1.49k
                }
684
685
1.49k
                break;
686
0
            }
687
688
246
            case FILTER_LESS_OR_EQUAL: {
689
246
                if (Compare::less(value, _high_value)) {
690
202
                    _high_value = value;
691
202
                    _high_op = op;
692
202
                }
693
694
246
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.66k
            }
701
3.66k
        }
702
703
3.67k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.67k
            Compare::equal(_high_value, _low_value)) {
705
65
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
65
            _high_value = TYPE_MIN;
707
65
            _low_value = TYPE_MAX;
708
65
        }
709
3.67k
    }
710
711
3.67k
    return Status::OK();
712
3.67k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
352
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
352
    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
352
    _contain_null = false;
621
622
352
    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
352
    } else {
659
352
        if (Compare::greater(_high_value, _low_value)) {
660
351
            switch (op) {
661
85
            case FILTER_LARGER: {
662
86
                if (Compare::greater_equal(value, _low_value)) {
663
86
                    _low_value = value;
664
86
                    _low_op = op;
665
86
                }
666
667
85
                break;
668
0
            }
669
670
106
            case FILTER_LARGER_OR_EQUAL: {
671
106
                if (Compare::greater(value, _low_value)) {
672
51
                    _low_value = value;
673
51
                    _low_op = op;
674
51
                }
675
676
106
                break;
677
0
            }
678
679
56
            case FILTER_LESS: {
680
56
                if (Compare::less_equal(value, _high_value)) {
681
55
                    _high_value = value;
682
55
                    _high_op = op;
683
55
                }
684
685
56
                break;
686
0
            }
687
688
106
            case FILTER_LESS_OR_EQUAL: {
689
106
                if (Compare::less(value, _high_value)) {
690
81
                    _high_value = value;
691
81
                    _high_op = op;
692
81
                }
693
694
106
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
351
            }
701
351
        }
702
703
351
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
351
            Compare::equal(_high_value, _low_value)) {
705
28
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
28
            _high_value = TYPE_MIN;
707
28
            _low_value = TYPE_MAX;
708
28
        }
709
351
    }
710
711
351
    return Status::OK();
712
352
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Line
Count
Source
614
70
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
70
    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
70
    _contain_null = false;
621
622
70
    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
69
    } else {
659
69
        if (Compare::greater(_high_value, _low_value)) {
660
69
            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
35
            case FILTER_LESS_OR_EQUAL: {
689
35
                if (Compare::less(value, _high_value)) {
690
1
                    _high_value = value;
691
1
                    _high_op = op;
692
1
                }
693
694
35
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
69
            }
701
69
        }
702
703
69
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
69
            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
69
    }
710
711
70
    return Status::OK();
712
70
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
195
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
195
    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
195
    _contain_null = false;
621
622
195
    if (is_fixed_value_range()) {
623
3
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
3
        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
2
        case FILTER_LESS_OR_EQUAL: {
647
2
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
2
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
3
        }
655
656
3
        _high_value = TYPE_MIN;
657
3
        _low_value = TYPE_MAX;
658
192
    } else {
659
193
        if (Compare::greater(_high_value, _low_value)) {
660
193
            switch (op) {
661
20
            case FILTER_LARGER: {
662
20
                if (Compare::greater_equal(value, _low_value)) {
663
20
                    _low_value = value;
664
20
                    _low_op = op;
665
20
                }
666
667
20
                break;
668
0
            }
669
670
68
            case FILTER_LARGER_OR_EQUAL: {
671
68
                if (Compare::greater(value, _low_value)) {
672
43
                    _low_value = value;
673
43
                    _low_op = op;
674
43
                }
675
676
68
                break;
677
0
            }
678
679
39
            case FILTER_LESS: {
680
39
                if (Compare::less_equal(value, _high_value)) {
681
38
                    _high_value = value;
682
38
                    _high_op = op;
683
38
                }
684
685
39
                break;
686
0
            }
687
688
65
            case FILTER_LESS_OR_EQUAL: {
689
65
                if (Compare::less(value, _high_value)) {
690
41
                    _high_value = value;
691
41
                    _high_op = op;
692
41
                }
693
694
65
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
193
            }
701
193
        }
702
703
190
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
190
            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
190
    }
710
711
193
    return Status::OK();
712
195
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
976
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
976
    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
976
    _contain_null = false;
621
622
976
    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
976
    } else {
659
976
        if (Compare::greater(_high_value, _low_value)) {
660
974
            switch (op) {
661
162
            case FILTER_LARGER: {
662
162
                if (Compare::greater_equal(value, _low_value)) {
663
160
                    _low_value = value;
664
160
                    _low_op = op;
665
160
                }
666
667
162
                break;
668
0
            }
669
670
381
            case FILTER_LARGER_OR_EQUAL: {
671
381
                if (Compare::greater(value, _low_value)) {
672
125
                    _low_value = value;
673
125
                    _low_op = op;
674
125
                }
675
676
381
                break;
677
0
            }
678
679
52
            case FILTER_LESS: {
680
52
                if (Compare::less_equal(value, _high_value)) {
681
52
                    _high_value = value;
682
52
                    _high_op = op;
683
52
                }
684
685
52
                break;
686
0
            }
687
688
379
            case FILTER_LESS_OR_EQUAL: {
689
379
                if (Compare::less(value, _high_value)) {
690
123
                    _high_value = value;
691
123
                    _high_op = op;
692
123
                }
693
694
379
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
974
            }
701
974
        }
702
703
974
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
974
            Compare::equal(_high_value, _low_value)) {
705
52
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
52
            _high_value = TYPE_MIN;
707
52
            _low_value = TYPE_MAX;
708
52
        }
709
974
    }
710
711
974
    return Status::OK();
712
976
}
_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
99
            case FILTER_LARGER: {
662
99
                if (Compare::greater_equal(value, _low_value)) {
663
99
                    _low_value = value;
664
99
                    _low_op = op;
665
99
                }
666
667
99
                break;
668
0
            }
669
670
28
            case FILTER_LARGER_OR_EQUAL: {
671
28
                if (Compare::greater(value, _low_value)) {
672
19
                    _low_value = value;
673
19
                    _low_op = op;
674
19
                }
675
676
28
                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
22
            case FILTER_LESS_OR_EQUAL: {
689
22
                if (Compare::less(value, _high_value)) {
690
15
                    _high_value = value;
691
15
                    _high_op = op;
692
15
                }
693
694
22
                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
161
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
161
            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
161
    }
710
711
161
    return Status::OK();
712
162
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9add_rangeENS_11SQLFilterOpENS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
614
72
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
72
    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
72
    _contain_null = false;
621
622
72
    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
72
    } else {
659
72
        if (Compare::greater(_high_value, _low_value)) {
660
72
            switch (op) {
661
18
            case FILTER_LARGER: {
662
18
                if (Compare::greater_equal(value, _low_value)) {
663
17
                    _low_value = value;
664
17
                    _low_op = op;
665
17
                }
666
667
18
                break;
668
0
            }
669
670
20
            case FILTER_LARGER_OR_EQUAL: {
671
20
                if (Compare::greater(value, _low_value)) {
672
13
                    _low_value = value;
673
13
                    _low_op = op;
674
13
                }
675
676
20
                break;
677
0
            }
678
679
15
            case FILTER_LESS: {
680
15
                if (Compare::less_equal(value, _high_value)) {
681
15
                    _high_value = value;
682
15
                    _high_op = op;
683
15
                }
684
685
15
                break;
686
0
            }
687
688
20
            case FILTER_LESS_OR_EQUAL: {
689
20
                if (Compare::less(value, _high_value)) {
690
13
                    _high_value = value;
691
13
                    _high_op = op;
692
13
                }
693
694
20
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
72
            }
701
72
        }
702
703
73
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
73
            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
73
    }
710
711
73
    return Status::OK();
712
72
}
713
714
template <PrimitiveType primitive_type>
715
499k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
499k
    switch (_high_op) {
717
75
    case FILTER_LESS: {
718
75
        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
75
        case FILTER_LARGER_OR_EQUAL: {
724
75
            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
75
        }
731
732
0
        break;
733
75
    }
734
735
499k
    case FILTER_LESS_OR_EQUAL: {
736
499k
        switch (_low_op) {
737
1.00k
        case FILTER_LARGER: {
738
1.00k
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
498k
        case FILTER_LARGER_OR_EQUAL: {
742
498k
            return Compare::less_equal(value, _high_value) &&
743
499k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
499k
        }
750
499k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
499k
    }
756
757
0
    return false;
758
499k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
121k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
121k
    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
121k
    case FILTER_LESS_OR_EQUAL: {
736
121k
        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
121k
        case FILTER_LARGER_OR_EQUAL: {
742
121k
            return Compare::less_equal(value, _high_value) &&
743
121k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
121k
        }
750
121k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
121k
    }
756
757
0
    return false;
758
121k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
145
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
145
    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
145
    case FILTER_LESS_OR_EQUAL: {
736
145
        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
145
        case FILTER_LARGER_OR_EQUAL: {
742
145
            return Compare::less_equal(value, _high_value) &&
743
145
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
145
        }
750
145
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
145
    }
756
757
0
    return false;
758
145
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
67.4k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
67.4k
    switch (_high_op) {
717
66
    case FILTER_LESS: {
718
66
        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
66
        case FILTER_LARGER_OR_EQUAL: {
724
66
            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
66
        }
731
732
0
        break;
733
66
    }
734
735
67.3k
    case FILTER_LESS_OR_EQUAL: {
736
67.3k
        switch (_low_op) {
737
396
        case FILTER_LARGER: {
738
396
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
66.9k
        case FILTER_LARGER_OR_EQUAL: {
742
66.9k
            return Compare::less_equal(value, _high_value) &&
743
67.1k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
67.3k
        }
750
67.3k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
67.4k
    }
756
757
0
    return false;
758
67.4k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
2.97k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
2.97k
    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
2.97k
    case FILTER_LESS_OR_EQUAL: {
736
2.97k
        switch (_low_op) {
737
599
        case FILTER_LARGER: {
738
599
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
2.37k
        case FILTER_LARGER_OR_EQUAL: {
742
2.37k
            return Compare::less_equal(value, _high_value) &&
743
2.37k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
2.97k
        }
750
2.97k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
2.97k
    }
756
757
0
    return false;
758
2.97k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
186
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
186
    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
186
    case FILTER_LESS_OR_EQUAL: {
736
186
        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
186
        case FILTER_LARGER_OR_EQUAL: {
742
186
            return Compare::less_equal(value, _high_value) &&
743
186
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
186
        }
750
186
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
186
    }
756
757
0
    return false;
758
186
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE11is_in_rangeERKf
Line
Count
Source
715
44
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
44
    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
44
    case FILTER_LESS_OR_EQUAL: {
736
44
        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
44
        case FILTER_LARGER_OR_EQUAL: {
742
44
            return Compare::less_equal(value, _high_value) &&
743
44
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
44
        }
750
44
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
44
    }
756
757
0
    return false;
758
44
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE11is_in_rangeERKd
Line
Count
Source
715
161
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
161
    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
162
    case FILTER_LESS_OR_EQUAL: {
736
162
        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
161
        case FILTER_LARGER_OR_EQUAL: {
742
161
            return Compare::less_equal(value, _high_value) &&
743
162
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
162
        }
750
162
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
161
    }
756
757
0
    return false;
758
161
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE11is_in_rangeERKj
Line
Count
Source
715
23
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
23
    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
23
    case FILTER_LESS_OR_EQUAL: {
736
23
        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
23
        case FILTER_LARGER_OR_EQUAL: {
742
23
            return Compare::less_equal(value, _high_value) &&
743
23
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
23
        }
750
23
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
23
    }
756
757
0
    return false;
758
23
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE11is_in_rangeERKo
Line
Count
Source
715
24
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
24
    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
24
    case FILTER_LESS_OR_EQUAL: {
736
24
        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
24
        case FILTER_LARGER_OR_EQUAL: {
742
24
            return Compare::less_equal(value, _high_value) &&
743
24
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
24
        }
750
24
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
24
    }
756
757
0
    return false;
758
24
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
635
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
635
    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
636
    case FILTER_LESS_OR_EQUAL: {
736
636
        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
637
        case FILTER_LARGER_OR_EQUAL: {
742
637
            return Compare::less_equal(value, _high_value) &&
743
640
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
636
        }
750
636
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
635
    }
756
757
0
    return false;
758
635
}
_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
294k
                   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.55k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.55k
    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.55k
    case FILTER_LESS_OR_EQUAL: {
736
1.55k
        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.55k
        case FILTER_LARGER_OR_EQUAL: {
742
1.55k
            return Compare::less_equal(value, _high_value) &&
743
1.55k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.55k
        }
750
1.55k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.55k
    }
756
757
0
    return false;
758
1.55k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
63
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
63
    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
63
    case FILTER_LESS_OR_EQUAL: {
736
63
        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
63
        case FILTER_LARGER_OR_EQUAL: {
742
63
            return Compare::less_equal(value, _high_value) &&
743
64
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
63
        }
750
63
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
63
    }
756
757
0
    return false;
758
63
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
9.37k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
9.37k
    switch (_high_op) {
717
5
    case FILTER_LESS: {
718
5
        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
5
        case FILTER_LARGER_OR_EQUAL: {
724
5
            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
5
        }
731
732
0
        break;
733
5
    }
734
735
9.36k
    case FILTER_LESS_OR_EQUAL: {
736
9.36k
        switch (_low_op) {
737
9
        case FILTER_LARGER: {
738
9
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
9.35k
        case FILTER_LARGER_OR_EQUAL: {
742
9.35k
            return Compare::less_equal(value, _high_value) &&
743
9.35k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
9.36k
        }
750
9.36k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
9.37k
    }
756
757
0
    return false;
758
9.37k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
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
57
    case FILTER_LESS_OR_EQUAL: {
736
57
        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
57
        case FILTER_LARGER_OR_EQUAL: {
742
57
            return Compare::less_equal(value, _high_value) &&
743
57
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
57
        }
750
57
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
57
    }
756
757
0
    return false;
758
57
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
531
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
531
    switch (_high_op) {
717
4
    case FILTER_LESS: {
718
4
        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
4
        case FILTER_LARGER_OR_EQUAL: {
724
4
            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
4
        }
731
732
0
        break;
733
4
    }
734
735
531
    case FILTER_LESS_OR_EQUAL: {
736
531
        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
535
        case FILTER_LARGER_OR_EQUAL: {
742
535
            return Compare::less_equal(value, _high_value) &&
743
535
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
531
        }
750
531
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
531
    }
756
757
0
    return false;
758
531
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
154
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
154
    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
154
    case FILTER_LESS_OR_EQUAL: {
736
154
        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
154
        case FILTER_LARGER_OR_EQUAL: {
742
154
            return Compare::less_equal(value, _high_value) &&
743
154
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
154
        }
750
154
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
154
    }
756
757
0
    return false;
758
154
}
_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
385
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
385
    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
385
    case FILTER_LESS_OR_EQUAL: {
736
385
        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
385
        case FILTER_LARGER_OR_EQUAL: {
742
385
            return Compare::less_equal(value, _high_value) &&
743
385
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
385
        }
750
385
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
385
    }
756
757
0
    return false;
758
385
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
71
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
71
    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
71
    case FILTER_LESS_OR_EQUAL: {
736
71
        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
71
        case FILTER_LARGER_OR_EQUAL: {
742
71
            return Compare::less_equal(value, _high_value) &&
743
71
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
71
        }
750
71
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
71
    }
756
757
0
    return false;
758
71
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE11is_in_rangeERKNS_7DecimalIlEE
Line
Count
Source
715
355
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
355
    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
355
    case FILTER_LESS_OR_EQUAL: {
736
355
        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
355
        case FILTER_LARGER_OR_EQUAL: {
742
355
            return Compare::less_equal(value, _high_value) &&
743
355
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
355
        }
750
355
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
355
    }
756
757
0
    return false;
758
355
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE11is_in_rangeERKNS_12Decimal128V3E
Line
Count
Source
715
219
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
219
    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
219
    case FILTER_LESS_OR_EQUAL: {
736
219
        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
219
        case FILTER_LARGER_OR_EQUAL: {
742
219
            return Compare::less_equal(value, _high_value) &&
743
219
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
219
        }
750
219
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
219
    }
756
757
0
    return false;
758
219
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE11is_in_rangeERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
715
42
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
42
    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
42
    case FILTER_LESS_OR_EQUAL: {
736
42
        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
42
        case FILTER_LARGER_OR_EQUAL: {
742
42
            return Compare::less_equal(value, _high_value) &&
743
42
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
42
        }
750
42
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
42
    }
756
757
0
    return false;
758
42
}
759
760
template <PrimitiveType primitive_type>
761
466k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
466k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
466k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
25.4k
        set_empty_value_range();
770
25.4k
    }
771
772
466k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
466k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
433k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
401
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
401
                             range._fixed_values.begin(), range._fixed_values.end(),
778
401
                             std::inserter(result_values, result_values.begin()));
779
433k
        } 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
433k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
433k
            IteratorType iter = range._fixed_values.begin();
790
931k
            while (iter != range._fixed_values.end()) {
791
499k
                if (this->is_in_range(*iter)) {
792
499k
                    result_values.insert(*iter);
793
499k
                }
794
498k
                ++iter;
795
498k
            }
796
433k
        }
797
798
436k
        if (!result_values.empty()) {
799
436k
            _fixed_values = std::move(result_values);
800
436k
            _contain_null = false;
801
436k
            _high_value = TYPE_MIN;
802
436k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
433k
    } else {
807
32.6k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
982
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
982
                set_contain_null(true);
811
982
            }
812
31.6k
        } else {
813
31.6k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
31.6k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
31.6k
        }
816
32.6k
    }
817
466k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
122k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
122k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
122k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
278
        set_empty_value_range();
770
278
    }
771
772
122k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
122k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
120k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
1
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
1
                             range._fixed_values.begin(), range._fixed_values.end(),
778
1
                             std::inserter(result_values, result_values.begin()));
779
120k
        } 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
120k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
120k
            IteratorType iter = range._fixed_values.begin();
790
240k
            while (iter != range._fixed_values.end()) {
791
120k
                if (this->is_in_range(*iter)) {
792
120k
                    result_values.insert(*iter);
793
120k
                }
794
120k
                ++iter;
795
120k
            }
796
120k
        }
797
798
121k
        if (!result_values.empty()) {
799
121k
            _fixed_values = std::move(result_values);
800
121k
            _contain_null = false;
801
121k
            _high_value = TYPE_MIN;
802
121k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
120k
    } else {
807
1.81k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
30
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
30
                set_contain_null(true);
811
30
            }
812
1.79k
        } else {
813
1.79k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.79k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.79k
        }
816
1.81k
    }
817
122k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
Line
Count
Source
761
174
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
174
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
174
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
174
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
174
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
105
        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
105
        } 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
105
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
105
            IteratorType iter = range._fixed_values.begin();
790
250
            while (iter != range._fixed_values.end()) {
791
145
                if (this->is_in_range(*iter)) {
792
145
                    result_values.insert(*iter);
793
145
                }
794
145
                ++iter;
795
145
            }
796
105
        }
797
798
105
        if (!result_values.empty()) {
799
105
            _fixed_values = std::move(result_values);
800
105
            _contain_null = false;
801
105
            _high_value = TYPE_MIN;
802
105
            _low_value = TYPE_MAX;
803
105
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
105
    } else {
807
69
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
33
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
33
                set_contain_null(true);
811
33
            }
812
36
        } else {
813
36
            static_cast<void>(add_range(range._high_op, range._high_value));
814
36
            static_cast<void>(add_range(range._low_op, range._low_value));
815
36
        }
816
69
    }
817
174
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
7.87k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
7.87k
    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.87k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
154
        set_empty_value_range();
770
154
    }
771
772
7.87k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
7.87k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
6.74k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
119
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
119
                             range._fixed_values.begin(), range._fixed_values.end(),
778
119
                             std::inserter(result_values, result_values.begin()));
779
6.62k
        } 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
6.62k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
6.62k
            IteratorType iter = range._fixed_values.begin();
790
74.7k
            while (iter != range._fixed_values.end()) {
791
68.1k
                if (this->is_in_range(*iter)) {
792
67.4k
                    result_values.insert(*iter);
793
67.4k
                }
794
68.1k
                ++iter;
795
68.1k
            }
796
6.62k
        }
797
798
6.79k
        if (!result_values.empty()) {
799
6.79k
            _fixed_values = std::move(result_values);
800
6.79k
            _contain_null = false;
801
6.79k
            _high_value = TYPE_MIN;
802
6.79k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
6.74k
    } else {
807
1.13k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
226
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
226
                set_contain_null(true);
811
226
            }
812
908
        } else {
813
908
            static_cast<void>(add_range(range._high_op, range._high_value));
814
908
            static_cast<void>(add_range(range._low_op, range._low_value));
815
908
        }
816
1.13k
    }
817
7.87k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
26.5k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
26.5k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
26.5k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
25.0k
        set_empty_value_range();
770
25.0k
    }
771
772
26.5k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
26.5k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.45k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
61
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
61
                             range._fixed_values.begin(), range._fixed_values.end(),
778
61
                             std::inserter(result_values, result_values.begin()));
779
1.39k
        } 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.39k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.38k
            IteratorType iter = range._fixed_values.begin();
790
4.34k
            while (iter != range._fixed_values.end()) {
791
2.95k
                if (this->is_in_range(*iter)) {
792
2.94k
                    result_values.insert(*iter);
793
2.94k
                }
794
2.95k
                ++iter;
795
2.95k
            }
796
1.38k
        }
797
798
1.45k
        if (!result_values.empty()) {
799
1.45k
            _fixed_values = std::move(result_values);
800
1.45k
            _contain_null = false;
801
1.45k
            _high_value = TYPE_MIN;
802
1.45k
            _low_value = TYPE_MAX;
803
1.45k
        } else {
804
6
            set_empty_value_range();
805
6
        }
806
25.0k
    } else {
807
25.0k
        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
25.0k
        } else {
813
25.0k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
25.0k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
25.0k
        }
816
25.0k
    }
817
26.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
193
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
193
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
193
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
193
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
193
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
183
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
1
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
1
                             range._fixed_values.begin(), range._fixed_values.end(),
778
1
                             std::inserter(result_values, result_values.begin()));
779
182
        } 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
182
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
182
            IteratorType iter = range._fixed_values.begin();
790
368
            while (iter != range._fixed_values.end()) {
791
186
                if (this->is_in_range(*iter)) {
792
185
                    result_values.insert(*iter);
793
185
                }
794
186
                ++iter;
795
186
            }
796
182
        }
797
798
183
        if (!result_values.empty()) {
799
183
            _fixed_values = std::move(result_values);
800
183
            _contain_null = false;
801
183
            _high_value = TYPE_MIN;
802
183
            _low_value = TYPE_MAX;
803
183
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
183
    } 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
193
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
108
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
108
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
109
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
108
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
108
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
50
        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
34
        } 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
34
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
34
            IteratorType iter = range._fixed_values.begin();
790
78
            while (iter != range._fixed_values.end()) {
791
44
                if (this->is_in_range(*iter)) {
792
44
                    result_values.insert(*iter);
793
44
                }
794
44
                ++iter;
795
44
            }
796
34
        }
797
798
50
        if (!result_values.empty()) {
799
50
            _fixed_values = std::move(result_values);
800
50
            _contain_null = false;
801
50
            _high_value = TYPE_MIN;
802
50
            _low_value = TYPE_MAX;
803
50
        } 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
41
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
41
                set_contain_null(true);
811
41
            }
812
39
        } else {
813
19
            static_cast<void>(add_range(range._high_op, range._high_value));
814
19
            static_cast<void>(add_range(range._low_op, range._low_value));
815
19
        }
816
58
    }
817
108
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
207
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
207
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
209
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
207
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
207
    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
279
            while (iter != range._fixed_values.end()) {
791
162
                if (this->is_in_range(*iter)) {
792
162
                    result_values.insert(*iter);
793
162
                }
794
161
                ++iter;
795
161
            }
796
118
        }
797
798
121
        if (!result_values.empty()) {
799
121
            _fixed_values = std::move(result_values);
800
121
            _contain_null = false;
801
121
            _high_value = TYPE_MIN;
802
121
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
118
    } else {
807
89
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
44
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
43
                set_contain_null(true);
811
43
            }
812
45
        } else {
813
45
            static_cast<void>(add_range(range._high_op, range._high_value));
814
45
            static_cast<void>(add_range(range._low_op, range._low_value));
815
45
        }
816
89
    }
817
207
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE12intersectionERS2_
Line
Count
Source
761
21
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
21
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
21
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
21
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
21
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
18
        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
18
        } 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
18
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
18
            IteratorType iter = range._fixed_values.begin();
790
41
            while (iter != range._fixed_values.end()) {
791
23
                if (this->is_in_range(*iter)) {
792
23
                    result_values.insert(*iter);
793
23
                }
794
23
                ++iter;
795
23
            }
796
18
        }
797
798
18
        if (!result_values.empty()) {
799
18
            _fixed_values = std::move(result_values);
800
18
            _contain_null = false;
801
18
            _high_value = TYPE_MIN;
802
18
            _low_value = TYPE_MAX;
803
18
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
18
    } else {
807
3
        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
3
        } 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
3
    }
817
21
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE12intersectionERS2_
Line
Count
Source
761
20
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
20
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
20
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
20
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
20
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
19
        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
19
        } 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
19
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
19
            IteratorType iter = range._fixed_values.begin();
790
43
            while (iter != range._fixed_values.end()) {
791
24
                if (this->is_in_range(*iter)) {
792
24
                    result_values.insert(*iter);
793
24
                }
794
24
                ++iter;
795
24
            }
796
19
        }
797
798
19
        if (!result_values.empty()) {
799
19
            _fixed_values = std::move(result_values);
800
19
            _contain_null = false;
801
19
            _high_value = TYPE_MIN;
802
19
            _low_value = TYPE_MAX;
803
19
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
19
    } 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
20
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
530
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
530
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
531
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
530
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
530
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
474
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
2
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
2
                             range._fixed_values.begin(), range._fixed_values.end(),
778
2
                             std::inserter(result_values, result_values.begin()));
779
472
        } 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
473
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
473
            IteratorType iter = range._fixed_values.begin();
790
1.11k
            while (iter != range._fixed_values.end()) {
791
638
                if (this->is_in_range(*iter)) {
792
637
                    result_values.insert(*iter);
793
637
                }
794
638
                ++iter;
795
638
            }
796
473
        }
797
798
476
        if (!result_values.empty()) {
799
476
            _fixed_values = std::move(result_values);
800
476
            _contain_null = false;
801
476
            _high_value = TYPE_MIN;
802
476
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
474
    } else {
807
56
        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
22
            static_cast<void>(add_range(range._high_op, range._high_value));
814
22
            static_cast<void>(add_range(range._low_op, range._low_value));
815
22
        }
816
56
    }
817
530
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
293k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
293k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
293k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
9
        set_empty_value_range();
770
9
    }
771
772
293k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
293k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
292k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
22
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
22
                             range._fixed_values.begin(), range._fixed_values.end(),
778
22
                             std::inserter(result_values, result_values.begin()));
779
292k
        } 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
292k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
292k
            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
292k
        }
797
798
293k
        if (!result_values.empty()) {
799
293k
            _fixed_values = std::move(result_values);
800
293k
            _contain_null = false;
801
293k
            _high_value = TYPE_MIN;
802
293k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
292k
    } else {
807
1.48k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
181
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
181
                set_contain_null(true);
811
181
            }
812
1.30k
        } else {
813
1.30k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.30k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.30k
        }
816
1.48k
    }
817
293k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
3.57k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
3.57k
    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.62k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
3.57k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
3.57k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.37k
        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.33k
        } 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.33k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.32k
            IteratorType iter = range._fixed_values.begin();
790
2.87k
            while (iter != range._fixed_values.end()) {
791
1.56k
                if (this->is_in_range(*iter)) {
792
1.56k
                    result_values.insert(*iter);
793
1.56k
                }
794
1.54k
                ++iter;
795
1.54k
            }
796
1.32k
        }
797
798
1.38k
        if (!result_values.empty()) {
799
1.38k
            _fixed_values = std::move(result_values);
800
1.38k
            _contain_null = false;
801
1.38k
            _high_value = TYPE_MIN;
802
1.38k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
2.19k
    } else {
807
2.19k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
143
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
142
                set_contain_null(true);
811
142
            }
812
2.05k
        } else {
813
2.05k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2.05k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2.05k
        }
816
2.19k
    }
817
3.57k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
37
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
37
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
37
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
37
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
37
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
36
        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
36
        } 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
36
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
36
            IteratorType iter = range._fixed_values.begin();
790
99
            while (iter != range._fixed_values.end()) {
791
64
                if (this->is_in_range(*iter)) {
792
64
                    result_values.insert(*iter);
793
64
                }
794
63
                ++iter;
795
63
            }
796
36
        }
797
798
37
        if (!result_values.empty()) {
799
37
            _fixed_values = std::move(result_values);
800
37
            _contain_null = false;
801
37
            _high_value = TYPE_MIN;
802
37
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
36
    } 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
37
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
9.37k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
9.37k
    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.37k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
16
        set_empty_value_range();
770
16
    }
771
772
9.37k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
9.37k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
9.24k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
23
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
23
                             range._fixed_values.begin(), range._fixed_values.end(),
778
23
                             std::inserter(result_values, result_values.begin()));
779
9.21k
        } 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.22k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
9.22k
            IteratorType iter = range._fixed_values.begin();
790
18.5k
            while (iter != range._fixed_values.end()) {
791
9.39k
                if (this->is_in_range(*iter)) {
792
9.39k
                    result_values.insert(*iter);
793
9.39k
                }
794
9.35k
                ++iter;
795
9.35k
            }
796
9.22k
        }
797
798
9.28k
        if (!result_values.empty()) {
799
9.28k
            _fixed_values = std::move(result_values);
800
9.28k
            _contain_null = false;
801
9.28k
            _high_value = TYPE_MIN;
802
9.28k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
9.24k
    } else {
807
133
        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
61
                set_contain_null(true);
811
61
            }
812
76
        } else {
813
76
            static_cast<void>(add_range(range._high_op, range._high_value));
814
76
            static_cast<void>(add_range(range._low_op, range._low_value));
815
76
        }
816
133
    }
817
9.37k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12intersectionERS2_
Line
Count
Source
761
33
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
33
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
33
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
33
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
33
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
33
        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
33
        } 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
33
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
33
            IteratorType iter = range._fixed_values.begin();
790
90
            while (iter != range._fixed_values.end()) {
791
57
                if (this->is_in_range(*iter)) {
792
57
                    result_values.insert(*iter);
793
57
                }
794
57
                ++iter;
795
57
            }
796
33
        }
797
798
33
        if (!result_values.empty()) {
799
33
            _fixed_values = std::move(result_values);
800
33
            _contain_null = false;
801
33
            _high_value = TYPE_MIN;
802
33
            _low_value = TYPE_MAX;
803
33
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
33
    } 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
33
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12intersectionERS2_
Line
Count
Source
761
587
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
587
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
587
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
587
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
587
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
492
        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
444
        } 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
444
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
441
            IteratorType iter = range._fixed_values.begin();
790
959
            while (iter != range._fixed_values.end()) {
791
533
                if (this->is_in_range(*iter)) {
792
533
                    result_values.insert(*iter);
793
533
                }
794
518
                ++iter;
795
518
            }
796
441
        }
797
798
518
        if (!result_values.empty()) {
799
518
            _fixed_values = std::move(result_values);
800
518
            _contain_null = false;
801
518
            _high_value = TYPE_MIN;
802
518
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
492
    } else {
807
95
        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
60
        } else {
813
60
            static_cast<void>(add_range(range._high_op, range._high_value));
814
60
            static_cast<void>(add_range(range._low_op, range._low_value));
815
60
        }
816
95
    }
817
587
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
110
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
110
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
110
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
110
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
110
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
79
        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
79
        } 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
79
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
79
            IteratorType iter = range._fixed_values.begin();
790
233
            while (iter != range._fixed_values.end()) {
791
154
                if (this->is_in_range(*iter)) {
792
154
                    result_values.insert(*iter);
793
154
                }
794
154
                ++iter;
795
154
            }
796
79
        }
797
798
79
        if (!result_values.empty()) {
799
79
            _fixed_values = std::move(result_values);
800
79
            _contain_null = false;
801
79
            _high_value = TYPE_MIN;
802
79
            _low_value = TYPE_MAX;
803
79
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
79
    } else {
807
31
        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
22
        } else {
813
22
            static_cast<void>(add_range(range._high_op, range._high_value));
814
22
            static_cast<void>(add_range(range._low_op, range._low_value));
815
22
        }
816
31
    }
817
110
}
_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
433
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
433
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
433
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
433
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
433
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
387
        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
371
        } 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
372
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
372
            IteratorType iter = range._fixed_values.begin();
790
756
            while (iter != range._fixed_values.end()) {
791
385
                if (this->is_in_range(*iter)) {
792
385
                    result_values.insert(*iter);
793
385
                }
794
384
                ++iter;
795
384
            }
796
372
        }
797
798
388
        if (!result_values.empty()) {
799
388
            _fixed_values = std::move(result_values);
800
388
            _contain_null = false;
801
388
            _high_value = TYPE_MIN;
802
388
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
387
    } else {
807
46
        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
33
                set_contain_null(true);
811
33
            }
812
35
        } else {
813
11
            static_cast<void>(add_range(range._high_op, range._high_value));
814
11
            static_cast<void>(add_range(range._low_op, range._low_value));
815
11
        }
816
46
    }
817
433
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12intersectionERS2_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12intersectionERS2_
Line
Count
Source
761
85
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
85
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
85
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
85
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
85
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
57
        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
57
        } 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
57
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
57
            IteratorType iter = range._fixed_values.begin();
790
128
            while (iter != range._fixed_values.end()) {
791
71
                if (this->is_in_range(*iter)) {
792
71
                    result_values.insert(*iter);
793
71
                }
794
71
                ++iter;
795
71
            }
796
57
        }
797
798
57
        if (!result_values.empty()) {
799
57
            _fixed_values = std::move(result_values);
800
57
            _contain_null = false;
801
57
            _high_value = TYPE_MIN;
802
57
            _low_value = TYPE_MAX;
803
57
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
57
    } else {
807
28
        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
24
        } else {
813
24
            static_cast<void>(add_range(range._high_op, range._high_value));
814
24
            static_cast<void>(add_range(range._low_op, range._low_value));
815
24
        }
816
28
    }
817
85
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
586
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
586
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
590
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
586
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
586
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
263
        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
211
        } 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
211
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
211
            IteratorType iter = range._fixed_values.begin();
790
565
            while (iter != range._fixed_values.end()) {
791
355
                if (this->is_in_range(*iter)) {
792
355
                    result_values.insert(*iter);
793
355
                }
794
354
                ++iter;
795
354
            }
796
211
        }
797
798
264
        if (!result_values.empty()) {
799
264
            _fixed_values = std::move(result_values);
800
264
            _contain_null = false;
801
264
            _high_value = TYPE_MIN;
802
264
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
323
    } else {
807
323
        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
257
        } else {
813
257
            static_cast<void>(add_range(range._high_op, range._high_value));
814
257
            static_cast<void>(add_range(range._low_op, range._low_value));
815
257
        }
816
323
    }
817
586
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
212
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
212
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
212
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
212
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
212
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
203
        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
203
        } 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
203
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
203
            IteratorType iter = range._fixed_values.begin();
790
420
            while (iter != range._fixed_values.end()) {
791
218
                if (this->is_in_range(*iter)) {
792
218
                    result_values.insert(*iter);
793
218
                }
794
217
                ++iter;
795
217
            }
796
203
        }
797
798
204
        if (!result_values.empty()) {
799
204
            _fixed_values = std::move(result_values);
800
204
            _contain_null = false;
801
204
            _high_value = TYPE_MIN;
802
204
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
203
    } else {
807
9
        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
9
        } else {
813
9
            static_cast<void>(add_range(range._high_op, range._high_value));
814
9
            static_cast<void>(add_range(range._low_op, range._low_value));
815
9
        }
816
9
    }
817
212
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
44
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
44
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
44
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
44
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
44
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
36
        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
36
        } 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
36
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
36
            IteratorType iter = range._fixed_values.begin();
790
78
            while (iter != range._fixed_values.end()) {
791
42
                if (this->is_in_range(*iter)) {
792
42
                    result_values.insert(*iter);
793
42
                }
794
42
                ++iter;
795
42
            }
796
36
        }
797
798
36
        if (!result_values.empty()) {
799
36
            _fixed_values = std::move(result_values);
800
36
            _contain_null = false;
801
36
            _high_value = TYPE_MIN;
802
36
            _low_value = TYPE_MAX;
803
36
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
36
    } else {
807
8
        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
7
        } else {
813
7
            static_cast<void>(add_range(range._high_op, range._high_value));
814
7
            static_cast<void>(add_range(range._low_op, range._low_value));
815
7
        }
816
8
    }
817
44
}
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
562k
                                     bool* should_break) {
823
562k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
562k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
562k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
562k
    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
562k
    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
562k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
562k
    if (range.is_fixed_value_range()) {
842
289k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
57
            if (range.is_range_value_convertible()) {
844
56
                range.convert_to_range_value();
845
56
                *exact_value = false;
846
56
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
57
        }
851
289k
    } else {
852
273k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
273k
            !range.is_reject_split_type()) {
854
151k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
151k
                                                 _end_include);
856
857
151k
            if (!(*eos) &&
858
152k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
152k
                                                 _end_include, max_scan_key_num)) {
860
151k
                _has_range_value = true;
861
151k
            }
862
151k
            return Status::OK();
863
151k
        }
864
273k
    }
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.7k
            auto fixed_value_set = range.get_fixed_value_set();
871
98.7k
            ConstIterator iter = fixed_value_set.begin();
872
873
199k
            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.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
98.7k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
190k
        else {
890
190k
            auto fixed_value_set = range.get_fixed_value_set();
891
190k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
380k
            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
381k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
190k
                        _begin_scan_keys[i].add_value(
903
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
190k
                        _end_scan_keys[i].add_value(
905
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
190k
                    } // append follow ScanKey
907
417
                    else {
908
417
                        _begin_scan_keys.push_back(start_base_key_range);
909
417
                        _begin_scan_keys.back().add_value(
910
417
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
417
                        _end_scan_keys.push_back(end_base_key_range);
912
417
                        _end_scan_keys.back().add_value(
913
417
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
417
                    }
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
190k
        }
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
16
            CHECK(range.contain_null());
935
16
            if (_begin_scan_keys.empty()) {
936
16
                _begin_scan_keys.emplace_back();
937
16
                _begin_scan_keys.back().add_null();
938
16
                _end_scan_keys.emplace_back();
939
16
                _end_scan_keys.back().add_null();
940
16
            } 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
23.7k
            _begin_scan_keys.emplace_back();
948
23.7k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
23.7k
                                                      range.get_range_min_value(), range.scale()),
950
23.7k
                                              range.contain_null());
951
23.7k
            _end_scan_keys.emplace_back();
952
23.7k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
23.7k
                    range.get_range_max_value(), range.scale()));
954
98.3k
        } else {
955
198k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
100k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
100k
                                                      range.get_range_min_value(), range.scale()),
958
100k
                                              range.contain_null());
959
100k
            }
960
961
199k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
100k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
100k
                        range.get_range_max_value(), range.scale()));
964
100k
            }
965
98.3k
        }
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
562k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.42k
                                     bool* should_break) {
823
2.42k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.42k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.42k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.42k
    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.42k
    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.42k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.42k
    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
2.41k
    } else {
852
2.41k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.41k
            !range.is_reject_split_type()) {
854
2.36k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.36k
                                                 _end_include);
856
857
2.36k
            if (!(*eos) &&
858
2.37k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.39k
                                                 _end_include, max_scan_key_num)) {
860
2.39k
                _has_range_value = true;
861
2.39k
            }
862
2.36k
            return Status::OK();
863
2.36k
        }
864
2.41k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
52
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
9
        if (_begin_scan_keys.empty()) {
870
9
            auto fixed_value_set = range.get_fixed_value_set();
871
9
            ConstIterator iter = fixed_value_set.begin();
872
873
20
            for (; iter != fixed_value_set.end(); ++iter) {
874
11
                _begin_scan_keys.emplace_back();
875
11
                _begin_scan_keys.back().add_value(
876
11
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
11
                _end_scan_keys.emplace_back();
878
11
                _end_scan_keys.back().add_value(
879
11
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
11
            }
881
882
9
            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
9
        } // 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
9
        _begin_include = true;
927
9
        _end_include = true;
928
9
    } // Extend ScanKey with range value
929
43
    else {
930
43
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
43
        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
43
        } 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
41
        } else {
955
75
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
34
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
34
                                                      range.get_range_min_value(), range.scale()),
958
34
                                              range.contain_null());
959
34
            }
960
961
75
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
34
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
34
                        range.get_range_max_value(), range.scale()));
964
34
            }
965
41
        }
966
43
        _begin_include = range.is_begin_include();
967
43
        _end_include = range.is_end_include();
968
43
    }
969
970
52
    return Status::OK();
971
2.42k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
297
                                     bool* should_break) {
823
297
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
297
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
297
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
297
    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
297
    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
297
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
297
    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
294
    } else {
852
294
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
294
            !range.is_reject_split_type()) {
854
227
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
227
                                                 _end_include);
856
857
227
            if (!(*eos) &&
858
228
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
228
                                                 _end_include, max_scan_key_num)) {
860
228
                _has_range_value = true;
861
228
            }
862
227
            return Status::OK();
863
227
        }
864
294
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
70
    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
67
    else {
930
67
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
67
        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
67
        } 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
67
        } else {
955
453
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
386
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
386
                                                      range.get_range_min_value(), range.scale()),
958
386
                                              range.contain_null());
959
386
            }
960
961
453
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
386
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
386
                        range.get_range_max_value(), range.scale()));
964
386
            }
965
67
        }
966
67
        _begin_include = range.is_begin_include();
967
67
        _end_include = range.is_end_include();
968
67
    }
969
970
70
    return Status::OK();
971
297
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
70.1k
                                     bool* should_break) {
823
70.1k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
70.1k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
70.1k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
70.1k
    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
70.1k
    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
70.1k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
70.1k
    if (range.is_fixed_value_range()) {
842
2.33k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
53
            if (range.is_range_value_convertible()) {
844
53
                range.convert_to_range_value();
845
53
                *exact_value = false;
846
53
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
53
        }
851
67.8k
    } else {
852
67.8k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
67.8k
            !range.is_reject_split_type()) {
854
66.8k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
66.8k
                                                 _end_include);
856
857
66.8k
            if (!(*eos) &&
858
67.0k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
67.2k
                                                 _end_include, max_scan_key_num)) {
860
67.2k
                _has_range_value = true;
861
67.2k
            }
862
66.8k
            return Status::OK();
863
66.8k
        }
864
67.8k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3.28k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.28k
        if (_begin_scan_keys.empty()) {
870
2.21k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.21k
            ConstIterator iter = fixed_value_set.begin();
872
873
5.15k
            for (; iter != fixed_value_set.end(); ++iter) {
874
2.93k
                _begin_scan_keys.emplace_back();
875
2.93k
                _begin_scan_keys.back().add_value(
876
2.93k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
2.93k
                _end_scan_keys.emplace_back();
878
2.93k
                _end_scan_keys.back().add_value(
879
2.93k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
2.93k
            }
881
882
2.21k
            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.21k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
70
        else {
890
70
            auto fixed_value_set = range.get_fixed_value_set();
891
70
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
154
            for (int i = 0; i < original_key_range_size; ++i) {
894
84
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
84
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
84
                ConstIterator iter = fixed_value_set.begin();
898
899
170
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
88
                    if (iter == fixed_value_set.begin()) {
902
88
                        _begin_scan_keys[i].add_value(
903
88
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
88
                        _end_scan_keys[i].add_value(
905
88
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
88
                    } // 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
86
                }
916
917
84
                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
84
            }
924
70
        }
925
926
2.28k
        _begin_include = true;
927
2.28k
        _end_include = true;
928
2.28k
    } // Extend ScanKey with range value
929
1.00k
    else {
930
1.00k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.00k
        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.00k
        } else if (_begin_scan_keys.empty()) {
947
145
            _begin_scan_keys.emplace_back();
948
145
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
145
                                                      range.get_range_min_value(), range.scale()),
950
145
                                              range.contain_null());
951
145
            _end_scan_keys.emplace_back();
952
145
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
145
                    range.get_range_max_value(), range.scale()));
954
856
        } else {
955
3.71k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
2.85k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
2.85k
                                                      range.get_range_min_value(), range.scale()),
958
2.85k
                                              range.contain_null());
959
2.85k
            }
960
961
3.71k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
2.86k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
2.86k
                        range.get_range_max_value(), range.scale()));
964
2.86k
            }
965
856
        }
966
1.00k
        _begin_include = range.is_begin_include();
967
1.00k
        _end_include = range.is_end_include();
968
1.00k
    }
969
970
3.28k
    return Status::OK();
971
70.1k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
81.0k
                                     bool* should_break) {
823
81.0k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
81.0k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
81.0k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
81.0k
    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
81.0k
    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
81.0k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
81.0k
    if (range.is_fixed_value_range()) {
842
1.02k
        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
80.0k
    } else {
852
80.0k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
80.0k
            !range.is_reject_split_type()) {
854
79.5k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
79.5k
                                                 _end_include);
856
857
79.5k
            if (!(*eos) &&
858
79.6k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
79.6k
                                                 _end_include, max_scan_key_num)) {
860
79.2k
                _has_range_value = true;
861
79.2k
            }
862
79.5k
            return Status::OK();
863
79.5k
        }
864
80.0k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.59k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
1.02k
        if (_begin_scan_keys.empty()) {
870
1.02k
            auto fixed_value_set = range.get_fixed_value_set();
871
1.02k
            ConstIterator iter = fixed_value_set.begin();
872
873
2.53k
            for (; iter != fixed_value_set.end(); ++iter) {
874
1.50k
                _begin_scan_keys.emplace_back();
875
1.50k
                _begin_scan_keys.back().add_value(
876
1.50k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
1.50k
                _end_scan_keys.emplace_back();
878
1.50k
                _end_scan_keys.back().add_value(
879
1.50k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
1.50k
            }
881
882
1.02k
            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.02k
        } // 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
1.02k
        _begin_include = true;
927
1.02k
        _end_include = true;
928
1.02k
    } // Extend ScanKey with range value
929
567
    else {
930
567
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
567
        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
567
        } else if (_begin_scan_keys.empty()) {
947
28
            _begin_scan_keys.emplace_back();
948
28
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
28
                                                      range.get_range_min_value(), range.scale()),
950
28
                                              range.contain_null());
951
28
            _end_scan_keys.emplace_back();
952
28
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
28
                    range.get_range_max_value(), range.scale()));
954
539
        } else {
955
1.28k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
742
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
742
                                                      range.get_range_min_value(), range.scale()),
958
742
                                              range.contain_null());
959
742
            }
960
961
1.28k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
742
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
742
                        range.get_range_max_value(), range.scale()));
964
742
            }
965
539
        }
966
567
        _begin_include = range.is_begin_include();
967
567
        _end_include = range.is_end_include();
968
567
    }
969
970
1.59k
    return Status::OK();
971
81.0k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.07k
                                     bool* should_break) {
823
4.07k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.07k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.07k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.07k
    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.07k
    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.07k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.07k
    if (range.is_fixed_value_range()) {
842
133
        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
3.94k
    } else {
852
3.94k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
3.94k
            !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
3.94k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.07k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
133
        if (_begin_scan_keys.empty()) {
870
133
            auto fixed_value_set = range.get_fixed_value_set();
871
133
            ConstIterator iter = fixed_value_set.begin();
872
873
268
            for (; iter != fixed_value_set.end(); ++iter) {
874
135
                _begin_scan_keys.emplace_back();
875
135
                _begin_scan_keys.back().add_value(
876
135
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
135
                _end_scan_keys.emplace_back();
878
135
                _end_scan_keys.back().add_value(
879
135
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
135
            }
881
882
133
            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
133
        } // 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
133
        _begin_include = true;
927
133
        _end_include = true;
928
133
    } // Extend ScanKey with range value
929
3.94k
    else {
930
3.94k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
3.94k
        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
3.94k
        } else if (_begin_scan_keys.empty()) {
947
3.87k
            _begin_scan_keys.emplace_back();
948
3.87k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
3.87k
                                                      range.get_range_min_value(), range.scale()),
950
3.87k
                                              range.contain_null());
951
3.87k
            _end_scan_keys.emplace_back();
952
3.87k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
3.87k
                    range.get_range_max_value(), range.scale()));
954
3.87k
        } else {
955
121
            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
121
            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
65
        }
966
3.94k
        _begin_include = range.is_begin_include();
967
3.94k
        _end_include = range.is_end_include();
968
3.94k
    }
969
970
4.07k
    return Status::OK();
971
4.07k
}
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
405
                                     bool* should_break) {
823
405
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
405
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
405
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
405
    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
405
    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
405
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
405
    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
390
    } else {
852
390
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
390
            !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
390
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
405
    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
38
            for (; iter != fixed_value_set.end(); ++iter) {
874
25
                _begin_scan_keys.emplace_back();
875
25
                _begin_scan_keys.back().add_value(
876
25
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
25
                _end_scan_keys.emplace_back();
878
25
                _end_scan_keys.back().add_value(
879
25
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
25
            }
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
391
    else {
930
391
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
391
        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
390
        } else if (_begin_scan_keys.empty()) {
947
384
            _begin_scan_keys.emplace_back();
948
384
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
384
                                                      range.get_range_min_value(), range.scale()),
950
384
                                              range.contain_null());
951
384
            _end_scan_keys.emplace_back();
952
384
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
384
                    range.get_range_max_value(), range.scale()));
954
384
        } else {
955
88
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
82
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
82
                                                      range.get_range_min_value(), range.scale()),
958
82
                                              range.contain_null());
959
82
            }
960
961
88
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
82
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
82
                        range.get_range_max_value(), range.scale()));
964
82
            }
965
6
        }
966
391
        _begin_include = range.is_begin_include();
967
391
        _end_include = range.is_end_include();
968
391
    }
969
970
405
    return Status::OK();
971
405
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
390k
                                     bool* should_break) {
823
390k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
390k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
390k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
390k
    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
390k
    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
390k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
390k
    if (range.is_fixed_value_range()) {
842
285k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
2
            if (range.is_range_value_convertible()) {
844
2
                range.convert_to_range_value();
845
2
                *exact_value = false;
846
2
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
2
        }
851
285k
    } else {
852
105k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
105k
            !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
105k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
390k
    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.8k
            auto fixed_value_set = range.get_fixed_value_set();
871
94.8k
            ConstIterator iter = fixed_value_set.begin();
872
873
190k
            for (; iter != fixed_value_set.end(); ++iter) {
874
95.2k
                _begin_scan_keys.emplace_back();
875
95.2k
                _begin_scan_keys.back().add_value(
876
95.2k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
95.2k
                _end_scan_keys.emplace_back();
878
95.2k
                _end_scan_keys.back().add_value(
879
95.2k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
95.2k
            }
881
882
94.8k
            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.8k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
190k
        else {
890
190k
            auto fixed_value_set = range.get_fixed_value_set();
891
190k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
380k
            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
381k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
190k
                        _begin_scan_keys[i].add_value(
903
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
190k
                        _end_scan_keys[i].add_value(
905
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
190k
                    } // append follow ScanKey
907
419
                    else {
908
419
                        _begin_scan_keys.push_back(start_base_key_range);
909
419
                        _begin_scan_keys.back().add_value(
910
419
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
419
                        _end_scan_keys.push_back(end_base_key_range);
912
419
                        _end_scan_keys.back().add_value(
913
419
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
419
                    }
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
190k
        }
925
926
284k
        _begin_include = true;
927
284k
        _end_include = true;
928
284k
    } // Extend ScanKey with range value
929
105k
    else {
930
105k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
105k
        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
105k
        } else if (_begin_scan_keys.empty()) {
947
9.28k
            _begin_scan_keys.emplace_back();
948
9.28k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
9.28k
                                                      range.get_range_min_value(), range.scale()),
950
9.28k
                                              range.contain_null());
951
9.28k
            _end_scan_keys.emplace_back();
952
9.28k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
9.28k
                    range.get_range_max_value(), range.scale()));
954
96.4k
        } else {
955
192k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
96.1k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
96.1k
                                                      range.get_range_min_value(), range.scale()),
958
96.1k
                                              range.contain_null());
959
96.1k
            }
960
961
192k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
96.1k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
96.1k
                        range.get_range_max_value(), range.scale()));
964
96.1k
            }
965
96.4k
        }
966
105k
        _begin_include = range.is_begin_include();
967
105k
        _end_include = range.is_end_include();
968
105k
    }
969
970
390k
    return Status::OK();
971
390k
}
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.19k
                                     bool* should_break) {
823
3.19k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.19k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.19k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.19k
    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.19k
    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.19k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.19k
    if (range.is_fixed_value_range()) {
842
279
        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.91k
    } else {
852
2.91k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.91k
            !range.is_reject_split_type()) {
854
2.80k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.80k
                                                 _end_include);
856
857
2.80k
            if (!(*eos) &&
858
2.80k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.80k
                                                 _end_include, max_scan_key_num)) {
860
2.72k
                _has_range_value = true;
861
2.72k
            }
862
2.80k
            return Status::OK();
863
2.80k
        }
864
2.91k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
388
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
280
        if (_begin_scan_keys.empty()) {
870
277
            auto fixed_value_set = range.get_fixed_value_set();
871
277
            ConstIterator iter = fixed_value_set.begin();
872
873
588
            for (; iter != fixed_value_set.end(); ++iter) {
874
311
                _begin_scan_keys.emplace_back();
875
311
                _begin_scan_keys.back().add_value(
876
311
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
311
                _end_scan_keys.emplace_back();
878
311
                _end_scan_keys.back().add_value(
879
311
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
311
            }
881
882
277
            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
277
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
3
        else {
890
3
            auto fixed_value_set = range.get_fixed_value_set();
891
3
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
5
            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
3
        }
925
926
280
        _begin_include = true;
927
280
        _end_include = true;
928
280
    } // Extend ScanKey with range value
929
108
    else {
930
108
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
108
        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
108
        } 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
108
        } else {
955
246
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
138
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
138
                                                      range.get_range_min_value(), range.scale()),
958
138
                                              range.contain_null());
959
138
            }
960
961
248
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
140
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
140
                        range.get_range_max_value(), range.scale()));
964
140
            }
965
108
        }
966
108
        _begin_include = range.is_begin_include();
967
108
        _end_include = range.is_end_include();
968
108
    }
969
970
388
    return Status::OK();
971
3.19k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE12EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
13
                                     bool* should_break) {
823
13
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
13
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
13
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
13
    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
13
    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
13
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
13
    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
10
    } else {
852
10
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
10
            !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
10
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
13
    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
10
    else {
930
10
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
10
        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
10
        } else if (_begin_scan_keys.empty()) {
947
10
            _begin_scan_keys.emplace_back();
948
10
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
10
                                                      range.get_range_min_value(), range.scale()),
950
10
                                              range.contain_null());
951
10
            _end_scan_keys.emplace_back();
952
10
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
10
                    range.get_range_max_value(), range.scale()));
954
10
        } 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
10
        _begin_include = range.is_begin_include();
967
10
        _end_include = range.is_end_include();
968
10
    }
969
970
13
    return Status::OK();
971
13
}
_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
59
        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.38k
    } else {
852
2.39k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.38k
            !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.38k
    }
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
58
        if (_begin_scan_keys.empty()) {
870
57
            auto fixed_value_set = range.get_fixed_value_set();
871
57
            ConstIterator iter = fixed_value_set.begin();
872
873
114
            for (; iter != fixed_value_set.end(); ++iter) {
874
57
                _begin_scan_keys.emplace_back();
875
57
                _begin_scan_keys.back().add_value(
876
57
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
57
                _end_scan_keys.emplace_back();
878
57
                _end_scan_keys.back().add_value(
879
57
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
57
            }
881
882
57
            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
57
        } // 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
5
            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
1
        }
925
926
58
        _begin_include = true;
927
58
        _end_include = true;
928
58
    } // Extend ScanKey with range value
929
2.38k
    else {
930
2.38k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.38k
        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.38k
        } else if (_begin_scan_keys.empty()) {
947
2.38k
            _begin_scan_keys.emplace_back();
948
2.38k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.38k
                                                      range.get_range_min_value(), range.scale()),
950
2.38k
                                              range.contain_null());
951
2.38k
            _end_scan_keys.emplace_back();
952
2.38k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.38k
                    range.get_range_max_value(), range.scale()));
954
2.38k
        } else {
955
3
            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
3
            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
1
        }
966
2.38k
        _begin_include = range.is_begin_include();
967
2.38k
        _end_include = range.is_end_include();
968
2.38k
    }
969
970
2.44k
    return Status::OK();
971
2.44k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.84k
                                     bool* should_break) {
823
2.84k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.84k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.84k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.84k
    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.84k
    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.84k
    if (range.is_fixed_value_range()) {
842
89
        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.75k
    } else {
852
2.75k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.75k
            !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.75k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.84k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
89
        if (_begin_scan_keys.empty()) {
870
89
            auto fixed_value_set = range.get_fixed_value_set();
871
89
            ConstIterator iter = fixed_value_set.begin();
872
873
243
            for (; iter != fixed_value_set.end(); ++iter) {
874
154
                _begin_scan_keys.emplace_back();
875
154
                _begin_scan_keys.back().add_value(
876
154
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
154
                _end_scan_keys.emplace_back();
878
154
                _end_scan_keys.back().add_value(
879
154
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
154
            }
881
882
89
            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
89
        } // 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
89
        _begin_include = true;
927
89
        _end_include = true;
928
89
    } // Extend ScanKey with range value
929
2.75k
    else {
930
2.75k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.75k
        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.74k
        } else if (_begin_scan_keys.empty()) {
947
2.74k
            _begin_scan_keys.emplace_back();
948
2.74k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.74k
                                                      range.get_range_min_value(), range.scale()),
950
2.74k
                                              range.contain_null());
951
2.74k
            _end_scan_keys.emplace_back();
952
2.74k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.74k
                    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
2.75k
        _begin_include = range.is_begin_include();
967
2.75k
        _end_include = range.is_end_include();
968
2.75k
    }
969
970
2.84k
    return Status::OK();
971
2.84k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
46
                                     bool* should_break) {
823
46
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
46
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
46
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
46
    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
46
    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
46
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
46
    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
45
    } else {
852
45
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
45
            !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
45
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
46
    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
45
    else {
930
45
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
45
        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
45
        } else if (_begin_scan_keys.empty()) {
947
44
            _begin_scan_keys.emplace_back();
948
44
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
44
                                                      range.get_range_min_value(), range.scale()),
950
44
                                              range.contain_null());
951
44
            _end_scan_keys.emplace_back();
952
44
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
44
                    range.get_range_max_value(), range.scale()));
954
44
        } 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
45
        _begin_include = range.is_begin_include();
967
45
        _end_include = range.is_end_include();
968
45
    }
969
970
46
    return Status::OK();
971
46
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.03k
                                     bool* should_break) {
823
2.03k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.03k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.03k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.03k
    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.03k
    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.03k
    if (range.is_fixed_value_range()) {
842
6
        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
2.02k
    } else {
852
2.02k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.02k
            !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.02k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.03k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
5
        if (_begin_scan_keys.empty()) {
870
5
            auto fixed_value_set = range.get_fixed_value_set();
871
5
            ConstIterator iter = fixed_value_set.begin();
872
873
13
            for (; iter != fixed_value_set.end(); ++iter) {
874
8
                _begin_scan_keys.emplace_back();
875
8
                _begin_scan_keys.back().add_value(
876
8
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
8
                _end_scan_keys.emplace_back();
878
8
                _end_scan_keys.back().add_value(
879
8
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
8
            }
881
882
5
            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
5
        } // 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
5
        _begin_include = true;
927
5
        _end_include = true;
928
5
    } // Extend ScanKey with range value
929
2.02k
    else {
930
2.02k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.02k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
3
            CHECK(range.contain_null());
935
3
            if (_begin_scan_keys.empty()) {
936
3
                _begin_scan_keys.emplace_back();
937
3
                _begin_scan_keys.back().add_null();
938
3
                _end_scan_keys.emplace_back();
939
3
                _end_scan_keys.back().add_null();
940
3
            } 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.04k
        } else if (_begin_scan_keys.empty()) {
947
2.04k
            _begin_scan_keys.emplace_back();
948
2.04k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.04k
                                                      range.get_range_min_value(), range.scale()),
950
2.04k
                                              range.contain_null());
951
2.04k
            _end_scan_keys.emplace_back();
952
2.04k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.04k
                    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
2.02k
        _begin_include = range.is_begin_include();
967
2.02k
        _end_include = range.is_end_include();
968
2.02k
    }
969
970
2.03k
    return Status::OK();
971
2.03k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
578
                                     bool* should_break) {
823
578
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
578
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
578
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
578
    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
578
    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
578
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
578
    if (range.is_fixed_value_range()) {
842
26
        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
552
    } else {
852
553
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
552
            !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
552
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
578
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
26
        if (_begin_scan_keys.empty()) {
870
24
            auto fixed_value_set = range.get_fixed_value_set();
871
24
            ConstIterator iter = fixed_value_set.begin();
872
873
62
            for (; iter != fixed_value_set.end(); ++iter) {
874
38
                _begin_scan_keys.emplace_back();
875
38
                _begin_scan_keys.back().add_value(
876
38
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
38
                _end_scan_keys.emplace_back();
878
38
                _end_scan_keys.back().add_value(
879
38
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
38
            }
881
882
24
            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
24
        } // 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
26
        _begin_include = true;
927
26
        _end_include = true;
928
26
    } // Extend ScanKey with range value
929
552
    else {
930
552
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
552
        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
553
        } else if (_begin_scan_keys.empty()) {
947
553
            _begin_scan_keys.emplace_back();
948
553
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
553
                                                      range.get_range_min_value(), range.scale()),
950
553
                                              range.contain_null());
951
553
            _end_scan_keys.emplace_back();
952
553
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
553
                    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
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
18.4E
            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
18.4E
        }
966
552
        _begin_include = range.is_begin_include();
967
552
        _end_include = range.is_end_include();
968
552
    }
969
970
578
    return Status::OK();
971
578
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
852
                                     bool* should_break) {
823
852
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
852
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
852
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
852
    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
852
    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
852
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
852
    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
832
    } else {
852
832
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
832
            !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
832
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
852
    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
832
    else {
930
832
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
832
        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
832
        } else if (_begin_scan_keys.empty()) {
947
802
            _begin_scan_keys.emplace_back();
948
802
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
802
                                                      range.get_range_min_value(), range.scale()),
950
802
                                              range.contain_null());
951
802
            _end_scan_keys.emplace_back();
952
802
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
802
                    range.get_range_max_value(), range.scale()));
954
802
        } else {
955
74
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
44
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
44
                                                      range.get_range_min_value(), range.scale()),
958
44
                                              range.contain_null());
959
44
            }
960
961
74
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
44
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
44
                        range.get_range_max_value(), range.scale()));
964
44
            }
965
30
        }
966
832
        _begin_include = range.is_begin_include();
967
832
        _end_include = range.is_end_include();
968
832
    }
969
970
852
    return Status::OK();
971
852
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.25k
                                     bool* should_break) {
823
1.25k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.25k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.25k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.25k
    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.25k
    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.25k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.25k
    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.25k
    } else {
852
1.25k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.25k
            !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.25k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.25k
    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.25k
    else {
930
1.25k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.25k
        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.25k
        } else if (_begin_scan_keys.empty()) {
947
1.15k
            _begin_scan_keys.emplace_back();
948
1.15k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.15k
                                                      range.get_range_min_value(), range.scale()),
950
1.15k
                                              range.contain_null());
951
1.15k
            _end_scan_keys.emplace_back();
952
1.15k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.15k
                    range.get_range_max_value(), range.scale()));
954
1.15k
        } else {
955
202
            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
202
            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
94
        }
966
1.25k
        _begin_include = range.is_begin_include();
967
1.25k
        _end_include = range.is_end_include();
968
1.25k
    }
969
970
1.25k
    return Status::OK();
971
1.25k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
382
                                     bool* should_break) {
823
382
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
382
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
382
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
382
    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
382
    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
382
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
382
    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
366
    } else {
852
366
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
366
            !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
366
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
382
    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
366
    else {
930
366
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
366
        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
365
        } else if (_begin_scan_keys.empty()) {
947
307
            _begin_scan_keys.emplace_back();
948
307
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
307
                                                      range.get_range_min_value(), range.scale()),
950
307
                                              range.contain_null());
951
307
            _end_scan_keys.emplace_back();
952
307
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
307
                    range.get_range_max_value(), range.scale()));
954
307
        } else {
955
118
            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
118
            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
58
        }
966
366
        _begin_include = range.is_begin_include();
967
366
        _end_include = range.is_end_include();
968
366
    }
969
970
382
    return Status::OK();
971
382
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris