Coverage Report

Created: 2026-03-25 08:51

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.26M
std::string cast_to_string(T value, int scale) {
61
1.26M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.06k
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.37k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.37k
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.65k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.65k
        return ((Decimal<int128_t>)value).to_string(scale);
67
2.65k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.24k
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
177k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
177k
        return std::to_string(static_cast<int>(value));
71
177k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
9.25k
        return int128_to_string(value);
73
9.25k
    } 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
7.51k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
7.51k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
7.51k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
0
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
0
        return IPv4Value::to_string(value);
87
4
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
4
        return IPv6Value::to_string(value);
89
3.37k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.37k
        return CastToString::from_number(value);
91
1.06M
    } else {
92
1.06M
        return boost::lexical_cast<std::string>(value);
93
1.06M
    }
94
1.26M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
177k
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
177k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
177k
        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
177k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE4EsEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
9.41k
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
9.41k
    } else {
92
9.41k
        return boost::lexical_cast<std::string>(value);
93
9.41k
    }
94
9.41k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE5EiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
164k
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
164k
    } else {
92
164k
        return boost::lexical_cast<std::string>(value);
93
164k
    }
94
164k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
180k
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
180k
    } else {
92
180k
        return boost::lexical_cast<std::string>(value);
93
180k
    }
94
180k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
9.25k
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
9.25k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
9.25k
        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
9.25k
}
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
1.00k
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
1.00k
    } else {
92
1.00k
        return boost::lexical_cast<std::string>(value);
93
1.00k
    }
94
1.00k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
450k
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
450k
    } else {
92
450k
        return boost::lexical_cast<std::string>(value);
93
450k
    }
94
450k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE23ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE11ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.27k
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
3.27k
    } else {
92
3.27k
        return boost::lexical_cast<std::string>(value);
93
3.27k
    }
94
3.27k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
250k
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
250k
    } else {
92
250k
        return boost::lexical_cast<std::string>(value);
93
250k
    }
94
250k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE12ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
74
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
74
    } else {
92
74
        return boost::lexical_cast<std::string>(value);
93
74
    }
94
74
}
_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
7.51k
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
7.51k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
7.51k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
7.51k
        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
7.51k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE20ENS_14DecimalV2ValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
242
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
242
    } else {
92
242
        return boost::lexical_cast<std::string>(value);
93
242
    }
94
242
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.37k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
3.37k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.37k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
3.37k
}
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.06k
std::string cast_to_string(T value, int scale) {
61
1.06k
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.06k
        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.06k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.37k
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.37k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.37k
        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.37k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
2.65k
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.65k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.65k
        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.65k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.24k
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
1.24k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.24k
        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.24k
}
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
159k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
2.06k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_reject_split_typeEv
Line
Count
Source
139
91
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_reject_split_typeEv
Line
Count
Source
139
63.8k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
86.7k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
4.37k
    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
34
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_reject_split_typeEv
Line
Count
Source
139
2.64k
    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
22.1k
    void set_empty_value_range() {
144
22.1k
        _fixed_values.clear();
145
22.1k
        _low_value = TYPE_MAX;
146
22.1k
        _high_value = TYPE_MIN;
147
22.1k
        _contain_null = false;
148
22.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
139
    void set_empty_value_range() {
144
139
        _fixed_values.clear();
145
139
        _low_value = TYPE_MAX;
146
139
        _high_value = TYPE_MIN;
147
139
        _contain_null = false;
148
139
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_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_13PrimitiveTypeE5EE21set_empty_value_rangeEv
Line
Count
Source
143
348
    void set_empty_value_range() {
144
348
        _fixed_values.clear();
145
348
        _low_value = TYPE_MAX;
146
348
        _high_value = TYPE_MIN;
147
348
        _contain_null = false;
148
348
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
21.1k
    void set_empty_value_range() {
144
21.1k
        _fixed_values.clear();
145
21.1k
        _low_value = TYPE_MAX;
146
21.1k
        _high_value = TYPE_MIN;
147
21.1k
        _contain_null = false;
148
21.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_empty_value_rangeEv
Line
Count
Source
143
22
    void set_empty_value_range() {
144
22
        _fixed_values.clear();
145
22
        _low_value = TYPE_MAX;
146
22
        _high_value = TYPE_MIN;
147
22
        _contain_null = false;
148
22
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_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
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_empty_value_rangeEv
Line
Count
Source
143
22
    void set_empty_value_range() {
144
22
        _fixed_values.clear();
145
22
        _low_value = TYPE_MAX;
146
22
        _high_value = TYPE_MIN;
147
22
        _contain_null = false;
148
22
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_empty_value_rangeEv
Line
Count
Source
143
4
    void set_empty_value_range() {
144
4
        _fixed_values.clear();
145
4
        _low_value = TYPE_MAX;
146
4
        _high_value = TYPE_MIN;
147
4
        _contain_null = false;
148
4
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_empty_value_rangeEv
Line
Count
Source
143
271
    void set_empty_value_range() {
144
271
        _fixed_values.clear();
145
271
        _low_value = TYPE_MAX;
146
271
        _high_value = TYPE_MIN;
147
271
        _contain_null = false;
148
271
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_empty_value_rangeEv
Line
Count
Source
143
55
    void set_empty_value_range() {
144
55
        _fixed_values.clear();
145
55
        _low_value = TYPE_MAX;
146
55
        _high_value = TYPE_MIN;
147
55
        _contain_null = false;
148
55
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_empty_value_rangeEv
Line
Count
Source
143
77
    void set_empty_value_range() {
144
77
        _fixed_values.clear();
145
77
        _low_value = TYPE_MAX;
146
77
        _high_value = TYPE_MIN;
147
77
        _contain_null = false;
148
77
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_empty_value_rangeEv
Line
Count
Source
143
6
    void set_empty_value_range() {
144
6
        _fixed_values.clear();
145
6
        _low_value = TYPE_MAX;
146
6
        _high_value = TYPE_MIN;
147
6
        _contain_null = false;
148
6
    }
_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
6
    void set_empty_value_range() {
144
6
        _fixed_values.clear();
145
6
        _low_value = TYPE_MAX;
146
6
        _high_value = TYPE_MIN;
147
6
        _contain_null = false;
148
6
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_empty_value_rangeEv
Line
Count
Source
143
4
    void set_empty_value_range() {
144
4
        _fixed_values.clear();
145
4
        _low_value = TYPE_MAX;
146
4
        _high_value = TYPE_MIN;
147
4
        _contain_null = false;
148
4
    }
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
167k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_fixed_value_setEv
Line
Count
Source
150
15
    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.93k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_fixed_value_setEv
Line
Count
Source
150
993
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
144
    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
10
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
162k
    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
127
    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
68
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_fixed_value_setEv
Line
Count
Source
150
187
    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
11
    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
23
    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
471k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
2.16k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
508
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
133k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
174k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
8.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
901
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
126k
    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
34
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_max_valueEv
Line
Count
Source
152
2.83k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_max_valueEv
Line
Count
Source
152
60
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_max_valueEv
Line
Count
Source
152
4.74k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
6.96k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
243
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
3.29k
    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
981
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.33k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
2.63k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
1.20k
    CppType get_range_max_value() const { return _high_value; }
153
154
471k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.16k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
510
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
133k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
174k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
8.92k
    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
900
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
126k
    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
34
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_min_valueEv
Line
Count
Source
154
2.83k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_min_valueEv
Line
Count
Source
154
60
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_min_valueEv
Line
Count
Source
154
4.74k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
6.92k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
243
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
3.30k
    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
986
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.32k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
2.64k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
1.18k
    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
235k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
2.09k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
155
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
64.8k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
87.0k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
4.38k
    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
410
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
63.0k
    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
34
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16is_begin_includeEv
Line
Count
Source
168
2.73k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16is_begin_includeEv
Line
Count
Source
168
30
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16is_begin_includeEv
Line
Count
Source
168
2.36k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
3.51k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
122
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
1.63k
    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
496
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
636
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.30k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
611
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
169
170
235k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14is_end_includeEv
Line
Count
Source
170
2.09k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14is_end_includeEv
Line
Count
Source
170
155
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
64.9k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
87.1k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
4.40k
    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
410
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
63.1k
    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
34
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14is_end_includeEv
Line
Count
Source
170
2.73k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14is_end_includeEv
Line
Count
Source
170
30
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14is_end_includeEv
Line
Count
Source
170
2.36k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
3.52k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
123
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
1.62k
    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
494
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
634
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.30k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
611
    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
480k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
3.02k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
530
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
73.7k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12contain_nullEv
Line
Count
Source
176
156k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12contain_nullEv
Line
Count
Source
176
4.69k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
67
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
113
    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
552
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
226k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
213
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12contain_nullEv
Line
Count
Source
176
37
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12contain_nullEv
Line
Count
Source
176
3.15k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12contain_nullEv
Line
Count
Source
176
33
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12contain_nullEv
Line
Count
Source
176
2.51k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
3.99k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
122
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
1.69k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
589
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
710
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.32k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
677
    bool contain_null() const { return _contain_null; }
177
178
570k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.13k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
160
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
71.4k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
88.9k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.76k
    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
431
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20get_fixed_value_sizeEv
Line
Count
Source
178
388k
    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
40
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.98k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20get_fixed_value_sizeEv
Line
Count
Source
178
36
    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
3.84k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
123
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.66k
    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
539
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
703
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.33k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
627
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
1.06k
    void set_whole_value_range() {
181
1.06k
        _fixed_values.clear();
182
1.06k
        _low_value = TYPE_MIN;
183
1.06k
        _high_value = TYPE_MAX;
184
1.06k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
1.06k
        _high_op = FILTER_LESS_OR_EQUAL;
186
1.06k
        _contain_null = _is_nullable_col;
187
1.06k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
233
    void set_whole_value_range() {
181
233
        _fixed_values.clear();
182
233
        _low_value = TYPE_MIN;
183
233
        _high_value = TYPE_MAX;
184
233
        _low_op = FILTER_LARGER_OR_EQUAL;
185
233
        _high_op = FILTER_LESS_OR_EQUAL;
186
233
        _contain_null = _is_nullable_col;
187
233
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_whole_value_rangeEv
Line
Count
Source
180
31
    void set_whole_value_range() {
181
31
        _fixed_values.clear();
182
31
        _low_value = TYPE_MIN;
183
31
        _high_value = TYPE_MAX;
184
31
        _low_op = FILTER_LARGER_OR_EQUAL;
185
31
        _high_op = FILTER_LESS_OR_EQUAL;
186
31
        _contain_null = _is_nullable_col;
187
31
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
438
    void set_whole_value_range() {
181
438
        _fixed_values.clear();
182
438
        _low_value = TYPE_MIN;
183
438
        _high_value = TYPE_MAX;
184
438
        _low_op = FILTER_LARGER_OR_EQUAL;
185
438
        _high_op = FILTER_LESS_OR_EQUAL;
186
438
        _contain_null = _is_nullable_col;
187
438
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_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
    }
_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
11
    void set_whole_value_range() {
181
11
        _fixed_values.clear();
182
11
        _low_value = TYPE_MIN;
183
11
        _high_value = TYPE_MAX;
184
11
        _low_op = FILTER_LARGER_OR_EQUAL;
185
11
        _high_op = FILTER_LESS_OR_EQUAL;
186
11
        _contain_null = _is_nullable_col;
187
11
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_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
    }
_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
18
    void set_whole_value_range() {
181
18
        _fixed_values.clear();
182
18
        _low_value = TYPE_MIN;
183
18
        _high_value = TYPE_MAX;
184
18
        _low_op = FILTER_LARGER_OR_EQUAL;
185
18
        _high_op = FILTER_LESS_OR_EQUAL;
186
18
        _contain_null = _is_nullable_col;
187
18
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_whole_value_rangeEv
Line
Count
Source
180
29
    void set_whole_value_range() {
181
29
        _fixed_values.clear();
182
29
        _low_value = TYPE_MIN;
183
29
        _high_value = TYPE_MAX;
184
29
        _low_op = FILTER_LARGER_OR_EQUAL;
185
29
        _high_op = FILTER_LESS_OR_EQUAL;
186
29
        _contain_null = _is_nullable_col;
187
29
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_whole_value_rangeEv
Line
Count
Source
180
37
    void set_whole_value_range() {
181
37
        _fixed_values.clear();
182
37
        _low_value = TYPE_MIN;
183
37
        _high_value = TYPE_MAX;
184
37
        _low_op = FILTER_LARGER_OR_EQUAL;
185
37
        _high_op = FILTER_LESS_OR_EQUAL;
186
37
        _contain_null = _is_nullable_col;
187
37
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
37
    void set_whole_value_range() {
181
37
        _fixed_values.clear();
182
37
        _low_value = TYPE_MIN;
183
37
        _high_value = TYPE_MAX;
184
37
        _low_op = FILTER_LARGER_OR_EQUAL;
185
37
        _high_op = FILTER_LESS_OR_EQUAL;
186
37
        _contain_null = _is_nullable_col;
187
37
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_whole_value_rangeEv
Line
Count
Source
180
29
    void set_whole_value_range() {
181
29
        _fixed_values.clear();
182
29
        _low_value = TYPE_MIN;
183
29
        _high_value = TYPE_MAX;
184
29
        _low_op = FILTER_LARGER_OR_EQUAL;
185
29
        _high_op = FILTER_LESS_OR_EQUAL;
186
29
        _contain_null = _is_nullable_col;
187
29
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
96
    void set_whole_value_range() {
181
96
        _fixed_values.clear();
182
96
        _low_value = TYPE_MIN;
183
96
        _high_value = TYPE_MAX;
184
96
        _low_op = FILTER_LARGER_OR_EQUAL;
185
96
        _high_op = FILTER_LESS_OR_EQUAL;
186
96
        _contain_null = _is_nullable_col;
187
96
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_whole_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_whole_value_rangeEv
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
2
    void set_whole_value_range() {
181
2
        _fixed_values.clear();
182
2
        _low_value = TYPE_MIN;
183
2
        _high_value = TYPE_MAX;
184
2
        _low_op = FILTER_LARGER_OR_EQUAL;
185
2
        _high_op = FILTER_LESS_OR_EQUAL;
186
2
        _contain_null = _is_nullable_col;
187
2
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_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
    }
188
189
585
    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
585
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
585
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
585
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
585
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_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
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_whole_value_rangeEv
Line
Count
Source
189
106
    bool is_whole_value_range() const {
190
106
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
106
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
106
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
106
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
106
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_whole_value_rangeEv
Line
Count
Source
189
22
    bool is_whole_value_range() const {
190
22
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
22
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
22
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
22
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
22
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_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
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_whole_value_rangeEv
Line
Count
Source
189
22
    bool is_whole_value_range() const {
190
22
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
22
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
22
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
22
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
22
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_whole_value_rangeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_whole_value_rangeEv
Line
Count
Source
189
4
    bool is_whole_value_range() const {
190
4
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
4
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
4
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
4
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
4
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_whole_value_rangeEv
Line
Count
Source
189
261
    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
261
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
261
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
261
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
261
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_whole_value_rangeEv
Line
Count
Source
189
55
    bool is_whole_value_range() const {
190
55
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
55
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
55
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
55
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
55
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
59
    bool is_whole_value_range() const {
190
59
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
60
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
59
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
59
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
59
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_whole_value_rangeEv
Line
Count
Source
189
6
    bool is_whole_value_range() const {
190
6
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
6
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
6
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
6
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
6
    }
_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
6
    bool is_whole_value_range() const {
190
6
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
6
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
6
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
6
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
6
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_whole_value_rangeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_whole_value_rangeEv
Line
Count
Source
189
4
    bool is_whole_value_range() const {
190
4
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
4
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
4
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
4
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
4
    }
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
1.65k
    void set_contain_null(bool contain_null) {
205
1.65k
        if (contain_null) {
206
595
            set_empty_value_range();
207
1.05k
        } else {
208
1.05k
            set_whole_value_range();
209
1.05k
        }
210
1.65k
        _contain_null = _is_nullable_col && contain_null;
211
1.65k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
233
    void set_contain_null(bool contain_null) {
205
233
        if (contain_null) {
206
0
            set_empty_value_range();
207
233
        } else {
208
233
            set_whole_value_range();
209
233
        }
210
233
        _contain_null = _is_nullable_col && contain_null;
211
233
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
33
    void set_contain_null(bool contain_null) {
205
33
        if (contain_null) {
206
2
            set_empty_value_range();
207
31
        } else {
208
31
            set_whole_value_range();
209
31
        }
210
33
        _contain_null = _is_nullable_col && contain_null;
211
33
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
545
    void set_contain_null(bool contain_null) {
205
545
        if (contain_null) {
206
110
            set_empty_value_range();
207
435
        } else {
208
435
            set_whole_value_range();
209
435
        }
210
545
        _contain_null = _is_nullable_col && contain_null;
211
545
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
23
    void set_contain_null(bool contain_null) {
205
23
        if (contain_null) {
206
1
            set_empty_value_range();
207
22
        } else {
208
22
            set_whole_value_range();
209
22
        }
210
23
        _contain_null = _is_nullable_col && contain_null;
211
23
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16set_contain_nullEb
Line
Count
Source
204
25
    void set_contain_null(bool contain_null) {
205
25
        if (contain_null) {
206
22
            set_empty_value_range();
207
22
        } else {
208
3
            set_whole_value_range();
209
3
        }
210
25
        _contain_null = _is_nullable_col && contain_null;
211
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE16set_contain_nullEb
Line
Count
Source
204
29
    void set_contain_null(bool contain_null) {
205
29
        if (contain_null) {
206
18
            set_empty_value_range();
207
18
        } else {
208
11
            set_whole_value_range();
209
11
        }
210
29
        _contain_null = _is_nullable_col && contain_null;
211
29
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
46
    void set_contain_null(bool contain_null) {
205
46
        if (contain_null) {
206
22
            set_empty_value_range();
207
24
        } else {
208
24
            set_whole_value_range();
209
24
        }
210
46
        _contain_null = _is_nullable_col && contain_null;
211
46
    }
_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
22
    void set_contain_null(bool contain_null) {
205
22
        if (contain_null) {
206
4
            set_empty_value_range();
207
18
        } else {
208
18
            set_whole_value_range();
209
18
        }
210
22
        _contain_null = _is_nullable_col && contain_null;
211
22
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16set_contain_nullEb
Line
Count
Source
204
291
    void set_contain_null(bool contain_null) {
205
291
        if (contain_null) {
206
262
            set_empty_value_range();
207
262
        } else {
208
29
            set_whole_value_range();
209
29
        }
210
291
        _contain_null = _is_nullable_col && contain_null;
211
291
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
92
    void set_contain_null(bool contain_null) {
205
92
        if (contain_null) {
206
56
            set_empty_value_range();
207
56
        } else {
208
36
            set_whole_value_range();
209
36
        }
210
93
        _contain_null = _is_nullable_col && contain_null;
211
92
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
100
    void set_contain_null(bool contain_null) {
205
100
        if (contain_null) {
206
62
            set_empty_value_range();
207
62
        } else {
208
38
            set_whole_value_range();
209
38
        }
210
100
        _contain_null = _is_nullable_col && contain_null;
211
100
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
35
    void set_contain_null(bool contain_null) {
205
35
        if (contain_null) {
206
6
            set_empty_value_range();
207
29
        } else {
208
29
            set_whole_value_range();
209
29
        }
210
35
        _contain_null = _is_nullable_col && contain_null;
211
35
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
114
    void set_contain_null(bool contain_null) {
205
114
        if (contain_null) {
206
18
            set_empty_value_range();
207
96
        } else {
208
96
            set_whole_value_range();
209
96
        }
210
114
        _contain_null = _is_nullable_col && contain_null;
211
114
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16set_contain_nullEb
Line
Count
Source
204
6
    void set_contain_null(bool contain_null) {
205
6
        if (contain_null) {
206
6
            set_empty_value_range();
207
6
        } else {
208
0
            set_whole_value_range();
209
0
        }
210
6
        _contain_null = _is_nullable_col && contain_null;
211
6
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16set_contain_nullEb
Line
Count
Source
204
25
    void set_contain_null(bool contain_null) {
205
25
        if (contain_null) {
206
0
            set_empty_value_range();
207
25
        } else {
208
25
            set_whole_value_range();
209
25
        }
210
25
        _contain_null = _is_nullable_col && contain_null;
211
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16set_contain_nullEb
Line
Count
Source
204
6
    void set_contain_null(bool contain_null) {
205
6
        if (contain_null) {
206
4
            set_empty_value_range();
207
4
        } else {
208
2
            set_whole_value_range();
209
2
        }
210
6
        _contain_null = _is_nullable_col && contain_null;
211
6
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16set_contain_nullEb
Line
Count
Source
204
24
    void set_contain_null(bool contain_null) {
205
24
        if (contain_null) {
206
2
            set_empty_value_range();
207
22
        } else {
208
22
            set_whole_value_range();
209
22
        }
210
24
        _contain_null = _is_nullable_col && contain_null;
211
24
    }
212
213
388k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
81.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
1.80k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
16.3k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
77.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
362
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
146
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
383
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
28
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
30
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.30k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9precisionEv
Line
Count
Source
213
172k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9precisionEv
Line
Count
Source
213
793
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9precisionEv
Line
Count
Source
213
31
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
27.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
49
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
4.30k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
1.77k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
191
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
262
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
543
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
343
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
296
    int precision() const { return _precision; }
214
215
1.66M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
258k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
11.2k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
183k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
258k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
9.62k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
146
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
384
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
28
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
34
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.31k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE5scaleEv
Line
Count
Source
215
622k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE5scaleEv
Line
Count
Source
215
797
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
3.30k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
278k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
123
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
9.19k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
9.30k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
246
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
3.57k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.32k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
1.92k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
2.99k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
1.54k
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
314k
                                      const CppType& value) {
219
314k
        static_cast<void>(range.add_fixed_value(value));
220
314k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
79.3k
                                      const CppType& value) {
219
79.3k
        static_cast<void>(range.add_fixed_value(value));
220
79.3k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
113
                                      const CppType& value) {
219
113
        static_cast<void>(range.add_fixed_value(value));
220
113
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
51.8k
                                      const CppType& value) {
219
51.8k
        static_cast<void>(range.add_fixed_value(value));
220
51.8k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
1.80k
                                      const CppType& value) {
219
1.80k
        static_cast<void>(range.add_fixed_value(value));
220
1.80k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
219
                                      const CppType& value) {
219
219
        static_cast<void>(range.add_fixed_value(value));
220
219
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
28
                                      const CppType& value) {
219
28
        static_cast<void>(range.add_fixed_value(value));
220
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
147
                                      const CppType& value) {
219
147
        static_cast<void>(range.add_fixed_value(value));
220
147
    }
_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
27
                                      const CppType& value) {
219
27
        static_cast<void>(range.add_fixed_value(value));
220
27
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
560
                                      const CppType& value) {
219
560
        static_cast<void>(range.add_fixed_value(value));
220
560
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
170k
                                      const CppType& value) {
219
170k
        static_cast<void>(range.add_fixed_value(value));
220
170k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
344
                                      const CppType& value) {
219
344
        static_cast<void>(range.add_fixed_value(value));
220
344
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
35
                                      const CppType& value) {
219
35
        static_cast<void>(range.add_fixed_value(value));
220
35
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
7.86k
                                      const CppType& value) {
219
7.86k
        static_cast<void>(range.add_fixed_value(value));
220
7.86k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
60
                                      const CppType& value) {
219
60
        static_cast<void>(range.add_fixed_value(value));
220
60
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
401
                                      const CppType& value) {
219
401
        static_cast<void>(range.add_fixed_value(value));
220
401
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
183
                                      const CppType& value) {
219
183
        static_cast<void>(range.add_fixed_value(value));
220
183
    }
_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
189
                                      const CppType& value) {
219
189
        static_cast<void>(range.add_fixed_value(value));
220
189
    }
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
173
                                      const CppType& value) {
219
173
        static_cast<void>(range.add_fixed_value(value));
220
173
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
239
                                      const CppType& value) {
219
239
        static_cast<void>(range.add_fixed_value(value));
220
239
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
52
                                      const CppType& value) {
219
52
        static_cast<void>(range.add_fixed_value(value));
220
52
    }
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.69k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
44
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
25
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
898
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14empty_functionERS2_NS_11SQLFilterOpERKl
Line
Count
Source
228
30
                               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
39
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
114
                               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
116
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
360
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
140
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
17
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
17
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
40
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
228
33
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
638
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
18
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
25
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
228
7
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14empty_functionERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
228
9
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
108
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
96.6k
                                const CppType& value) {
232
96.6k
        static_cast<void>(range.add_range(op, value));
233
96.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
1.44k
                                const CppType& value) {
232
1.44k
        static_cast<void>(range.add_range(op, value));
233
1.44k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.65k
                                const CppType& value) {
232
1.65k
        static_cast<void>(range.add_range(op, value));
233
1.65k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
9.25k
                                const CppType& value) {
232
9.25k
        static_cast<void>(range.add_range(op, value));
233
9.25k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
55.4k
                                const CppType& value) {
232
55.4k
        static_cast<void>(range.add_range(op, value));
233
55.4k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
149
                                const CppType& value) {
232
149
        static_cast<void>(range.add_range(op, value));
233
149
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
62
                                const CppType& value) {
232
62
        static_cast<void>(range.add_range(op, value));
233
62
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
169
                                const CppType& value) {
232
169
        static_cast<void>(range.add_range(op, value));
233
169
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
4
                                const CppType& value) {
232
4
        static_cast<void>(range.add_range(op, value));
233
4
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
4
                                const CppType& value) {
232
4
        static_cast<void>(range.add_range(op, value));
233
4
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
792
                                const CppType& value) {
232
792
        static_cast<void>(range.add_range(op, value));
233
792
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.82k
                                const CppType& value) {
232
1.82k
        static_cast<void>(range.add_range(op, value));
233
1.82k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
327
                                const CppType& value) {
232
327
        static_cast<void>(range.add_range(op, value));
233
327
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
19.6k
                                const CppType& value) {
232
19.6k
        static_cast<void>(range.add_range(op, value));
233
19.6k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
3.85k
                                const CppType& value) {
232
3.85k
        static_cast<void>(range.add_range(op, value));
233
3.85k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
1.16k
                                const CppType& value) {
232
1.16k
        static_cast<void>(range.add_range(op, value));
233
1.16k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
162
                                const CppType& value) {
232
162
        static_cast<void>(range.add_range(op, value));
233
162
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
421
                                const CppType& value) {
232
421
        static_cast<void>(range.add_range(op, value));
233
421
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
231
108
                                const CppType& value) {
232
108
        static_cast<void>(range.add_range(op, value));
233
108
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
231
147
                                const CppType& value) {
232
147
        static_cast<void>(range.add_range(op, value));
233
147
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
386k
                                                                            int scale) {
238
386k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
386k
                                                precision, scale);
240
386k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
81.2k
                                                                            int scale) {
238
81.2k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
81.2k
                                                precision, scale);
240
81.2k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.78k
                                                                            int scale) {
238
1.78k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.78k
                                                precision, scale);
240
1.78k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
16.2k
                                                                            int scale) {
238
16.2k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
16.2k
                                                precision, scale);
240
16.2k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
77.4k
                                                                            int scale) {
238
77.4k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
77.4k
                                                precision, scale);
240
77.4k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
359
                                                                            int scale) {
238
359
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
359
                                                precision, scale);
240
359
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
142
                                                                            int scale) {
238
142
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
142
                                                precision, scale);
240
142
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
379
                                                                            int scale) {
238
379
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
379
                                                precision, scale);
240
379
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
28
                                                                            int scale) {
238
28
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
28
                                                precision, scale);
240
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
30
                                                                            int scale) {
238
30
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
30
                                                precision, scale);
240
30
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.29k
                                                                            int scale) {
238
1.29k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.29k
                                                precision, scale);
240
1.29k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
171k
                                                                            int scale) {
238
171k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
171k
                                                precision, scale);
240
171k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
787
                                                                            int scale) {
238
787
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
787
                                                precision, scale);
240
787
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE31create_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_13PrimitiveTypeE25EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
27.5k
                                                                            int scale) {
238
27.5k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
27.5k
                                                precision, scale);
240
27.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
49
                                                                            int scale) {
238
49
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
49
                                                precision, scale);
240
49
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.27k
                                                                            int scale) {
238
4.27k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.27k
                                                precision, scale);
240
4.27k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.74k
                                                                            int scale) {
238
1.74k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.74k
                                                precision, scale);
240
1.74k
    }
_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
191
                                                                            int scale) {
238
191
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
191
                                                precision, scale);
240
191
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
261
                                                                            int scale) {
238
261
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
261
                                                precision, scale);
240
261
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
540
                                                                            int scale) {
238
540
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
540
                                                precision, scale);
240
540
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
344
                                                                            int scale) {
238
344
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
344
                                                precision, scale);
240
344
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
292
                                                                            int scale) {
238
292
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
292
                                                precision, scale);
240
292
    }
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
633k
    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.27k
    std::string debug_string() {
310
1.27k
        std::stringstream ss;
311
1.27k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
1.27k
        ss << "ScanKeys:";
313
314
6.35k
        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
5.08k
        }
318
1.27k
        return ss.str();
319
1.27k
    }
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
289k
    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
1.61M
        : _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.00M
        : _column_name(std::move(col_name)),
381
2.00M
          _column_type(primitive_type),
382
1.09M
          _low_value(min),
383
1.09M
          _high_value(max),
384
2.00M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.00M
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.00M
          _is_nullable_col(is_nullable_col),
387
2.00M
          _contain_null(is_nullable_col && contain_null),
388
2.00M
          _precision(precision),
389
2.00M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKaSA_bbii
Line
Count
Source
380
181k
        : _column_name(std::move(col_name)),
381
181k
          _column_type(primitive_type),
382
181k
          _low_value(min),
383
181k
          _high_value(max),
384
181k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
181k
          _high_op(FILTER_LESS_OR_EQUAL),
386
181k
          _is_nullable_col(is_nullable_col),
387
181k
          _contain_null(is_nullable_col && contain_null),
388
181k
          _precision(precision),
389
181k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
18.4k
        : _column_name(std::move(col_name)),
381
18.4k
          _column_type(primitive_type),
382
18.4k
          _low_value(min),
383
18.4k
          _high_value(max),
384
18.4k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
18.4k
          _high_op(FILTER_LESS_OR_EQUAL),
386
18.4k
          _is_nullable_col(is_nullable_col),
387
18.4k
          _contain_null(is_nullable_col && contain_null),
388
18.4k
          _precision(precision),
389
18.4k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
233k
        : _column_name(std::move(col_name)),
381
233k
          _column_type(primitive_type),
382
233k
          _low_value(min),
383
233k
          _high_value(max),
384
233k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
233k
          _high_op(FILTER_LESS_OR_EQUAL),
386
233k
          _is_nullable_col(is_nullable_col),
387
233k
          _contain_null(is_nullable_col && contain_null),
388
233k
          _precision(precision),
389
233k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
436k
        : _column_name(std::move(col_name)),
381
436k
          _column_type(primitive_type),
382
436k
          _low_value(min),
383
436k
          _high_value(max),
384
436k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
436k
          _high_op(FILTER_LESS_OR_EQUAL),
386
436k
          _is_nullable_col(is_nullable_col),
387
436k
          _contain_null(is_nullable_col && contain_null),
388
436k
          _precision(precision),
389
436k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_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_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
8.77k
        : _column_name(std::move(col_name)),
381
8.77k
          _column_type(primitive_type),
382
8.77k
          _low_value(min),
383
8.77k
          _high_value(max),
384
8.77k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
8.77k
          _high_op(FILTER_LESS_OR_EQUAL),
386
8.77k
          _is_nullable_col(is_nullable_col),
387
8.77k
          _contain_null(is_nullable_col && contain_null),
388
8.77k
          _precision(precision),
389
8.77k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
11.5k
        : _column_name(std::move(col_name)),
381
11.5k
          _column_type(primitive_type),
382
11.5k
          _low_value(min),
383
11.5k
          _high_value(max),
384
11.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.5k
          _is_nullable_col(is_nullable_col),
387
11.5k
          _contain_null(is_nullable_col && contain_null),
388
11.5k
          _precision(precision),
389
11.5k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
358
        : _column_name(std::move(col_name)),
381
358
          _column_type(primitive_type),
382
358
          _low_value(min),
383
358
          _high_value(max),
384
358
          _low_op(FILTER_LARGER_OR_EQUAL),
385
358
          _high_op(FILTER_LESS_OR_EQUAL),
386
358
          _is_nullable_col(is_nullable_col),
387
358
          _contain_null(is_nullable_col && contain_null),
388
358
          _precision(precision),
389
358
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
400
        : _column_name(std::move(col_name)),
381
400
          _column_type(primitive_type),
382
400
          _low_value(min),
383
400
          _high_value(max),
384
400
          _low_op(FILTER_LARGER_OR_EQUAL),
385
400
          _high_op(FILTER_LESS_OR_EQUAL),
386
400
          _is_nullable_col(is_nullable_col),
387
400
          _contain_null(is_nullable_col && contain_null),
388
400
          _precision(precision),
389
400
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
15.2k
        : _column_name(std::move(col_name)),
381
15.2k
          _column_type(primitive_type),
382
15.2k
          _low_value(min),
383
15.2k
          _high_value(max),
384
15.2k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
15.2k
          _high_op(FILTER_LESS_OR_EQUAL),
386
15.2k
          _is_nullable_col(is_nullable_col),
387
15.2k
          _contain_null(is_nullable_col && contain_null),
388
15.2k
          _precision(precision),
389
15.2k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
736k
        : _column_name(std::move(col_name)),
381
736k
          _column_type(primitive_type),
382
736k
          _low_value(min),
383
736k
          _high_value(max),
384
736k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
736k
          _high_op(FILTER_LESS_OR_EQUAL),
386
736k
          _is_nullable_col(is_nullable_col),
387
736k
          _contain_null(is_nullable_col && contain_null),
388
736k
          _precision(precision),
389
736k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
82.0k
        : _column_name(std::move(col_name)),
381
82.0k
          _column_type(primitive_type),
382
82.0k
          _low_value(min),
383
82.0k
          _high_value(max),
384
82.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
82.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
82.0k
          _is_nullable_col(is_nullable_col),
387
82.0k
          _contain_null(is_nullable_col && contain_null),
388
82.0k
          _precision(precision),
389
82.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
569
        : _column_name(std::move(col_name)),
381
569
          _column_type(primitive_type),
382
569
          _low_value(min),
383
569
          _high_value(max),
384
569
          _low_op(FILTER_LARGER_OR_EQUAL),
385
569
          _high_op(FILTER_LESS_OR_EQUAL),
386
569
          _is_nullable_col(is_nullable_col),
387
569
          _contain_null(is_nullable_col && contain_null),
388
569
          _precision(precision),
389
569
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_15DateV2ValueTypeEEESD_bbii
Line
Count
Source
380
117k
        : _column_name(std::move(col_name)),
381
117k
          _column_type(primitive_type),
382
117k
          _low_value(min),
383
117k
          _high_value(max),
384
117k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
117k
          _high_op(FILTER_LESS_OR_EQUAL),
386
117k
          _is_nullable_col(is_nullable_col),
387
117k
          _contain_null(is_nullable_col && contain_null),
388
117k
          _precision(precision),
389
117k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
600
        : _column_name(std::move(col_name)),
381
600
          _column_type(primitive_type),
382
600
          _low_value(min),
383
600
          _high_value(max),
384
600
          _low_op(FILTER_LARGER_OR_EQUAL),
385
600
          _high_op(FILTER_LESS_OR_EQUAL),
386
600
          _is_nullable_col(is_nullable_col),
387
600
          _contain_null(is_nullable_col && contain_null),
388
600
          _precision(precision),
389
600
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
84.9k
        : _column_name(std::move(col_name)),
381
84.9k
          _column_type(primitive_type),
382
84.9k
          _low_value(min),
383
84.9k
          _high_value(max),
384
84.9k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
84.9k
          _high_op(FILTER_LESS_OR_EQUAL),
386
84.9k
          _is_nullable_col(is_nullable_col),
387
84.9k
          _contain_null(is_nullable_col && contain_null),
388
84.9k
          _precision(precision),
389
84.9k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
10.7k
        : _column_name(std::move(col_name)),
381
10.7k
          _column_type(primitive_type),
382
10.7k
          _low_value(min),
383
10.7k
          _high_value(max),
384
10.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
10.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
10.7k
          _is_nullable_col(is_nullable_col),
387
10.7k
          _contain_null(is_nullable_col && contain_null),
388
10.7k
          _precision(precision),
389
10.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
543
        : _column_name(std::move(col_name)),
381
543
          _column_type(primitive_type),
382
543
          _low_value(min),
383
543
          _high_value(max),
384
543
          _low_op(FILTER_LARGER_OR_EQUAL),
385
543
          _high_op(FILTER_LESS_OR_EQUAL),
386
543
          _is_nullable_col(is_nullable_col),
387
543
          _contain_null(is_nullable_col && contain_null),
388
543
          _precision(precision),
389
543
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
7.99k
        : _column_name(std::move(col_name)),
381
7.99k
          _column_type(primitive_type),
382
7.99k
          _low_value(min),
383
7.99k
          _high_value(max),
384
7.99k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
7.99k
          _high_op(FILTER_LESS_OR_EQUAL),
386
7.99k
          _is_nullable_col(is_nullable_col),
387
7.99k
          _contain_null(is_nullable_col && contain_null),
388
7.99k
          _precision(precision),
389
7.99k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
598
        : _column_name(std::move(col_name)),
381
598
          _column_type(primitive_type),
382
598
          _low_value(min),
383
598
          _high_value(max),
384
598
          _low_op(FILTER_LARGER_OR_EQUAL),
385
598
          _high_op(FILTER_LESS_OR_EQUAL),
386
598
          _is_nullable_col(is_nullable_col),
387
598
          _contain_null(is_nullable_col && contain_null),
388
598
          _precision(precision),
389
598
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
9.49k
        : _column_name(std::move(col_name)),
381
9.49k
          _column_type(primitive_type),
382
9.49k
          _low_value(min),
383
9.49k
          _high_value(max),
384
9.49k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
9.49k
          _high_op(FILTER_LESS_OR_EQUAL),
386
9.49k
          _is_nullable_col(is_nullable_col),
387
9.49k
          _contain_null(is_nullable_col && contain_null),
388
9.49k
          _precision(precision),
389
9.49k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
24.0k
        : _column_name(std::move(col_name)),
381
24.0k
          _column_type(primitive_type),
382
24.0k
          _low_value(min),
383
24.0k
          _high_value(max),
384
24.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
24.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
24.0k
          _is_nullable_col(is_nullable_col),
387
24.0k
          _contain_null(is_nullable_col && contain_null),
388
24.0k
          _precision(precision),
389
24.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
11.2k
        : _column_name(std::move(col_name)),
381
11.2k
          _column_type(primitive_type),
382
11.2k
          _low_value(min),
383
11.2k
          _high_value(max),
384
11.2k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.2k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.2k
          _is_nullable_col(is_nullable_col),
387
11.2k
          _contain_null(is_nullable_col && contain_null),
388
11.2k
          _precision(precision),
389
11.2k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
2.10k
        : _column_name(std::move(col_name)),
381
2.10k
          _column_type(primitive_type),
382
2.10k
          _low_value(min),
383
2.10k
          _high_value(max),
384
2.10k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.10k
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.10k
          _is_nullable_col(is_nullable_col),
387
2.10k
          _contain_null(is_nullable_col && contain_null),
388
2.10k
          _precision(precision),
389
2.10k
          _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
1.61M
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.61M
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
99.5k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
99.5k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
16.5k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
16.5k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
216k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
216k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
358k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
358k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.6k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.6k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
8.60k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
8.60k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
13.8k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
13.8k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
537
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
537
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
549
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
549
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
90.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
90.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
80.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
80.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
8.94k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
8.94k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
563k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
563k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
81.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
81.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
596
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
596
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
9.19k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
9.19k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
23.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
23.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.9k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.9k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
1.80k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.80k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
543
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
543
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
7.76k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
7.76k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
328
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
328
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
368
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
368
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
323k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
323k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
323k
    _fixed_values.insert(value);
404
323k
    _contain_null = false;
405
406
323k
    _high_value = TYPE_MIN;
407
323k
    _low_value = TYPE_MAX;
408
409
323k
    return Status::OK();
410
323k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_fixed_valueERKa
Line
Count
Source
398
79.4k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
79.4k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
79.4k
    _fixed_values.insert(value);
404
79.4k
    _contain_null = false;
405
406
79.4k
    _high_value = TYPE_MIN;
407
79.4k
    _low_value = TYPE_MAX;
408
409
79.4k
    return Status::OK();
410
79.4k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_fixed_valueERKs
Line
Count
Source
398
111
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
111
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
111
    _fixed_values.insert(value);
404
111
    _contain_null = false;
405
406
111
    _high_value = TYPE_MIN;
407
111
    _low_value = TYPE_MAX;
408
409
111
    return Status::OK();
410
111
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
52.4k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
52.4k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
52.4k
    _fixed_values.insert(value);
404
52.4k
    _contain_null = false;
405
406
52.4k
    _high_value = TYPE_MIN;
407
52.4k
    _low_value = TYPE_MAX;
408
409
52.4k
    return Status::OK();
410
52.4k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
9.25k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
9.25k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
9.25k
    _fixed_values.insert(value);
404
9.25k
    _contain_null = false;
405
406
9.25k
    _high_value = TYPE_MIN;
407
9.25k
    _low_value = TYPE_MAX;
408
409
9.25k
    return Status::OK();
410
9.25k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
232
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
232
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
232
    _fixed_values.insert(value);
404
232
    _contain_null = false;
405
406
232
    _high_value = TYPE_MIN;
407
232
    _low_value = TYPE_MAX;
408
409
232
    return Status::OK();
410
232
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
29
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
29
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
29
    _fixed_values.insert(value);
404
29
    _contain_null = false;
405
406
29
    _high_value = TYPE_MIN;
407
29
    _low_value = TYPE_MAX;
408
409
29
    return Status::OK();
410
29
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
162
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
162
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
162
    _fixed_values.insert(value);
404
162
    _contain_null = false;
405
406
162
    _high_value = TYPE_MIN;
407
162
    _low_value = TYPE_MAX;
408
409
162
    return Status::OK();
410
162
}
_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
27
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
27
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
27
    _fixed_values.insert(value);
404
27
    _contain_null = false;
405
406
27
    _high_value = TYPE_MIN;
407
27
    _low_value = TYPE_MAX;
408
409
27
    return Status::OK();
410
27
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
568
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
568
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
568
    _fixed_values.insert(value);
404
568
    _contain_null = false;
405
406
568
    _high_value = TYPE_MIN;
407
568
    _low_value = TYPE_MAX;
408
409
568
    return Status::OK();
410
568
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
170k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
170k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
170k
    _fixed_values.insert(value);
404
170k
    _contain_null = false;
405
406
170k
    _high_value = TYPE_MIN;
407
170k
    _low_value = TYPE_MAX;
408
409
170k
    return Status::OK();
410
170k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
362
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
362
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
362
    _fixed_values.insert(value);
404
362
    _contain_null = false;
405
406
362
    _high_value = TYPE_MIN;
407
362
    _low_value = TYPE_MAX;
408
409
362
    return Status::OK();
410
362
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
35
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
35
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
35
    _fixed_values.insert(value);
404
35
    _contain_null = false;
405
406
35
    _high_value = TYPE_MIN;
407
35
    _low_value = TYPE_MAX;
408
409
35
    return Status::OK();
410
35
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
7.93k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
7.93k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
7.93k
    _fixed_values.insert(value);
404
7.93k
    _contain_null = false;
405
406
7.93k
    _high_value = TYPE_MIN;
407
7.93k
    _low_value = TYPE_MAX;
408
409
7.93k
    return Status::OK();
410
7.93k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
60
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
60
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
60
    _fixed_values.insert(value);
404
60
    _contain_null = false;
405
406
60
    _high_value = TYPE_MIN;
407
60
    _low_value = TYPE_MAX;
408
409
60
    return Status::OK();
410
60
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
445
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
445
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
445
    _fixed_values.insert(value);
404
445
    _contain_null = false;
405
406
445
    _high_value = TYPE_MIN;
407
445
    _low_value = TYPE_MAX;
408
409
445
    return Status::OK();
410
445
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
301
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
301
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
301
    _fixed_values.insert(value);
404
301
    _contain_null = false;
405
406
301
    _high_value = TYPE_MIN;
407
301
    _low_value = TYPE_MAX;
408
409
301
    return Status::OK();
410
301
}
_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
189
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
189
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
189
    _fixed_values.insert(value);
404
189
    _contain_null = false;
405
406
189
    _high_value = TYPE_MIN;
407
189
    _low_value = TYPE_MAX;
408
409
189
    return Status::OK();
410
189
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
104
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
104
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
104
    _fixed_values.insert(value);
404
104
    _contain_null = false;
405
406
104
    _high_value = TYPE_MIN;
407
104
    _low_value = TYPE_MAX;
408
409
104
    return Status::OK();
410
104
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
330
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
330
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
330
    _fixed_values.insert(value);
404
330
    _contain_null = false;
405
406
330
    _high_value = TYPE_MIN;
407
330
    _low_value = TYPE_MAX;
408
409
330
    return Status::OK();
410
330
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
239
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
239
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
239
    _fixed_values.insert(value);
404
239
    _contain_null = false;
405
406
239
    _high_value = TYPE_MIN;
407
239
    _low_value = TYPE_MAX;
408
409
239
    return Status::OK();
410
239
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
52
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
52
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
52
    _fixed_values.insert(value);
404
52
    _contain_null = false;
405
406
52
    _high_value = TYPE_MIN;
407
52
    _low_value = TYPE_MAX;
408
409
52
    return Status::OK();
410
52
}
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
5.17M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
5.17M
    return _fixed_values.size() != 0;
420
5.17M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_fixed_value_rangeEv
Line
Count
Source
418
736k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
736k
    return _fixed_values.size() != 0;
420
736k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
19.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
19.3k
    return _fixed_values.size() != 0;
420
19.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
475k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
475k
    return _fixed_values.size() != 0;
420
475k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
806k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
806k
    return _fixed_values.size() != 0;
420
806k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
31.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
31.3k
    return _fixed_values.size() != 0;
420
31.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
8.93k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
8.93k
    return _fixed_values.size() != 0;
420
8.93k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
12.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
12.3k
    return _fixed_values.size() != 0;
420
12.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
495
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
495
    return _fixed_values.size() != 0;
420
495
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
559
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
559
    return _fixed_values.size() != 0;
420
559
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
19.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
19.4k
    return _fixed_values.size() != 0;
420
19.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_fixed_value_rangeEv
Line
Count
Source
418
2.59M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
2.59M
    return _fixed_values.size() != 0;
420
2.59M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_fixed_value_rangeEv
Line
Count
Source
418
83.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
83.7k
    return _fixed_values.size() != 0;
420
83.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_fixed_value_rangeEv
Line
Count
Source
418
838
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
838
    return _fixed_values.size() != 0;
420
838
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_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_13PrimitiveTypeE12EE20is_fixed_value_rangeEv
Line
Count
Source
418
954
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
954
    return _fixed_values.size() != 0;
420
954
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
96.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
96.4k
    return _fixed_values.size() != 0;
420
96.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_fixed_value_rangeEv
Line
Count
Source
418
25.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
25.7k
    return _fixed_values.size() != 0;
420
25.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
1.03k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
1.03k
    return _fixed_values.size() != 0;
420
1.03k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
15.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
15.5k
    return _fixed_values.size() != 0;
420
15.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
597
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
597
    return _fixed_values.size() != 0;
420
597
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
11.8k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
11.8k
    return _fixed_values.size() != 0;
420
11.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_fixed_value_rangeEv
Line
Count
Source
418
27.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
27.2k
    return _fixed_values.size() != 0;
420
27.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_fixed_value_rangeEv
Line
Count
Source
418
17.8k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
17.8k
    return _fixed_values.size() != 0;
420
17.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
4.83k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
4.83k
    return _fixed_values.size() != 0;
420
4.83k
}
421
422
template <PrimitiveType primitive_type>
423
1.88M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.88M
    return Compare::greater(_high_value, _low_value);
425
1.88M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
102k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
102k
    return Compare::greater(_high_value, _low_value);
425
102k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
16.6k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
16.6k
    return Compare::greater(_high_value, _low_value);
425
16.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
280k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
280k
    return Compare::greater(_high_value, _low_value);
425
280k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
482k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
482k
    return Compare::greater(_high_value, _low_value);
425
482k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
16.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
16.0k
    return Compare::greater(_high_value, _low_value);
425
16.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
8.55k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.55k
    return Compare::greater(_high_value, _low_value);
425
8.55k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
11.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
11.1k
    return Compare::greater(_high_value, _low_value);
425
11.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
334
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
334
    return Compare::greater(_high_value, _low_value);
425
334
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
369
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
369
    return Compare::greater(_high_value, _low_value);
425
369
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_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_13PrimitiveTypeE10EE20is_scope_value_rangeEv
Line
Count
Source
423
622k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
622k
    return Compare::greater(_high_value, _low_value);
425
622k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_scope_value_rangeEv
Line
Count
Source
423
80.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
80.8k
    return Compare::greater(_high_value, _low_value);
425
80.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
570
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
570
    return Compare::greater(_high_value, _low_value);
425
570
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
92.7k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
92.7k
    return Compare::greater(_high_value, _low_value);
425
92.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
577
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
577
    return Compare::greater(_high_value, _low_value);
425
577
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
82.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
82.3k
    return Compare::greater(_high_value, _low_value);
425
82.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
12.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.3k
    return Compare::greater(_high_value, _low_value);
425
12.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
660
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
660
    return Compare::greater(_high_value, _low_value);
425
660
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
9.26k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
9.26k
    return Compare::greater(_high_value, _low_value);
425
9.26k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_scope_value_rangeEv
Line
Count
Source
423
597
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
597
    return Compare::greater(_high_value, _low_value);
425
597
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
9.71k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
9.71k
    return Compare::greater(_high_value, _low_value);
425
9.71k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
23.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
23.8k
    return Compare::greater(_high_value, _low_value);
425
23.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
12.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.1k
    return Compare::greater(_high_value, _low_value);
425
12.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
2.40k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
2.40k
    return Compare::greater(_high_value, _low_value);
425
2.40k
}
426
427
template <PrimitiveType primitive_type>
428
2.58M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.58M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.58M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.58M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
260k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
260k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
260k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
260k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
16.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
16.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
16.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
16.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
295k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
295k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
295k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
295k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
486k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
486k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
486k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
486k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
16.5k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
16.5k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
16.5k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
16.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
8.64k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.64k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.64k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.64k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_empty_value_rangeEv
Line
Count
Source
428
11.3k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
11.3k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
11.3k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
11.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_empty_value_rangeEv
Line
Count
Source
428
369
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
369
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
369
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
369
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
412
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
412
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
412
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
412
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_empty_value_rangeEv
Line
Count
Source
428
15.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
15.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
15.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
15.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_empty_value_rangeEv
Line
Count
Source
428
1.12M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.12M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.12M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.12M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
81.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
81.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
81.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
81.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
617
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
617
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
617
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
617
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
108k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
108k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
108k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
108k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
645
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
645
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
645
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
645
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
83.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
83.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
83.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
83.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
12.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_empty_value_rangeEv
Line
Count
Source
428
663
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
663
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
663
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
663
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
9.74k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
9.74k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
9.74k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
9.74k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_empty_value_rangeEv
Line
Count
Source
428
597
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
597
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
597
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
597
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
9.82k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
9.82k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
9.82k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
9.82k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
24.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
24.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
24.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
24.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_empty_value_rangeEv
Line
Count
Source
428
12.5k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.5k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.5k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
2.52k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.52k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.52k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.52k
}
435
436
template <PrimitiveType primitive_type>
437
179k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
179k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
179k
    if (!is_enumeration_type(_column_type)) {
443
19.3k
        return false;
444
19.3k
    }
445
446
159k
    return true;
447
179k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.07k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.07k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.07k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.07k
    return true;
447
2.07k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
91
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
91
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
91
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
91
    return true;
447
91
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_fixed_value_convertibleEv
Line
Count
Source
437
63.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
63.7k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
63.7k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
63.7k
    return true;
447
63.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
86.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
86.7k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
86.7k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
86.7k
    return true;
447
86.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
4.38k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
4.38k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
4.38k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
4.38k
    return true;
447
4.38k
}
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
402
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
402
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
402
    if (!is_enumeration_type(_column_type)) {
443
402
        return false;
444
402
    }
445
446
0
    return true;
447
402
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
8.50k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
8.50k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
8.50k
    if (!is_enumeration_type(_column_type)) {
443
8.49k
        return false;
444
8.49k
    }
445
446
4
    return true;
447
8.50k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_fixed_value_convertibleEv
Line
Count
Source
437
34
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
34
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
34
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
34
    return true;
447
34
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.64k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.64k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.64k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.64k
    return true;
447
2.64k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_fixed_value_convertibleEv
Line
Count
Source
437
30
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
30
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
30
    if (!is_enumeration_type(_column_type)) {
443
30
        return false;
444
30
    }
445
446
0
    return true;
447
30
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.35k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.35k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.36k
    if (!is_enumeration_type(_column_type)) {
443
2.36k
        return false;
444
2.36k
    }
445
446
18.4E
    return true;
447
2.35k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
3.42k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
3.42k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
3.46k
    if (!is_enumeration_type(_column_type)) {
443
3.46k
        return false;
444
3.46k
    }
445
446
18.4E
    return true;
447
3.42k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
119
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
119
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
121
    if (!is_enumeration_type(_column_type)) {
443
121
        return false;
444
121
    }
445
446
18.4E
    return true;
447
119
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.61k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.61k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.63k
    if (!is_enumeration_type(_column_type)) {
443
1.63k
        return false;
444
1.63k
    }
445
446
18.4E
    return true;
447
1.61k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
487
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
487
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
487
    if (!is_enumeration_type(_column_type)) {
443
486
        return false;
444
486
    }
445
446
1
    return true;
447
487
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
632
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
632
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
632
    if (!is_enumeration_type(_column_type)) {
443
631
        return false;
444
631
    }
445
446
1
    return true;
447
632
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.19k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.19k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.20k
    if (!is_enumeration_type(_column_type)) {
443
1.20k
        return false;
444
1.20k
    }
445
446
18.4E
    return true;
447
1.19k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
536
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
536
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
540
    if (!is_enumeration_type(_column_type)) {
443
540
        return false;
444
540
    }
445
446
18.4E
    return true;
447
536
}
448
449
template <PrimitiveType primitive_type>
450
155
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
155
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
155
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
154
    return true;
460
155
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
152
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
152
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
152
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
152
    return true;
460
152
}
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
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_range_value_convertibleEv
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
155k
        bool& begin_include, bool& end_include) {
467
155k
    if constexpr (!_is_reject_split_type) {
468
155k
        begin_include = true;
469
155k
        end_include = true;
470
471
155k
        bool is_empty = false;
472
473
155k
        if (!is_begin_include()) {
474
10.1k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
10.1k
            } else {
477
10.1k
                ++_low_value;
478
10.1k
            }
479
10.1k
        }
480
481
155k
        if (!is_end_include()) {
482
683
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
683
            } else {
485
683
                --_high_value;
486
683
            }
487
683
        }
488
489
155k
        if (Compare::less(_high_value, _low_value)) {
490
26
            is_empty = true;
491
26
        }
492
493
155k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
155k
    }
499
155k
    return false;
500
155k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.06k
        bool& begin_include, bool& end_include) {
467
2.06k
    if constexpr (!_is_reject_split_type) {
468
2.06k
        begin_include = true;
469
2.06k
        end_include = true;
470
471
2.06k
        bool is_empty = false;
472
473
2.06k
        if (!is_begin_include()) {
474
68
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
68
            } else {
477
68
                ++_low_value;
478
68
            }
479
68
        }
480
481
2.06k
        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.06k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.06k
        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.06k
    }
499
2.06k
    return false;
500
2.06k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
91
        bool& begin_include, bool& end_include) {
467
91
    if constexpr (!_is_reject_split_type) {
468
91
        begin_include = true;
469
91
        end_include = true;
470
471
91
        bool is_empty = false;
472
473
91
        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
91
        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
91
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
91
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
91
    }
499
91
    return false;
500
91
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
63.7k
        bool& begin_include, bool& end_include) {
467
63.7k
    if constexpr (!_is_reject_split_type) {
468
63.7k
        begin_include = true;
469
63.7k
        end_include = true;
470
471
63.7k
        bool is_empty = false;
472
473
63.7k
        if (!is_begin_include()) {
474
559
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
559
            } else {
477
559
                ++_low_value;
478
559
            }
479
559
        }
480
481
63.7k
        if (!is_end_include()) {
482
582
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
582
            } else {
485
582
                --_high_value;
486
582
            }
487
582
        }
488
489
63.7k
        if (Compare::less(_high_value, _low_value)) {
490
26
            is_empty = true;
491
26
        }
492
493
63.7k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
63.7k
    }
499
63.7k
    return false;
500
63.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
86.6k
        bool& begin_include, bool& end_include) {
467
86.6k
    if constexpr (!_is_reject_split_type) {
468
86.6k
        begin_include = true;
469
86.6k
        end_include = true;
470
471
86.6k
        bool is_empty = false;
472
473
86.6k
        if (!is_begin_include()) {
474
9.55k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
9.55k
            } else {
477
9.55k
                ++_low_value;
478
9.55k
            }
479
9.55k
        }
480
481
86.6k
        if (!is_end_include()) {
482
7
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
7
            } else {
485
7
                --_high_value;
486
7
            }
487
7
        }
488
489
86.6k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
86.6k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
86.6k
    }
499
86.6k
    return false;
500
86.6k
}
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
34
        bool& begin_include, bool& end_include) {
467
34
    if constexpr (!_is_reject_split_type) {
468
34
        begin_include = true;
469
34
        end_include = true;
470
471
34
        bool is_empty = false;
472
473
34
        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
34
        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
34
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
34
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
34
    }
499
34
    return false;
500
34
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.65k
        bool& begin_include, bool& end_include) {
467
2.65k
    if constexpr (!_is_reject_split_type) {
468
2.65k
        begin_include = true;
469
2.65k
        end_include = true;
470
471
2.65k
        bool is_empty = false;
472
473
2.65k
        if (!is_begin_include()) {
474
12
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
12
            } else {
477
12
                ++_low_value;
478
12
            }
479
12
        }
480
481
2.65k
        if (!is_end_include()) {
482
74
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
74
            } else {
485
74
                --_high_value;
486
74
            }
487
74
        }
488
489
2.65k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.65k
        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.65k
    }
499
2.65k
    return false;
500
2.65k
}
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
155k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
155k
    if constexpr (!_is_reject_split_type) {
508
155k
        CppType min_value = get_range_min_value();
509
155k
        CppType max_value = get_range_max_value();
510
155k
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
34
            min_value.set_type(TimeType::TIME_DATE);
512
34
            max_value.set_type(TimeType::TIME_DATE);
513
34
        }
514
155k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
155k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
26
            DCHECK(contain_null());
518
26
        }
519
520
155k
        auto no_split = [&]() -> bool {
521
149k
            begin_scan_keys.emplace_back();
522
149k
            begin_scan_keys.back().add_value(
523
149k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
149k
                    contain_null());
525
149k
            end_scan_keys.emplace_back();
526
149k
            end_scan_keys.back().add_value(
527
149k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
149k
                    empty_range_only_null ? true : false);
529
149k
            return true;
530
149k
        };
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
63.0k
        auto no_split = [&]() -> bool {
521
63.0k
            begin_scan_keys.emplace_back();
522
63.0k
            begin_scan_keys.back().add_value(
523
63.0k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
63.0k
                    contain_null());
525
63.0k
            end_scan_keys.emplace_back();
526
63.0k
            end_scan_keys.back().add_value(
527
63.0k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
63.0k
                    empty_range_only_null ? true : false);
529
63.0k
            return true;
530
63.0k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
86.2k
        auto no_split = [&]() -> bool {
521
86.2k
            begin_scan_keys.emplace_back();
522
86.2k
            begin_scan_keys.back().add_value(
523
86.2k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
86.2k
                    contain_null());
525
86.2k
            end_scan_keys.emplace_back();
526
86.2k
            end_scan_keys.back().add_value(
527
86.2k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
86.2k
                    empty_range_only_null ? true : false);
529
86.2k
            return true;
530
86.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
155k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
26
            return no_split();
533
26
        }
534
535
387k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
129k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
129k
                return value;
539
257k
            } else {
540
257k
                return (int128_t)value;
541
257k
            }
542
387k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKaE_clESA_
Line
Count
Source
535
91.5k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
91.5k
            } else {
540
91.5k
                return (int128_t)value;
541
91.5k
            }
542
91.5k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKsE_clESA_
Line
Count
Source
535
4.45k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
4.45k
            } else {
540
4.45k
                return (int128_t)value;
541
4.45k
            }
542
4.45k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKiE_clESA_
Line
Count
Source
535
73.4k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
73.4k
            } else {
540
73.4k
                return (int128_t)value;
541
73.4k
            }
542
73.4k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
88.4k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
88.4k
            } else {
540
88.4k
                return (int128_t)value;
541
88.4k
            }
542
88.4k
        };
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
1.66k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
1.66k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
1.66k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
1.66k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
128k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
128k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
128k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
128k
        };
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
155k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
155k
        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
155k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
149k
            return no_split();
552
149k
        }
553
5.66k
        int step_size = cast_set<int>(step_size_may_overflow);
554
5.66k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
5.66k
        if (contain_null()) {
558
2.76k
            begin_scan_keys.emplace_back();
559
2.76k
            begin_scan_keys.back().add_null();
560
2.76k
            end_scan_keys.emplace_back();
561
2.76k
            end_scan_keys.back().add_null();
562
2.76k
        }
563
232k
        while (true) {
564
232k
            begin_scan_keys.emplace_back();
565
232k
            begin_scan_keys.back().add_value(
566
232k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
232k
            if (cast(max_value) - min_value < step_size) {
569
4.92k
                min_value = max_value;
570
227k
            } else {
571
227k
                min_value += step_size;
572
227k
            }
573
574
232k
            end_scan_keys.emplace_back();
575
232k
            end_scan_keys.back().add_value(
576
232k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
232k
            if (Compare::equal(min_value, max_value)) {
579
5.90k
                break;
580
5.90k
            }
581
226k
            ++min_value;
582
226k
            ++real_step_size;
583
226k
            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
226k
        }
592
593
5.66k
        return step_size != 0;
594
5.66k
    }
595
0
    return false;
596
155k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.07k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.07k
    if constexpr (!_is_reject_split_type) {
508
2.07k
        CppType min_value = get_range_min_value();
509
2.07k
        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.07k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.07k
        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.07k
        auto no_split = [&]() -> bool {
521
2.07k
            begin_scan_keys.emplace_back();
522
2.07k
            begin_scan_keys.back().add_value(
523
2.07k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.07k
                    contain_null());
525
2.07k
            end_scan_keys.emplace_back();
526
2.07k
            end_scan_keys.back().add_value(
527
2.07k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.07k
                    empty_range_only_null ? true : false);
529
2.07k
            return true;
530
2.07k
        };
531
2.07k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.07k
        auto cast = [](const CppType& value) {
536
2.07k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.07k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.07k
                return value;
539
2.07k
            } else {
540
2.07k
                return (int128_t)value;
541
2.07k
            }
542
2.07k
        };
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.07k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.07k
        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.07k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.07k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.07k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.07k
        if (contain_null()) {
558
1.64k
            begin_scan_keys.emplace_back();
559
1.64k
            begin_scan_keys.back().add_null();
560
1.64k
            end_scan_keys.emplace_back();
561
1.64k
            end_scan_keys.back().add_null();
562
1.64k
        }
563
89.4k
        while (true) {
564
89.4k
            begin_scan_keys.emplace_back();
565
89.4k
            begin_scan_keys.back().add_value(
566
89.4k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
89.4k
            if (cast(max_value) - min_value < step_size) {
569
2.06k
                min_value = max_value;
570
87.3k
            } else {
571
87.3k
                min_value += step_size;
572
87.3k
            }
573
574
89.4k
            end_scan_keys.emplace_back();
575
89.4k
            end_scan_keys.back().add_value(
576
89.4k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
89.4k
            if (Compare::equal(min_value, max_value)) {
579
2.11k
                break;
580
2.11k
            }
581
87.2k
            ++min_value;
582
87.2k
            ++real_step_size;
583
87.2k
            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
87.2k
        }
592
593
2.07k
        return step_size != 0;
594
2.07k
    }
595
0
    return false;
596
2.07k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
91
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
91
    if constexpr (!_is_reject_split_type) {
508
91
        CppType min_value = get_range_min_value();
509
91
        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
91
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
91
        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
91
        auto no_split = [&]() -> bool {
521
91
            begin_scan_keys.emplace_back();
522
91
            begin_scan_keys.back().add_value(
523
91
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
91
                    contain_null());
525
91
            end_scan_keys.emplace_back();
526
91
            end_scan_keys.back().add_value(
527
91
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
91
                    empty_range_only_null ? true : false);
529
91
            return true;
530
91
        };
531
91
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
91
        auto cast = [](const CppType& value) {
536
91
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
91
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
91
                return value;
539
91
            } else {
540
91
                return (int128_t)value;
541
91
            }
542
91
        };
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
91
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
91
        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
91
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
91
        int step_size = cast_set<int>(step_size_may_overflow);
554
91
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
91
        if (contain_null()) {
558
85
            begin_scan_keys.emplace_back();
559
85
            begin_scan_keys.back().add_null();
560
85
            end_scan_keys.emplace_back();
561
85
            end_scan_keys.back().add_null();
562
85
        }
563
4.36k
        while (true) {
564
4.36k
            begin_scan_keys.emplace_back();
565
4.36k
            begin_scan_keys.back().add_value(
566
4.36k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
4.36k
            if (cast(max_value) - min_value < step_size) {
569
91
                min_value = max_value;
570
4.27k
            } else {
571
4.27k
                min_value += step_size;
572
4.27k
            }
573
574
4.36k
            end_scan_keys.emplace_back();
575
4.36k
            end_scan_keys.back().add_value(
576
4.36k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
4.36k
            if (Compare::equal(min_value, max_value)) {
579
91
                break;
580
91
            }
581
4.27k
            ++min_value;
582
4.27k
            ++real_step_size;
583
4.27k
            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
4.27k
        }
592
593
91
        return step_size != 0;
594
91
    }
595
0
    return false;
596
91
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
64.1k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
64.1k
    if constexpr (!_is_reject_split_type) {
508
64.1k
        CppType min_value = get_range_min_value();
509
64.1k
        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
64.1k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
64.1k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
26
            DCHECK(contain_null());
518
26
        }
519
520
64.1k
        auto no_split = [&]() -> bool {
521
64.1k
            begin_scan_keys.emplace_back();
522
64.1k
            begin_scan_keys.back().add_value(
523
64.1k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
64.1k
                    contain_null());
525
64.1k
            end_scan_keys.emplace_back();
526
64.1k
            end_scan_keys.back().add_value(
527
64.1k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
64.1k
                    empty_range_only_null ? true : false);
529
64.1k
            return true;
530
64.1k
        };
531
64.1k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
26
            return no_split();
533
26
        }
534
535
64.1k
        auto cast = [](const CppType& value) {
536
64.1k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
64.1k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
64.1k
                return value;
539
64.1k
            } else {
540
64.1k
                return (int128_t)value;
541
64.1k
            }
542
64.1k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
64.1k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
64.1k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
64.1k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
63.4k
            return no_split();
552
63.4k
        }
553
706
        int step_size = cast_set<int>(step_size_may_overflow);
554
706
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
706
        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
9.56k
        while (true) {
564
9.56k
            begin_scan_keys.emplace_back();
565
9.56k
            begin_scan_keys.back().add_value(
566
9.56k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
9.56k
            if (cast(max_value) - min_value < step_size) {
569
137
                min_value = max_value;
570
9.43k
            } else {
571
9.43k
                min_value += step_size;
572
9.43k
            }
573
574
9.56k
            end_scan_keys.emplace_back();
575
9.56k
            end_scan_keys.back().add_value(
576
9.56k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
9.56k
            if (Compare::equal(min_value, max_value)) {
579
733
                break;
580
733
            }
581
8.83k
            ++min_value;
582
8.83k
            ++real_step_size;
583
8.83k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
8.83k
        }
592
593
706
        return step_size != 0;
594
706
    }
595
0
    return false;
596
64.1k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
86.6k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
86.6k
    if constexpr (!_is_reject_split_type) {
508
86.6k
        CppType min_value = get_range_min_value();
509
86.6k
        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
86.6k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
86.6k
        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
86.6k
        auto no_split = [&]() -> bool {
521
86.6k
            begin_scan_keys.emplace_back();
522
86.6k
            begin_scan_keys.back().add_value(
523
86.6k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
86.6k
                    contain_null());
525
86.6k
            end_scan_keys.emplace_back();
526
86.6k
            end_scan_keys.back().add_value(
527
86.6k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
86.6k
                    empty_range_only_null ? true : false);
529
86.6k
            return true;
530
86.6k
        };
531
86.6k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
86.6k
        auto cast = [](const CppType& value) {
536
86.6k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
86.6k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
86.6k
                return value;
539
86.6k
            } else {
540
86.6k
                return (int128_t)value;
541
86.6k
            }
542
86.6k
        };
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
86.6k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
86.6k
        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
86.6k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
86.5k
            return no_split();
552
86.5k
        }
553
112
        int step_size = cast_set<int>(step_size_may_overflow);
554
112
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
112
        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.84k
        while (true) {
564
1.84k
            begin_scan_keys.emplace_back();
565
1.84k
            begin_scan_keys.back().add_value(
566
1.84k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.84k
            if (cast(max_value) - min_value < step_size) {
569
7
                min_value = max_value;
570
1.83k
            } else {
571
1.83k
                min_value += step_size;
572
1.83k
            }
573
574
1.84k
            end_scan_keys.emplace_back();
575
1.84k
            end_scan_keys.back().add_value(
576
1.84k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.84k
            if (Compare::equal(min_value, max_value)) {
579
276
                break;
580
276
            }
581
1.56k
            ++min_value;
582
1.56k
            ++real_step_size;
583
1.56k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
1.56k
        }
592
593
112
        return step_size != 0;
594
112
    }
595
0
    return false;
596
86.6k
}
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
34
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
34
    if constexpr (!_is_reject_split_type) {
508
34
        CppType min_value = get_range_min_value();
509
34
        CppType max_value = get_range_max_value();
510
34
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
34
            min_value.set_type(TimeType::TIME_DATE);
512
34
            max_value.set_type(TimeType::TIME_DATE);
513
34
        }
514
34
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
34
        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
34
        auto no_split = [&]() -> bool {
521
34
            begin_scan_keys.emplace_back();
522
34
            begin_scan_keys.back().add_value(
523
34
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
34
                    contain_null());
525
34
            end_scan_keys.emplace_back();
526
34
            end_scan_keys.back().add_value(
527
34
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
34
                    empty_range_only_null ? true : false);
529
34
            return true;
530
34
        };
531
34
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
34
        auto cast = [](const CppType& value) {
536
34
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
34
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
34
                return value;
539
34
            } else {
540
34
                return (int128_t)value;
541
34
            }
542
34
        };
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
34
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
34
        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
34
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
34
        int step_size = cast_set<int>(step_size_may_overflow);
554
34
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
34
        if (contain_null()) {
558
34
            begin_scan_keys.emplace_back();
559
34
            begin_scan_keys.back().add_null();
560
34
            end_scan_keys.emplace_back();
561
34
            end_scan_keys.back().add_null();
562
34
        }
563
1.63k
        while (true) {
564
1.63k
            begin_scan_keys.emplace_back();
565
1.63k
            begin_scan_keys.back().add_value(
566
1.63k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.63k
            if (cast(max_value) - min_value < step_size) {
569
34
                min_value = max_value;
570
1.59k
            } else {
571
1.59k
                min_value += step_size;
572
1.59k
            }
573
574
1.63k
            end_scan_keys.emplace_back();
575
1.63k
            end_scan_keys.back().add_value(
576
1.63k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.63k
            if (Compare::equal(min_value, max_value)) {
579
34
                break;
580
34
            }
581
1.59k
            ++min_value;
582
1.59k
            ++real_step_size;
583
1.59k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
1.59k
        }
592
593
34
        return step_size != 0;
594
34
    }
595
0
    return false;
596
34
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.64k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.64k
    if constexpr (!_is_reject_split_type) {
508
2.64k
        CppType min_value = get_range_min_value();
509
2.64k
        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.64k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.64k
        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.64k
        auto no_split = [&]() -> bool {
521
2.64k
            begin_scan_keys.emplace_back();
522
2.64k
            begin_scan_keys.back().add_value(
523
2.64k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.64k
                    contain_null());
525
2.64k
            end_scan_keys.emplace_back();
526
2.64k
            end_scan_keys.back().add_value(
527
2.64k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.64k
                    empty_range_only_null ? true : false);
529
2.64k
            return true;
530
2.64k
        };
531
2.64k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.64k
        auto cast = [](const CppType& value) {
536
2.64k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.64k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.64k
                return value;
539
2.64k
            } else {
540
2.64k
                return (int128_t)value;
541
2.64k
            }
542
2.64k
        };
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.64k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.64k
        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.64k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.64k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.64k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.64k
        if (contain_null()) {
558
994
            begin_scan_keys.emplace_back();
559
994
            begin_scan_keys.back().add_null();
560
994
            end_scan_keys.emplace_back();
561
994
            end_scan_keys.back().add_null();
562
994
        }
563
125k
        while (true) {
564
125k
            begin_scan_keys.emplace_back();
565
125k
            begin_scan_keys.back().add_value(
566
125k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
125k
            if (cast(max_value) - min_value < step_size) {
569
2.58k
                min_value = max_value;
570
122k
            } else {
571
122k
                min_value += step_size;
572
122k
            }
573
574
125k
            end_scan_keys.emplace_back();
575
125k
            end_scan_keys.back().add_value(
576
125k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
125k
            if (Compare::equal(min_value, max_value)) {
579
2.66k
                break;
580
2.66k
            }
581
122k
            ++min_value;
582
122k
            ++real_step_size;
583
122k
            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
122k
        }
592
593
2.64k
        return step_size != 0;
594
2.64k
    }
595
0
    return false;
596
2.64k
}
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
77
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
77
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
77
    if (!_fixed_values.empty()) {
605
77
        _low_value = *_fixed_values.begin();
606
77
        _low_op = FILTER_LARGER_OR_EQUAL;
607
77
        _high_value = *_fixed_values.rbegin();
608
77
        _high_op = FILTER_LESS_OR_EQUAL;
609
77
        _fixed_values.clear();
610
77
    }
611
77
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
76
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
76
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
76
    if (!_fixed_values.empty()) {
605
76
        _low_value = *_fixed_values.begin();
606
76
        _low_op = FILTER_LARGER_OR_EQUAL;
607
76
        _high_value = *_fixed_values.rbegin();
608
76
        _high_op = FILTER_LESS_OR_EQUAL;
609
76
        _fixed_values.clear();
610
76
    }
611
76
}
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
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_range_valueEv
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
141k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
141k
    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
141k
    _contain_null = false;
621
622
141k
    if (is_fixed_value_range()) {
623
7.31k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
7.31k
        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
6.96k
        case FILTER_LARGER_OR_EQUAL: {
632
6.96k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
6.96k
            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
355
        case FILTER_LESS_OR_EQUAL: {
647
355
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
355
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
7.31k
        }
655
656
7.31k
        _high_value = TYPE_MIN;
657
7.31k
        _low_value = TYPE_MAX;
658
134k
    } else {
659
134k
        if (Compare::greater(_high_value, _low_value)) {
660
67.9k
            switch (op) {
661
30.6k
            case FILTER_LARGER: {
662
30.6k
                if (Compare::greater_equal(value, _low_value)) {
663
30.6k
                    _low_value = value;
664
30.6k
                    _low_op = op;
665
30.6k
                }
666
667
30.6k
                break;
668
0
            }
669
670
16.8k
            case FILTER_LARGER_OR_EQUAL: {
671
16.8k
                if (Compare::greater(value, _low_value)) {
672
15.5k
                    _low_value = value;
673
15.5k
                    _low_op = op;
674
15.5k
                }
675
676
16.8k
                break;
677
0
            }
678
679
5.75k
            case FILTER_LESS: {
680
5.75k
                if (Compare::less_equal(value, _high_value)) {
681
5.74k
                    _high_value = value;
682
5.74k
                    _high_op = op;
683
5.74k
                }
684
685
5.75k
                break;
686
0
            }
687
688
14.6k
            case FILTER_LESS_OR_EQUAL: {
689
14.6k
                if (Compare::less(value, _high_value)) {
690
13.5k
                    _high_value = value;
691
13.5k
                    _high_op = op;
692
13.5k
                }
693
694
14.6k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
67.9k
            }
701
67.9k
        }
702
703
134k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
134k
            Compare::equal(_high_value, _low_value)) {
705
8.79k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
8.79k
            _high_value = TYPE_MIN;
707
8.79k
            _low_value = TYPE_MAX;
708
8.79k
        }
709
134k
    }
710
711
141k
    return Status::OK();
712
141k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
2.17k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2.17k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
2.17k
    _contain_null = false;
621
622
2.17k
    if (is_fixed_value_range()) {
623
94
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
94
        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
70
        case FILTER_LARGER_OR_EQUAL: {
632
70
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
70
            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
24
        case FILTER_LESS_OR_EQUAL: {
647
24
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
24
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
94
        }
655
656
94
        _high_value = TYPE_MIN;
657
94
        _low_value = TYPE_MAX;
658
2.08k
    } else {
659
2.08k
        if (Compare::greater(_high_value, _low_value)) {
660
1.80k
            switch (op) {
661
387
            case FILTER_LARGER: {
662
387
                if (Compare::greater_equal(value, _low_value)) {
663
383
                    _low_value = value;
664
383
                    _low_op = op;
665
383
                }
666
667
387
                break;
668
0
            }
669
670
581
            case FILTER_LARGER_OR_EQUAL: {
671
581
                if (Compare::greater(value, _low_value)) {
672
349
                    _low_value = value;
673
349
                    _low_op = op;
674
349
                }
675
676
581
                break;
677
0
            }
678
679
370
            case FILTER_LESS: {
680
370
                if (Compare::less_equal(value, _high_value)) {
681
369
                    _high_value = value;
682
369
                    _high_op = op;
683
369
                }
684
685
370
                break;
686
0
            }
687
688
470
            case FILTER_LESS_OR_EQUAL: {
689
470
                if (Compare::less(value, _high_value)) {
690
243
                    _high_value = value;
691
243
                    _high_op = op;
692
243
                }
693
694
470
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.80k
            }
701
1.80k
        }
702
703
2.07k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
2.07k
            Compare::equal(_high_value, _low_value)) {
705
74
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
74
            _high_value = TYPE_MIN;
707
74
            _low_value = TYPE_MAX;
708
74
        }
709
2.07k
    }
710
711
2.16k
    return Status::OK();
712
2.17k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
1.75k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.75k
    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.75k
    _contain_null = false;
621
622
1.75k
    if (is_fixed_value_range()) {
623
22
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
22
        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
        case FILTER_LARGER_OR_EQUAL: {
632
11
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
11
            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
11
        case FILTER_LESS_OR_EQUAL: {
647
11
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
11
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
22
        }
655
656
22
        _high_value = TYPE_MIN;
657
22
        _low_value = TYPE_MAX;
658
1.72k
    } else {
659
1.72k
        if (Compare::greater(_high_value, _low_value)) {
660
1.70k
            switch (op) {
661
1.28k
            case FILTER_LARGER: {
662
1.28k
                if (Compare::greater_equal(value, _low_value)) {
663
1.28k
                    _low_value = value;
664
1.28k
                    _low_op = op;
665
1.28k
                }
666
667
1.28k
                break;
668
0
            }
669
670
286
            case FILTER_LARGER_OR_EQUAL: {
671
286
                if (Compare::greater(value, _low_value)) {
672
249
                    _low_value = value;
673
249
                    _low_op = op;
674
249
                }
675
676
286
                break;
677
0
            }
678
679
14
            case FILTER_LESS: {
680
14
                if (Compare::less_equal(value, _high_value)) {
681
14
                    _high_value = value;
682
14
                    _high_op = op;
683
14
                }
684
685
14
                break;
686
0
            }
687
688
121
            case FILTER_LESS_OR_EQUAL: {
689
121
                if (Compare::less(value, _high_value)) {
690
74
                    _high_value = value;
691
74
                    _high_op = op;
692
74
                }
693
694
121
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.70k
            }
701
1.70k
        }
702
703
1.71k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.71k
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
1.71k
    }
710
711
1.73k
    return Status::OK();
712
1.75k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
10.5k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
10.5k
    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.5k
    _contain_null = false;
621
622
10.5k
    if (is_fixed_value_range()) {
623
592
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
592
        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
421
        case FILTER_LARGER_OR_EQUAL: {
632
421
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
421
            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
171
        case FILTER_LESS_OR_EQUAL: {
647
171
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
171
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
592
        }
655
656
592
        _high_value = TYPE_MIN;
657
592
        _low_value = TYPE_MAX;
658
9.99k
    } else {
659
9.99k
        if (Compare::greater(_high_value, _low_value)) {
660
9.47k
            switch (op) {
661
2.30k
            case FILTER_LARGER: {
662
2.30k
                if (Compare::greater_equal(value, _low_value)) {
663
2.30k
                    _low_value = value;
664
2.30k
                    _low_op = op;
665
2.30k
                }
666
667
2.30k
                break;
668
0
            }
669
670
3.17k
            case FILTER_LARGER_OR_EQUAL: {
671
3.17k
                if (Compare::greater(value, _low_value)) {
672
2.72k
                    _low_value = value;
673
2.72k
                    _low_op = op;
674
2.72k
                }
675
676
3.17k
                break;
677
0
            }
678
679
860
            case FILTER_LESS: {
680
860
                if (Compare::less_equal(value, _high_value)) {
681
859
                    _high_value = value;
682
859
                    _high_op = op;
683
859
                }
684
685
860
                break;
686
0
            }
687
688
3.12k
            case FILTER_LESS_OR_EQUAL: {
689
3.12k
                if (Compare::less(value, _high_value)) {
690
2.68k
                    _high_value = value;
691
2.68k
                    _high_op = op;
692
2.68k
                }
693
694
3.12k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
9.47k
            }
701
9.47k
        }
702
703
9.96k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
9.96k
            Compare::equal(_high_value, _low_value)) {
705
625
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
625
            _high_value = TYPE_MIN;
707
625
            _low_value = TYPE_MAX;
708
625
        }
709
9.96k
    }
710
711
10.5k
    return Status::OK();
712
10.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
97.7k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
97.7k
    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
97.7k
    _contain_null = false;
621
622
97.7k
    if (is_fixed_value_range()) {
623
6.48k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
6.48k
        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
6.36k
        case FILTER_LARGER_OR_EQUAL: {
632
6.36k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
6.36k
            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
115
        case FILTER_LESS_OR_EQUAL: {
647
115
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
115
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
6.48k
        }
655
656
6.48k
        _high_value = TYPE_MIN;
657
6.48k
        _low_value = TYPE_MAX;
658
91.2k
    } else {
659
91.2k
        if (Compare::greater(_high_value, _low_value)) {
660
25.5k
            switch (op) {
661
11.5k
            case FILTER_LARGER: {
662
11.5k
                if (Compare::greater_equal(value, _low_value)) {
663
11.5k
                    _low_value = value;
664
11.5k
                    _low_op = op;
665
11.5k
                }
666
667
11.5k
                break;
668
0
            }
669
670
5.37k
            case FILTER_LARGER_OR_EQUAL: {
671
5.37k
                if (Compare::greater(value, _low_value)) {
672
5.36k
                    _low_value = value;
673
5.36k
                    _low_op = op;
674
5.36k
                }
675
676
5.37k
                break;
677
0
            }
678
679
43
            case FILTER_LESS: {
680
43
                if (Compare::less_equal(value, _high_value)) {
681
42
                    _high_value = value;
682
42
                    _high_op = op;
683
42
                }
684
685
43
                break;
686
0
            }
687
688
8.62k
            case FILTER_LESS_OR_EQUAL: {
689
8.62k
                if (Compare::less(value, _high_value)) {
690
8.59k
                    _high_value = value;
691
8.59k
                    _high_op = op;
692
8.59k
                }
693
694
8.62k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
25.5k
            }
701
25.5k
        }
702
703
91.2k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
91.2k
            Compare::equal(_high_value, _low_value)) {
705
7.43k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
7.43k
            _high_value = TYPE_MIN;
707
7.43k
            _low_value = TYPE_MAX;
708
7.43k
        }
709
91.2k
    }
710
711
97.7k
    return Status::OK();
712
97.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
156
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
156
    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
156
    _contain_null = false;
621
622
156
    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
156
    } else {
659
156
        if (Compare::greater(_high_value, _low_value)) {
660
156
            switch (op) {
661
80
            case FILTER_LARGER: {
662
80
                if (Compare::greater_equal(value, _low_value)) {
663
79
                    _low_value = value;
664
79
                    _low_op = op;
665
79
                }
666
667
80
                break;
668
0
            }
669
670
19
            case FILTER_LARGER_OR_EQUAL: {
671
19
                if (Compare::greater(value, _low_value)) {
672
16
                    _low_value = value;
673
16
                    _low_op = op;
674
16
                }
675
676
19
                break;
677
0
            }
678
679
8
            case FILTER_LESS: {
680
8
                if (Compare::less_equal(value, _high_value)) {
681
8
                    _high_value = value;
682
8
                    _high_op = op;
683
8
                }
684
685
8
                break;
686
0
            }
687
688
49
            case FILTER_LESS_OR_EQUAL: {
689
49
                if (Compare::less(value, _high_value)) {
690
47
                    _high_value = value;
691
47
                    _high_op = op;
692
47
                }
693
694
49
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
156
            }
701
156
        }
702
703
155
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
155
            Compare::equal(_high_value, _low_value)) {
705
14
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
14
            _high_value = TYPE_MIN;
707
14
            _low_value = TYPE_MAX;
708
14
        }
709
155
    }
710
711
155
    return Status::OK();
712
156
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
83
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
83
    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
83
    _contain_null = false;
621
622
83
    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
83
    } else {
659
83
        if (Compare::greater(_high_value, _low_value)) {
660
82
            switch (op) {
661
31
            case FILTER_LARGER: {
662
31
                if (Compare::greater_equal(value, _low_value)) {
663
31
                    _low_value = value;
664
31
                    _low_op = op;
665
31
                }
666
667
31
                break;
668
0
            }
669
670
23
            case FILTER_LARGER_OR_EQUAL: {
671
23
                if (Compare::greater(value, _low_value)) {
672
13
                    _low_value = value;
673
13
                    _low_op = op;
674
13
                }
675
676
23
                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
19
            case FILTER_LESS_OR_EQUAL: {
689
19
                if (Compare::less(value, _high_value)) {
690
7
                    _high_value = value;
691
7
                    _high_op = op;
692
7
                }
693
694
19
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
82
            }
701
82
        }
702
703
82
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
82
            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
82
    }
710
711
82
    return Status::OK();
712
83
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
215
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
215
    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
215
    _contain_null = false;
621
622
215
    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
215
    } else {
659
216
        if (Compare::greater(_high_value, _low_value)) {
660
216
            switch (op) {
661
42
            case FILTER_LARGER: {
662
42
                if (Compare::greater_equal(value, _low_value)) {
663
42
                    _low_value = value;
664
42
                    _low_op = op;
665
42
                }
666
667
42
                break;
668
0
            }
669
670
70
            case FILTER_LARGER_OR_EQUAL: {
671
70
                if (Compare::greater(value, _low_value)) {
672
39
                    _low_value = value;
673
39
                    _low_op = op;
674
39
                }
675
676
70
                break;
677
0
            }
678
679
41
            case FILTER_LESS: {
680
41
                if (Compare::less_equal(value, _high_value)) {
681
41
                    _high_value = value;
682
41
                    _high_op = op;
683
41
                }
684
685
41
                break;
686
0
            }
687
688
66
            case FILTER_LESS_OR_EQUAL: {
689
66
                if (Compare::less(value, _high_value)) {
690
36
                    _high_value = value;
691
36
                    _high_op = op;
692
36
                }
693
694
66
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
216
            }
701
216
        }
702
703
216
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
216
            Compare::equal(_high_value, _low_value)) {
705
14
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
14
            _high_value = TYPE_MIN;
707
14
            _low_value = TYPE_MAX;
708
14
        }
709
216
    }
710
711
216
    return Status::OK();
712
215
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
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_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
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
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
3
                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
1
            case FILTER_LESS_OR_EQUAL: {
689
1
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
1
                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_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
832
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
832
    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
832
    _contain_null = false;
621
622
832
    if (is_fixed_value_range()) {
623
10
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
10
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
5
        case FILTER_LARGER_OR_EQUAL: {
632
5
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
5
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
5
        case FILTER_LESS_OR_EQUAL: {
647
5
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
5
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
10
        }
655
656
10
        _high_value = TYPE_MIN;
657
10
        _low_value = TYPE_MAX;
658
822
    } else {
659
822
        if (Compare::greater(_high_value, _low_value)) {
660
820
            switch (op) {
661
656
            case FILTER_LARGER: {
662
658
                if (Compare::greater_equal(value, _low_value)) {
663
658
                    _low_value = value;
664
658
                    _low_op = op;
665
658
                }
666
667
656
                break;
668
0
            }
669
670
74
            case FILTER_LARGER_OR_EQUAL: {
671
74
                if (Compare::greater(value, _low_value)) {
672
35
                    _low_value = value;
673
35
                    _low_op = op;
674
35
                }
675
676
74
                break;
677
0
            }
678
679
23
            case FILTER_LESS: {
680
23
                if (Compare::less_equal(value, _high_value)) {
681
23
                    _high_value = value;
682
23
                    _high_op = op;
683
23
                }
684
685
23
                break;
686
0
            }
687
688
62
            case FILTER_LESS_OR_EQUAL: {
689
62
                if (Compare::less(value, _high_value)) {
690
44
                    _high_value = value;
691
44
                    _high_op = op;
692
44
                }
693
694
62
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
820
            }
701
820
        }
702
703
824
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
824
            Compare::equal(_high_value, _low_value)) {
705
10
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
10
            _high_value = TYPE_MIN;
707
10
            _low_value = TYPE_MAX;
708
10
        }
709
824
    }
710
711
834
    return Status::OK();
712
832
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.90k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.90k
    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.90k
    _contain_null = false;
621
622
1.90k
    if (is_fixed_value_range()) {
623
14
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
14
        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
7
        case FILTER_LARGER_OR_EQUAL: {
632
7
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
7
            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
14
        }
655
656
14
        _high_value = TYPE_MIN;
657
14
        _low_value = TYPE_MAX;
658
1.89k
    } else {
659
1.89k
        if (Compare::greater(_high_value, _low_value)) {
660
1.86k
            switch (op) {
661
996
            case FILTER_LARGER: {
662
997
                if (Compare::greater_equal(value, _low_value)) {
663
997
                    _low_value = value;
664
997
                    _low_op = op;
665
997
                }
666
667
996
                break;
668
0
            }
669
670
427
            case FILTER_LARGER_OR_EQUAL: {
671
427
                if (Compare::greater(value, _low_value)) {
672
327
                    _low_value = value;
673
327
                    _low_op = op;
674
327
                }
675
676
427
                break;
677
0
            }
678
679
37
            case FILTER_LESS: {
680
37
                if (Compare::less_equal(value, _high_value)) {
681
36
                    _high_value = value;
682
36
                    _high_op = op;
683
36
                }
684
685
37
                break;
686
0
            }
687
688
406
            case FILTER_LESS_OR_EQUAL: {
689
406
                if (Compare::less(value, _high_value)) {
690
378
                    _high_value = value;
691
378
                    _high_op = op;
692
378
                }
693
694
406
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.86k
            }
701
1.86k
        }
702
703
1.89k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.89k
            Compare::equal(_high_value, _low_value)) {
705
191
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
191
            _high_value = TYPE_MIN;
707
191
            _low_value = TYPE_MAX;
708
191
        }
709
1.89k
    }
710
711
1.90k
    return Status::OK();
712
1.90k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
399
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
399
    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
399
    _contain_null = false;
621
622
399
    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
399
    } else {
659
401
        if (Compare::greater(_high_value, _low_value)) {
660
401
            switch (op) {
661
29
            case FILTER_LARGER: {
662
30
                if (Compare::greater_equal(value, _low_value)) {
663
30
                    _low_value = value;
664
30
                    _low_op = op;
665
30
                }
666
667
29
                break;
668
0
            }
669
670
184
            case FILTER_LARGER_OR_EQUAL: {
671
184
                if (Compare::greater(value, _low_value)) {
672
99
                    _low_value = value;
673
99
                    _low_op = op;
674
99
                }
675
676
184
                break;
677
0
            }
678
679
25
            case FILTER_LESS: {
680
25
                if (Compare::less_equal(value, _high_value)) {
681
24
                    _high_value = value;
682
24
                    _high_op = op;
683
24
                }
684
685
25
                break;
686
0
            }
687
688
163
            case FILTER_LESS_OR_EQUAL: {
689
163
                if (Compare::less(value, _high_value)) {
690
126
                    _high_value = value;
691
126
                    _high_op = op;
692
126
                }
693
694
163
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
401
            }
701
401
        }
702
703
398
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
398
            Compare::equal(_high_value, _low_value)) {
705
18
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
18
            _high_value = TYPE_MIN;
707
18
            _low_value = TYPE_MAX;
708
18
        }
709
398
    }
710
711
398
    return Status::OK();
712
399
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
19.7k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
19.7k
    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
19.7k
    _contain_null = false;
621
622
19.7k
    if (is_fixed_value_range()) {
623
39
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
39
        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
29
        case FILTER_LARGER_OR_EQUAL: {
632
29
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
29
            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
39
        }
655
656
39
        _high_value = TYPE_MIN;
657
39
        _low_value = TYPE_MAX;
658
19.7k
    } else {
659
19.7k
        if (Compare::greater(_high_value, _low_value)) {
660
19.6k
            switch (op) {
661
12.6k
            case FILTER_LARGER: {
662
12.6k
                if (Compare::greater_equal(value, _low_value)) {
663
12.6k
                    _low_value = value;
664
12.6k
                    _low_op = op;
665
12.6k
                }
666
667
12.6k
                break;
668
0
            }
669
670
4.13k
            case FILTER_LARGER_OR_EQUAL: {
671
4.13k
                if (Compare::greater(value, _low_value)) {
672
4.08k
                    _low_value = value;
673
4.08k
                    _low_op = op;
674
4.08k
                }
675
676
4.13k
                break;
677
0
            }
678
679
2.61k
            case FILTER_LESS: {
680
2.61k
                if (Compare::less_equal(value, _high_value)) {
681
2.60k
                    _high_value = value;
682
2.60k
                    _high_op = op;
683
2.60k
                }
684
685
2.61k
                break;
686
0
            }
687
688
278
            case FILTER_LESS_OR_EQUAL: {
689
278
                if (Compare::less(value, _high_value)) {
690
235
                    _high_value = value;
691
235
                    _high_op = op;
692
235
                }
693
694
278
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
19.6k
            }
701
19.6k
        }
702
703
19.7k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
19.7k
            Compare::equal(_high_value, _low_value)) {
705
64
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
64
            _high_value = TYPE_MIN;
707
64
            _low_value = TYPE_MAX;
708
64
        }
709
19.7k
    }
710
711
19.7k
    return Status::OK();
712
19.7k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.91k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.91k
    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.91k
    _contain_null = false;
621
622
3.91k
    if (is_fixed_value_range()) {
623
14
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
14
        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
5
        case FILTER_LESS_OR_EQUAL: {
647
5
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
5
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
14
        }
655
656
14
        _high_value = TYPE_MIN;
657
14
        _low_value = TYPE_MAX;
658
3.89k
    } else {
659
3.90k
        if (Compare::greater(_high_value, _low_value)) {
660
3.90k
            switch (op) {
661
207
            case FILTER_LARGER: {
662
207
                if (Compare::greater_equal(value, _low_value)) {
663
207
                    _low_value = value;
664
207
                    _low_op = op;
665
207
                }
666
667
207
                break;
668
0
            }
669
670
1.81k
            case FILTER_LARGER_OR_EQUAL: {
671
1.81k
                if (Compare::greater(value, _low_value)) {
672
1.77k
                    _low_value = value;
673
1.77k
                    _low_op = op;
674
1.77k
                }
675
676
1.81k
                break;
677
0
            }
678
679
1.37k
            case FILTER_LESS: {
680
1.37k
                if (Compare::less_equal(value, _high_value)) {
681
1.37k
                    _high_value = value;
682
1.37k
                    _high_op = op;
683
1.37k
                }
684
685
1.37k
                break;
686
0
            }
687
688
507
            case FILTER_LESS_OR_EQUAL: {
689
507
                if (Compare::less(value, _high_value)) {
690
475
                    _high_value = value;
691
475
                    _high_op = op;
692
475
                }
693
694
507
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.90k
            }
701
3.90k
        }
702
703
3.87k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.87k
            Compare::equal(_high_value, _low_value)) {
705
41
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
41
            _high_value = TYPE_MIN;
707
41
            _low_value = TYPE_MAX;
708
41
        }
709
3.87k
    }
710
711
3.89k
    return Status::OK();
712
3.91k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
1.35k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.35k
    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.35k
    _contain_null = false;
621
622
1.35k
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
1.35k
    } else {
659
1.35k
        if (Compare::greater(_high_value, _low_value)) {
660
1.35k
            switch (op) {
661
317
            case FILTER_LARGER: {
662
317
                if (Compare::greater_equal(value, _low_value)) {
663
317
                    _low_value = value;
664
317
                    _low_op = op;
665
317
                }
666
667
317
                break;
668
0
            }
669
670
409
            case FILTER_LARGER_OR_EQUAL: {
671
409
                if (Compare::greater(value, _low_value)) {
672
199
                    _low_value = value;
673
199
                    _low_op = op;
674
199
                }
675
676
409
                break;
677
0
            }
678
679
227
            case FILTER_LESS: {
680
227
                if (Compare::less_equal(value, _high_value)) {
681
225
                    _high_value = value;
682
225
                    _high_op = op;
683
225
                }
684
685
227
                break;
686
0
            }
687
688
406
            case FILTER_LESS_OR_EQUAL: {
689
406
                if (Compare::less(value, _high_value)) {
690
303
                    _high_value = value;
691
303
                    _high_op = op;
692
303
                }
693
694
406
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.35k
            }
701
1.35k
        }
702
703
1.34k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.34k
            Compare::equal(_high_value, _low_value)) {
705
118
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
118
            _high_value = TYPE_MIN;
707
118
            _low_value = TYPE_MAX;
708
118
        }
709
1.34k
    }
710
711
1.34k
    return Status::OK();
712
1.35k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
211
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
211
    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
211
    _contain_null = false;
621
622
211
    if (is_fixed_value_range()) {
623
47
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
47
        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
39
        case FILTER_LARGER_OR_EQUAL: {
632
39
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
39
            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
47
        }
655
656
47
        _high_value = TYPE_MIN;
657
47
        _low_value = TYPE_MAX;
658
164
    } else {
659
164
        if (Compare::greater(_high_value, _low_value)) {
660
163
            switch (op) {
661
18
            case FILTER_LARGER: {
662
18
                if (Compare::greater_equal(value, _low_value)) {
663
18
                    _low_value = value;
664
18
                    _low_op = op;
665
18
                }
666
667
18
                break;
668
0
            }
669
670
39
            case FILTER_LARGER_OR_EQUAL: {
671
39
                if (Compare::greater(value, _low_value)) {
672
15
                    _low_value = value;
673
15
                    _low_op = op;
674
15
                }
675
676
39
                break;
677
0
            }
678
679
31
            case FILTER_LESS: {
680
33
                if (Compare::less_equal(value, _high_value)) {
681
33
                    _high_value = value;
682
33
                    _high_op = op;
683
33
                }
684
685
31
                break;
686
0
            }
687
688
74
            case FILTER_LESS_OR_EQUAL: {
689
74
                if (Compare::less(value, _high_value)) {
690
49
                    _high_value = value;
691
49
                    _high_op = op;
692
49
                }
693
694
74
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
163
            }
701
163
        }
702
703
164
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
164
            Compare::equal(_high_value, _low_value)) {
705
34
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
34
            _high_value = TYPE_MIN;
707
34
            _low_value = TYPE_MAX;
708
34
        }
709
164
    }
710
711
211
    return Status::OK();
712
211
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
425
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
425
    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
425
    _contain_null = false;
621
622
425
    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
425
    } else {
659
425
        if (Compare::greater(_high_value, _low_value)) {
660
424
            switch (op) {
661
23
            case FILTER_LARGER: {
662
26
                if (Compare::greater_equal(value, _low_value)) {
663
26
                    _low_value = value;
664
26
                    _low_op = op;
665
26
                }
666
667
23
                break;
668
0
            }
669
670
186
            case FILTER_LARGER_OR_EQUAL: {
671
186
                if (Compare::greater(value, _low_value)) {
672
184
                    _low_value = value;
673
184
                    _low_op = op;
674
184
                }
675
676
186
                break;
677
0
            }
678
679
32
            case FILTER_LESS: {
680
32
                if (Compare::less_equal(value, _high_value)) {
681
32
                    _high_value = value;
682
32
                    _high_op = op;
683
32
                }
684
685
32
                break;
686
0
            }
687
688
182
            case FILTER_LESS_OR_EQUAL: {
689
182
                if (Compare::less(value, _high_value)) {
690
182
                    _high_value = value;
691
182
                    _high_op = op;
692
182
                }
693
694
182
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
424
            }
701
424
        }
702
703
429
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
429
            Compare::equal(_high_value, _low_value)) {
705
158
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
158
            _high_value = TYPE_MIN;
707
158
            _low_value = TYPE_MAX;
708
158
        }
709
429
    }
710
711
429
    return Status::OK();
712
425
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9add_rangeENS_11SQLFilterOpENS_12Decimal128V3E
Line
Count
Source
614
108
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
108
    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
108
    _contain_null = false;
621
622
108
    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
108
    } else {
659
108
        if (Compare::greater(_high_value, _low_value)) {
660
106
            switch (op) {
661
74
            case FILTER_LARGER: {
662
74
                if (Compare::greater_equal(value, _low_value)) {
663
72
                    _low_value = value;
664
72
                    _low_op = op;
665
72
                }
666
667
74
                break;
668
0
            }
669
670
16
            case FILTER_LARGER_OR_EQUAL: {
671
16
                if (Compare::greater(value, _low_value)) {
672
16
                    _low_value = value;
673
16
                    _low_op = op;
674
16
                }
675
676
16
                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
14
            case FILTER_LESS_OR_EQUAL: {
689
14
                if (Compare::less(value, _high_value)) {
690
14
                    _high_value = value;
691
14
                    _high_op = op;
692
14
                }
693
694
14
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
106
            }
701
106
        }
702
703
105
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
105
            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
105
    }
710
711
105
    return Status::OK();
712
108
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9add_rangeENS_11SQLFilterOpENS_7DecimalIN4wide7integerILm256EiEEEE
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
189
            switch (op) {
661
42
            case FILTER_LARGER: {
662
43
                if (Compare::greater_equal(value, _low_value)) {
663
43
                    _low_value = value;
664
43
                    _low_op = op;
665
43
                }
666
667
42
                break;
668
0
            }
669
670
55
            case FILTER_LARGER_OR_EQUAL: {
671
55
                if (Compare::greater(value, _low_value)) {
672
32
                    _low_value = value;
673
32
                    _low_op = op;
674
32
                }
675
676
55
                break;
677
0
            }
678
679
39
            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
39
                break;
686
0
            }
687
688
54
            case FILTER_LESS_OR_EQUAL: {
689
54
                if (Compare::less(value, _high_value)) {
690
32
                    _high_value = value;
691
32
                    _high_op = op;
692
32
                }
693
694
54
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
189
            }
701
189
        }
702
703
192
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
192
            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
192
    }
710
711
192
    return Status::OK();
712
190
}
713
714
template <PrimitiveType primitive_type>
715
313k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
313k
    switch (_high_op) {
717
2
    case FILTER_LESS: {
718
2
        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
2
        case FILTER_LARGER_OR_EQUAL: {
724
2
            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
2
        }
731
732
0
        break;
733
2
    }
734
735
313k
    case FILTER_LESS_OR_EQUAL: {
736
313k
        switch (_low_op) {
737
978
        case FILTER_LARGER: {
738
978
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
312k
        case FILTER_LARGER_OR_EQUAL: {
742
312k
            return Compare::less_equal(value, _high_value) &&
743
313k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
313k
        }
750
313k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
313k
    }
756
757
0
    return false;
758
313k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
79.4k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
79.4k
    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
79.4k
    case FILTER_LESS_OR_EQUAL: {
736
79.4k
        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
79.4k
        case FILTER_LARGER_OR_EQUAL: {
742
79.4k
            return Compare::less_equal(value, _high_value) &&
743
79.4k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
79.4k
        }
750
79.4k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
79.4k
    }
756
757
0
    return false;
758
79.4k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
115
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
115
    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
115
    case FILTER_LESS_OR_EQUAL: {
736
115
        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
113
        case FILTER_LARGER_OR_EQUAL: {
742
113
            return Compare::less_equal(value, _high_value) &&
743
113
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
115
        }
750
115
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
115
    }
756
757
0
    return false;
758
115
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
51.2k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
51.2k
    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
51.2k
    case FILTER_LESS_OR_EQUAL: {
736
51.2k
        switch (_low_op) {
737
394
        case FILTER_LARGER: {
738
394
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
50.8k
        case FILTER_LARGER_OR_EQUAL: {
742
50.8k
            return Compare::less_equal(value, _high_value) &&
743
50.8k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
51.2k
        }
750
51.2k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
51.2k
    }
756
757
0
    return false;
758
51.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
1.76k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.76k
    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.76k
    case FILTER_LESS_OR_EQUAL: {
736
1.76k
        switch (_low_op) {
737
584
        case FILTER_LARGER: {
738
584
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
1.18k
        case FILTER_LARGER_OR_EQUAL: {
742
1.18k
            return Compare::less_equal(value, _high_value) &&
743
1.18k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.76k
        }
750
1.76k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.76k
    }
756
757
0
    return false;
758
1.76k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
216
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
216
    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
216
    case FILTER_LESS_OR_EQUAL: {
736
216
        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
215
        case FILTER_LARGER_OR_EQUAL: {
742
215
            return Compare::less_equal(value, _high_value) &&
743
215
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
216
        }
750
216
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
216
    }
756
757
0
    return false;
758
216
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE11is_in_rangeERKf
Line
Count
Source
715
28
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
28
    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
28
    case FILTER_LESS_OR_EQUAL: {
736
28
        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
28
        case FILTER_LARGER_OR_EQUAL: {
742
28
            return Compare::less_equal(value, _high_value) &&
743
28
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
28
        }
750
28
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
28
    }
756
757
0
    return false;
758
28
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE11is_in_rangeERKd
Line
Count
Source
715
142
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
142
    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
143
    case FILTER_LESS_OR_EQUAL: {
736
143
        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
143
        case FILTER_LARGER_OR_EQUAL: {
742
143
            return Compare::less_equal(value, _high_value) &&
743
143
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
143
        }
750
143
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
142
    }
756
757
0
    return false;
758
142
}
_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
27
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
27
    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
27
    case FILTER_LESS_OR_EQUAL: {
736
27
        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
27
        case FILTER_LARGER_OR_EQUAL: {
742
27
            return Compare::less_equal(value, _high_value) &&
743
27
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
27
        }
750
27
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
27
    }
756
757
0
    return false;
758
27
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
555
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
555
    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
556
    case FILTER_LESS_OR_EQUAL: {
736
556
        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
556
        case FILTER_LARGER_OR_EQUAL: {
742
556
            return Compare::less_equal(value, _high_value) &&
743
561
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
556
        }
750
556
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
555
    }
756
757
0
    return false;
758
555
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
170k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
170k
    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
170k
    case FILTER_LESS_OR_EQUAL: {
736
170k
        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
170k
        case FILTER_LARGER_OR_EQUAL: {
742
170k
            return Compare::less_equal(value, _high_value) &&
743
171k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
170k
        }
750
170k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
170k
    }
756
757
0
    return false;
758
170k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
344
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
344
    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
345
    case FILTER_LESS_OR_EQUAL: {
736
345
        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
348
        case FILTER_LARGER_OR_EQUAL: {
742
348
            return Compare::less_equal(value, _high_value) &&
743
348
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
345
        }
750
345
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
344
    }
756
757
0
    return false;
758
344
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
35
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
35
    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
35
    case FILTER_LESS_OR_EQUAL: {
736
35
        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
35
        case FILTER_LARGER_OR_EQUAL: {
742
35
            return Compare::less_equal(value, _high_value) &&
743
35
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
35
        }
750
35
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
35
    }
756
757
0
    return false;
758
35
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
7.86k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
7.86k
    switch (_high_op) {
717
2
    case FILTER_LESS: {
718
2
        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
2
        case FILTER_LARGER_OR_EQUAL: {
724
2
            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
2
        }
731
732
0
        break;
733
2
    }
734
735
7.85k
    case FILTER_LESS_OR_EQUAL: {
736
7.85k
        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
7.86k
        case FILTER_LARGER_OR_EQUAL: {
742
7.86k
            return Compare::less_equal(value, _high_value) &&
743
7.86k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
7.85k
        }
750
7.85k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
7.86k
    }
756
757
0
    return false;
758
7.86k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
60
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
60
    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
60
    case FILTER_LESS_OR_EQUAL: {
736
60
        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
60
        case FILTER_LARGER_OR_EQUAL: {
742
60
            return Compare::less_equal(value, _high_value) &&
743
60
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
60
        }
750
60
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
60
    }
756
757
0
    return false;
758
60
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
400
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
400
    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
400
    case FILTER_LESS_OR_EQUAL: {
736
400
        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
405
        case FILTER_LARGER_OR_EQUAL: {
742
405
            return Compare::less_equal(value, _high_value) &&
743
405
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
400
        }
750
400
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
400
    }
756
757
0
    return false;
758
400
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
182
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
182
    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
182
    case FILTER_LESS_OR_EQUAL: {
736
182
        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
182
        case FILTER_LARGER_OR_EQUAL: {
742
182
            return Compare::less_equal(value, _high_value) &&
743
182
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
182
        }
750
182
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
182
    }
756
757
0
    return false;
758
182
}
_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
189
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
189
    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
189
    case FILTER_LESS_OR_EQUAL: {
736
189
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
189
        case FILTER_LARGER_OR_EQUAL: {
742
189
            return Compare::less_equal(value, _high_value) &&
743
189
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
189
        }
750
189
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
189
    }
756
757
0
    return false;
758
189
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
69
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
69
    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
72
        case FILTER_LARGER_OR_EQUAL: {
742
72
            return Compare::less_equal(value, _high_value) &&
743
72
                   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
69
    }
756
757
0
    return false;
758
69
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE11is_in_rangeERKNS_7DecimalIlEE
Line
Count
Source
715
174
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
174
    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
174
    case FILTER_LESS_OR_EQUAL: {
736
174
        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
175
        case FILTER_LARGER_OR_EQUAL: {
742
175
            return Compare::less_equal(value, _high_value) &&
743
175
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
174
        }
750
174
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
174
    }
756
757
0
    return false;
758
174
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE11is_in_rangeERKNS_12Decimal128V3E
Line
Count
Source
715
234
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
234
    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
235
    case FILTER_LESS_OR_EQUAL: {
736
235
        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
237
        case FILTER_LARGER_OR_EQUAL: {
742
237
            return Compare::less_equal(value, _high_value) &&
743
237
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
235
        }
750
235
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
234
    }
756
757
0
    return false;
758
234
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE11is_in_rangeERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
715
50
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
50
    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
52
    case FILTER_LESS_OR_EQUAL: {
736
52
        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
52
        case FILTER_LARGER_OR_EQUAL: {
742
52
            return Compare::less_equal(value, _high_value) &&
743
52
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
52
        }
750
52
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
50
    }
756
757
0
    return false;
758
50
}
759
760
template <PrimitiveType primitive_type>
761
288k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
288k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
288k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
21.5k
        set_empty_value_range();
770
21.5k
    }
771
772
288k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
288k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
264k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
164
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
164
                             range._fixed_values.begin(), range._fixed_values.end(),
778
164
                             std::inserter(result_values, result_values.begin()));
779
264k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
9
            IteratorType iter = _fixed_values.begin();
781
782
33
            while (iter != _fixed_values.end()) {
783
24
                if (range.is_in_range(*iter)) {
784
23
                    result_values.insert(*iter);
785
23
                }
786
24
                ++iter;
787
24
            }
788
264k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
264k
            IteratorType iter = range._fixed_values.begin();
790
576k
            while (iter != range._fixed_values.end()) {
791
313k
                if (this->is_in_range(*iter)) {
792
313k
                    result_values.insert(*iter);
793
313k
                }
794
312k
                ++iter;
795
312k
            }
796
264k
        }
797
798
266k
        if (!result_values.empty()) {
799
266k
            _fixed_values = std::move(result_values);
800
266k
            _contain_null = false;
801
266k
            _high_value = TYPE_MIN;
802
266k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
264k
    } else {
807
24.3k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
294
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
293
                set_contain_null(true);
811
293
            }
812
24.0k
        } else {
813
24.0k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
24.0k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
24.0k
        }
816
24.3k
    }
817
288k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
79.7k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
79.7k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
79.7k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
138
        set_empty_value_range();
770
138
    }
771
772
79.7k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
79.7k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
78.7k
        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
78.7k
        } 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
78.7k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
78.5k
            IteratorType iter = range._fixed_values.begin();
790
157k
            while (iter != range._fixed_values.end()) {
791
79.2k
                if (this->is_in_range(*iter)) {
792
79.2k
                    result_values.insert(*iter);
793
79.2k
                }
794
78.6k
                ++iter;
795
78.6k
            }
796
78.5k
        }
797
798
79.6k
        if (!result_values.empty()) {
799
79.6k
            _fixed_values = std::move(result_values);
800
79.6k
            _contain_null = false;
801
79.6k
            _high_value = TYPE_MIN;
802
79.6k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
78.7k
    } else {
807
1.05k
        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.05k
        } else {
813
1.05k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.05k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.05k
        }
816
1.05k
    }
817
79.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
Line
Count
Source
761
111
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
111
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
114
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
6
        set_empty_value_range();
770
6
    }
771
772
111
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
111
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
71
        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
71
        } 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
71
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
70
            IteratorType iter = range._fixed_values.begin();
790
180
            while (iter != range._fixed_values.end()) {
791
111
                if (this->is_in_range(*iter)) {
792
111
                    result_values.insert(*iter);
793
111
                }
794
110
                ++iter;
795
110
            }
796
70
        }
797
798
74
        if (!result_values.empty()) {
799
74
            _fixed_values = std::move(result_values);
800
74
            _contain_null = false;
801
74
            _high_value = TYPE_MIN;
802
74
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
71
    } else {
807
40
        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
39
        } else {
813
39
            static_cast<void>(add_range(range._high_op, range._high_value));
814
39
            static_cast<void>(add_range(range._low_op, range._low_value));
815
39
        }
816
40
    }
817
111
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
6.20k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
6.20k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
6.20k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
238
        set_empty_value_range();
770
238
    }
771
772
6.20k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
6.20k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
5.45k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
97
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
97
                             range._fixed_values.begin(), range._fixed_values.end(),
778
97
                             std::inserter(result_values, result_values.begin()));
779
5.35k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
5.35k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
5.35k
            IteratorType iter = range._fixed_values.begin();
790
56.8k
            while (iter != range._fixed_values.end()) {
791
51.5k
                if (this->is_in_range(*iter)) {
792
51.2k
                    result_values.insert(*iter);
793
51.2k
                }
794
51.5k
                ++iter;
795
51.5k
            }
796
5.35k
        }
797
798
5.50k
        if (!result_values.empty()) {
799
5.50k
            _fixed_values = std::move(result_values);
800
5.50k
            _contain_null = false;
801
5.50k
            _high_value = TYPE_MIN;
802
5.50k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
5.45k
    } else {
807
753
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
54
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
53
                set_contain_null(true);
811
53
            }
812
701
        } else {
813
701
            static_cast<void>(add_range(range._high_op, range._high_value));
814
701
            static_cast<void>(add_range(range._low_op, range._low_value));
815
701
        }
816
753
    }
817
6.20k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
21.9k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
21.9k
    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.9k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
21.1k
        set_empty_value_range();
770
21.1k
    }
771
772
21.9k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
21.9k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
829
        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
768
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
9
            IteratorType iter = _fixed_values.begin();
781
782
33
            while (iter != _fixed_values.end()) {
783
24
                if (range.is_in_range(*iter)) {
784
23
                    result_values.insert(*iter);
785
23
                }
786
24
                ++iter;
787
24
            }
788
759
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
759
            IteratorType iter = range._fixed_values.begin();
790
2.50k
            while (iter != range._fixed_values.end()) {
791
1.74k
                if (this->is_in_range(*iter)) {
792
1.73k
                    result_values.insert(*iter);
793
1.73k
                }
794
1.74k
                ++iter;
795
1.74k
            }
796
759
        }
797
798
829
        if (!result_values.empty()) {
799
829
            _fixed_values = std::move(result_values);
800
829
            _contain_null = false;
801
829
            _high_value = TYPE_MIN;
802
829
            _low_value = TYPE_MAX;
803
829
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
21.1k
    } else {
807
21.1k
        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
21.1k
        } else {
813
21.1k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
21.1k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
21.1k
        }
816
21.1k
    }
817
21.9k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
213
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
213
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
214
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
213
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
213
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
199
        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
197
        } 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
197
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
197
            IteratorType iter = range._fixed_values.begin();
790
412
            while (iter != range._fixed_values.end()) {
791
216
                if (this->is_in_range(*iter)) {
792
216
                    result_values.insert(*iter);
793
216
                }
794
215
                ++iter;
795
215
            }
796
197
        }
797
798
200
        if (!result_values.empty()) {
799
200
            _fixed_values = std::move(result_values);
800
200
            _contain_null = false;
801
200
            _high_value = TYPE_MIN;
802
200
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
199
    } else {
807
14
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
11
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
11
                set_contain_null(true);
811
11
            }
812
11
        } 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
14
    }
817
213
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
46
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
46
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
46
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
46
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
46
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
25
        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
25
        } 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
25
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
25
            IteratorType iter = range._fixed_values.begin();
790
52
            while (iter != range._fixed_values.end()) {
791
27
                if (this->is_in_range(*iter)) {
792
27
                    result_values.insert(*iter);
793
27
                }
794
27
                ++iter;
795
27
            }
796
25
        }
797
798
26
        if (!result_values.empty()) {
799
26
            _fixed_values = std::move(result_values);
800
26
            _contain_null = false;
801
26
            _high_value = TYPE_MIN;
802
26
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
25
    } else {
807
21
        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
12
        } else {
813
12
            static_cast<void>(add_range(range._high_op, range._high_value));
814
12
            static_cast<void>(add_range(range._low_op, range._low_value));
815
12
        }
816
21
    }
817
46
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
144
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
144
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
144
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
144
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
144
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
104
        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
104
        } 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
245
            while (iter != range._fixed_values.end()) {
791
141
                if (this->is_in_range(*iter)) {
792
141
                    result_values.insert(*iter);
793
141
                }
794
140
                ++iter;
795
140
            }
796
105
        }
797
798
108
        if (!result_values.empty()) {
799
108
            _fixed_values = std::move(result_values);
800
108
            _contain_null = false;
801
108
            _high_value = TYPE_MIN;
802
108
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
104
    } else {
807
40
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
11
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
11
                set_contain_null(true);
811
11
            }
812
29
        } else {
813
29
            static_cast<void>(add_range(range._high_op, range._high_value));
814
29
            static_cast<void>(add_range(range._low_op, range._low_value));
815
29
        }
816
40
    }
817
144
}
_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
23
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
23
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
23
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
23
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
23
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
22
        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
22
        } 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
22
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
22
            IteratorType iter = range._fixed_values.begin();
790
49
            while (iter != range._fixed_values.end()) {
791
27
                if (this->is_in_range(*iter)) {
792
27
                    result_values.insert(*iter);
793
27
                }
794
27
                ++iter;
795
27
            }
796
22
        }
797
798
22
        if (!result_values.empty()) {
799
22
            _fixed_values = std::move(result_values);
800
22
            _contain_null = false;
801
22
            _high_value = TYPE_MIN;
802
22
            _low_value = TYPE_MAX;
803
22
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
22
    } 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
23
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
421
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
421
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
423
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
421
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
421
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
393
        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
393
        } 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
394
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
394
            IteratorType iter = range._fixed_values.begin();
790
946
            while (iter != range._fixed_values.end()) {
791
556
                if (this->is_in_range(*iter)) {
792
556
                    result_values.insert(*iter);
793
556
                }
794
552
                ++iter;
795
552
            }
796
394
        }
797
798
406
        if (!result_values.empty()) {
799
406
            _fixed_values = std::move(result_values);
800
406
            _contain_null = false;
801
406
            _high_value = TYPE_MIN;
802
406
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
393
    } else {
807
28
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
2
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
2
                set_contain_null(true);
811
2
            }
812
26
        } else {
813
26
            static_cast<void>(add_range(range._high_op, range._high_value));
814
26
            static_cast<void>(add_range(range._low_op, range._low_value));
815
26
        }
816
28
    }
817
421
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
170k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
170k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
170k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
8
        set_empty_value_range();
770
8
    }
771
772
170k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
170k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
169k
        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
169k
        } 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
169k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
169k
            IteratorType iter = range._fixed_values.begin();
790
339k
            while (iter != range._fixed_values.end()) {
791
170k
                if (this->is_in_range(*iter)) {
792
170k
                    result_values.insert(*iter);
793
170k
                }
794
170k
                ++iter;
795
170k
            }
796
169k
        }
797
798
170k
        if (!result_values.empty()) {
799
170k
            _fixed_values = std::move(result_values);
800
170k
            _contain_null = false;
801
170k
            _high_value = TYPE_MIN;
802
170k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
169k
    } else {
807
863
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
131
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
130
                set_contain_null(true);
811
130
            }
812
734
        } else {
813
734
            static_cast<void>(add_range(range._high_op, range._high_value));
814
734
            static_cast<void>(add_range(range._low_op, range._low_value));
815
734
        }
816
863
    }
817
170k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
361
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
361
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
364
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
361
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
361
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
291
        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
291
        } 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
291
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
290
            IteratorType iter = range._fixed_values.begin();
790
627
            while (iter != range._fixed_values.end()) {
791
344
                if (this->is_in_range(*iter)) {
792
344
                    result_values.insert(*iter);
793
344
                }
794
337
                ++iter;
795
337
            }
796
290
        }
797
798
296
        if (!result_values.empty()) {
799
296
            _fixed_values = std::move(result_values);
800
296
            _contain_null = false;
801
296
            _high_value = TYPE_MIN;
802
296
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
291
    } else {
807
70
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
28
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
27
                set_contain_null(true);
811
27
            }
812
44
        } else {
813
44
            static_cast<void>(add_range(range._high_op, range._high_value));
814
44
            static_cast<void>(add_range(range._low_op, range._low_value));
815
44
        }
816
70
    }
817
361
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
23
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
23
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
23
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
23
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
23
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
23
        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
23
        } 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
23
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
23
            IteratorType iter = range._fixed_values.begin();
790
58
            while (iter != range._fixed_values.end()) {
791
35
                if (this->is_in_range(*iter)) {
792
35
                    result_values.insert(*iter);
793
35
                }
794
35
                ++iter;
795
35
            }
796
23
        }
797
798
23
        if (!result_values.empty()) {
799
23
            _fixed_values = std::move(result_values);
800
23
            _contain_null = false;
801
23
            _high_value = TYPE_MIN;
802
23
            _low_value = TYPE_MAX;
803
23
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
23
    } 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
23
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
7.90k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
7.90k
    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.90k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
16
        set_empty_value_range();
770
16
    }
771
772
7.90k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
7.90k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
7.79k
        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
7.79k
        } 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
7.80k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
7.80k
            IteratorType iter = range._fixed_values.begin();
790
15.6k
            while (iter != range._fixed_values.end()) {
791
7.86k
                if (this->is_in_range(*iter)) {
792
7.86k
                    result_values.insert(*iter);
793
7.86k
                }
794
7.85k
                ++iter;
795
7.85k
            }
796
7.80k
        }
797
798
7.82k
        if (!result_values.empty()) {
799
7.82k
            _fixed_values = std::move(result_values);
800
7.82k
            _contain_null = false;
801
7.82k
            _high_value = TYPE_MIN;
802
7.82k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
7.79k
    } else {
807
106
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
31
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
31
                set_contain_null(true);
811
31
            }
812
78
        } else {
813
78
            static_cast<void>(add_range(range._high_op, range._high_value));
814
78
            static_cast<void>(add_range(range._low_op, range._low_value));
815
78
        }
816
106
    }
817
7.90k
}
_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
93
            while (iter != range._fixed_values.end()) {
791
60
                if (this->is_in_range(*iter)) {
792
60
                    result_values.insert(*iter);
793
60
                }
794
60
                ++iter;
795
60
            }
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
402
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
402
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
402
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
402
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
402
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
362
        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
362
        } 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
362
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
362
            IteratorType iter = range._fixed_values.begin();
790
759
            while (iter != range._fixed_values.end()) {
791
402
                if (this->is_in_range(*iter)) {
792
402
                    result_values.insert(*iter);
793
402
                }
794
397
                ++iter;
795
397
            }
796
362
        }
797
798
373
        if (!result_values.empty()) {
799
373
            _fixed_values = std::move(result_values);
800
373
            _contain_null = false;
801
373
            _high_value = TYPE_MIN;
802
373
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
362
    } else {
807
40
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
3
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
3
                set_contain_null(true);
811
3
            }
812
37
        } else {
813
37
            static_cast<void>(add_range(range._high_op, range._high_value));
814
37
            static_cast<void>(add_range(range._low_op, range._low_value));
815
37
        }
816
40
    }
817
402
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
188
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
188
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
188
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
188
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
188
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
83
        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
83
        } 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
83
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
82
            IteratorType iter = range._fixed_values.begin();
790
264
            while (iter != range._fixed_values.end()) {
791
182
                if (this->is_in_range(*iter)) {
792
182
                    result_values.insert(*iter);
793
182
                }
794
182
                ++iter;
795
182
            }
796
82
        }
797
798
83
        if (!result_values.empty()) {
799
83
            _fixed_values = std::move(result_values);
800
83
            _contain_null = false;
801
83
            _high_value = TYPE_MIN;
802
83
            _low_value = TYPE_MAX;
803
83
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
105
    } else {
807
105
        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
96
        } else {
813
96
            static_cast<void>(add_range(range._high_op, range._high_value));
814
96
            static_cast<void>(add_range(range._low_op, range._low_value));
815
96
        }
816
105
    }
817
188
}
_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
182
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
182
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
182
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
182
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
182
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
178
        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
178
        } 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
178
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
178
            IteratorType iter = range._fixed_values.begin();
790
366
            while (iter != range._fixed_values.end()) {
791
188
                if (this->is_in_range(*iter)) {
792
188
                    result_values.insert(*iter);
793
188
                }
794
188
                ++iter;
795
188
            }
796
178
        }
797
798
179
        if (!result_values.empty()) {
799
179
            _fixed_values = std::move(result_values);
800
179
            _contain_null = false;
801
179
            _high_value = TYPE_MIN;
802
179
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
178
    } else {
807
4
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
3
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
3
                set_contain_null(true);
811
3
            }
812
3
        } 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
4
    }
817
182
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12intersectionERS2_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12intersectionERS2_
Line
Count
Source
761
74
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
74
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
75
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
74
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
74
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
48
        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
48
        } 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
48
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
48
            IteratorType iter = range._fixed_values.begin();
790
117
            while (iter != range._fixed_values.end()) {
791
70
                if (this->is_in_range(*iter)) {
792
70
                    result_values.insert(*iter);
793
70
                }
794
69
                ++iter;
795
69
            }
796
48
        }
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
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
48
    } else {
807
26
        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
26
        } else {
813
26
            static_cast<void>(add_range(range._high_op, range._high_value));
814
26
            static_cast<void>(add_range(range._low_op, range._low_value));
815
26
        }
816
26
    }
817
74
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
116
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
116
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
116
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
116
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
116
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
109
        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
109
        } 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
109
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
108
            IteratorType iter = range._fixed_values.begin();
790
279
            while (iter != range._fixed_values.end()) {
791
173
                if (this->is_in_range(*iter)) {
792
173
                    result_values.insert(*iter);
793
173
                }
794
171
                ++iter;
795
171
            }
796
108
        }
797
798
110
        if (!result_values.empty()) {
799
110
            _fixed_values = std::move(result_values);
800
110
            _contain_null = false;
801
110
            _high_value = TYPE_MIN;
802
110
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
109
    } else {
807
7
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
2
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
2
                set_contain_null(true);
811
2
            }
812
5
        } else {
813
5
            static_cast<void>(add_range(range._high_op, range._high_value));
814
5
            static_cast<void>(add_range(range._low_op, range._low_value));
815
5
        }
816
7
    }
817
116
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
227
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
227
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
227
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
227
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
227
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
224
        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
224
        } 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
225
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
225
            IteratorType iter = range._fixed_values.begin();
790
462
            while (iter != range._fixed_values.end()) {
791
237
                if (this->is_in_range(*iter)) {
792
235
                    result_values.insert(*iter);
793
235
                }
794
237
                ++iter;
795
237
            }
796
225
        }
797
798
229
        if (!result_values.empty()) {
799
229
            _fixed_values = std::move(result_values);
800
229
            _contain_null = false;
801
229
            _high_value = TYPE_MIN;
802
229
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
224
    } 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
227
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
68
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
68
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
68
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
68
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
68
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
45
        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
45
        } 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
46
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
46
            IteratorType iter = range._fixed_values.begin();
790
98
            while (iter != range._fixed_values.end()) {
791
52
                if (this->is_in_range(*iter)) {
792
52
                    result_values.insert(*iter);
793
52
                }
794
52
                ++iter;
795
52
            }
796
46
        }
797
798
45
        if (!result_values.empty()) {
799
45
            _fixed_values = std::move(result_values);
800
45
            _contain_null = false;
801
45
            _high_value = TYPE_MIN;
802
45
            _low_value = TYPE_MAX;
803
45
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
45
    } else {
807
23
        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
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
23
    }
817
68
}
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
403k
                                     bool* should_break) {
823
403k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
403k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
403k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
403k
    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
403k
    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
403k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
403k
    if (range.is_fixed_value_range()) {
842
167k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
78
            if (range.is_range_value_convertible()) {
844
77
                range.convert_to_range_value();
845
77
                *exact_value = false;
846
77
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
78
        }
851
236k
    } else {
852
236k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
236k
            !range.is_reject_split_type()) {
854
155k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
155k
                                                 _end_include);
856
857
155k
            if (!(*eos) &&
858
155k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
155k
                                                 _end_include, max_scan_key_num)) {
860
154k
                _has_range_value = true;
861
154k
            }
862
155k
            return Status::OK();
863
155k
        }
864
236k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
248k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
167k
        if (_begin_scan_keys.empty()) {
870
58.7k
            auto fixed_value_set = range.get_fixed_value_set();
871
58.7k
            ConstIterator iter = fixed_value_set.begin();
872
873
121k
            for (; iter != fixed_value_set.end(); ++iter) {
874
62.3k
                _begin_scan_keys.emplace_back();
875
62.3k
                _begin_scan_keys.back().add_value(
876
62.3k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
62.3k
                _end_scan_keys.emplace_back();
878
62.3k
                _end_scan_keys.back().add_value(
879
62.3k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
62.3k
            }
881
882
58.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
58.7k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
108k
        else {
890
108k
            auto fixed_value_set = range.get_fixed_value_set();
891
108k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
217k
            for (int i = 0; i < original_key_range_size; ++i) {
894
108k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
108k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
108k
                ConstIterator iter = fixed_value_set.begin();
898
899
217k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
108k
                    if (iter == fixed_value_set.begin()) {
902
108k
                        _begin_scan_keys[i].add_value(
903
108k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
108k
                        _end_scan_keys[i].add_value(
905
108k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
108k
                    } // append follow ScanKey
907
373
                    else {
908
373
                        _begin_scan_keys.push_back(start_base_key_range);
909
373
                        _begin_scan_keys.back().add_value(
910
373
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
373
                        _end_scan_keys.push_back(end_base_key_range);
912
373
                        _end_scan_keys.back().add_value(
913
373
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
373
                    }
915
108k
                }
916
917
108k
                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
108k
            }
924
108k
        }
925
926
167k
        _begin_include = true;
927
167k
        _end_include = true;
928
167k
    } // Extend ScanKey with range value
929
80.9k
    else {
930
80.9k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
80.9k
        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
80.9k
        } else if (_begin_scan_keys.empty()) {
947
23.9k
            _begin_scan_keys.emplace_back();
948
23.9k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
23.9k
                                                      range.get_range_min_value(), range.scale()),
950
23.9k
                                              range.contain_null());
951
23.9k
            _end_scan_keys.emplace_back();
952
23.9k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
23.9k
                    range.get_range_max_value(), range.scale()));
954
57.0k
        } else {
955
118k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
61.2k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
61.2k
                                                      range.get_range_min_value(), range.scale()),
958
61.2k
                                              range.contain_null());
959
61.2k
            }
960
961
118k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
61.4k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
61.4k
                        range.get_range_max_value(), range.scale()));
964
61.4k
            }
965
57.0k
        }
966
80.9k
        _begin_include = range.is_begin_include();
967
80.9k
        _end_include = range.is_end_include();
968
80.9k
    }
969
970
248k
    return Status::OK();
971
403k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.12k
                                     bool* should_break) {
823
2.12k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.12k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.12k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.12k
    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.12k
    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.12k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.12k
    if (range.is_fixed_value_range()) {
842
15
        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.10k
    } else {
852
2.10k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.10k
            !range.is_reject_split_type()) {
854
2.06k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.06k
                                                 _end_include);
856
857
2.06k
            if (!(*eos) &&
858
2.07k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.08k
                                                 _end_include, max_scan_key_num)) {
860
2.08k
                _has_range_value = true;
861
2.08k
            }
862
2.06k
            return Status::OK();
863
2.06k
        }
864
2.10k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
51
    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
35
            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
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
35
    else {
930
35
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
35
        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
35
        } 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
33
        } else {
955
79
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
46
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
46
                                                      range.get_range_min_value(), range.scale()),
958
46
                                              range.contain_null());
959
46
            }
960
961
79
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
46
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
46
                        range.get_range_max_value(), range.scale()));
964
46
            }
965
33
        }
966
35
        _begin_include = range.is_begin_include();
967
35
        _end_include = range.is_end_include();
968
35
    }
969
970
51
    return Status::OK();
971
2.12k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
158
                                     bool* should_break) {
823
158
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
158
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
158
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
158
    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
158
    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
158
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
158
    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
155
    } else {
852
155
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
155
            !range.is_reject_split_type()) {
854
91
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
91
                                                 _end_include);
856
857
91
            if (!(*eos) &&
858
91
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
91
                                                 _end_include, max_scan_key_num)) {
860
91
                _has_range_value = true;
861
91
            }
862
91
            return Status::OK();
863
91
        }
864
155
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
67
    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
64
    else {
930
64
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
64
        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
64
        } 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
64
        } else {
955
419
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
355
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
355
                                                      range.get_range_min_value(), range.scale()),
958
355
                                              range.contain_null());
959
355
            }
960
961
417
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
353
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
353
                        range.get_range_max_value(), range.scale()));
964
353
            }
965
64
        }
966
64
        _begin_include = range.is_begin_include();
967
64
        _end_include = range.is_end_include();
968
64
    }
969
970
67
    return Status::OK();
971
158
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
67.8k
                                     bool* should_break) {
823
67.8k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
67.8k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
67.8k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
67.8k
    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
67.8k
    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
67.8k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
67.8k
    if (range.is_fixed_value_range()) {
842
3.01k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
76
            if (range.is_range_value_convertible()) {
844
76
                range.convert_to_range_value();
845
76
                *exact_value = false;
846
76
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
76
        }
851
64.8k
    } else {
852
64.8k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
64.8k
            !range.is_reject_split_type()) {
854
63.8k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
63.8k
                                                 _end_include);
856
857
63.8k
            if (!(*eos) &&
858
64.0k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
64.0k
                                                 _end_include, max_scan_key_num)) {
860
63.6k
                _has_range_value = true;
861
63.6k
            }
862
63.8k
            return Status::OK();
863
63.8k
        }
864
64.8k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.02k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.93k
        if (_begin_scan_keys.empty()) {
870
2.82k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.82k
            ConstIterator iter = fixed_value_set.begin();
872
873
8.40k
            for (; iter != fixed_value_set.end(); ++iter) {
874
5.57k
                _begin_scan_keys.emplace_back();
875
5.57k
                _begin_scan_keys.back().add_value(
876
5.57k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
5.57k
                _end_scan_keys.emplace_back();
878
5.57k
                _end_scan_keys.back().add_value(
879
5.57k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
5.57k
            }
881
882
2.82k
            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.82k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
106
        else {
890
106
            auto fixed_value_set = range.get_fixed_value_set();
891
106
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
234
            for (int i = 0; i < original_key_range_size; ++i) {
894
128
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
128
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
128
                ConstIterator iter = fixed_value_set.begin();
898
899
253
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
127
                    if (iter == fixed_value_set.begin()) {
902
127
                        _begin_scan_keys[i].add_value(
903
127
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
127
                        _end_scan_keys[i].add_value(
905
127
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
127
                    } // 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
125
                }
916
917
128
                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
128
            }
924
106
        }
925
926
2.93k
        _begin_include = true;
927
2.93k
        _end_include = true;
928
2.93k
    } // Extend ScanKey with range value
929
1.09k
    else {
930
1.09k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.09k
        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.09k
        } else if (_begin_scan_keys.empty()) {
947
137
            _begin_scan_keys.emplace_back();
948
137
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
137
                                                      range.get_range_min_value(), range.scale()),
950
137
                                              range.contain_null());
951
137
            _end_scan_keys.emplace_back();
952
137
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
137
                    range.get_range_max_value(), range.scale()));
954
960
        } else {
955
5.50k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
4.54k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
4.54k
                                                      range.get_range_min_value(), range.scale()),
958
4.54k
                                              range.contain_null());
959
4.54k
            }
960
961
5.51k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
4.55k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
4.55k
                        range.get_range_max_value(), range.scale()));
964
4.55k
            }
965
960
        }
966
1.09k
        _begin_include = range.is_begin_include();
967
1.09k
        _end_include = range.is_end_include();
968
1.09k
    }
969
970
4.02k
    return Status::OK();
971
67.8k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
88.0k
                                     bool* should_break) {
823
88.0k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
88.0k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
88.0k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
88.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
88.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
88.0k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
88.0k
    if (range.is_fixed_value_range()) {
842
992
        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
87.0k
    } else {
852
87.0k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
87.0k
            !range.is_reject_split_type()) {
854
86.7k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
86.7k
                                                 _end_include);
856
857
86.7k
            if (!(*eos) &&
858
86.7k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
86.6k
                                                 _end_include, max_scan_key_num)) {
860
86.2k
                _has_range_value = true;
861
86.2k
            }
862
86.7k
            return Status::OK();
863
86.7k
        }
864
87.0k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.30k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
993
        if (_begin_scan_keys.empty()) {
870
993
            auto fixed_value_set = range.get_fixed_value_set();
871
993
            ConstIterator iter = fixed_value_set.begin();
872
873
2.58k
            for (; iter != fixed_value_set.end(); ++iter) {
874
1.58k
                _begin_scan_keys.emplace_back();
875
1.58k
                _begin_scan_keys.back().add_value(
876
1.58k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
1.58k
                _end_scan_keys.emplace_back();
878
1.58k
                _end_scan_keys.back().add_value(
879
1.58k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
1.58k
            }
881
882
993
            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
993
        } // 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
989
        _begin_include = true;
927
989
        _end_include = true;
928
989
    } // Extend ScanKey with range value
929
314
    else {
930
314
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
314
        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
314
        } else if (_begin_scan_keys.empty()) {
947
23
            _begin_scan_keys.emplace_back();
948
23
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
23
                                                      range.get_range_min_value(), range.scale()),
950
23
                                              range.contain_null());
951
23
            _end_scan_keys.emplace_back();
952
23
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
23
                    range.get_range_max_value(), range.scale()));
954
291
        } else {
955
1.00k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
714
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
714
                                                      range.get_range_min_value(), range.scale()),
958
714
                                              range.contain_null());
959
714
            }
960
961
1.00k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
715
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
715
                        range.get_range_max_value(), range.scale()));
964
715
            }
965
291
        }
966
314
        _begin_include = range.is_begin_include();
967
314
        _end_include = range.is_end_include();
968
314
    }
969
970
1.30k
    return Status::OK();
971
88.0k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.60k
                                     bool* should_break) {
823
4.60k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.60k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.60k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.60k
    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.60k
    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.60k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.60k
    if (range.is_fixed_value_range()) {
842
144
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
4.45k
    } else {
852
4.45k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
4.45k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
4.45k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.60k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
144
        if (_begin_scan_keys.empty()) {
870
144
            auto fixed_value_set = range.get_fixed_value_set();
871
144
            ConstIterator iter = fixed_value_set.begin();
872
873
306
            for (; iter != fixed_value_set.end(); ++iter) {
874
162
                _begin_scan_keys.emplace_back();
875
162
                _begin_scan_keys.back().add_value(
876
162
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
162
                _end_scan_keys.emplace_back();
878
162
                _end_scan_keys.back().add_value(
879
162
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
162
            }
881
882
144
            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
144
        } // 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
144
        _begin_include = true;
927
144
        _end_include = true;
928
144
    } // Extend ScanKey with range value
929
4.45k
    else {
930
4.45k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
4.45k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
4.45k
        } else if (_begin_scan_keys.empty()) {
947
4.38k
            _begin_scan_keys.emplace_back();
948
4.38k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
4.38k
                                                      range.get_range_min_value(), range.scale()),
950
4.38k
                                              range.contain_null());
951
4.38k
            _end_scan_keys.emplace_back();
952
4.38k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
4.38k
                    range.get_range_max_value(), range.scale()));
954
4.38k
        } else {
955
154
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
80
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
80
                                                      range.get_range_min_value(), range.scale()),
958
80
                                              range.contain_null());
959
80
            }
960
961
154
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
80
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
80
                        range.get_range_max_value(), range.scale()));
964
80
            }
965
74
        }
966
4.45k
        _begin_include = range.is_begin_include();
967
4.45k
        _end_include = range.is_end_include();
968
4.45k
    }
969
970
4.60k
    return Status::OK();
971
4.60k
}
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
420
                                     bool* should_break) {
823
420
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
420
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
420
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
420
    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
420
    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
420
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
420
    if (range.is_fixed_value_range()) {
842
11
        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
409
    } else {
852
409
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
409
            !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
409
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
420
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
10
        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
22
            for (; iter != fixed_value_set.end(); ++iter) {
874
13
                _begin_scan_keys.emplace_back();
875
13
                _begin_scan_keys.back().add_value(
876
13
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
13
                _end_scan_keys.emplace_back();
878
13
                _end_scan_keys.back().add_value(
879
13
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
13
            }
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
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
10
        _begin_include = true;
927
10
        _end_include = true;
928
10
    } // Extend ScanKey with range value
929
410
    else {
930
410
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
410
        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
409
        } else if (_begin_scan_keys.empty()) {
947
401
            _begin_scan_keys.emplace_back();
948
401
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
401
                                                      range.get_range_min_value(), range.scale()),
950
401
                                              range.contain_null());
951
401
            _end_scan_keys.emplace_back();
952
401
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
401
                    range.get_range_max_value(), range.scale()));
954
401
        } else {
955
98
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
90
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
90
                                                      range.get_range_min_value(), range.scale()),
958
90
                                              range.contain_null());
959
90
            }
960
961
98
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
90
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
90
                        range.get_range_max_value(), range.scale()));
964
90
            }
965
8
        }
966
410
        _begin_include = range.is_begin_include();
967
410
        _end_include = range.is_end_include();
968
410
    }
969
970
420
    return Status::OK();
971
420
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
226k
                                     bool* should_break) {
823
226k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
226k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
226k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
226k
    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
226k
    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
226k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
226k
    if (range.is_fixed_value_range()) {
842
162k
        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
162k
    } else {
852
63.7k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
63.7k
            !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
63.7k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
226k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
162k
        if (_begin_scan_keys.empty()) {
870
54.3k
            auto fixed_value_set = range.get_fixed_value_set();
871
54.3k
            ConstIterator iter = fixed_value_set.begin();
872
873
108k
            for (; iter != fixed_value_set.end(); ++iter) {
874
54.4k
                _begin_scan_keys.emplace_back();
875
54.4k
                _begin_scan_keys.back().add_value(
876
54.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
54.4k
                _end_scan_keys.emplace_back();
878
54.4k
                _end_scan_keys.back().add_value(
879
54.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
54.4k
            }
881
882
54.3k
            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
54.3k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
108k
        else {
890
108k
            auto fixed_value_set = range.get_fixed_value_set();
891
108k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
217k
            for (int i = 0; i < original_key_range_size; ++i) {
894
108k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
108k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
108k
                ConstIterator iter = fixed_value_set.begin();
898
899
217k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
108k
                    if (iter == fixed_value_set.begin()) {
902
108k
                        _begin_scan_keys[i].add_value(
903
108k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
108k
                        _end_scan_keys[i].add_value(
905
108k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
108k
                    } // append follow ScanKey
907
375
                    else {
908
375
                        _begin_scan_keys.push_back(start_base_key_range);
909
375
                        _begin_scan_keys.back().add_value(
910
375
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
375
                        _end_scan_keys.push_back(end_base_key_range);
912
375
                        _end_scan_keys.back().add_value(
913
375
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
375
                    }
915
108k
                }
916
917
108k
                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
108k
            }
924
108k
        }
925
926
162k
        _begin_include = true;
927
162k
        _end_include = true;
928
162k
    } // Extend ScanKey with range value
929
63.9k
    else {
930
63.9k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
63.9k
        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
63.9k
        } else if (_begin_scan_keys.empty()) {
947
8.54k
            _begin_scan_keys.emplace_back();
948
8.54k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
8.54k
                                                      range.get_range_min_value(), range.scale()),
950
8.54k
                                              range.contain_null());
951
8.54k
            _end_scan_keys.emplace_back();
952
8.54k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
8.54k
                    range.get_range_max_value(), range.scale()));
954
55.3k
        } else {
955
110k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
55.0k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
55.0k
                                                      range.get_range_min_value(), range.scale()),
958
55.0k
                                              range.contain_null());
959
55.0k
            }
960
961
110k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
55.2k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
55.2k
                        range.get_range_max_value(), range.scale()));
964
55.2k
            }
965
55.3k
        }
966
63.9k
        _begin_include = range.is_begin_include();
967
63.9k
        _end_include = range.is_end_include();
968
63.9k
    }
969
970
226k
    return Status::OK();
971
226k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE23EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE11EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
37
                                     bool* should_break) {
823
37
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
37
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
37
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
37
    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
37
    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
37
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
37
    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
34
    } else {
852
34
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
34
            !range.is_reject_split_type()) {
854
34
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
34
                                                 _end_include);
856
857
34
            if (!(*eos) &&
858
34
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
34
                                                 _end_include, max_scan_key_num)) {
860
34
                _has_range_value = true;
861
34
            }
862
34
            return Status::OK();
863
34
        }
864
34
    }
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
37
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE25EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.85k
                                     bool* should_break) {
823
2.85k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.85k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.85k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.85k
    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.85k
    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.85k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.85k
    if (range.is_fixed_value_range()) {
842
127
        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.73k
    } else {
852
2.73k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.73k
            !range.is_reject_split_type()) {
854
2.64k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.64k
                                                 _end_include);
856
857
2.64k
            if (!(*eos) &&
858
2.64k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.64k
                                                 _end_include, max_scan_key_num)) {
860
2.58k
                _has_range_value = true;
861
2.58k
            }
862
2.64k
            return Status::OK();
863
2.64k
        }
864
2.73k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
212
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
127
        if (_begin_scan_keys.empty()) {
870
125
            auto fixed_value_set = range.get_fixed_value_set();
871
125
            ConstIterator iter = fixed_value_set.begin();
872
873
266
            for (; iter != fixed_value_set.end(); ++iter) {
874
141
                _begin_scan_keys.emplace_back();
875
141
                _begin_scan_keys.back().add_value(
876
141
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
141
                _end_scan_keys.emplace_back();
878
141
                _end_scan_keys.back().add_value(
879
141
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
141
            }
881
882
125
            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
125
        } // 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
127
        _begin_include = true;
927
127
        _end_include = true;
928
127
    } // Extend ScanKey with range value
929
85
    else {
930
85
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
85
        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
85
        } 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
85
        } else {
955
194
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
109
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
109
                                                      range.get_range_min_value(), range.scale()),
958
109
                                              range.contain_null());
959
109
            }
960
961
194
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
109
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
109
                        range.get_range_max_value(), range.scale()));
964
109
            }
965
85
        }
966
85
        _begin_include = range.is_begin_include();
967
85
        _end_include = range.is_end_include();
968
85
    }
969
970
212
    return Status::OK();
971
2.85k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE12EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
33
                                     bool* should_break) {
823
33
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
33
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
33
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
33
    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
33
    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
33
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
33
    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
30
    } else {
852
30
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
30
            !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
30
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
33
    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
30
    else {
930
30
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
30
        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
30
        } else if (_begin_scan_keys.empty()) {
947
30
            _begin_scan_keys.emplace_back();
948
30
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
30
                                                      range.get_range_min_value(), range.scale()),
950
30
                                              range.contain_null());
951
30
            _end_scan_keys.emplace_back();
952
30
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
30
                    range.get_range_max_value(), range.scale()));
954
30
        } 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
30
        _begin_include = range.is_begin_include();
967
30
        _end_include = range.is_end_include();
968
30
    }
969
970
33
    return Status::OK();
971
33
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE26EEENS_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
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.42k
    if (range.is_fixed_value_range()) {
842
68
        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.35k
    } else {
852
2.35k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.35k
            !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.35k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.42k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
68
        if (_begin_scan_keys.empty()) {
870
66
            auto fixed_value_set = range.get_fixed_value_set();
871
66
            ConstIterator iter = fixed_value_set.begin();
872
873
134
            for (; iter != fixed_value_set.end(); ++iter) {
874
68
                _begin_scan_keys.emplace_back();
875
68
                _begin_scan_keys.back().add_value(
876
68
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
68
                _end_scan_keys.emplace_back();
878
68
                _end_scan_keys.back().add_value(
879
68
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
68
            }
881
882
66
            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
66
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
2
        else {
890
2
            auto fixed_value_set = range.get_fixed_value_set();
891
2
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
6
            for (int i = 0; i < original_key_range_size; ++i) {
894
4
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
4
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
4
                ConstIterator iter = fixed_value_set.begin();
898
899
8
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
4
                    if (iter == fixed_value_set.begin()) {
902
4
                        _begin_scan_keys[i].add_value(
903
4
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
4
                        _end_scan_keys[i].add_value(
905
4
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
4
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
4
                }
916
917
4
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
4
            }
924
2
        }
925
926
68
        _begin_include = true;
927
68
        _end_include = true;
928
68
    } // Extend ScanKey with range value
929
2.35k
    else {
930
2.35k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.35k
        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.36k
        } else if (_begin_scan_keys.empty()) {
947
2.36k
            _begin_scan_keys.emplace_back();
948
2.36k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.36k
                                                      range.get_range_min_value(), range.scale()),
950
2.36k
                                              range.contain_null());
951
2.36k
            _end_scan_keys.emplace_back();
952
2.36k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.36k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
2
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
2
                                                      range.get_range_min_value(), range.scale()),
958
2
                                              range.contain_null());
959
2
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
2
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
2
                        range.get_range_max_value(), range.scale()));
964
2
            }
965
18.4E
        }
966
2.35k
        _begin_include = range.is_begin_include();
967
2.35k
        _end_include = range.is_end_include();
968
2.35k
    }
969
970
2.42k
    return Status::OK();
971
2.42k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.62k
                                     bool* should_break) {
823
3.62k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.62k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.62k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.62k
    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.62k
    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
3.62k
    if (range.is_fixed_value_range()) {
842
186
        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.43k
    } else {
852
3.43k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
3.43k
            !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.43k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3.62k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
187
        if (_begin_scan_keys.empty()) {
870
187
            auto fixed_value_set = range.get_fixed_value_set();
871
187
            ConstIterator iter = fixed_value_set.begin();
872
873
470
            for (; iter != fixed_value_set.end(); ++iter) {
874
283
                _begin_scan_keys.emplace_back();
875
283
                _begin_scan_keys.back().add_value(
876
283
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
283
                _end_scan_keys.emplace_back();
878
283
                _end_scan_keys.back().add_value(
879
283
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
283
            }
881
882
187
            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
187
        } // 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
185
        _begin_include = true;
927
185
        _end_include = true;
928
185
    } // Extend ScanKey with range value
929
3.43k
    else {
930
3.43k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
3.43k
        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
3.44k
        } else if (_begin_scan_keys.empty()) {
947
3.44k
            _begin_scan_keys.emplace_back();
948
3.44k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
3.44k
                                                      range.get_range_min_value(), range.scale()),
950
3.44k
                                              range.contain_null());
951
3.44k
            _end_scan_keys.emplace_back();
952
3.44k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
3.44k
                    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
3.43k
        _begin_include = range.is_begin_include();
967
3.43k
        _end_include = range.is_end_include();
968
3.43k
    }
969
970
3.62k
    return Status::OK();
971
3.62k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
119
                                     bool* should_break) {
823
119
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
119
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
119
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
119
    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
119
    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
119
    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
118
    } else {
852
119
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
118
            !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
118
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
119
    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
118
    else {
930
118
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
118
        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
118
        } else if (_begin_scan_keys.empty()) {
947
118
            _begin_scan_keys.emplace_back();
948
118
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
118
                                                      range.get_range_min_value(), range.scale()),
950
118
                                              range.contain_null());
951
118
            _end_scan_keys.emplace_back();
952
118
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
118
                    range.get_range_max_value(), range.scale()));
954
118
        } else {
955
1
            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
1
            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
0
        }
966
118
        _begin_include = range.is_begin_include();
967
118
        _end_include = range.is_end_include();
968
118
    }
969
970
119
    return Status::OK();
971
119
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.63k
                                     bool* should_break) {
823
1.63k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.63k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.63k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.63k
    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.63k
    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.63k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.63k
    if (range.is_fixed_value_range()) {
842
12
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
1
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
1
        }
851
1.62k
    } else {
852
1.62k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.62k
            !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.62k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.63k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
11
        if (_begin_scan_keys.empty()) {
870
11
            auto fixed_value_set = range.get_fixed_value_set();
871
11
            ConstIterator iter = fixed_value_set.begin();
872
873
31
            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
11
            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
11
        } // 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
11
        _begin_include = true;
927
11
        _end_include = true;
928
11
    } // Extend ScanKey with range value
929
1.62k
    else {
930
1.62k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.62k
        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
1.63k
        } else if (_begin_scan_keys.empty()) {
947
1.63k
            _begin_scan_keys.emplace_back();
948
1.63k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.63k
                                                      range.get_range_min_value(), range.scale()),
950
1.63k
                                              range.contain_null());
951
1.63k
            _end_scan_keys.emplace_back();
952
1.63k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.63k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
30
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
30
                                                      range.get_range_min_value(), range.scale()),
958
30
                                              range.contain_null());
959
30
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
30
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
30
                        range.get_range_max_value(), range.scale()));
964
30
            }
965
18.4E
        }
966
1.62k
        _begin_include = range.is_begin_include();
967
1.62k
        _end_include = range.is_end_include();
968
1.62k
    }
969
970
1.63k
    return Status::OK();
971
1.63k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
511
                                     bool* should_break) {
823
511
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
511
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
511
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
511
    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
511
    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
511
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
511
    if (range.is_fixed_value_range()) {
842
23
        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
488
    } else {
852
488
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
488
            !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
488
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
511
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
23
        if (_begin_scan_keys.empty()) {
870
21
            auto fixed_value_set = range.get_fixed_value_set();
871
21
            ConstIterator iter = fixed_value_set.begin();
872
873
54
            for (; iter != fixed_value_set.end(); ++iter) {
874
33
                _begin_scan_keys.emplace_back();
875
33
                _begin_scan_keys.back().add_value(
876
33
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
33
                _end_scan_keys.emplace_back();
878
33
                _end_scan_keys.back().add_value(
879
33
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
33
            }
881
882
21
            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
21
        } // 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
23
        _begin_include = true;
927
23
        _end_include = true;
928
23
    } // Extend ScanKey with range value
929
488
    else {
930
488
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
488
        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
490
        } else if (_begin_scan_keys.empty()) {
947
490
            _begin_scan_keys.emplace_back();
948
490
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
490
                                                      range.get_range_min_value(), range.scale()),
950
490
                                              range.contain_null());
951
490
            _end_scan_keys.emplace_back();
952
490
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
490
                    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
488
        _begin_include = range.is_begin_include();
967
488
        _end_include = range.is_end_include();
968
488
    }
969
970
511
    return Status::OK();
971
511
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
668
                                     bool* should_break) {
823
668
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
668
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
668
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
668
    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
668
    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
668
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
668
    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
648
    } else {
852
648
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
648
            !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
648
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
668
    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
648
    else {
930
648
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
648
        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
648
        } else if (_begin_scan_keys.empty()) {
947
629
            _begin_scan_keys.emplace_back();
948
629
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
629
                                                      range.get_range_min_value(), range.scale()),
950
629
                                              range.contain_null());
951
629
            _end_scan_keys.emplace_back();
952
629
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
629
                    range.get_range_max_value(), range.scale()));
954
629
        } else {
955
54
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
35
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
35
                                                      range.get_range_min_value(), range.scale()),
958
35
                                              range.contain_null());
959
35
            }
960
961
54
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
35
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
35
                        range.get_range_max_value(), range.scale()));
964
35
            }
965
19
        }
966
648
        _begin_include = range.is_begin_include();
967
648
        _end_include = range.is_end_include();
968
648
    }
969
970
668
    return Status::OK();
971
668
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.31k
                                     bool* should_break) {
823
1.31k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.31k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.31k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.31k
    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.31k
    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.31k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.31k
    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.30k
    } else {
852
1.30k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.30k
            !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.30k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.31k
    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.30k
    else {
930
1.30k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.30k
        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.30k
        } else if (_begin_scan_keys.empty()) {
947
1.20k
            _begin_scan_keys.emplace_back();
948
1.20k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.20k
                                                      range.get_range_min_value(), range.scale()),
950
1.20k
                                              range.contain_null());
951
1.20k
            _end_scan_keys.emplace_back();
952
1.20k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.20k
                    range.get_range_max_value(), range.scale()));
954
1.20k
        } else {
955
206
            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
206
            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
98
        }
966
1.30k
        _begin_include = range.is_begin_include();
967
1.30k
        _end_include = range.is_end_include();
968
1.30k
    }
969
970
1.31k
    return Status::OK();
971
1.31k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
607
                                     bool* should_break) {
823
607
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
607
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
607
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
607
    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
607
    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
607
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
607
    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
591
    } else {
852
591
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
591
            !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
591
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
607
    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
591
    else {
930
591
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
591
        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
590
        } else if (_begin_scan_keys.empty()) {
947
533
            _begin_scan_keys.emplace_back();
948
533
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
533
                                                      range.get_range_min_value(), range.scale()),
950
533
                                              range.contain_null());
951
533
            _end_scan_keys.emplace_back();
952
533
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
533
                    range.get_range_max_value(), range.scale()));
954
533
        } else {
955
117
            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
117
            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
57
        }
966
591
        _begin_include = range.is_begin_include();
967
591
        _end_include = range.is_end_include();
968
591
    }
969
970
607
    return Status::OK();
971
607
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris