Coverage Report

Created: 2026-03-16 08:03

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.30M
std::string cast_to_string(T value, int scale) {
61
1.30M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.24k
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.68k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.68k
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.95k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.95k
        return ((Decimal<int128_t>)value).to_string(scale);
67
2.95k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.77k
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
207k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
207k
        return std::to_string(static_cast<int>(value));
71
207k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
7.57k
        return int128_to_string(value);
73
7.57k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.78k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.78k
        char buf[30];
76
4.78k
        datetimev2_val.to_string(buf);
77
4.78k
        std::stringstream ss;
78
4.78k
        ss << buf;
79
4.78k
        return ss.str();
80
5.48k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
5.48k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
5.48k
        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.23k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.23k
        return CastToString::from_number(value);
91
1.07M
    } else {
92
1.07M
        return boost::lexical_cast<std::string>(value);
93
1.07M
    }
94
1.30M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
207k
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
207k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
207k
        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
207k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE4EsEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
9.40k
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.40k
    } else {
92
9.40k
        return boost::lexical_cast<std::string>(value);
93
9.40k
    }
94
9.40k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE5EiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
183k
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
183k
    } else {
92
183k
        return boost::lexical_cast<std::string>(value);
93
183k
    }
94
183k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
166k
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
166k
    } else {
92
166k
        return boost::lexical_cast<std::string>(value);
93
166k
    }
94
166k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
7.57k
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
7.57k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
7.57k
        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
7.57k
}
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.12k
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.12k
    } else {
92
1.12k
        return boost::lexical_cast<std::string>(value);
93
1.12k
    }
94
1.12k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
446k
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
446k
    } else {
92
446k
        return boost::lexical_cast<std::string>(value);
93
446k
    }
94
446k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE23ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE11ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
814
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
814
    } else {
92
814
        return boost::lexical_cast<std::string>(value);
93
814
    }
94
814
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
263k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
263k
    } else {
92
263k
        return boost::lexical_cast<std::string>(value);
93
263k
    }
94
263k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE12ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
42
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
42
    } else {
92
42
        return boost::lexical_cast<std::string>(value);
93
42
    }
94
42
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE26ENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4.78k
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.78k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.78k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.78k
        char buf[30];
76
4.78k
        datetimev2_val.to_string(buf);
77
4.78k
        std::stringstream ss;
78
4.78k
        ss << buf;
79
4.78k
        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.78k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE42ENS_16TimestampTzValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
5.48k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
5.48k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
5.48k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
5.48k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
5.48k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE20ENS_14DecimalV2ValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
219
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
219
    } else {
92
219
        return boost::lexical_cast<std::string>(value);
93
219
    }
94
219
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.23k
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.23k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.23k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
3.23k
}
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.24k
std::string cast_to_string(T value, int scale) {
61
1.24k
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
1.24k
        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.24k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.68k
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.68k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.68k
        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.68k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
2.95k
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.95k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.95k
        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.95k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.77k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
1.77k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.77k
        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.77k
}
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
156k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
2.43k
    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
67.3k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
80.3k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
3.58k
    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
8
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_reject_split_typeEv
Line
Count
Source
139
2.77k
    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
28.1k
    void set_empty_value_range() {
144
28.1k
        _fixed_values.clear();
145
28.1k
        _low_value = TYPE_MAX;
146
28.1k
        _high_value = TYPE_MIN;
147
28.1k
        _contain_null = false;
148
28.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
84
    void set_empty_value_range() {
144
84
        _fixed_values.clear();
145
84
        _low_value = TYPE_MAX;
146
84
        _high_value = TYPE_MIN;
147
84
        _contain_null = false;
148
84
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_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_13PrimitiveTypeE5EE21set_empty_value_rangeEv
Line
Count
Source
143
331
    void set_empty_value_range() {
144
331
        _fixed_values.clear();
145
331
        _low_value = TYPE_MAX;
146
331
        _high_value = TYPE_MIN;
147
331
        _contain_null = false;
148
331
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
27.1k
    void set_empty_value_range() {
144
27.1k
        _fixed_values.clear();
145
27.1k
        _low_value = TYPE_MAX;
146
27.1k
        _high_value = TYPE_MIN;
147
27.1k
        _contain_null = false;
148
27.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
20
    void set_empty_value_range() {
144
20
        _fixed_values.clear();
145
20
        _low_value = TYPE_MAX;
146
20
        _high_value = TYPE_MIN;
147
20
        _contain_null = false;
148
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_empty_value_rangeEv
Line
Count
Source
143
34
    void set_empty_value_range() {
144
34
        _fixed_values.clear();
145
34
        _low_value = TYPE_MAX;
146
34
        _high_value = TYPE_MIN;
147
34
        _contain_null = false;
148
34
    }
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
312
    void set_empty_value_range() {
144
312
        _fixed_values.clear();
145
312
        _low_value = TYPE_MAX;
146
312
        _high_value = TYPE_MIN;
147
312
        _contain_null = false;
148
312
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_empty_value_rangeEv
Line
Count
Source
143
44
    void set_empty_value_range() {
144
44
        _fixed_values.clear();
145
44
        _low_value = TYPE_MAX;
146
44
        _high_value = TYPE_MIN;
147
44
        _contain_null = false;
148
44
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_empty_value_rangeEv
Line
Count
Source
143
85
    void set_empty_value_range() {
144
85
        _fixed_values.clear();
145
85
        _low_value = TYPE_MAX;
146
85
        _high_value = TYPE_MIN;
147
85
        _contain_null = false;
148
85
    }
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
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_empty_value_rangeEv
Line
Count
Source
143
1
    void set_empty_value_range() {
144
1
        _fixed_values.clear();
145
1
        _low_value = TYPE_MAX;
146
1
        _high_value = TYPE_MIN;
147
1
        _contain_null = false;
148
1
    }
_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
164k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_fixed_value_setEv
Line
Count
Source
150
18
    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.10k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_fixed_value_setEv
Line
Count
Source
150
982
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
139
    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
12
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
160k
    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
10
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_fixed_value_setEv
Line
Count
Source
150
319
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_fixed_value_setEv
Line
Count
Source
150
5
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_fixed_value_setEv
Line
Count
Source
150
72
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_fixed_value_setEv
Line
Count
Source
150
117
    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
4
    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
28
    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
465k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
2.49k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
490
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
142k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
161k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
7.28k
    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
1.00k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
125k
    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
8
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_max_valueEv
Line
Count
Source
152
2.97k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_max_valueEv
Line
Count
Source
152
16
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_max_valueEv
Line
Count
Source
152
4.64k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
5.10k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
219
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
3.18k
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_range_max_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_range_max_valueEv
Line
Count
Source
152
1.15k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.63k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
2.94k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
1.74k
    CppType get_range_max_value() const { return _high_value; }
153
154
465k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.49k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
490
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
142k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
161k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
7.30k
    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
1.00k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
125k
    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
8
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_min_valueEv
Line
Count
Source
154
2.97k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_min_valueEv
Line
Count
Source
154
16
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_min_valueEv
Line
Count
Source
154
4.63k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
5.10k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
220
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
3.19k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_range_min_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_range_min_valueEv
Line
Count
Source
154
1.15k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.63k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
2.93k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
1.73k
    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
231k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
2.45k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
146
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
68.3k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
80.7k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
3.63k
    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
467
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
62.6k
    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
8
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16is_begin_includeEv
Line
Count
Source
168
2.87k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16is_begin_includeEv
Line
Count
Source
168
8
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16is_begin_includeEv
Line
Count
Source
168
2.31k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
2.56k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
109
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
1.58k
    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
577
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
812
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.46k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
876
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
169
170
231k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14is_end_includeEv
Line
Count
Source
170
2.45k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14is_end_includeEv
Line
Count
Source
170
146
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
68.4k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
80.8k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
3.62k
    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
466
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
62.6k
    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
8
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14is_end_includeEv
Line
Count
Source
170
2.87k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14is_end_includeEv
Line
Count
Source
170
8
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14is_end_includeEv
Line
Count
Source
170
2.31k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
2.56k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
110
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
1.58k
    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
578
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
811
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.46k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
876
    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
499k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
3.15k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
519
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
79.3k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12contain_nullEv
Line
Count
Source
176
172k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12contain_nullEv
Line
Count
Source
176
3.84k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
66
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
175
    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
605
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
224k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
158
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12contain_nullEv
Line
Count
Source
176
18
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12contain_nullEv
Line
Count
Source
176
3.49k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12contain_nullEv
Line
Count
Source
176
13
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12contain_nullEv
Line
Count
Source
176
2.46k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
2.81k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
110
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
1.63k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
692
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
856
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.47k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
967
    bool contain_null() const { return _contain_null; }
177
178
561k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.50k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
152
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
73.5k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
82.9k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
3.93k
    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
491
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20get_fixed_value_sizeEv
Line
Count
Source
178
383k
    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
27
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20get_fixed_value_sizeEv
Line
Count
Source
178
3.51k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20get_fixed_value_sizeEv
Line
Count
Source
178
18
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.46k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.78k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
112
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.58k
    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
635
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
851
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.47k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
900
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
958
    void set_whole_value_range() {
181
958
        _fixed_values.clear();
182
958
        _low_value = TYPE_MIN;
183
958
        _high_value = TYPE_MAX;
184
958
        _low_op = FILTER_LARGER_OR_EQUAL;
185
958
        _high_op = FILTER_LESS_OR_EQUAL;
186
958
        _contain_null = _is_nullable_col;
187
958
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
200
    void set_whole_value_range() {
181
200
        _fixed_values.clear();
182
200
        _low_value = TYPE_MIN;
183
200
        _high_value = TYPE_MAX;
184
200
        _low_op = FILTER_LARGER_OR_EQUAL;
185
200
        _high_op = FILTER_LESS_OR_EQUAL;
186
200
        _contain_null = _is_nullable_col;
187
200
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_whole_value_rangeEv
Line
Count
Source
180
34
    void set_whole_value_range() {
181
34
        _fixed_values.clear();
182
34
        _low_value = TYPE_MIN;
183
34
        _high_value = TYPE_MAX;
184
34
        _low_op = FILTER_LARGER_OR_EQUAL;
185
34
        _high_op = FILTER_LESS_OR_EQUAL;
186
34
        _contain_null = _is_nullable_col;
187
34
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
409
    void set_whole_value_range() {
181
409
        _fixed_values.clear();
182
409
        _low_value = TYPE_MIN;
183
409
        _high_value = TYPE_MAX;
184
409
        _low_op = FILTER_LARGER_OR_EQUAL;
185
409
        _high_op = FILTER_LESS_OR_EQUAL;
186
409
        _contain_null = _is_nullable_col;
187
409
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_whole_value_rangeEv
Line
Count
Source
180
19
    void set_whole_value_range() {
181
19
        _fixed_values.clear();
182
19
        _low_value = TYPE_MIN;
183
19
        _high_value = TYPE_MAX;
184
19
        _low_op = FILTER_LARGER_OR_EQUAL;
185
19
        _high_op = FILTER_LESS_OR_EQUAL;
186
19
        _contain_null = _is_nullable_col;
187
19
    }
_ZN5doris16ColumnValueRangeILNS_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
8
    void set_whole_value_range() {
181
8
        _fixed_values.clear();
182
8
        _low_value = TYPE_MIN;
183
8
        _high_value = TYPE_MAX;
184
8
        _low_op = FILTER_LARGER_OR_EQUAL;
185
8
        _high_op = FILTER_LESS_OR_EQUAL;
186
8
        _contain_null = _is_nullable_col;
187
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_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
    }
_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
33
    void set_whole_value_range() {
181
33
        _fixed_values.clear();
182
33
        _low_value = TYPE_MIN;
183
33
        _high_value = TYPE_MAX;
184
33
        _low_op = FILTER_LARGER_OR_EQUAL;
185
33
        _high_op = FILTER_LESS_OR_EQUAL;
186
33
        _contain_null = _is_nullable_col;
187
33
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_whole_value_rangeEv
Line
Count
Source
180
23
    void set_whole_value_range() {
181
23
        _fixed_values.clear();
182
23
        _low_value = TYPE_MIN;
183
23
        _high_value = TYPE_MAX;
184
23
        _low_op = FILTER_LARGER_OR_EQUAL;
185
23
        _high_op = FILTER_LESS_OR_EQUAL;
186
23
        _contain_null = _is_nullable_col;
187
23
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
44
    void set_whole_value_range() {
181
44
        _fixed_values.clear();
182
44
        _low_value = TYPE_MIN;
183
44
        _high_value = TYPE_MAX;
184
44
        _low_op = FILTER_LARGER_OR_EQUAL;
185
44
        _high_op = FILTER_LESS_OR_EQUAL;
186
44
        _contain_null = _is_nullable_col;
187
44
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_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_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
34
    void set_whole_value_range() {
181
34
        _fixed_values.clear();
182
34
        _low_value = TYPE_MIN;
183
34
        _high_value = TYPE_MAX;
184
34
        _low_op = FILTER_LARGER_OR_EQUAL;
185
34
        _high_op = FILTER_LESS_OR_EQUAL;
186
34
        _contain_null = _is_nullable_col;
187
34
    }
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
30
    void set_whole_value_range() {
181
30
        _fixed_values.clear();
182
30
        _low_value = TYPE_MIN;
183
30
        _high_value = TYPE_MAX;
184
30
        _low_op = FILTER_LARGER_OR_EQUAL;
185
30
        _high_op = FILTER_LESS_OR_EQUAL;
186
30
        _contain_null = _is_nullable_col;
187
30
    }
_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
35
    void set_whole_value_range() {
181
35
        _fixed_values.clear();
182
35
        _low_value = TYPE_MIN;
183
35
        _high_value = TYPE_MAX;
184
35
        _low_op = FILTER_LARGER_OR_EQUAL;
185
35
        _high_op = FILTER_LESS_OR_EQUAL;
186
35
        _contain_null = _is_nullable_col;
187
35
    }
188
189
643
    bool is_whole_value_range() const {
190
643
        DCHECK(_is_nullable_col || !contain_null())
191
1
                << "Non-nullable column cannot contains null value";
192
193
643
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
643
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
643
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
643
    }
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
133
    bool is_whole_value_range() const {
190
133
        DCHECK(_is_nullable_col || !contain_null())
191
1
                << "Non-nullable column cannot contains null value";
192
193
133
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
133
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
133
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
133
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_whole_value_rangeEv
Line
Count
Source
189
21
    bool is_whole_value_range() const {
190
21
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
21
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
21
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
21
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
21
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_whole_value_rangeEv
Line
Count
Source
189
20
    bool is_whole_value_range() const {
190
20
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
20
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
20
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
20
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
20
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_whole_value_rangeEv
Line
Count
Source
189
34
    bool is_whole_value_range() const {
190
34
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
34
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
34
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
34
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
34
    }
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
276
    bool is_whole_value_range() const {
190
276
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
276
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
276
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
276
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
276
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_whole_value_rangeEv
Line
Count
Source
189
45
    bool is_whole_value_range() const {
190
45
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
45
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
45
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
45
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
45
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
72
    bool is_whole_value_range() const {
190
72
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
73
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
72
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
72
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
72
    }
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.60k
    void set_contain_null(bool contain_null) {
205
1.60k
        if (contain_null) {
206
651
            set_empty_value_range();
207
953
        } else {
208
953
            set_whole_value_range();
209
953
        }
210
1.60k
        _contain_null = _is_nullable_col && contain_null;
211
1.60k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
200
    void set_contain_null(bool contain_null) {
205
200
        if (contain_null) {
206
0
            set_empty_value_range();
207
200
        } else {
208
200
            set_whole_value_range();
209
200
        }
210
200
        _contain_null = _is_nullable_col && contain_null;
211
200
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
35
    void set_contain_null(bool contain_null) {
205
35
        if (contain_null) {
206
2
            set_empty_value_range();
207
33
        } else {
208
33
            set_whole_value_range();
209
33
        }
210
36
        _contain_null = _is_nullable_col && contain_null;
211
35
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
543
    void set_contain_null(bool contain_null) {
205
543
        if (contain_null) {
206
138
            set_empty_value_range();
207
405
        } else {
208
405
            set_whole_value_range();
209
405
        }
210
543
        _contain_null = _is_nullable_col && contain_null;
211
543
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
20
    void set_contain_null(bool contain_null) {
205
20
        if (contain_null) {
206
1
            set_empty_value_range();
207
19
        } else {
208
19
            set_whole_value_range();
209
19
        }
210
20
        _contain_null = _is_nullable_col && contain_null;
211
20
    }
_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
28
    void set_contain_null(bool contain_null) {
205
28
        if (contain_null) {
206
20
            set_empty_value_range();
207
20
        } else {
208
8
            set_whole_value_range();
209
8
        }
210
28
        _contain_null = _is_nullable_col && contain_null;
211
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
71
    void set_contain_null(bool contain_null) {
205
71
        if (contain_null) {
206
34
            set_empty_value_range();
207
37
        } else {
208
37
            set_whole_value_range();
209
37
        }
210
71
        _contain_null = _is_nullable_col && contain_null;
211
71
    }
_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
309
    void set_contain_null(bool contain_null) {
205
309
        if (contain_null) {
206
276
            set_empty_value_range();
207
276
        } else {
208
33
            set_whole_value_range();
209
33
        }
210
309
        _contain_null = _is_nullable_col && contain_null;
211
309
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
67
    void set_contain_null(bool contain_null) {
205
67
        if (contain_null) {
206
44
            set_empty_value_range();
207
44
        } else {
208
23
            set_whole_value_range();
209
23
        }
210
68
        _contain_null = _is_nullable_col && contain_null;
211
67
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
118
    void set_contain_null(bool contain_null) {
205
118
        if (contain_null) {
206
74
            set_empty_value_range();
207
74
        } else {
208
44
            set_whole_value_range();
209
44
        }
210
118
        _contain_null = _is_nullable_col && contain_null;
211
118
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
31
    void set_contain_null(bool contain_null) {
205
31
        if (contain_null) {
206
6
            set_empty_value_range();
207
25
        } else {
208
25
            set_whole_value_range();
209
25
        }
210
31
        _contain_null = _is_nullable_col && contain_null;
211
31
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
52
    void set_contain_null(bool contain_null) {
205
52
        if (contain_null) {
206
18
            set_empty_value_range();
207
34
        } else {
208
34
            set_whole_value_range();
209
34
        }
210
52
        _contain_null = _is_nullable_col && contain_null;
211
52
    }
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
30
    void set_contain_null(bool contain_null) {
205
30
        if (contain_null) {
206
0
            set_empty_value_range();
207
30
        } else {
208
30
            set_whole_value_range();
209
30
        }
210
30
        _contain_null = _is_nullable_col && contain_null;
211
30
    }
_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
37
    void set_contain_null(bool contain_null) {
205
37
        if (contain_null) {
206
2
            set_empty_value_range();
207
35
        } else {
208
35
            set_whole_value_range();
209
35
        }
210
37
        _contain_null = _is_nullable_col && contain_null;
211
37
    }
212
213
407k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
79.1k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
1.58k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
15.4k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
103k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
335
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
195
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
541
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
44
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
48
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.20k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9precisionEv
Line
Count
Source
213
169k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9precisionEv
Line
Count
Source
213
837
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9precisionEv
Line
Count
Source
213
56
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
30.1k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
42
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
3.54k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
741
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
171
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
313
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
258
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
384
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
505
    int precision() const { return _precision; }
214
215
1.71M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
287k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
11.0k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
200k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
270k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
7.92k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
195
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
541
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
44
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
52
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.32k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE5scaleEv
Line
Count
Source
215
615k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE5scaleEv
Line
Count
Source
215
838
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
873
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
293k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
84
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
8.34k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
6.23k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
223
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
3.40k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.55k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
1.95k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
3.34k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
2.28k
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
304k
                                      const CppType& value) {
219
304k
        static_cast<void>(range.add_fixed_value(value));
220
304k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
77.1k
                                      const CppType& value) {
219
77.1k
        static_cast<void>(range.add_fixed_value(value));
220
77.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
234
                                      const CppType& value) {
219
234
        static_cast<void>(range.add_fixed_value(value));
220
234
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
45.0k
                                      const CppType& value) {
219
45.0k
        static_cast<void>(range.add_fixed_value(value));
220
45.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
881
                                      const CppType& value) {
219
881
        static_cast<void>(range.add_fixed_value(value));
220
881
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
206
                                      const CppType& value) {
219
206
        static_cast<void>(range.add_fixed_value(value));
220
206
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
43
                                      const CppType& value) {
219
43
        static_cast<void>(range.add_fixed_value(value));
220
43
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
193
                                      const CppType& value) {
219
193
        static_cast<void>(range.add_fixed_value(value));
220
193
    }
_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
28
                                      const CppType& value) {
219
28
        static_cast<void>(range.add_fixed_value(value));
220
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
550
                                      const CppType& value) {
219
550
        static_cast<void>(range.add_fixed_value(value));
220
550
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
167k
                                      const CppType& value) {
219
167k
        static_cast<void>(range.add_fixed_value(value));
220
167k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
389
                                      const CppType& value) {
219
389
        static_cast<void>(range.add_fixed_value(value));
220
389
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
72
                                      const CppType& value) {
219
72
        static_cast<void>(range.add_fixed_value(value));
220
72
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
9.93k
                                      const CppType& value) {
219
9.93k
        static_cast<void>(range.add_fixed_value(value));
220
9.93k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
55
                                      const CppType& value) {
219
55
        static_cast<void>(range.add_fixed_value(value));
220
55
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
433
                                      const CppType& value) {
219
433
        static_cast<void>(range.add_fixed_value(value));
220
433
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
167
                                      const CppType& value) {
219
167
        static_cast<void>(range.add_fixed_value(value));
220
167
    }
_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
165
                                      const CppType& value) {
219
165
        static_cast<void>(range.add_fixed_value(value));
220
165
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
218
66
                                      const CppType& value) {
219
66
        static_cast<void>(range.add_fixed_value(value));
220
66
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
218
187
                                      const CppType& value) {
219
187
        static_cast<void>(range.add_fixed_value(value));
220
187
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
251
                                      const CppType& value) {
219
251
        static_cast<void>(range.add_fixed_value(value));
220
251
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
94
                                      const CppType& value) {
219
94
        static_cast<void>(range.add_fixed_value(value));
220
94
    }
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.29k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
61
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
56
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
720
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14empty_functionERS2_NS_11SQLFilterOpERKl
Line
Count
Source
228
36
                               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
76
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
172
                               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
95
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
311
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
105
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
34
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
13
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
30
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
228
77
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
254
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
4
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
55
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
228
8
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14empty_functionERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
228
23
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
154
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
114k
                                const CppType& value) {
232
114k
        static_cast<void>(range.add_range(op, value));
233
114k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
1.36k
                                const CppType& value) {
232
1.36k
        static_cast<void>(range.add_range(op, value));
233
1.36k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.35k
                                const CppType& value) {
232
1.35k
        static_cast<void>(range.add_range(op, value));
233
1.35k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
9.71k
                                const CppType& value) {
232
9.71k
        static_cast<void>(range.add_range(op, value));
233
9.71k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
75.1k
                                const CppType& value) {
232
75.1k
        static_cast<void>(range.add_range(op, value));
233
75.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
115
                                const CppType& value) {
232
115
        static_cast<void>(range.add_range(op, value));
233
115
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
66
                                const CppType& value) {
232
66
        static_cast<void>(range.add_range(op, value));
233
66
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
222
                                const CppType& value) {
232
222
        static_cast<void>(range.add_range(op, value));
233
222
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
20
                                const CppType& value) {
232
20
        static_cast<void>(range.add_range(op, value));
233
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
20
                                const CppType& value) {
232
20
        static_cast<void>(range.add_range(op, value));
233
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
665
                                const CppType& value) {
232
665
        static_cast<void>(range.add_range(op, value));
233
665
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.35k
                                const CppType& value) {
232
1.35k
        static_cast<void>(range.add_range(op, value));
233
1.35k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
361
                                const CppType& value) {
232
361
        static_cast<void>(range.add_range(op, value));
233
361
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
20.1k
                                const CppType& value) {
232
20.1k
        static_cast<void>(range.add_range(op, value));
233
20.1k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
3.02k
                                const CppType& value) {
232
3.02k
        static_cast<void>(range.add_range(op, value));
233
3.02k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
429
                                const CppType& value) {
232
429
        static_cast<void>(range.add_range(op, value));
233
429
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
231
4
                                const CppType& value) {
232
4
        static_cast<void>(range.add_range(op, value));
233
4
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
176
                                const CppType& value) {
232
176
        static_cast<void>(range.add_range(op, value));
233
176
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
114
                                const CppType& value) {
232
114
        static_cast<void>(range.add_range(op, value));
233
114
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
231
124
                                const CppType& value) {
232
124
        static_cast<void>(range.add_range(op, value));
233
124
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
231
257
                                const CppType& value) {
232
257
        static_cast<void>(range.add_range(op, value));
233
257
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
407k
                                                                            int scale) {
238
407k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
407k
                                                precision, scale);
240
407k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
78.9k
                                                                            int scale) {
238
78.9k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
78.9k
                                                precision, scale);
240
78.9k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.57k
                                                                            int scale) {
238
1.57k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.57k
                                                precision, scale);
240
1.57k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
15.3k
                                                                            int scale) {
238
15.3k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
15.3k
                                                precision, scale);
240
15.3k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
102k
                                                                            int scale) {
238
102k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
102k
                                                precision, scale);
240
102k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
334
                                                                            int scale) {
238
334
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
334
                                                precision, scale);
240
334
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
195
                                                                            int scale) {
238
195
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
195
                                                precision, scale);
240
195
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
535
                                                                            int scale) {
238
535
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
535
                                                precision, scale);
240
535
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
44
                                                                            int scale) {
238
44
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
44
                                                precision, scale);
240
44
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
48
                                                                            int scale) {
238
48
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
48
                                                precision, scale);
240
48
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.19k
                                                                            int scale) {
238
1.19k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.19k
                                                precision, scale);
240
1.19k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
169k
                                                                            int scale) {
238
169k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
169k
                                                precision, scale);
240
169k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
824
                                                                            int scale) {
238
824
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
824
                                                precision, scale);
240
824
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
56
                                                                            int scale) {
238
56
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
56
                                                precision, scale);
240
56
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
30.0k
                                                                            int scale) {
238
30.0k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
30.0k
                                                precision, scale);
240
30.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
42
                                                                            int scale) {
238
42
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
42
                                                precision, scale);
240
42
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
3.52k
                                                                            int scale) {
238
3.52k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
3.52k
                                                precision, scale);
240
3.52k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
737
                                                                            int scale) {
238
737
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
737
                                                precision, scale);
240
737
    }
_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
171
                                                                            int scale) {
238
171
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
171
                                                precision, scale);
240
171
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
312
                                                                            int scale) {
238
312
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
312
                                                precision, scale);
240
312
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
254
                                                                            int scale) {
238
254
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
254
                                                precision, scale);
240
254
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
380
                                                                            int scale) {
238
380
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
380
                                                precision, scale);
240
380
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
503
                                                                            int scale) {
238
503
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
503
                                                precision, scale);
240
503
    }
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
619k
    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
2.10k
    std::string debug_string() {
310
2.10k
        std::stringstream ss;
311
2.10k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
2.10k
        ss << "ScanKeys:";
313
314
14.3k
        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
12.2k
        }
318
2.10k
        return ss.str();
319
2.10k
    }
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
285k
    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.60M
        : _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.01M
        : _column_name(std::move(col_name)),
381
2.01M
          _column_type(primitive_type),
382
1.08M
          _low_value(min),
383
1.08M
          _high_value(max),
384
2.01M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.01M
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.01M
          _is_nullable_col(is_nullable_col),
387
2.01M
          _contain_null(is_nullable_col && contain_null),
388
2.01M
          _precision(precision),
389
2.01M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKaSA_bbii
Line
Count
Source
380
175k
        : _column_name(std::move(col_name)),
381
175k
          _column_type(primitive_type),
382
175k
          _low_value(min),
383
175k
          _high_value(max),
384
175k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
175k
          _high_op(FILTER_LESS_OR_EQUAL),
386
175k
          _is_nullable_col(is_nullable_col),
387
175k
          _contain_null(is_nullable_col && contain_null),
388
175k
          _precision(precision),
389
175k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
16.0k
        : _column_name(std::move(col_name)),
381
16.0k
          _column_type(primitive_type),
382
16.0k
          _low_value(min),
383
16.0k
          _high_value(max),
384
16.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
16.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
16.0k
          _is_nullable_col(is_nullable_col),
387
16.0k
          _contain_null(is_nullable_col && contain_null),
388
16.0k
          _precision(precision),
389
16.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
239k
        : _column_name(std::move(col_name)),
381
239k
          _column_type(primitive_type),
382
239k
          _low_value(min),
383
239k
          _high_value(max),
384
239k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
239k
          _high_op(FILTER_LESS_OR_EQUAL),
386
239k
          _is_nullable_col(is_nullable_col),
387
239k
          _contain_null(is_nullable_col && contain_null),
388
239k
          _precision(precision),
389
239k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
462k
        : _column_name(std::move(col_name)),
381
462k
          _column_type(primitive_type),
382
462k
          _low_value(min),
383
462k
          _high_value(max),
384
462k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
462k
          _high_op(FILTER_LESS_OR_EQUAL),
386
462k
          _is_nullable_col(is_nullable_col),
387
462k
          _contain_null(is_nullable_col && contain_null),
388
462k
          _precision(precision),
389
462k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_bbii
Line
Count
Source
380
10.0k
        : _column_name(std::move(col_name)),
381
10.0k
          _column_type(primitive_type),
382
10.0k
          _low_value(min),
383
10.0k
          _high_value(max),
384
10.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
10.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
10.0k
          _is_nullable_col(is_nullable_col),
387
10.0k
          _contain_null(is_nullable_col && contain_null),
388
10.0k
          _precision(precision),
389
10.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
7.53k
        : _column_name(std::move(col_name)),
381
7.53k
          _column_type(primitive_type),
382
7.53k
          _low_value(min),
383
7.53k
          _high_value(max),
384
7.53k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
7.53k
          _high_op(FILTER_LESS_OR_EQUAL),
386
7.53k
          _is_nullable_col(is_nullable_col),
387
7.53k
          _contain_null(is_nullable_col && contain_null),
388
7.53k
          _precision(precision),
389
7.53k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
11.0k
        : _column_name(std::move(col_name)),
381
11.0k
          _column_type(primitive_type),
382
11.0k
          _low_value(min),
383
11.0k
          _high_value(max),
384
11.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.0k
          _is_nullable_col(is_nullable_col),
387
11.0k
          _contain_null(is_nullable_col && contain_null),
388
11.0k
          _precision(precision),
389
11.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
367
        : _column_name(std::move(col_name)),
381
367
          _column_type(primitive_type),
382
367
          _low_value(min),
383
367
          _high_value(max),
384
367
          _low_op(FILTER_LARGER_OR_EQUAL),
385
367
          _high_op(FILTER_LESS_OR_EQUAL),
386
367
          _is_nullable_col(is_nullable_col),
387
367
          _contain_null(is_nullable_col && contain_null),
388
367
          _precision(precision),
389
367
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
394
        : _column_name(std::move(col_name)),
381
394
          _column_type(primitive_type),
382
394
          _low_value(min),
383
394
          _high_value(max),
384
394
          _low_op(FILTER_LARGER_OR_EQUAL),
385
394
          _high_op(FILTER_LESS_OR_EQUAL),
386
394
          _is_nullable_col(is_nullable_col),
387
394
          _contain_null(is_nullable_col && contain_null),
388
394
          _precision(precision),
389
394
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
13.9k
        : _column_name(std::move(col_name)),
381
13.9k
          _column_type(primitive_type),
382
13.9k
          _low_value(min),
383
13.9k
          _high_value(max),
384
13.9k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.9k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.9k
          _is_nullable_col(is_nullable_col),
387
13.9k
          _contain_null(is_nullable_col && contain_null),
388
13.9k
          _precision(precision),
389
13.9k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
725k
        : _column_name(std::move(col_name)),
381
725k
          _column_type(primitive_type),
382
725k
          _low_value(min),
383
725k
          _high_value(max),
384
725k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
725k
          _high_op(FILTER_LESS_OR_EQUAL),
386
725k
          _is_nullable_col(is_nullable_col),
387
725k
          _contain_null(is_nullable_col && contain_null),
388
725k
          _precision(precision),
389
725k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
83.8k
        : _column_name(std::move(col_name)),
381
83.8k
          _column_type(primitive_type),
382
83.8k
          _low_value(min),
383
83.8k
          _high_value(max),
384
83.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
83.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
83.8k
          _is_nullable_col(is_nullable_col),
387
83.8k
          _contain_null(is_nullable_col && contain_null),
388
83.8k
          _precision(precision),
389
83.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
463
        : _column_name(std::move(col_name)),
381
463
          _column_type(primitive_type),
382
463
          _low_value(min),
383
463
          _high_value(max),
384
463
          _low_op(FILTER_LARGER_OR_EQUAL),
385
463
          _high_op(FILTER_LESS_OR_EQUAL),
386
463
          _is_nullable_col(is_nullable_col),
387
463
          _contain_null(is_nullable_col && contain_null),
388
463
          _precision(precision),
389
463
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_15DateV2ValueTypeEEESD_bbii
Line
Count
Source
380
122k
        : _column_name(std::move(col_name)),
381
122k
          _column_type(primitive_type),
382
122k
          _low_value(min),
383
122k
          _high_value(max),
384
122k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
122k
          _high_op(FILTER_LESS_OR_EQUAL),
386
122k
          _is_nullable_col(is_nullable_col),
387
122k
          _contain_null(is_nullable_col && contain_null),
388
122k
          _precision(precision),
389
122k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
442
        : _column_name(std::move(col_name)),
381
442
          _column_type(primitive_type),
382
442
          _low_value(min),
383
442
          _high_value(max),
384
442
          _low_op(FILTER_LARGER_OR_EQUAL),
385
442
          _high_op(FILTER_LESS_OR_EQUAL),
386
442
          _is_nullable_col(is_nullable_col),
387
442
          _contain_null(is_nullable_col && contain_null),
388
442
          _precision(precision),
389
442
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
79.5k
        : _column_name(std::move(col_name)),
381
79.5k
          _column_type(primitive_type),
382
79.5k
          _low_value(min),
383
79.5k
          _high_value(max),
384
79.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
79.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
79.5k
          _is_nullable_col(is_nullable_col),
387
79.5k
          _contain_null(is_nullable_col && contain_null),
388
79.5k
          _precision(precision),
389
79.5k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
6.75k
        : _column_name(std::move(col_name)),
381
6.75k
          _column_type(primitive_type),
382
6.75k
          _low_value(min),
383
6.75k
          _high_value(max),
384
6.75k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
6.75k
          _high_op(FILTER_LESS_OR_EQUAL),
386
6.75k
          _is_nullable_col(is_nullable_col),
387
6.75k
          _contain_null(is_nullable_col && contain_null),
388
6.75k
          _precision(precision),
389
6.75k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
538
        : _column_name(std::move(col_name)),
381
538
          _column_type(primitive_type),
382
538
          _low_value(min),
383
538
          _high_value(max),
384
538
          _low_op(FILTER_LARGER_OR_EQUAL),
385
538
          _high_op(FILTER_LESS_OR_EQUAL),
386
538
          _is_nullable_col(is_nullable_col),
387
538
          _contain_null(is_nullable_col && contain_null),
388
538
          _precision(precision),
389
538
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
6.99k
        : _column_name(std::move(col_name)),
381
6.99k
          _column_type(primitive_type),
382
6.99k
          _low_value(min),
383
6.99k
          _high_value(max),
384
6.99k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
6.99k
          _high_op(FILTER_LESS_OR_EQUAL),
386
6.99k
          _is_nullable_col(is_nullable_col),
387
6.99k
          _contain_null(is_nullable_col && contain_null),
388
6.99k
          _precision(precision),
389
6.99k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
370
        : _column_name(std::move(col_name)),
381
370
          _column_type(primitive_type),
382
370
          _low_value(min),
383
370
          _high_value(max),
384
370
          _low_op(FILTER_LARGER_OR_EQUAL),
385
370
          _high_op(FILTER_LESS_OR_EQUAL),
386
370
          _is_nullable_col(is_nullable_col),
387
370
          _contain_null(is_nullable_col && contain_null),
388
370
          _precision(precision),
389
370
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
8.39k
        : _column_name(std::move(col_name)),
381
8.39k
          _column_type(primitive_type),
382
8.39k
          _low_value(min),
383
8.39k
          _high_value(max),
384
8.39k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
8.39k
          _high_op(FILTER_LESS_OR_EQUAL),
386
8.39k
          _is_nullable_col(is_nullable_col),
387
8.39k
          _contain_null(is_nullable_col && contain_null),
388
8.39k
          _precision(precision),
389
8.39k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
25.6k
        : _column_name(std::move(col_name)),
381
25.6k
          _column_type(primitive_type),
382
25.6k
          _low_value(min),
383
25.6k
          _high_value(max),
384
25.6k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
25.6k
          _high_op(FILTER_LESS_OR_EQUAL),
386
25.6k
          _is_nullable_col(is_nullable_col),
387
25.6k
          _contain_null(is_nullable_col && contain_null),
388
25.6k
          _precision(precision),
389
25.6k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
10.8k
        : _column_name(std::move(col_name)),
381
10.8k
          _column_type(primitive_type),
382
10.8k
          _low_value(min),
383
10.8k
          _high_value(max),
384
10.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
10.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
10.8k
          _is_nullable_col(is_nullable_col),
387
10.8k
          _contain_null(is_nullable_col && contain_null),
388
10.8k
          _precision(precision),
389
10.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
3.16k
        : _column_name(std::move(col_name)),
381
3.16k
          _column_type(primitive_type),
382
3.16k
          _low_value(min),
383
3.16k
          _high_value(max),
384
3.16k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
3.16k
          _high_op(FILTER_LESS_OR_EQUAL),
386
3.16k
          _is_nullable_col(is_nullable_col),
387
3.16k
          _contain_null(is_nullable_col && contain_null),
388
3.16k
          _precision(precision),
389
3.16k
          _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.60M
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.60M
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
95.9k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
95.9k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
14.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
14.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
224k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
224k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
359k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
359k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
9.71k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
9.71k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
7.30k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
7.30k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.5k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.5k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.7k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.7k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
406
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
406
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
400
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
400
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
92.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
92.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
75.8k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
75.8k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
5.98k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
5.98k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
555k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
555k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
82.8k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
82.8k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
370
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
370
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
8.05k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
8.05k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
25.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
25.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.4k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.4k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
2.65k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
2.65k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
532
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
532
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
6.80k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
6.80k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
323
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
323
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
345
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
345
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
318k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
318k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
318k
    _fixed_values.insert(value);
404
318k
    _contain_null = false;
405
406
318k
    _high_value = TYPE_MIN;
407
318k
    _low_value = TYPE_MAX;
408
409
318k
    return Status::OK();
410
318k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_fixed_valueERKa
Line
Count
Source
398
77.3k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
77.3k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
77.3k
    _fixed_values.insert(value);
404
77.3k
    _contain_null = false;
405
406
77.3k
    _high_value = TYPE_MIN;
407
77.3k
    _low_value = TYPE_MAX;
408
409
77.3k
    return Status::OK();
410
77.3k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_fixed_valueERKs
Line
Count
Source
398
235
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
235
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
235
    _fixed_values.insert(value);
404
235
    _contain_null = false;
405
406
235
    _high_value = TYPE_MIN;
407
235
    _low_value = TYPE_MAX;
408
409
235
    return Status::OK();
410
235
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
45.5k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
45.5k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
45.5k
    _fixed_values.insert(value);
404
45.5k
    _contain_null = false;
405
406
45.5k
    _high_value = TYPE_MIN;
407
45.5k
    _low_value = TYPE_MAX;
408
409
45.5k
    return Status::OK();
410
45.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
14.2k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
14.2k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
14.2k
    _fixed_values.insert(value);
404
14.2k
    _contain_null = false;
405
406
14.2k
    _high_value = TYPE_MIN;
407
14.2k
    _low_value = TYPE_MAX;
408
409
14.2k
    return Status::OK();
410
14.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
220
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
220
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
220
    _fixed_values.insert(value);
404
220
    _contain_null = false;
405
406
220
    _high_value = TYPE_MIN;
407
220
    _low_value = TYPE_MAX;
408
409
220
    return Status::OK();
410
220
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
43
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
43
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
43
    _fixed_values.insert(value);
404
43
    _contain_null = false;
405
406
43
    _high_value = TYPE_MIN;
407
43
    _low_value = TYPE_MAX;
408
409
43
    return Status::OK();
410
43
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
210
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
210
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
210
    _fixed_values.insert(value);
404
210
    _contain_null = false;
405
406
210
    _high_value = TYPE_MIN;
407
210
    _low_value = TYPE_MAX;
408
409
210
    return Status::OK();
410
210
}
_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
28
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
28
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
28
    _fixed_values.insert(value);
404
28
    _contain_null = false;
405
406
28
    _high_value = TYPE_MIN;
407
28
    _low_value = TYPE_MAX;
408
409
28
    return Status::OK();
410
28
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
552
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
552
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
552
    _fixed_values.insert(value);
404
552
    _contain_null = false;
405
406
552
    _high_value = TYPE_MIN;
407
552
    _low_value = TYPE_MAX;
408
409
552
    return Status::OK();
410
552
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
168k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
168k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
168k
    _fixed_values.insert(value);
404
168k
    _contain_null = false;
405
406
168k
    _high_value = TYPE_MIN;
407
168k
    _low_value = TYPE_MAX;
408
409
168k
    return Status::OK();
410
168k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
393
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
393
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
393
    _fixed_values.insert(value);
404
393
    _contain_null = false;
405
406
393
    _high_value = TYPE_MIN;
407
393
    _low_value = TYPE_MAX;
408
409
393
    return Status::OK();
410
393
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
72
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
72
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
72
    _fixed_values.insert(value);
404
72
    _contain_null = false;
405
406
72
    _high_value = TYPE_MIN;
407
72
    _low_value = TYPE_MAX;
408
409
72
    return Status::OK();
410
72
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
9.98k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
9.98k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
9.98k
    _fixed_values.insert(value);
404
9.98k
    _contain_null = false;
405
406
9.98k
    _high_value = TYPE_MIN;
407
9.98k
    _low_value = TYPE_MAX;
408
409
9.98k
    return Status::OK();
410
9.98k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
55
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
55
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
55
    _fixed_values.insert(value);
404
55
    _contain_null = false;
405
406
55
    _high_value = TYPE_MIN;
407
55
    _low_value = TYPE_MAX;
408
409
55
    return Status::OK();
410
55
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
453
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
453
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
453
    _fixed_values.insert(value);
404
453
    _contain_null = false;
405
406
453
    _high_value = TYPE_MIN;
407
453
    _low_value = TYPE_MAX;
408
409
453
    return Status::OK();
410
453
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
210
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
210
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
210
    _fixed_values.insert(value);
404
210
    _contain_null = false;
405
406
210
    _high_value = TYPE_MIN;
407
210
    _low_value = TYPE_MAX;
408
409
210
    return Status::OK();
410
210
}
_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
166
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
166
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
166
    _fixed_values.insert(value);
404
166
    _contain_null = false;
405
406
166
    _high_value = TYPE_MIN;
407
166
    _low_value = TYPE_MAX;
408
409
166
    return Status::OK();
410
166
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
90
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
90
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
90
    _fixed_values.insert(value);
404
90
    _contain_null = false;
405
406
90
    _high_value = TYPE_MIN;
407
90
    _low_value = TYPE_MAX;
408
409
90
    return Status::OK();
410
90
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
187
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
187
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
187
    _fixed_values.insert(value);
404
187
    _contain_null = false;
405
406
187
    _high_value = TYPE_MIN;
407
187
    _low_value = TYPE_MAX;
408
409
187
    return Status::OK();
410
187
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
252
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
252
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
252
    _fixed_values.insert(value);
404
252
    _contain_null = false;
405
406
252
    _high_value = TYPE_MIN;
407
252
    _low_value = TYPE_MAX;
408
409
252
    return Status::OK();
410
252
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
94
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
94
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
94
    _fixed_values.insert(value);
404
94
    _contain_null = false;
405
406
94
    _high_value = TYPE_MIN;
407
94
    _low_value = TYPE_MAX;
408
409
94
    return Status::OK();
410
94
}
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
719k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
719k
    return _fixed_values.size() != 0;
420
719k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
17.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
17.4k
    return _fixed_values.size() != 0;
420
17.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
482k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
482k
    return _fixed_values.size() != 0;
420
482k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
839k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
839k
    return _fixed_values.size() != 0;
420
839k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
26.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
26.3k
    return _fixed_values.size() != 0;
420
26.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
7.82k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.82k
    return _fixed_values.size() != 0;
420
7.82k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
12.1k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
12.1k
    return _fixed_values.size() != 0;
420
12.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
504
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
504
    return _fixed_values.size() != 0;
420
504
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
546
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
546
    return _fixed_values.size() != 0;
420
546
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.7k
    return _fixed_values.size() != 0;
420
18.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_fixed_value_rangeEv
Line
Count
Source
418
2.56M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
2.56M
    return _fixed_values.size() != 0;
420
2.56M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_fixed_value_rangeEv
Line
Count
Source
418
85.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
85.9k
    return _fixed_values.size() != 0;
420
85.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_fixed_value_rangeEv
Line
Count
Source
418
793
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
793
    return _fixed_values.size() != 0;
420
793
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_fixed_value_rangeEv
Line
Count
Source
418
200k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
200k
    return _fixed_values.size() != 0;
420
200k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_fixed_value_rangeEv
Line
Count
Source
418
701
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
701
    return _fixed_values.size() != 0;
420
701
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
91.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
91.4k
    return _fixed_values.size() != 0;
420
91.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.0k
    return _fixed_values.size() != 0;
420
18.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
987
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
987
    return _fixed_values.size() != 0;
420
987
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
14.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
14.3k
    return _fixed_values.size() != 0;
420
14.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
369
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
369
    return _fixed_values.size() != 0;
420
369
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
11.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
11.2k
    return _fixed_values.size() != 0;
420
11.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_fixed_value_rangeEv
Line
Count
Source
418
29.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
29.7k
    return _fixed_values.size() != 0;
420
29.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.1k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.1k
    return _fixed_values.size() != 0;
420
18.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
7.37k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.37k
    return _fixed_values.size() != 0;
420
7.37k
}
421
422
template <PrimitiveType primitive_type>
423
1.87M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.87M
    return Compare::greater(_high_value, _low_value);
425
1.87M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
98.6k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
98.6k
    return Compare::greater(_high_value, _low_value);
425
98.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
14.6k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.6k
    return Compare::greater(_high_value, _low_value);
425
14.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
292k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
292k
    return Compare::greater(_high_value, _low_value);
425
292k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
485k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
485k
    return Compare::greater(_high_value, _low_value);
425
485k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
13.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.3k
    return Compare::greater(_high_value, _low_value);
425
13.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
7.33k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
7.33k
    return Compare::greater(_high_value, _low_value);
425
7.33k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
10.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
10.5k
    return Compare::greater(_high_value, _low_value);
425
10.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
327
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
327
    return Compare::greater(_high_value, _low_value);
425
327
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
342
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
342
    return Compare::greater(_high_value, _low_value);
425
342
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_scope_value_rangeEv
Line
Count
Source
423
13.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.1k
    return Compare::greater(_high_value, _low_value);
425
13.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_scope_value_rangeEv
Line
Count
Source
423
617k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
617k
    return Compare::greater(_high_value, _low_value);
425
617k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_scope_value_rangeEv
Line
Count
Source
423
82.6k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
82.6k
    return Compare::greater(_high_value, _low_value);
425
82.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
414
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
414
    return Compare::greater(_high_value, _low_value);
425
414
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
95.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
95.0k
    return Compare::greater(_high_value, _low_value);
425
95.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
410
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
410
    return Compare::greater(_high_value, _low_value);
425
410
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
77.9k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
77.9k
    return Compare::greater(_high_value, _low_value);
425
77.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
8.51k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.51k
    return Compare::greater(_high_value, _low_value);
425
8.51k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
647
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
647
    return Compare::greater(_high_value, _low_value);
425
647
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
8.38k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.38k
    return Compare::greater(_high_value, _low_value);
425
8.38k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_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_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
8.69k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.69k
    return Compare::greater(_high_value, _low_value);
425
8.69k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
26.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
26.1k
    return Compare::greater(_high_value, _low_value);
425
26.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
11.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
11.8k
    return Compare::greater(_high_value, _low_value);
425
11.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
3.58k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
3.58k
    return Compare::greater(_high_value, _low_value);
425
3.58k
}
426
427
template <PrimitiveType primitive_type>
428
2.56M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.56M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.56M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.56M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
252k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
252k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
252k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
252k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
14.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
303k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
303k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
303k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
303k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
489k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
489k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
489k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
489k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
13.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
13.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
13.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
13.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
7.40k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
7.40k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
7.40k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
7.40k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_empty_value_rangeEv
Line
Count
Source
428
10.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
10.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
10.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
10.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_empty_value_rangeEv
Line
Count
Source
428
365
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
365
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
365
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
365
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
390
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
390
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
390
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
390
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_empty_value_rangeEv
Line
Count
Source
428
14.0k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.0k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.0k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_empty_value_rangeEv
Line
Count
Source
428
1.11M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.11M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.11M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.11M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
83.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
83.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
83.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
83.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
503
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
503
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
503
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
503
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
115k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
115k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
115k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
115k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
474
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
474
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
474
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
474
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
78.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
78.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
78.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
78.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
8.86k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.86k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.86k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.86k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_empty_value_rangeEv
Line
Count
Source
428
650
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
650
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
650
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
650
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
8.70k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.70k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.70k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.70k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_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_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
8.81k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.81k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.81k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.81k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
26.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
26.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
26.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
26.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_empty_value_rangeEv
Line
Count
Source
428
12.3k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.3k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.3k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
3.77k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
3.77k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
3.77k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
3.77k
}
435
436
template <PrimitiveType primitive_type>
437
176k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
176k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
176k
    if (!is_enumeration_type(_column_type)) {
443
19.2k
        return false;
444
19.2k
    }
445
446
156k
    return true;
447
176k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.44k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.44k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.44k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.44k
    return true;
447
2.44k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
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
67.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
67.5k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
67.5k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
67.5k
    return true;
447
67.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
80.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
80.4k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
80.4k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
80.4k
    return true;
447
80.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
3.59k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
3.59k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
3.59k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
3.59k
    return true;
447
3.59k
}
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
460
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
460
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
460
    if (!is_enumeration_type(_column_type)) {
443
460
        return false;
444
460
    }
445
446
0
    return true;
447
460
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
8.75k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
8.75k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
8.75k
    if (!is_enumeration_type(_column_type)) {
443
8.72k
        return false;
444
8.72k
    }
445
446
34
    return true;
447
8.75k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_fixed_value_convertibleEv
Line
Count
Source
437
8
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
8
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
8
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
8
    return true;
447
8
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.78k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.78k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.78k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.78k
    return true;
447
2.78k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_fixed_value_convertibleEv
Line
Count
Source
437
8
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
8
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
8
    if (!is_enumeration_type(_column_type)) {
443
8
        return false;
444
8
    }
445
446
0
    return true;
447
8
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.31k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.31k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.31k
    if (!is_enumeration_type(_column_type)) {
443
2.31k
        return false;
444
2.31k
    }
445
446
0
    return true;
447
2.31k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.55k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.55k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.55k
    if (!is_enumeration_type(_column_type)) {
443
2.55k
        return false;
444
2.55k
    }
445
446
1
    return true;
447
2.55k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
109
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
109
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
109
    if (!is_enumeration_type(_column_type)) {
443
109
        return false;
444
109
    }
445
446
0
    return true;
447
109
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.57k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.57k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.57k
    if (!is_enumeration_type(_column_type)) {
443
1.56k
        return false;
444
1.56k
    }
445
446
6
    return true;
447
1.57k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
574
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
574
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
575
    if (!is_enumeration_type(_column_type)) {
443
575
        return false;
444
575
    }
445
446
18.4E
    return true;
447
574
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
773
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
773
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
774
    if (!is_enumeration_type(_column_type)) {
443
774
        return false;
444
774
    }
445
446
18.4E
    return true;
447
773
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.35k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.35k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.35k
    if (!is_enumeration_type(_column_type)) {
443
1.35k
        return false;
444
1.35k
    }
445
446
0
    return true;
447
1.35k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
809
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
809
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
809
    if (!is_enumeration_type(_column_type)) {
443
807
        return false;
444
807
    }
445
446
2
    return true;
447
809
}
448
449
template <PrimitiveType primitive_type>
450
83
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
83
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
83
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
82
    return true;
460
83
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
80
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
80
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
80
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
80
    return true;
460
80
}
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
152k
        bool& begin_include, bool& end_include) {
467
152k
    if constexpr (!_is_reject_split_type) {
468
152k
        begin_include = true;
469
152k
        end_include = true;
470
471
152k
        bool is_empty = false;
472
473
152k
        if (!is_begin_include()) {
474
7.36k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
7.36k
            } else {
477
7.36k
                ++_low_value;
478
7.36k
            }
479
7.36k
        }
480
481
152k
        if (!is_end_include()) {
482
507
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
507
            } else {
485
507
                --_high_value;
486
507
            }
487
507
        }
488
489
152k
        if (Compare::less(_high_value, _low_value)) {
490
24
            is_empty = true;
491
24
        }
492
493
152k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
152k
    }
499
152k
    return false;
500
152k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.43k
        bool& begin_include, bool& end_include) {
467
2.43k
    if constexpr (!_is_reject_split_type) {
468
2.43k
        begin_include = true;
469
2.43k
        end_include = true;
470
471
2.43k
        bool is_empty = false;
472
473
2.43k
        if (!is_begin_include()) {
474
51
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
51
            } else {
477
51
                ++_low_value;
478
51
            }
479
51
        }
480
481
2.43k
        if (!is_end_include()) {
482
11
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
11
            } else {
485
11
                --_high_value;
486
11
            }
487
11
        }
488
489
2.43k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.43k
        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.43k
    }
499
2.43k
    return false;
500
2.43k
}
_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
67.2k
        bool& begin_include, bool& end_include) {
467
67.2k
    if constexpr (!_is_reject_split_type) {
468
67.2k
        begin_include = true;
469
67.2k
        end_include = true;
470
471
67.2k
        bool is_empty = false;
472
473
67.2k
        if (!is_begin_include()) {
474
597
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
597
            } else {
477
597
                ++_low_value;
478
597
            }
479
597
        }
480
481
67.2k
        if (!is_end_include()) {
482
418
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
418
            } else {
485
418
                --_high_value;
486
418
            }
487
418
        }
488
489
67.2k
        if (Compare::less(_high_value, _low_value)) {
490
24
            is_empty = true;
491
24
        }
492
493
67.2k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
67.2k
    }
499
67.2k
    return false;
500
67.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
80.3k
        bool& begin_include, bool& end_include) {
467
80.3k
    if constexpr (!_is_reject_split_type) {
468
80.3k
        begin_include = true;
469
80.3k
        end_include = true;
470
471
80.3k
        bool is_empty = false;
472
473
80.3k
        if (!is_begin_include()) {
474
6.70k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
6.70k
            } else {
477
6.70k
                ++_low_value;
478
6.70k
            }
479
6.70k
        }
480
481
80.3k
        if (!is_end_include()) {
482
8
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
8
            } else {
485
8
                --_high_value;
486
8
            }
487
8
        }
488
489
80.3k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
80.3k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
80.3k
    }
499
80.3k
    return false;
500
80.3k
}
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
8
        bool& begin_include, bool& end_include) {
467
8
    if constexpr (!_is_reject_split_type) {
468
8
        begin_include = true;
469
8
        end_include = true;
470
471
8
        bool is_empty = false;
472
473
8
        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
8
        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
8
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
8
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
8
    }
499
8
    return false;
500
8
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.77k
        bool& begin_include, bool& end_include) {
467
2.77k
    if constexpr (!_is_reject_split_type) {
468
2.77k
        begin_include = true;
469
2.77k
        end_include = true;
470
471
2.77k
        bool is_empty = false;
472
473
2.77k
        if (!is_begin_include()) {
474
18
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
18
            } else {
477
18
                ++_low_value;
478
18
            }
479
18
        }
480
481
2.77k
        if (!is_end_include()) {
482
70
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
70
            } else {
485
70
                --_high_value;
486
70
            }
487
70
        }
488
489
2.77k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.77k
        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.77k
    }
499
2.77k
    return false;
500
2.77k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
501
502
// The return value indicates whether the split result is range or fixed value.
503
template <PrimitiveType primitive_type>
504
bool ColumnValueRange<primitive_type>::convert_to_avg_range_value(
505
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
506
153k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
153k
    if constexpr (!_is_reject_split_type) {
508
153k
        CppType min_value = get_range_min_value();
509
153k
        CppType max_value = get_range_max_value();
510
153k
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
8
            min_value.set_type(TimeType::TIME_DATE);
512
8
            max_value.set_type(TimeType::TIME_DATE);
513
8
        }
514
153k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
153k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
24
            DCHECK(contain_null());
518
24
        }
519
520
153k
        auto no_split = [&]() -> bool {
521
145k
            begin_scan_keys.emplace_back();
522
145k
            begin_scan_keys.back().add_value(
523
145k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
145k
                    contain_null());
525
145k
            end_scan_keys.emplace_back();
526
145k
            end_scan_keys.back().add_value(
527
145k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
145k
                    empty_range_only_null ? true : false);
529
145k
            return true;
530
145k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
65.8k
        auto no_split = [&]() -> bool {
521
65.8k
            begin_scan_keys.emplace_back();
522
65.8k
            begin_scan_keys.back().add_value(
523
65.8k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
65.8k
                    contain_null());
525
65.8k
            end_scan_keys.emplace_back();
526
65.8k
            end_scan_keys.back().add_value(
527
65.8k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
65.8k
                    empty_range_only_null ? true : false);
529
65.8k
            return true;
530
65.8k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
79.9k
        auto no_split = [&]() -> bool {
521
79.9k
            begin_scan_keys.emplace_back();
522
79.9k
            begin_scan_keys.back().add_value(
523
79.9k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
79.9k
                    contain_null());
525
79.9k
            end_scan_keys.emplace_back();
526
79.9k
            end_scan_keys.back().add_value(
527
79.9k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
79.9k
                    empty_range_only_null ? true : false);
529
79.9k
            return true;
530
79.9k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
531
153k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
24
            return no_split();
533
24
        }
534
535
411k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
134k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
134k
                return value;
539
276k
            } else {
540
276k
                return (int128_t)value;
541
276k
            }
542
411k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKaE_clESA_
Line
Count
Source
535
107k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
107k
            } else {
540
107k
                return (int128_t)value;
541
107k
            }
542
107k
        };
_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
82.4k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
82.4k
            } else {
540
82.4k
                return (int128_t)value;
541
82.4k
            }
542
82.4k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
82.0k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
82.0k
            } else {
540
82.0k
                return (int128_t)value;
541
82.0k
            }
542
82.0k
        };
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
392
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
392
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
392
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
392
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
134k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
134k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
134k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
134k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIiEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIlEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_12Decimal128V3EE_clESB_
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
153k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
153k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
153k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
146k
            return no_split();
552
146k
        }
553
6.57k
        int step_size = cast_set<int>(step_size_may_overflow);
554
6.57k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6.57k
        if (contain_null()) {
558
3.15k
            begin_scan_keys.emplace_back();
559
3.15k
            begin_scan_keys.back().add_null();
560
3.15k
            end_scan_keys.emplace_back();
561
3.15k
            end_scan_keys.back().add_null();
562
3.15k
        }
563
258k
        while (true) {
564
258k
            begin_scan_keys.emplace_back();
565
258k
            begin_scan_keys.back().add_value(
566
258k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
258k
            if (cast(max_value) - min_value < step_size) {
569
5.41k
                min_value = max_value;
570
252k
            } else {
571
252k
                min_value += step_size;
572
252k
            }
573
574
258k
            end_scan_keys.emplace_back();
575
258k
            end_scan_keys.back().add_value(
576
258k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
258k
            if (Compare::equal(min_value, max_value)) {
579
6.82k
                break;
580
6.82k
            }
581
251k
            ++min_value;
582
251k
            ++real_step_size;
583
251k
            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
251k
        }
592
593
6.57k
        return step_size != 0;
594
6.57k
    }
595
0
    return false;
596
153k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.43k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.43k
    if constexpr (!_is_reject_split_type) {
508
2.43k
        CppType min_value = get_range_min_value();
509
2.43k
        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.43k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.43k
        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.43k
        auto no_split = [&]() -> bool {
521
2.43k
            begin_scan_keys.emplace_back();
522
2.43k
            begin_scan_keys.back().add_value(
523
2.43k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.43k
                    contain_null());
525
2.43k
            end_scan_keys.emplace_back();
526
2.43k
            end_scan_keys.back().add_value(
527
2.43k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.43k
                    empty_range_only_null ? true : false);
529
2.43k
            return true;
530
2.43k
        };
531
2.43k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.43k
        auto cast = [](const CppType& value) {
536
2.43k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.43k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.43k
                return value;
539
2.43k
            } else {
540
2.43k
                return (int128_t)value;
541
2.43k
            }
542
2.43k
        };
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.43k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.43k
        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.43k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.43k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.43k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.43k
        if (contain_null()) {
558
1.98k
            begin_scan_keys.emplace_back();
559
1.98k
            begin_scan_keys.back().add_null();
560
1.98k
            end_scan_keys.emplace_back();
561
1.98k
            end_scan_keys.back().add_null();
562
1.98k
        }
563
105k
        while (true) {
564
105k
            begin_scan_keys.emplace_back();
565
105k
            begin_scan_keys.back().add_value(
566
105k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
105k
            if (cast(max_value) - min_value < step_size) {
569
2.44k
                min_value = max_value;
570
102k
            } else {
571
102k
                min_value += step_size;
572
102k
            }
573
574
105k
            end_scan_keys.emplace_back();
575
105k
            end_scan_keys.back().add_value(
576
105k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
105k
            if (Compare::equal(min_value, max_value)) {
579
2.47k
                break;
580
2.47k
            }
581
102k
            ++min_value;
582
102k
            ++real_step_size;
583
102k
            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
102k
        }
592
593
2.43k
        return step_size != 0;
594
2.43k
    }
595
0
    return false;
596
2.43k
}
_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
67.5k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
67.5k
    if constexpr (!_is_reject_split_type) {
508
67.5k
        CppType min_value = get_range_min_value();
509
67.5k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
67.5k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
67.5k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
24
            DCHECK(contain_null());
518
24
        }
519
520
67.5k
        auto no_split = [&]() -> bool {
521
67.5k
            begin_scan_keys.emplace_back();
522
67.5k
            begin_scan_keys.back().add_value(
523
67.5k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
67.5k
                    contain_null());
525
67.5k
            end_scan_keys.emplace_back();
526
67.5k
            end_scan_keys.back().add_value(
527
67.5k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
67.5k
                    empty_range_only_null ? true : false);
529
67.5k
            return true;
530
67.5k
        };
531
67.5k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
24
            return no_split();
533
24
        }
534
535
67.4k
        auto cast = [](const CppType& value) {
536
67.4k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
67.4k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
67.4k
                return value;
539
67.4k
            } else {
540
67.4k
                return (int128_t)value;
541
67.4k
            }
542
67.4k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
67.4k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
67.4k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
67.4k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
66.4k
            return no_split();
552
66.4k
        }
553
1.01k
        int step_size = cast_set<int>(step_size_may_overflow);
554
1.01k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
1.01k
        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
15.2k
        while (true) {
564
15.2k
            begin_scan_keys.emplace_back();
565
15.2k
            begin_scan_keys.back().add_value(
566
15.2k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
15.2k
            if (cast(max_value) - min_value < step_size) {
569
153
                min_value = max_value;
570
15.0k
            } else {
571
15.0k
                min_value += step_size;
572
15.0k
            }
573
574
15.2k
            end_scan_keys.emplace_back();
575
15.2k
            end_scan_keys.back().add_value(
576
15.2k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
15.2k
            if (Compare::equal(min_value, max_value)) {
579
1.12k
                break;
580
1.12k
            }
581
14.1k
            ++min_value;
582
14.1k
            ++real_step_size;
583
14.1k
            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
14.1k
        }
592
593
1.01k
        return step_size != 0;
594
1.01k
    }
595
0
    return false;
596
67.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
80.3k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
80.3k
    if constexpr (!_is_reject_split_type) {
508
80.3k
        CppType min_value = get_range_min_value();
509
80.3k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
80.3k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
80.3k
        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
80.3k
        auto no_split = [&]() -> bool {
521
80.3k
            begin_scan_keys.emplace_back();
522
80.3k
            begin_scan_keys.back().add_value(
523
80.3k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
80.3k
                    contain_null());
525
80.3k
            end_scan_keys.emplace_back();
526
80.3k
            end_scan_keys.back().add_value(
527
80.3k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
80.3k
                    empty_range_only_null ? true : false);
529
80.3k
            return true;
530
80.3k
        };
531
80.3k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
80.3k
        auto cast = [](const CppType& value) {
536
80.3k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
80.3k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
80.3k
                return value;
539
80.3k
            } else {
540
80.3k
                return (int128_t)value;
541
80.3k
            }
542
80.3k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
80.3k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
80.3k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
80.3k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
80.1k
            return no_split();
552
80.1k
        }
553
248
        int step_size = cast_set<int>(step_size_may_overflow);
554
248
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
248
        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.72k
        while (true) {
564
1.72k
            begin_scan_keys.emplace_back();
565
1.72k
            begin_scan_keys.back().add_value(
566
1.72k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.72k
            if (cast(max_value) - min_value < step_size) {
569
4
                min_value = max_value;
570
1.71k
            } else {
571
1.71k
                min_value += step_size;
572
1.71k
            }
573
574
1.72k
            end_scan_keys.emplace_back();
575
1.72k
            end_scan_keys.back().add_value(
576
1.72k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.72k
            if (Compare::equal(min_value, max_value)) {
579
338
                break;
580
338
            }
581
1.38k
            ++min_value;
582
1.38k
            ++real_step_size;
583
1.38k
            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.38k
        }
592
593
248
        return step_size != 0;
594
248
    }
595
0
    return false;
596
80.3k
}
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
8
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
8
    if constexpr (!_is_reject_split_type) {
508
8
        CppType min_value = get_range_min_value();
509
8
        CppType max_value = get_range_max_value();
510
8
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
8
            min_value.set_type(TimeType::TIME_DATE);
512
8
            max_value.set_type(TimeType::TIME_DATE);
513
8
        }
514
8
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
8
        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
8
        auto no_split = [&]() -> bool {
521
8
            begin_scan_keys.emplace_back();
522
8
            begin_scan_keys.back().add_value(
523
8
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
8
                    contain_null());
525
8
            end_scan_keys.emplace_back();
526
8
            end_scan_keys.back().add_value(
527
8
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
8
                    empty_range_only_null ? true : false);
529
8
            return true;
530
8
        };
531
8
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
8
        auto cast = [](const CppType& value) {
536
8
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
8
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
8
                return value;
539
8
            } else {
540
8
                return (int128_t)value;
541
8
            }
542
8
        };
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
8
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
8
        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
8
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
8
        int step_size = cast_set<int>(step_size_may_overflow);
554
8
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
8
        if (contain_null()) {
558
8
            begin_scan_keys.emplace_back();
559
8
            begin_scan_keys.back().add_null();
560
8
            end_scan_keys.emplace_back();
561
8
            end_scan_keys.back().add_null();
562
8
        }
563
382
        while (true) {
564
382
            begin_scan_keys.emplace_back();
565
382
            begin_scan_keys.back().add_value(
566
382
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
382
            if (cast(max_value) - min_value < step_size) {
569
8
                min_value = max_value;
570
374
            } else {
571
374
                min_value += step_size;
572
374
            }
573
574
382
            end_scan_keys.emplace_back();
575
382
            end_scan_keys.back().add_value(
576
382
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
382
            if (Compare::equal(min_value, max_value)) {
579
8
                break;
580
8
            }
581
374
            ++min_value;
582
374
            ++real_step_size;
583
374
            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
374
        }
592
593
8
        return step_size != 0;
594
8
    }
595
0
    return false;
596
8
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.77k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.77k
    if constexpr (!_is_reject_split_type) {
508
2.77k
        CppType min_value = get_range_min_value();
509
2.77k
        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.77k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.77k
        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.77k
        auto no_split = [&]() -> bool {
521
2.77k
            begin_scan_keys.emplace_back();
522
2.77k
            begin_scan_keys.back().add_value(
523
2.77k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.77k
                    contain_null());
525
2.77k
            end_scan_keys.emplace_back();
526
2.77k
            end_scan_keys.back().add_value(
527
2.77k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.77k
                    empty_range_only_null ? true : false);
529
2.77k
            return true;
530
2.77k
        };
531
2.78k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.77k
        auto cast = [](const CppType& value) {
536
2.77k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.77k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.77k
                return value;
539
2.77k
            } else {
540
2.77k
                return (int128_t)value;
541
2.77k
            }
542
2.77k
        };
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.77k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.77k
        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.77k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.77k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.77k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.77k
        if (contain_null()) {
558
1.07k
            begin_scan_keys.emplace_back();
559
1.07k
            begin_scan_keys.back().add_null();
560
1.07k
            end_scan_keys.emplace_back();
561
1.07k
            end_scan_keys.back().add_null();
562
1.07k
        }
563
131k
        while (true) {
564
131k
            begin_scan_keys.emplace_back();
565
131k
            begin_scan_keys.back().add_value(
566
131k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
131k
            if (cast(max_value) - min_value < step_size) {
569
2.71k
                min_value = max_value;
570
128k
            } else {
571
128k
                min_value += step_size;
572
128k
            }
573
574
131k
            end_scan_keys.emplace_back();
575
131k
            end_scan_keys.back().add_value(
576
131k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
131k
            if (Compare::equal(min_value, max_value)) {
579
2.78k
                break;
580
2.78k
            }
581
128k
            ++min_value;
582
128k
            ++real_step_size;
583
128k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
128k
        }
592
593
2.77k
        return step_size != 0;
594
2.77k
    }
595
0
    return false;
596
2.77k
}
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
41
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
41
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
41
    if (!_fixed_values.empty()) {
605
41
        _low_value = *_fixed_values.begin();
606
41
        _low_op = FILTER_LARGER_OR_EQUAL;
607
41
        _high_value = *_fixed_values.rbegin();
608
41
        _high_op = FILTER_LESS_OR_EQUAL;
609
41
        _fixed_values.clear();
610
41
    }
611
41
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
40
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
40
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
40
    if (!_fixed_values.empty()) {
605
40
        _low_value = *_fixed_values.begin();
606
40
        _low_op = FILTER_LARGER_OR_EQUAL;
607
40
        _high_value = *_fixed_values.rbegin();
608
40
        _high_op = FILTER_LESS_OR_EQUAL;
609
40
        _fixed_values.clear();
610
40
    }
611
40
}
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
171k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
171k
    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
171k
    _contain_null = false;
621
622
171k
    if (is_fixed_value_range()) {
623
13.5k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
13.5k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
13.2k
        case FILTER_LARGER_OR_EQUAL: {
632
13.2k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
13.2k
            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
313
        case FILTER_LESS_OR_EQUAL: {
647
313
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
313
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
13.5k
        }
655
656
13.5k
        _high_value = TYPE_MIN;
657
13.5k
        _low_value = TYPE_MAX;
658
157k
    } else {
659
157k
        if (Compare::greater(_high_value, _low_value)) {
660
73.6k
            switch (op) {
661
30.2k
            case FILTER_LARGER: {
662
30.2k
                if (Compare::greater_equal(value, _low_value)) {
663
30.2k
                    _low_value = value;
664
30.2k
                    _low_op = op;
665
30.2k
                }
666
667
30.2k
                break;
668
0
            }
669
670
15.6k
            case FILTER_LARGER_OR_EQUAL: {
671
15.6k
                if (Compare::greater(value, _low_value)) {
672
14.4k
                    _low_value = value;
673
14.4k
                    _low_op = op;
674
14.4k
                }
675
676
15.6k
                break;
677
0
            }
678
679
5.10k
            case FILTER_LESS: {
680
5.10k
                if (Compare::less_equal(value, _high_value)) {
681
5.09k
                    _high_value = value;
682
5.09k
                    _high_op = op;
683
5.09k
                }
684
685
5.10k
                break;
686
0
            }
687
688
22.6k
            case FILTER_LESS_OR_EQUAL: {
689
22.6k
                if (Compare::less(value, _high_value)) {
690
21.6k
                    _high_value = value;
691
21.6k
                    _high_op = op;
692
21.6k
                }
693
694
22.6k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
73.6k
            }
701
73.6k
        }
702
703
157k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
157k
            Compare::equal(_high_value, _low_value)) {
705
14.2k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
14.2k
            _high_value = TYPE_MIN;
707
14.2k
            _low_value = TYPE_MAX;
708
14.2k
        }
709
157k
    }
710
711
171k
    return Status::OK();
712
171k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
1.92k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.92k
    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.92k
    _contain_null = false;
621
622
1.92k
    if (is_fixed_value_range()) {
623
110
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
110
        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
99
        case FILTER_LARGER_OR_EQUAL: {
632
99
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
99
            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
110
        }
655
656
110
        _high_value = TYPE_MIN;
657
110
        _low_value = TYPE_MAX;
658
1.81k
    } else {
659
1.81k
        if (Compare::greater(_high_value, _low_value)) {
660
1.61k
            switch (op) {
661
319
            case FILTER_LARGER: {
662
319
                if (Compare::greater_equal(value, _low_value)) {
663
319
                    _low_value = value;
664
319
                    _low_op = op;
665
319
                }
666
667
319
                break;
668
0
            }
669
670
472
            case FILTER_LARGER_OR_EQUAL: {
671
472
                if (Compare::greater(value, _low_value)) {
672
273
                    _low_value = value;
673
273
                    _low_op = op;
674
273
                }
675
676
472
                break;
677
0
            }
678
679
281
            case FILTER_LESS: {
680
281
                if (Compare::less_equal(value, _high_value)) {
681
278
                    _high_value = value;
682
278
                    _high_op = op;
683
278
                }
684
685
281
                break;
686
0
            }
687
688
542
            case FILTER_LESS_OR_EQUAL: {
689
542
                if (Compare::less(value, _high_value)) {
690
342
                    _high_value = value;
691
342
                    _high_op = op;
692
342
                }
693
694
542
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.61k
            }
701
1.61k
        }
702
703
1.81k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.81k
            Compare::equal(_high_value, _low_value)) {
705
124
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
124
            _high_value = TYPE_MIN;
707
124
            _low_value = TYPE_MAX;
708
124
        }
709
1.81k
    }
710
711
1.92k
    return Status::OK();
712
1.92k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
1.43k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.43k
    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.43k
    _contain_null = false;
621
622
1.43k
    if (is_fixed_value_range()) {
623
55
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
55
        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
28
        case FILTER_LARGER_OR_EQUAL: {
632
28
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
28
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
27
        case FILTER_LESS_OR_EQUAL: {
647
27
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
27
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
55
        }
655
656
55
        _high_value = TYPE_MIN;
657
55
        _low_value = TYPE_MAX;
658
1.38k
    } else {
659
1.38k
        if (Compare::greater(_high_value, _low_value)) {
660
1.35k
            switch (op) {
661
996
            case FILTER_LARGER: {
662
998
                if (Compare::greater_equal(value, _low_value)) {
663
998
                    _low_value = value;
664
998
                    _low_op = op;
665
998
                }
666
667
996
                break;
668
0
            }
669
670
178
            case FILTER_LARGER_OR_EQUAL: {
671
178
                if (Compare::greater(value, _low_value)) {
672
145
                    _low_value = value;
673
145
                    _low_op = op;
674
145
                }
675
676
178
                break;
677
0
            }
678
679
29
            case FILTER_LESS: {
680
29
                if (Compare::less_equal(value, _high_value)) {
681
27
                    _high_value = value;
682
27
                    _high_op = op;
683
27
                }
684
685
29
                break;
686
0
            }
687
688
160
            case FILTER_LESS_OR_EQUAL: {
689
160
                if (Compare::less(value, _high_value)) {
690
100
                    _high_value = value;
691
100
                    _high_op = op;
692
100
                }
693
694
160
                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.38k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.38k
            Compare::equal(_high_value, _low_value)) {
705
2
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
2
            _high_value = TYPE_MIN;
707
2
            _low_value = TYPE_MAX;
708
2
        }
709
1.38k
    }
710
711
1.43k
    return Status::OK();
712
1.43k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
10.9k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
10.9k
    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.9k
    _contain_null = false;
621
622
10.9k
    if (is_fixed_value_range()) {
623
495
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
495
        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
315
        case FILTER_LARGER_OR_EQUAL: {
632
315
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
315
            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
180
        case FILTER_LESS_OR_EQUAL: {
647
180
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
180
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
495
        }
655
656
495
        _high_value = TYPE_MIN;
657
495
        _low_value = TYPE_MAX;
658
10.4k
    } else {
659
10.4k
        if (Compare::greater(_high_value, _low_value)) {
660
9.97k
            switch (op) {
661
2.11k
            case FILTER_LARGER: {
662
2.11k
                if (Compare::greater_equal(value, _low_value)) {
663
2.10k
                    _low_value = value;
664
2.10k
                    _low_op = op;
665
2.10k
                }
666
667
2.11k
                break;
668
0
            }
669
670
3.60k
            case FILTER_LARGER_OR_EQUAL: {
671
3.60k
                if (Compare::greater(value, _low_value)) {
672
3.16k
                    _low_value = value;
673
3.16k
                    _low_op = op;
674
3.16k
                }
675
676
3.60k
                break;
677
0
            }
678
679
685
            case FILTER_LESS: {
680
685
                if (Compare::less_equal(value, _high_value)) {
681
679
                    _high_value = value;
682
679
                    _high_op = op;
683
679
                }
684
685
685
                break;
686
0
            }
687
688
3.56k
            case FILTER_LESS_OR_EQUAL: {
689
3.56k
                if (Compare::less(value, _high_value)) {
690
3.13k
                    _high_value = value;
691
3.13k
                    _high_op = op;
692
3.13k
                }
693
694
3.56k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
9.97k
            }
701
9.97k
        }
702
703
10.4k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
10.4k
            Compare::equal(_high_value, _low_value)) {
705
569
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
569
            _high_value = TYPE_MIN;
707
569
            _low_value = TYPE_MAX;
708
569
        }
709
10.4k
    }
710
711
10.9k
    return Status::OK();
712
10.9k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
129k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
129k
    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
129k
    _contain_null = false;
621
622
129k
    if (is_fixed_value_range()) {
623
12.8k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
12.8k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
12.7k
        case FILTER_LARGER_OR_EQUAL: {
632
12.7k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
12.7k
            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
80
        case FILTER_LESS_OR_EQUAL: {
647
80
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
80
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
12.8k
        }
655
656
12.8k
        _high_value = TYPE_MIN;
657
12.8k
        _low_value = TYPE_MAX;
658
116k
    } else {
659
116k
        if (Compare::greater(_high_value, _low_value)) {
660
33.0k
            switch (op) {
661
11.4k
            case FILTER_LARGER: {
662
11.4k
                if (Compare::greater_equal(value, _low_value)) {
663
11.4k
                    _low_value = value;
664
11.4k
                    _low_op = op;
665
11.4k
                }
666
667
11.4k
                break;
668
0
            }
669
670
4.81k
            case FILTER_LARGER_OR_EQUAL: {
671
4.81k
                if (Compare::greater(value, _low_value)) {
672
4.81k
                    _low_value = value;
673
4.81k
                    _low_op = op;
674
4.81k
                }
675
676
4.81k
                break;
677
0
            }
678
679
33
            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
33
                break;
686
0
            }
687
688
16.7k
            case FILTER_LESS_OR_EQUAL: {
689
16.7k
                if (Compare::less(value, _high_value)) {
690
16.7k
                    _high_value = value;
691
16.7k
                    _high_op = op;
692
16.7k
                }
693
694
16.7k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
33.0k
            }
701
33.0k
        }
702
703
116k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
116k
            Compare::equal(_high_value, _low_value)) {
705
13.3k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
13.3k
            _high_value = TYPE_MIN;
707
13.3k
            _low_value = TYPE_MAX;
708
13.3k
        }
709
116k
    }
710
711
129k
    return Status::OK();
712
129k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
121
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
121
    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
121
    _contain_null = false;
621
622
121
    if (is_fixed_value_range()) {
623
4
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
4
        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
2
        case FILTER_LARGER_OR_EQUAL: {
632
2
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
2
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
2
        case FILTER_LESS_OR_EQUAL: {
647
2
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
2
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
4
        }
655
656
4
        _high_value = TYPE_MIN;
657
4
        _low_value = TYPE_MAX;
658
117
    } else {
659
118
        if (Compare::greater(_high_value, _low_value)) {
660
118
            switch (op) {
661
17
            case FILTER_LARGER: {
662
17
                if (Compare::greater_equal(value, _low_value)) {
663
17
                    _low_value = value;
664
17
                    _low_op = op;
665
17
                }
666
667
17
                break;
668
0
            }
669
670
36
            case FILTER_LARGER_OR_EQUAL: {
671
36
                if (Compare::greater(value, _low_value)) {
672
33
                    _low_value = value;
673
33
                    _low_op = op;
674
33
                }
675
676
36
                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
53
            case FILTER_LESS_OR_EQUAL: {
689
53
                if (Compare::less(value, _high_value)) {
690
49
                    _high_value = value;
691
49
                    _high_op = op;
692
49
                }
693
694
53
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
118
            }
701
118
        }
702
703
113
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
113
            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
113
    }
710
711
117
    return Status::OK();
712
121
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
82
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
82
    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
82
    _contain_null = false;
621
622
82
    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
82
    } else {
659
82
        if (Compare::greater(_high_value, _low_value)) {
660
82
            switch (op) {
661
24
            case FILTER_LARGER: {
662
24
                if (Compare::greater_equal(value, _low_value)) {
663
24
                    _low_value = value;
664
24
                    _low_op = op;
665
24
                }
666
667
24
                break;
668
0
            }
669
670
26
            case FILTER_LARGER_OR_EQUAL: {
671
26
                if (Compare::greater(value, _low_value)) {
672
18
                    _low_value = value;
673
18
                    _low_op = op;
674
18
                }
675
676
26
                break;
677
0
            }
678
679
12
            case FILTER_LESS: {
680
12
                if (Compare::less_equal(value, _high_value)) {
681
12
                    _high_value = value;
682
12
                    _high_op = op;
683
12
                }
684
685
12
                break;
686
0
            }
687
688
20
            case FILTER_LESS_OR_EQUAL: {
689
20
                if (Compare::less(value, _high_value)) {
690
12
                    _high_value = value;
691
12
                    _high_op = op;
692
12
                }
693
694
20
                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
82
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
297
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
297
    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
297
    _contain_null = false;
621
622
297
    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
297
    } else {
659
300
        if (Compare::greater(_high_value, _low_value)) {
660
300
            switch (op) {
661
74
            case FILTER_LARGER: {
662
74
                if (Compare::greater_equal(value, _low_value)) {
663
73
                    _low_value = value;
664
73
                    _low_op = op;
665
73
                }
666
667
74
                break;
668
0
            }
669
670
91
            case FILTER_LARGER_OR_EQUAL: {
671
91
                if (Compare::greater(value, _low_value)) {
672
47
                    _low_value = value;
673
47
                    _low_op = op;
674
47
                }
675
676
91
                break;
677
0
            }
678
679
48
            case FILTER_LESS: {
680
48
                if (Compare::less_equal(value, _high_value)) {
681
47
                    _high_value = value;
682
47
                    _high_op = op;
683
47
                }
684
685
48
                break;
686
0
            }
687
688
87
            case FILTER_LESS_OR_EQUAL: {
689
87
                if (Compare::less(value, _high_value)) {
690
43
                    _high_value = value;
691
43
                    _high_op = op;
692
43
                }
693
694
87
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
300
            }
701
300
        }
702
703
295
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
295
            Compare::equal(_high_value, _low_value)) {
705
17
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
17
            _high_value = TYPE_MIN;
707
17
            _low_value = TYPE_MAX;
708
17
        }
709
295
    }
710
711
295
    return Status::OK();
712
297
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
Line
Count
Source
614
26
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
26
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
26
    _contain_null = false;
621
622
26
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
26
    } else {
659
26
        if (Compare::greater(_high_value, _low_value)) {
660
26
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
13
            case FILTER_LARGER_OR_EQUAL: {
671
13
                if (Compare::greater(value, _low_value)) {
672
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
13
                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
11
            case FILTER_LESS_OR_EQUAL: {
689
11
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
11
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
26
            }
701
26
        }
702
703
26
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
26
            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
26
    }
710
711
26
    return Status::OK();
712
26
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
Line
Count
Source
614
22
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
22
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
22
    _contain_null = false;
621
622
22
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
22
    } else {
659
22
        if (Compare::greater(_high_value, _low_value)) {
660
22
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
11
            case FILTER_LARGER_OR_EQUAL: {
671
11
                if (Compare::greater(value, _low_value)) {
672
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
11
                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
9
            case FILTER_LESS_OR_EQUAL: {
689
9
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
9
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
22
            }
701
22
        }
702
703
22
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
22
            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
22
    }
710
711
22
    return Status::OK();
712
22
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
711
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
711
    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
711
    _contain_null = false;
621
622
711
    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
711
    } else {
659
711
        if (Compare::greater(_high_value, _low_value)) {
660
708
            switch (op) {
661
544
            case FILTER_LARGER: {
662
544
                if (Compare::greater_equal(value, _low_value)) {
663
540
                    _low_value = value;
664
540
                    _low_op = op;
665
540
                }
666
667
544
                break;
668
0
            }
669
670
92
            case FILTER_LARGER_OR_EQUAL: {
671
92
                if (Compare::greater(value, _low_value)) {
672
46
                    _low_value = value;
673
46
                    _low_op = op;
674
46
                }
675
676
92
                break;
677
0
            }
678
679
13
            case FILTER_LESS: {
680
13
                if (Compare::less_equal(value, _high_value)) {
681
12
                    _high_value = value;
682
12
                    _high_op = op;
683
12
                }
684
685
13
                break;
686
0
            }
687
688
60
            case FILTER_LESS_OR_EQUAL: {
689
60
                if (Compare::less(value, _high_value)) {
690
43
                    _high_value = value;
691
43
                    _high_op = op;
692
43
                }
693
694
60
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
708
            }
701
708
        }
702
703
711
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
711
            Compare::equal(_high_value, _low_value)) {
705
2
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
2
            _high_value = TYPE_MIN;
707
2
            _low_value = TYPE_MAX;
708
2
        }
709
711
    }
710
711
711
    return Status::OK();
712
711
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.50k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.50k
    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.50k
    _contain_null = false;
621
622
1.50k
    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.48k
    } else {
659
1.48k
        if (Compare::greater(_high_value, _low_value)) {
660
1.41k
            switch (op) {
661
728
            case FILTER_LARGER: {
662
728
                if (Compare::greater_equal(value, _low_value)) {
663
727
                    _low_value = value;
664
727
                    _low_op = op;
665
727
                }
666
667
728
                break;
668
0
            }
669
670
354
            case FILTER_LARGER_OR_EQUAL: {
671
354
                if (Compare::greater(value, _low_value)) {
672
235
                    _low_value = value;
673
235
                    _low_op = op;
674
235
                }
675
676
354
                break;
677
0
            }
678
679
35
            case FILTER_LESS: {
680
35
                if (Compare::less_equal(value, _high_value)) {
681
34
                    _high_value = value;
682
34
                    _high_op = op;
683
34
                }
684
685
35
                break;
686
0
            }
687
688
290
            case FILTER_LESS_OR_EQUAL: {
689
290
                if (Compare::less(value, _high_value)) {
690
259
                    _high_value = value;
691
259
                    _high_op = op;
692
259
                }
693
694
290
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.41k
            }
701
1.41k
        }
702
703
1.48k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.48k
            Compare::equal(_high_value, _low_value)) {
705
19
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
19
            _high_value = TYPE_MIN;
707
19
            _low_value = TYPE_MAX;
708
19
        }
709
1.48k
    }
710
711
1.49k
    return Status::OK();
712
1.50k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
407
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
407
    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
407
    _contain_null = false;
621
622
407
    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
407
    } else {
659
407
        if (Compare::greater(_high_value, _low_value)) {
660
407
            switch (op) {
661
52
            case FILTER_LARGER: {
662
52
                if (Compare::greater_equal(value, _low_value)) {
663
52
                    _low_value = value;
664
52
                    _low_op = op;
665
52
                }
666
667
52
                break;
668
0
            }
669
670
198
            case FILTER_LARGER_OR_EQUAL: {
671
198
                if (Compare::greater(value, _low_value)) {
672
117
                    _low_value = value;
673
117
                    _low_op = op;
674
117
                }
675
676
198
                break;
677
0
            }
678
679
21
            case FILTER_LESS: {
680
21
                if (Compare::less_equal(value, _high_value)) {
681
20
                    _high_value = value;
682
20
                    _high_op = op;
683
20
                }
684
685
21
                break;
686
0
            }
687
688
138
            case FILTER_LESS_OR_EQUAL: {
689
138
                if (Compare::less(value, _high_value)) {
690
114
                    _high_value = value;
691
114
                    _high_op = op;
692
114
                }
693
694
138
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
407
            }
701
407
        }
702
703
412
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
412
            Compare::equal(_high_value, _low_value)) {
705
4
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
4
            _high_value = TYPE_MIN;
707
4
            _low_value = TYPE_MAX;
708
4
        }
709
412
    }
710
711
412
    return Status::OK();
712
407
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
20.2k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
20.2k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
20.2k
    _contain_null = false;
621
622
20.2k
    if (is_fixed_value_range()) {
623
15
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
15
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
13
        case FILTER_LARGER_OR_EQUAL: {
632
13
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
13
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
2
        case FILTER_LESS_OR_EQUAL: {
647
2
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
2
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
15
        }
655
656
15
        _high_value = TYPE_MIN;
657
15
        _low_value = TYPE_MAX;
658
20.2k
    } else {
659
20.2k
        if (Compare::greater(_high_value, _low_value)) {
660
20.2k
            switch (op) {
661
13.4k
            case FILTER_LARGER: {
662
13.4k
                if (Compare::greater_equal(value, _low_value)) {
663
13.4k
                    _low_value = value;
664
13.4k
                    _low_op = op;
665
13.4k
                }
666
667
13.4k
                break;
668
0
            }
669
670
3.99k
            case FILTER_LARGER_OR_EQUAL: {
671
3.99k
                if (Compare::greater(value, _low_value)) {
672
3.94k
                    _low_value = value;
673
3.94k
                    _low_op = op;
674
3.94k
                }
675
676
3.99k
                break;
677
0
            }
678
679
2.51k
            case FILTER_LESS: {
680
2.51k
                if (Compare::less_equal(value, _high_value)) {
681
2.51k
                    _high_value = value;
682
2.51k
                    _high_op = op;
683
2.51k
                }
684
685
2.51k
                break;
686
0
            }
687
688
305
            case FILTER_LESS_OR_EQUAL: {
689
305
                if (Compare::less(value, _high_value)) {
690
251
                    _high_value = value;
691
251
                    _high_op = op;
692
251
                }
693
694
305
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
20.2k
            }
701
20.2k
        }
702
703
20.2k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
20.2k
            Compare::equal(_high_value, _low_value)) {
705
45
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
45
            _high_value = TYPE_MIN;
707
45
            _low_value = TYPE_MAX;
708
45
        }
709
20.2k
    }
710
711
20.2k
    return Status::OK();
712
20.2k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.06k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.06k
    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.06k
    _contain_null = false;
621
622
3.06k
    if (is_fixed_value_range()) {
623
12
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
12
        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
8
        case FILTER_LARGER_OR_EQUAL: {
632
8
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
8
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
4
        case FILTER_LESS_OR_EQUAL: {
647
4
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
4
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
12
        }
655
656
12
        _high_value = TYPE_MIN;
657
12
        _low_value = TYPE_MAX;
658
3.05k
    } else {
659
3.05k
        if (Compare::greater(_high_value, _low_value)) {
660
3.05k
            switch (op) {
661
166
            case FILTER_LARGER: {
662
166
                if (Compare::greater_equal(value, _low_value)) {
663
166
                    _low_value = value;
664
166
                    _low_op = op;
665
166
                }
666
667
166
                break;
668
0
            }
669
670
1.42k
            case FILTER_LARGER_OR_EQUAL: {
671
1.42k
                if (Compare::greater(value, _low_value)) {
672
1.39k
                    _low_value = value;
673
1.39k
                    _low_op = op;
674
1.39k
                }
675
676
1.42k
                break;
677
0
            }
678
679
1.20k
            case FILTER_LESS: {
680
1.20k
                if (Compare::less_equal(value, _high_value)) {
681
1.20k
                    _high_value = value;
682
1.20k
                    _high_op = op;
683
1.20k
                }
684
685
1.20k
                break;
686
0
            }
687
688
255
            case FILTER_LESS_OR_EQUAL: {
689
255
                if (Compare::less(value, _high_value)) {
690
230
                    _high_value = value;
691
230
                    _high_op = op;
692
230
                }
693
694
255
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.05k
            }
701
3.05k
        }
702
703
3.05k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.05k
            Compare::equal(_high_value, _low_value)) {
705
21
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
21
            _high_value = TYPE_MIN;
707
21
            _low_value = TYPE_MAX;
708
21
        }
709
3.05k
    }
710
711
3.06k
    return Status::OK();
712
3.06k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
497
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
497
    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
497
    _contain_null = false;
621
622
497
    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
497
    } else {
659
497
        if (Compare::greater(_high_value, _low_value)) {
660
497
            switch (op) {
661
123
            case FILTER_LARGER: {
662
123
                if (Compare::greater_equal(value, _low_value)) {
663
123
                    _low_value = value;
664
123
                    _low_op = op;
665
123
                }
666
667
123
                break;
668
0
            }
669
670
151
            case FILTER_LARGER_OR_EQUAL: {
671
151
                if (Compare::greater(value, _low_value)) {
672
74
                    _low_value = value;
673
74
                    _low_op = op;
674
74
                }
675
676
151
                break;
677
0
            }
678
679
77
            case FILTER_LESS: {
680
77
                if (Compare::less_equal(value, _high_value)) {
681
76
                    _high_value = value;
682
76
                    _high_op = op;
683
76
                }
684
685
77
                break;
686
0
            }
687
688
146
            case FILTER_LESS_OR_EQUAL: {
689
146
                if (Compare::less(value, _high_value)) {
690
111
                    _high_value = value;
691
111
                    _high_op = op;
692
111
                }
693
694
146
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
497
            }
701
497
        }
702
703
496
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
496
            Compare::equal(_high_value, _low_value)) {
705
43
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
43
            _high_value = TYPE_MIN;
707
43
            _low_value = TYPE_MAX;
708
43
        }
709
496
    }
710
711
496
    return Status::OK();
712
497
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Line
Count
Source
614
4
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
4
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
4
    _contain_null = false;
621
622
4
    if (is_fixed_value_range()) {
623
1
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
1
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
1
        case FILTER_LARGER_OR_EQUAL: {
632
1
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
1
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
1
        }
655
656
1
        _high_value = TYPE_MIN;
657
1
        _low_value = TYPE_MAX;
658
3
    } else {
659
3
        if (Compare::greater(_high_value, _low_value)) {
660
3
            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
1
            case FILTER_LARGER_OR_EQUAL: {
671
1
                if (Compare::greater(value, _low_value)) {
672
0
                    _low_value = value;
673
0
                    _low_op = op;
674
0
                }
675
676
1
                break;
677
0
            }
678
679
0
            case FILTER_LESS: {
680
0
                if (Compare::less_equal(value, _high_value)) {
681
0
                    _high_value = value;
682
0
                    _high_op = op;
683
0
                }
684
685
0
                break;
686
0
            }
687
688
2
            case FILTER_LESS_OR_EQUAL: {
689
2
                if (Compare::less(value, _high_value)) {
690
1
                    _high_value = value;
691
1
                    _high_op = op;
692
1
                }
693
694
2
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3
            }
701
3
        }
702
703
3
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3
            Compare::equal(_high_value, _low_value)) {
705
1
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
1
            _high_value = TYPE_MIN;
707
1
            _low_value = TYPE_MAX;
708
1
        }
709
3
    }
710
711
4
    return Status::OK();
712
4
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
238
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
238
    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
238
    _contain_null = false;
621
622
238
    if (is_fixed_value_range()) {
623
24
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
24
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
24
        case FILTER_LARGER_OR_EQUAL: {
632
24
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
24
            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
24
        }
655
656
24
        _high_value = TYPE_MIN;
657
24
        _low_value = TYPE_MAX;
658
214
    } else {
659
214
        if (Compare::greater(_high_value, _low_value)) {
660
212
            switch (op) {
661
22
            case FILTER_LARGER: {
662
22
                if (Compare::greater_equal(value, _low_value)) {
663
22
                    _low_value = value;
664
22
                    _low_op = op;
665
22
                }
666
667
22
                break;
668
0
            }
669
670
64
            case FILTER_LARGER_OR_EQUAL: {
671
64
                if (Compare::greater(value, _low_value)) {
672
34
                    _low_value = value;
673
34
                    _low_op = op;
674
34
                }
675
676
64
                break;
677
0
            }
678
679
39
            case FILTER_LESS: {
680
39
                if (Compare::less_equal(value, _high_value)) {
681
39
                    _high_value = value;
682
39
                    _high_op = op;
683
39
                }
684
685
39
                break;
686
0
            }
687
688
88
            case FILTER_LESS_OR_EQUAL: {
689
88
                if (Compare::less(value, _high_value)) {
690
58
                    _high_value = value;
691
58
                    _high_op = op;
692
58
                }
693
694
88
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
212
            }
701
212
        }
702
703
214
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
214
            Compare::equal(_high_value, _low_value)) {
705
24
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
24
            _high_value = TYPE_MIN;
707
24
            _low_value = TYPE_MAX;
708
24
        }
709
214
    }
710
711
238
    return Status::OK();
712
238
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
118
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
118
    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
118
    _contain_null = false;
621
622
118
    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
118
    } else {
659
118
        if (Compare::greater(_high_value, _low_value)) {
660
117
            switch (op) {
661
23
            case FILTER_LARGER: {
662
23
                if (Compare::greater_equal(value, _low_value)) {
663
23
                    _low_value = value;
664
23
                    _low_op = op;
665
23
                }
666
667
23
                break;
668
0
            }
669
670
28
            case FILTER_LARGER_OR_EQUAL: {
671
28
                if (Compare::greater(value, _low_value)) {
672
26
                    _low_value = value;
673
26
                    _low_op = op;
674
26
                }
675
676
28
                break;
677
0
            }
678
679
38
            case FILTER_LESS: {
680
38
                if (Compare::less_equal(value, _high_value)) {
681
38
                    _high_value = value;
682
38
                    _high_op = op;
683
38
                }
684
685
38
                break;
686
0
            }
687
688
28
            case FILTER_LESS_OR_EQUAL: {
689
28
                if (Compare::less(value, _high_value)) {
690
26
                    _high_value = value;
691
26
                    _high_op = op;
692
26
                }
693
694
28
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
117
            }
701
117
        }
702
703
118
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
118
            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
118
    }
710
711
118
    return Status::OK();
712
118
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9add_rangeENS_11SQLFilterOpENS_12Decimal128V3E
Line
Count
Source
614
122
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
122
    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
122
    _contain_null = false;
621
622
122
    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
122
    } else {
659
122
        if (Compare::greater(_high_value, _low_value)) {
660
121
            switch (op) {
661
83
            case FILTER_LARGER: {
662
83
                if (Compare::greater_equal(value, _low_value)) {
663
83
                    _low_value = value;
664
83
                    _low_op = op;
665
83
                }
666
667
83
                break;
668
0
            }
669
670
19
            case FILTER_LARGER_OR_EQUAL: {
671
19
                if (Compare::greater(value, _low_value)) {
672
19
                    _low_value = value;
673
19
                    _low_op = op;
674
19
                }
675
676
19
                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
17
            case FILTER_LESS_OR_EQUAL: {
689
17
                if (Compare::less(value, _high_value)) {
690
17
                    _high_value = value;
691
17
                    _high_op = op;
692
17
                }
693
694
17
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
121
            }
701
121
        }
702
703
121
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
121
            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
121
    }
710
711
121
    return Status::OK();
712
122
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9add_rangeENS_11SQLFilterOpENS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
614
327
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
327
    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
327
    _contain_null = false;
621
622
327
    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
327
    } else {
659
327
        if (Compare::greater(_high_value, _low_value)) {
660
327
            switch (op) {
661
78
            case FILTER_LARGER: {
662
78
                if (Compare::greater_equal(value, _low_value)) {
663
78
                    _low_value = value;
664
78
                    _low_op = op;
665
78
                }
666
667
78
                break;
668
0
            }
669
670
92
            case FILTER_LARGER_OR_EQUAL: {
671
92
                if (Compare::greater(value, _low_value)) {
672
57
                    _low_value = value;
673
57
                    _low_op = op;
674
57
                }
675
676
92
                break;
677
0
            }
678
679
65
            case FILTER_LESS: {
680
65
                if (Compare::less_equal(value, _high_value)) {
681
65
                    _high_value = value;
682
65
                    _high_op = op;
683
65
                }
684
685
65
                break;
686
0
            }
687
688
92
            case FILTER_LESS_OR_EQUAL: {
689
92
                if (Compare::less(value, _high_value)) {
690
56
                    _high_value = value;
691
56
                    _high_op = op;
692
56
                }
693
694
92
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
327
            }
701
327
        }
702
703
324
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
324
            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
324
    }
710
711
324
    return Status::OK();
712
327
}
713
714
template <PrimitiveType primitive_type>
715
304k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
304k
    switch (_high_op) {
717
21
    case FILTER_LESS: {
718
21
        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
21
        case FILTER_LARGER_OR_EQUAL: {
724
21
            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
21
        }
731
732
0
        break;
733
21
    }
734
735
304k
    case FILTER_LESS_OR_EQUAL: {
736
304k
        switch (_low_op) {
737
44
        case FILTER_LARGER: {
738
44
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
303k
        case FILTER_LARGER_OR_EQUAL: {
742
303k
            return Compare::less_equal(value, _high_value) &&
743
303k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
304k
        }
750
304k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
304k
    }
756
757
0
    return false;
758
304k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
77.1k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
77.1k
    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
77.1k
    case FILTER_LESS_OR_EQUAL: {
736
77.1k
        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
77.1k
        case FILTER_LARGER_OR_EQUAL: {
742
77.1k
            return Compare::less_equal(value, _high_value) &&
743
77.1k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
77.1k
        }
750
77.1k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
77.1k
    }
756
757
0
    return false;
758
77.1k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
235
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
235
    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
237
    case FILTER_LESS_OR_EQUAL: {
736
237
        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
236
        case FILTER_LARGER_OR_EQUAL: {
742
236
            return Compare::less_equal(value, _high_value) &&
743
236
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
237
        }
750
237
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
235
    }
756
757
0
    return false;
758
235
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
45.0k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
45.0k
    switch (_high_op) {
717
6
    case FILTER_LESS: {
718
6
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
6
        case FILTER_LARGER_OR_EQUAL: {
724
6
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
6
        }
731
732
0
        break;
733
6
    }
734
735
45.0k
    case FILTER_LESS_OR_EQUAL: {
736
45.0k
        switch (_low_op) {
737
38
        case FILTER_LARGER: {
738
38
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
44.9k
        case FILTER_LARGER_OR_EQUAL: {
742
44.9k
            return Compare::less_equal(value, _high_value) &&
743
44.9k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
45.0k
        }
750
45.0k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
45.0k
    }
756
757
0
    return false;
758
45.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
819
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
819
    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
819
    case FILTER_LESS_OR_EQUAL: {
736
819
        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
819
        case FILTER_LARGER_OR_EQUAL: {
742
819
            return Compare::less_equal(value, _high_value) &&
743
819
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
819
        }
750
819
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
819
    }
756
757
0
    return false;
758
819
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
204
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
204
    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
204
    case FILTER_LESS_OR_EQUAL: {
736
204
        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
204
        case FILTER_LARGER_OR_EQUAL: {
742
204
            return Compare::less_equal(value, _high_value) &&
743
204
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
204
        }
750
204
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
204
    }
756
757
0
    return false;
758
204
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE11is_in_rangeERKf
Line
Count
Source
715
43
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
43
    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
43
    case FILTER_LESS_OR_EQUAL: {
736
43
        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
43
        case FILTER_LARGER_OR_EQUAL: {
742
43
            return Compare::less_equal(value, _high_value) &&
743
43
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
43
        }
750
43
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
43
    }
756
757
0
    return false;
758
43
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE11is_in_rangeERKd
Line
Count
Source
715
183
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
183
    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
185
    case FILTER_LESS_OR_EQUAL: {
736
185
        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
187
        case FILTER_LARGER_OR_EQUAL: {
742
187
            return Compare::less_equal(value, _high_value) &&
743
187
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
185
        }
750
185
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
183
    }
756
757
0
    return false;
758
183
}
_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
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
29
    case FILTER_LESS_OR_EQUAL: {
736
29
        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
29
        case FILTER_LARGER_OR_EQUAL: {
742
29
            return Compare::less_equal(value, _high_value) &&
743
29
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
29
        }
750
29
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
28
    }
756
757
0
    return false;
758
28
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
545
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
545
    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
547
    case FILTER_LESS_OR_EQUAL: {
736
547
        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
546
        case FILTER_LARGER_OR_EQUAL: {
742
546
            return Compare::less_equal(value, _high_value) &&
743
548
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
547
        }
750
547
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
545
    }
756
757
0
    return false;
758
545
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
167k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
167k
    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
168k
    case FILTER_LESS_OR_EQUAL: {
736
168k
        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
168k
        case FILTER_LARGER_OR_EQUAL: {
742
168k
            return Compare::less_equal(value, _high_value) &&
743
168k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
168k
        }
750
168k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
167k
    }
756
757
0
    return false;
758
167k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
387
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
387
    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
387
    case FILTER_LESS_OR_EQUAL: {
736
387
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
385
        case FILTER_LARGER_OR_EQUAL: {
742
385
            return Compare::less_equal(value, _high_value) &&
743
389
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
387
        }
750
387
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
387
    }
756
757
0
    return false;
758
387
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
72
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
72
    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
72
    case FILTER_LESS_OR_EQUAL: {
736
72
        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
72
        }
750
72
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
72
    }
756
757
0
    return false;
758
72
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
9.91k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
9.91k
    switch (_high_op) {
717
4
    case FILTER_LESS: {
718
4
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
4
        case FILTER_LARGER_OR_EQUAL: {
724
4
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
4
        }
731
732
0
        break;
733
4
    }
734
735
9.91k
    case FILTER_LESS_OR_EQUAL: {
736
9.91k
        switch (_low_op) {
737
6
        case FILTER_LARGER: {
738
6
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
9.91k
        case FILTER_LARGER_OR_EQUAL: {
742
9.91k
            return Compare::less_equal(value, _high_value) &&
743
9.91k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
9.91k
        }
750
9.91k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
9.91k
    }
756
757
0
    return false;
758
9.91k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
55
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
55
    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
55
    case FILTER_LESS_OR_EQUAL: {
736
55
        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
55
        case FILTER_LARGER_OR_EQUAL: {
742
55
            return Compare::less_equal(value, _high_value) &&
743
55
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
55
        }
750
55
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
55
    }
756
757
0
    return false;
758
55
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
430
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
430
    switch (_high_op) {
717
11
    case FILTER_LESS: {
718
11
        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
11
        case FILTER_LARGER_OR_EQUAL: {
724
11
            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
11
        }
731
732
0
        break;
733
11
    }
734
735
418
    case FILTER_LESS_OR_EQUAL: {
736
418
        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
418
        case FILTER_LARGER_OR_EQUAL: {
742
418
            return Compare::less_equal(value, _high_value) &&
743
418
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
418
        }
750
418
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
430
    }
756
757
0
    return false;
758
430
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
168
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
168
    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
168
    case FILTER_LESS_OR_EQUAL: {
736
168
        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
168
        case FILTER_LARGER_OR_EQUAL: {
742
168
            return Compare::less_equal(value, _high_value) &&
743
168
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
168
        }
750
168
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
168
    }
756
757
0
    return false;
758
168
}
_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
164
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
164
    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
164
    case FILTER_LESS_OR_EQUAL: {
736
164
        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
164
        case FILTER_LARGER_OR_EQUAL: {
742
164
            return Compare::less_equal(value, _high_value) &&
743
164
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
164
        }
750
164
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
164
    }
756
757
0
    return false;
758
164
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
66
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
66
    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
65
    case FILTER_LESS_OR_EQUAL: {
736
65
        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
65
        case FILTER_LARGER_OR_EQUAL: {
742
65
            return Compare::less_equal(value, _high_value) &&
743
65
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
65
        }
750
65
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
66
    }
756
757
0
    return false;
758
66
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE11is_in_rangeERKNS_7DecimalIlEE
Line
Count
Source
715
185
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
185
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
186
    case FILTER_LESS_OR_EQUAL: {
736
186
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
186
        case FILTER_LARGER_OR_EQUAL: {
742
186
            return Compare::less_equal(value, _high_value) &&
743
187
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
186
        }
750
186
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
185
    }
756
757
0
    return false;
758
185
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE11is_in_rangeERKNS_12Decimal128V3E
Line
Count
Source
715
249
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
249
    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
249
    case FILTER_LESS_OR_EQUAL: {
736
249
        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
250
        case FILTER_LARGER_OR_EQUAL: {
742
250
            return Compare::less_equal(value, _high_value) &&
743
250
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
249
        }
750
249
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
249
    }
756
757
0
    return false;
758
249
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE11is_in_rangeERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
715
94
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
94
    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
94
    case FILTER_LESS_OR_EQUAL: {
736
94
        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
94
        case FILTER_LARGER_OR_EQUAL: {
742
94
            return Compare::less_equal(value, _high_value) &&
743
94
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
94
        }
750
94
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
94
    }
756
757
0
    return false;
758
94
}
759
760
template <PrimitiveType primitive_type>
761
290k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
290k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
290k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
27.4k
        set_empty_value_range();
770
27.4k
    }
771
772
290k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
290k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
260k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
133
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
133
                             range._fixed_values.begin(), range._fixed_values.end(),
778
133
                             std::inserter(result_values, result_values.begin()));
779
260k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
10
            IteratorType iter = _fixed_values.begin();
781
782
38
            while (iter != _fixed_values.end()) {
783
28
                if (range.is_in_range(*iter)) {
784
28
                    result_values.insert(*iter);
785
28
                }
786
28
                ++iter;
787
28
            }
788
260k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
260k
            IteratorType iter = range._fixed_values.begin();
790
564k
            while (iter != range._fixed_values.end()) {
791
303k
                if (this->is_in_range(*iter)) {
792
303k
                    result_values.insert(*iter);
793
303k
                }
794
303k
                ++iter;
795
303k
            }
796
260k
        }
797
798
262k
        if (!result_values.empty()) {
799
262k
            _fixed_values = std::move(result_values);
800
262k
            _contain_null = false;
801
262k
            _high_value = TYPE_MIN;
802
262k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
260k
    } else {
807
29.9k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
323
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
320
                set_contain_null(true);
811
320
            }
812
29.6k
        } else {
813
29.6k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
29.6k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
29.6k
        }
816
29.9k
    }
817
290k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
77.5k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
77.5k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
77.5k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
84
        set_empty_value_range();
770
84
    }
771
772
77.5k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
77.5k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
76.6k
        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
76.6k
        } 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
76.6k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
76.5k
            IteratorType iter = range._fixed_values.begin();
790
153k
            while (iter != range._fixed_values.end()) {
791
77.0k
                if (this->is_in_range(*iter)) {
792
77.0k
                    result_values.insert(*iter);
793
77.0k
                }
794
76.6k
                ++iter;
795
76.6k
            }
796
76.5k
        }
797
798
77.2k
        if (!result_values.empty()) {
799
77.2k
            _fixed_values = std::move(result_values);
800
77.2k
            _contain_null = false;
801
77.2k
            _high_value = TYPE_MIN;
802
77.2k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
76.6k
    } else {
807
909
        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
909
        } else {
813
909
            static_cast<void>(add_range(range._high_op, range._high_value));
814
909
            static_cast<void>(add_range(range._low_op, range._low_value));
815
909
        }
816
909
    }
817
77.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
Line
Count
Source
761
158
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
158
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
158
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
4
        set_empty_value_range();
770
4
    }
771
772
158
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
158
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
118
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
118
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
118
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
116
            IteratorType iter = range._fixed_values.begin();
790
347
            while (iter != range._fixed_values.end()) {
791
233
                if (this->is_in_range(*iter)) {
792
233
                    result_values.insert(*iter);
793
233
                }
794
231
                ++iter;
795
231
            }
796
116
        }
797
798
123
        if (!result_values.empty()) {
799
123
            _fixed_values = std::move(result_values);
800
123
            _contain_null = false;
801
123
            _high_value = TYPE_MIN;
802
123
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
118
    } 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
158
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
4.97k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
4.97k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
4.97k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
193
        set_empty_value_range();
770
193
    }
771
772
4.97k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
4.97k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
4.29k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
36
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
36
                             range._fixed_values.begin(), range._fixed_values.end(),
778
36
                             std::inserter(result_values, result_values.begin()));
779
4.25k
        } 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
4.26k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
4.26k
            IteratorType iter = range._fixed_values.begin();
790
49.7k
            while (iter != range._fixed_values.end()) {
791
45.5k
                if (this->is_in_range(*iter)) {
792
44.8k
                    result_values.insert(*iter);
793
44.8k
                }
794
45.5k
                ++iter;
795
45.5k
            }
796
4.26k
        }
797
798
4.31k
        if (!result_values.empty()) {
799
4.31k
            _fixed_values = std::move(result_values);
800
4.31k
            _contain_null = false;
801
4.31k
            _high_value = TYPE_MIN;
802
4.31k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
4.29k
    } else {
807
689
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
68
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
66
                set_contain_null(true);
811
66
            }
812
623
        } else {
813
623
            static_cast<void>(add_range(range._high_op, range._high_value));
814
623
            static_cast<void>(add_range(range._low_op, range._low_value));
815
623
        }
816
689
    }
817
4.97k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
27.7k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
27.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
27.7k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
27.1k
        set_empty_value_range();
770
27.1k
    }
771
772
27.7k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
27.7k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
631
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
88
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
88
                             range._fixed_values.begin(), range._fixed_values.end(),
778
88
                             std::inserter(result_values, result_values.begin()));
779
543
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
10
            IteratorType iter = _fixed_values.begin();
781
782
38
            while (iter != _fixed_values.end()) {
783
28
                if (range.is_in_range(*iter)) {
784
28
                    result_values.insert(*iter);
785
28
                }
786
28
                ++iter;
787
28
            }
788
537
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
537
            IteratorType iter = range._fixed_values.begin();
790
1.32k
            while (iter != range._fixed_values.end()) {
791
792
                if (this->is_in_range(*iter)) {
792
792
                    result_values.insert(*iter);
793
792
                }
794
792
                ++iter;
795
792
            }
796
537
        }
797
798
633
        if (!result_values.empty()) {
799
633
            _fixed_values = std::move(result_values);
800
633
            _contain_null = false;
801
633
            _high_value = TYPE_MIN;
802
633
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
27.1k
    } else {
807
27.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
27.1k
        } else {
813
27.1k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
27.1k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
27.1k
        }
816
27.1k
    }
817
27.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
219
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
219
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
219
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
219
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
219
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
203
        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
201
        } 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
201
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
201
            IteratorType iter = range._fixed_values.begin();
790
404
            while (iter != range._fixed_values.end()) {
791
204
                if (this->is_in_range(*iter)) {
792
204
                    result_values.insert(*iter);
793
204
                }
794
203
                ++iter;
795
203
            }
796
201
        }
797
798
204
        if (!result_values.empty()) {
799
204
            _fixed_values = std::move(result_values);
800
204
            _contain_null = false;
801
204
            _high_value = TYPE_MIN;
802
204
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
203
    } else {
807
16
        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
10
        } else {
813
6
            static_cast<void>(add_range(range._high_op, range._high_value));
814
6
            static_cast<void>(add_range(range._low_op, range._low_value));
815
6
        }
816
16
    }
817
219
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
56
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
56
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
56
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
56
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
56
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
37
        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
37
        } 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
37
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
37
            IteratorType iter = range._fixed_values.begin();
790
79
            while (iter != range._fixed_values.end()) {
791
42
                if (this->is_in_range(*iter)) {
792
42
                    result_values.insert(*iter);
793
42
                }
794
42
                ++iter;
795
42
            }
796
37
        }
797
798
38
        if (!result_values.empty()) {
799
38
            _fixed_values = std::move(result_values);
800
38
            _contain_null = false;
801
38
            _high_value = TYPE_MIN;
802
38
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
37
    } else {
807
19
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
10
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
10
                set_contain_null(true);
811
10
            }
812
10
        } else {
813
9
            static_cast<void>(add_range(range._high_op, range._high_value));
814
9
            static_cast<void>(add_range(range._low_op, range._low_value));
815
9
        }
816
19
    }
817
56
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
193
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
193
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
193
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
193
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
193
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
134
        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
134
        } 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
135
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
135
            IteratorType iter = range._fixed_values.begin();
790
319
            while (iter != range._fixed_values.end()) {
791
186
                if (this->is_in_range(*iter)) {
792
186
                    result_values.insert(*iter);
793
186
                }
794
184
                ++iter;
795
184
            }
796
135
        }
797
798
139
        if (!result_values.empty()) {
799
139
            _fixed_values = std::move(result_values);
800
139
            _contain_null = false;
801
139
            _high_value = TYPE_MIN;
802
139
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
134
    } else {
807
59
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
17
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
17
                set_contain_null(true);
811
17
            }
812
42
        } else {
813
42
            static_cast<void>(add_range(range._high_op, range._high_value));
814
42
            static_cast<void>(add_range(range._low_op, range._low_value));
815
42
        }
816
59
    }
817
193
}
_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
25
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
25
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
25
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
25
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
25
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
21
        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
21
        } 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
21
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
21
            IteratorType iter = range._fixed_values.begin();
790
47
            while (iter != range._fixed_values.end()) {
791
29
                if (this->is_in_range(*iter)) {
792
29
                    result_values.insert(*iter);
793
29
                }
794
26
                ++iter;
795
26
            }
796
21
        }
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
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
21
    } else {
807
4
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
4
        } else {
813
4
            static_cast<void>(add_range(range._high_op, range._high_value));
814
4
            static_cast<void>(add_range(range._low_op, range._low_value));
815
4
        }
816
4
    }
817
25
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
444
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
444
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
444
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
444
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
444
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
417
        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
417
        } 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
417
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
416
            IteratorType iter = range._fixed_values.begin();
790
959
            while (iter != range._fixed_values.end()) {
791
546
                if (this->is_in_range(*iter)) {
792
546
                    result_values.insert(*iter);
793
546
                }
794
543
                ++iter;
795
543
            }
796
416
        }
797
798
421
        if (!result_values.empty()) {
799
421
            _fixed_values = std::move(result_values);
800
421
            _contain_null = false;
801
421
            _high_value = TYPE_MIN;
802
421
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
417
    } else {
807
27
        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
25
        } else {
813
25
            static_cast<void>(add_range(range._high_op, range._high_value));
814
25
            static_cast<void>(add_range(range._low_op, range._low_value));
815
25
        }
816
27
    }
817
444
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
167k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
167k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
167k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
36
        set_empty_value_range();
770
36
    }
771
772
167k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
167k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
167k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
5
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
5
                             range._fixed_values.begin(), range._fixed_values.end(),
778
5
                             std::inserter(result_values, result_values.begin()));
779
167k
        } 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
167k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
167k
            IteratorType iter = range._fixed_values.begin();
790
334k
            while (iter != range._fixed_values.end()) {
791
167k
                if (this->is_in_range(*iter)) {
792
167k
                    result_values.insert(*iter);
793
167k
                }
794
167k
                ++iter;
795
167k
            }
796
167k
        }
797
798
167k
        if (!result_values.empty()) {
799
167k
            _fixed_values = std::move(result_values);
800
167k
            _contain_null = false;
801
167k
            _high_value = TYPE_MIN;
802
167k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
167k
    } else {
807
690
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
138
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
138
                set_contain_null(true);
811
138
            }
812
552
        } else {
813
552
            static_cast<void>(add_range(range._high_op, range._high_value));
814
552
            static_cast<void>(add_range(range._low_op, range._low_value));
815
552
        }
816
690
    }
817
167k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
384
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
384
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
384
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
384
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
384
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
330
        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
330
        } 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
334
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
334
            IteratorType iter = range._fixed_values.begin();
790
718
            while (iter != range._fixed_values.end()) {
791
387
                if (this->is_in_range(*iter)) {
792
387
                    result_values.insert(*iter);
793
387
                }
794
384
                ++iter;
795
384
            }
796
334
        }
797
798
339
        if (!result_values.empty()) {
799
339
            _fixed_values = std::move(result_values);
800
339
            _contain_null = false;
801
339
            _high_value = TYPE_MIN;
802
339
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
330
    } else {
807
54
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
22
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
21
                set_contain_null(true);
811
21
            }
812
33
        } else {
813
33
            static_cast<void>(add_range(range._high_op, range._high_value));
814
33
            static_cast<void>(add_range(range._low_op, range._low_value));
815
33
        }
816
54
    }
817
384
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
40
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
40
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
40
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
40
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
40
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
40
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
40
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
40
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
40
            IteratorType iter = range._fixed_values.begin();
790
112
            while (iter != range._fixed_values.end()) {
791
72
                if (this->is_in_range(*iter)) {
792
72
                    result_values.insert(*iter);
793
72
                }
794
72
                ++iter;
795
72
            }
796
40
        }
797
798
40
        if (!result_values.empty()) {
799
40
            _fixed_values = std::move(result_values);
800
40
            _contain_null = false;
801
40
            _high_value = TYPE_MIN;
802
40
            _low_value = TYPE_MAX;
803
40
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
40
    } else {
807
0
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
0
        } else {
813
0
            static_cast<void>(add_range(range._high_op, range._high_value));
814
0
            static_cast<void>(add_range(range._low_op, range._low_value));
815
0
        }
816
0
    }
817
40
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
9.93k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
9.93k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
9.93k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
11
        set_empty_value_range();
770
11
    }
771
772
9.93k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
9.93k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
9.81k
        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
9.81k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
9.81k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
9.80k
            IteratorType iter = range._fixed_values.begin();
790
19.7k
            while (iter != range._fixed_values.end()) {
791
9.92k
                if (this->is_in_range(*iter)) {
792
9.92k
                    result_values.insert(*iter);
793
9.92k
                }
794
9.90k
                ++iter;
795
9.90k
            }
796
9.80k
        }
797
798
9.85k
        if (!result_values.empty()) {
799
9.85k
            _fixed_values = std::move(result_values);
800
9.85k
            _contain_null = false;
801
9.85k
            _high_value = TYPE_MIN;
802
9.85k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
9.81k
    } else {
807
120
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
37
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
36
                set_contain_null(true);
811
36
            }
812
83
        } else {
813
83
            static_cast<void>(add_range(range._high_op, range._high_value));
814
83
            static_cast<void>(add_range(range._low_op, range._low_value));
815
83
        }
816
120
    }
817
9.93k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12intersectionERS2_
Line
Count
Source
761
30
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
30
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
30
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
30
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
30
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
30
        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
30
        } 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
30
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
30
            IteratorType iter = range._fixed_values.begin();
790
85
            while (iter != range._fixed_values.end()) {
791
55
                if (this->is_in_range(*iter)) {
792
55
                    result_values.insert(*iter);
793
55
                }
794
55
                ++iter;
795
55
            }
796
30
        }
797
798
30
        if (!result_values.empty()) {
799
30
            _fixed_values = std::move(result_values);
800
30
            _contain_null = false;
801
30
            _high_value = TYPE_MIN;
802
30
            _low_value = TYPE_MAX;
803
30
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
30
    } 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
30
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12intersectionERS2_
Line
Count
Source
761
432
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
432
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
432
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
432
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
432
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
397
        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
397
        } 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
397
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
394
            IteratorType iter = range._fixed_values.begin();
790
816
            while (iter != range._fixed_values.end()) {
791
429
                if (this->is_in_range(*iter)) {
792
429
                    result_values.insert(*iter);
793
429
                }
794
422
                ++iter;
795
422
            }
796
394
        }
797
798
412
        if (!result_values.empty()) {
799
412
            _fixed_values = std::move(result_values);
800
412
            _contain_null = false;
801
412
            _high_value = TYPE_MIN;
802
412
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
397
    } else {
807
35
        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
32
        } else {
813
32
            static_cast<void>(add_range(range._high_op, range._high_value));
814
32
            static_cast<void>(add_range(range._low_op, range._low_value));
815
32
        }
816
35
    }
817
432
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
135
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
135
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
135
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
135
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
135
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
91
        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
91
        } 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
91
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
91
            IteratorType iter = range._fixed_values.begin();
790
258
            while (iter != range._fixed_values.end()) {
791
168
                if (this->is_in_range(*iter)) {
792
168
                    result_values.insert(*iter);
793
168
                }
794
167
                ++iter;
795
167
            }
796
91
        }
797
798
92
        if (!result_values.empty()) {
799
92
            _fixed_values = std::move(result_values);
800
92
            _contain_null = false;
801
92
            _high_value = TYPE_MIN;
802
92
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
91
    } else {
807
44
        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
35
        } else {
813
35
            static_cast<void>(add_range(range._high_op, range._high_value));
814
35
            static_cast<void>(add_range(range._low_op, range._low_value));
815
35
        }
816
44
    }
817
135
}
_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
165
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
165
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
165
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
165
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
165
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
162
        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
161
        } 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
161
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
161
            IteratorType iter = range._fixed_values.begin();
790
325
            while (iter != range._fixed_values.end()) {
791
164
                if (this->is_in_range(*iter)) {
792
164
                    result_values.insert(*iter);
793
164
                }
794
164
                ++iter;
795
164
            }
796
161
        }
797
798
162
        if (!result_values.empty()) {
799
162
            _fixed_values = std::move(result_values);
800
162
            _contain_null = false;
801
162
            _high_value = TYPE_MIN;
802
162
            _low_value = TYPE_MAX;
803
162
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
162
    } else {
807
3
        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
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
3
    }
817
165
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12intersectionERS2_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12intersectionERS2_
Line
Count
Source
761
82
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
82
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
82
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
1
        set_empty_value_range();
770
1
    }
771
772
82
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
82
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
51
        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
51
        } 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
51
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
51
            IteratorType iter = range._fixed_values.begin();
790
117
            while (iter != range._fixed_values.end()) {
791
66
                if (this->is_in_range(*iter)) {
792
64
                    result_values.insert(*iter);
793
64
                }
794
66
                ++iter;
795
66
            }
796
51
        }
797
798
51
        if (!result_values.empty()) {
799
51
            _fixed_values = std::move(result_values);
800
51
            _contain_null = false;
801
51
            _high_value = TYPE_MIN;
802
51
            _low_value = TYPE_MAX;
803
51
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
51
    } else {
807
31
        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
31
        } else {
813
31
            static_cast<void>(add_range(range._high_op, range._high_value));
814
31
            static_cast<void>(add_range(range._low_op, range._low_value));
815
31
        }
816
31
    }
817
82
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
136
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
136
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
136
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
136
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
136
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
131
        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
131
        } 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
131
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
130
            IteratorType iter = range._fixed_values.begin();
790
315
            while (iter != range._fixed_values.end()) {
791
186
                if (this->is_in_range(*iter)) {
792
186
                    result_values.insert(*iter);
793
186
                }
794
185
                ++iter;
795
185
            }
796
130
        }
797
798
132
        if (!result_values.empty()) {
799
132
            _fixed_values = std::move(result_values);
800
132
            _contain_null = false;
801
132
            _high_value = TYPE_MIN;
802
132
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
131
    } else {
807
5
        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
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
5
    }
817
136
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
234
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
234
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
234
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
234
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
234
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
230
        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
230
        } 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
230
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
230
            IteratorType iter = range._fixed_values.begin();
790
475
            while (iter != range._fixed_values.end()) {
791
248
                if (this->is_in_range(*iter)) {
792
248
                    result_values.insert(*iter);
793
248
                }
794
245
                ++iter;
795
245
            }
796
230
        }
797
798
236
        if (!result_values.empty()) {
799
236
            _fixed_values = std::move(result_values);
800
236
            _contain_null = false;
801
236
            _high_value = TYPE_MIN;
802
236
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
230
    } else {
807
4
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
4
        } else {
813
4
            static_cast<void>(add_range(range._high_op, range._high_value));
814
4
            static_cast<void>(add_range(range._low_op, range._low_value));
815
4
        }
816
4
    }
817
234
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
124
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
124
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
124
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
124
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
124
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
88
        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
88
        } 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
88
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
88
            IteratorType iter = range._fixed_values.begin();
790
182
            while (iter != range._fixed_values.end()) {
791
94
                if (this->is_in_range(*iter)) {
792
94
                    result_values.insert(*iter);
793
94
                }
794
94
                ++iter;
795
94
            }
796
88
        }
797
798
88
        if (!result_values.empty()) {
799
88
            _fixed_values = std::move(result_values);
800
88
            _contain_null = false;
801
88
            _high_value = TYPE_MIN;
802
88
            _low_value = TYPE_MAX;
803
88
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
88
    } else {
807
36
        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
35
        } else {
813
35
            static_cast<void>(add_range(range._high_op, range._high_value));
814
35
            static_cast<void>(add_range(range._low_op, range._low_value));
815
35
        }
816
36
    }
817
124
}
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
396k
                                     bool* should_break) {
823
396k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
396k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
396k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
396k
    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
396k
    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
396k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
396k
    if (range.is_fixed_value_range()) {
842
164k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
42
            if (range.is_range_value_convertible()) {
844
41
                range.convert_to_range_value();
845
41
                *exact_value = false;
846
41
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
42
        }
851
231k
    } else {
852
231k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
231k
            !range.is_reject_split_type()) {
854
152k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
152k
                                                 _end_include);
856
857
152k
            if (!(*eos) &&
858
153k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
153k
                                                 _end_include, max_scan_key_num)) {
860
152k
                _has_range_value = true;
861
152k
            }
862
152k
            return Status::OK();
863
152k
        }
864
231k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
243k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
164k
        if (_begin_scan_keys.empty()) {
870
57.3k
            auto fixed_value_set = range.get_fixed_value_set();
871
57.3k
            ConstIterator iter = fixed_value_set.begin();
872
873
116k
            for (; iter != fixed_value_set.end(); ++iter) {
874
58.8k
                _begin_scan_keys.emplace_back();
875
58.8k
                _begin_scan_keys.back().add_value(
876
58.8k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
58.8k
                _end_scan_keys.emplace_back();
878
58.8k
                _end_scan_keys.back().add_value(
879
58.8k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
58.8k
            }
881
882
57.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
57.3k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
106k
        else {
890
106k
            auto fixed_value_set = range.get_fixed_value_set();
891
106k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
213k
            for (int i = 0; i < original_key_range_size; ++i) {
894
106k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
106k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
106k
                ConstIterator iter = fixed_value_set.begin();
898
899
214k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
107k
                    if (iter == fixed_value_set.begin()) {
902
106k
                        _begin_scan_keys[i].add_value(
903
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
106k
                        _end_scan_keys[i].add_value(
905
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
106k
                    } // append follow ScanKey
907
455
                    else {
908
455
                        _begin_scan_keys.push_back(start_base_key_range);
909
455
                        _begin_scan_keys.back().add_value(
910
455
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
455
                        _end_scan_keys.push_back(end_base_key_range);
912
455
                        _end_scan_keys.back().add_value(
913
455
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
455
                    }
915
107k
                }
916
917
106k
                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
106k
            }
924
106k
        }
925
926
164k
        _begin_include = true;
927
164k
        _end_include = true;
928
164k
    } // Extend ScanKey with range value
929
79.1k
    else {
930
79.1k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
79.1k
        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
79.1k
        } else if (_begin_scan_keys.empty()) {
947
22.9k
            _begin_scan_keys.emplace_back();
948
22.9k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
22.9k
                                                      range.get_range_min_value(), range.scale()),
950
22.9k
                                              range.contain_null());
951
22.9k
            _end_scan_keys.emplace_back();
952
22.9k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
22.9k
                    range.get_range_max_value(), range.scale()));
954
56.1k
        } else {
955
119k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
63.4k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
63.4k
                                                      range.get_range_min_value(), range.scale()),
958
63.4k
                                              range.contain_null());
959
63.4k
            }
960
961
119k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
63.5k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
63.5k
                        range.get_range_max_value(), range.scale()));
964
63.5k
            }
965
56.1k
        }
966
79.1k
        _begin_include = range.is_begin_include();
967
79.1k
        _end_include = range.is_end_include();
968
79.1k
    }
969
970
243k
    return Status::OK();
971
396k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.48k
                                     bool* should_break) {
823
2.48k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.48k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.48k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.48k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2.48k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
2.48k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.48k
    if (range.is_fixed_value_range()) {
842
18
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.47k
    } else {
852
2.47k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.47k
            !range.is_reject_split_type()) {
854
2.43k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.43k
                                                 _end_include);
856
857
2.43k
            if (!(*eos) &&
858
2.44k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.45k
                                                 _end_include, max_scan_key_num)) {
860
2.45k
                _has_range_value = true;
861
2.45k
            }
862
2.43k
            return Status::OK();
863
2.43k
        }
864
2.47k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
54
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
18
        if (_begin_scan_keys.empty()) {
870
18
            auto fixed_value_set = range.get_fixed_value_set();
871
18
            ConstIterator iter = fixed_value_set.begin();
872
873
39
            for (; iter != fixed_value_set.end(); ++iter) {
874
21
                _begin_scan_keys.emplace_back();
875
21
                _begin_scan_keys.back().add_value(
876
21
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
21
                _end_scan_keys.emplace_back();
878
21
                _end_scan_keys.back().add_value(
879
21
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
21
            }
881
882
18
            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
18
        } // 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
17
        _begin_include = true;
927
17
        _end_include = true;
928
17
    } // Extend ScanKey with range value
929
37
    else {
930
37
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
37
        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
37
        } 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
35
        } else {
955
67
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
32
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
32
                                                      range.get_range_min_value(), range.scale()),
958
32
                                              range.contain_null());
959
32
            }
960
961
67
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
32
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
32
                        range.get_range_max_value(), range.scale()));
964
32
            }
965
35
        }
966
37
        _begin_include = range.is_begin_include();
967
37
        _end_include = range.is_end_include();
968
37
    }
969
970
54
    return Status::OK();
971
2.48k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
149
                                     bool* should_break) {
823
149
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
149
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
149
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
149
    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
149
    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
149
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
149
    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
146
    } else {
852
146
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
146
            !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
146
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
58
    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
55
    else {
930
55
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
55
        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
55
        } 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
55
        } else {
955
399
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
344
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
344
                                                      range.get_range_min_value(), range.scale()),
958
344
                                              range.contain_null());
959
344
            }
960
961
399
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
344
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
344
                        range.get_range_max_value(), range.scale()));
964
344
            }
965
55
        }
966
55
        _begin_include = range.is_begin_include();
967
55
        _end_include = range.is_end_include();
968
55
    }
969
970
58
    return Status::OK();
971
149
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
70.4k
                                     bool* should_break) {
823
70.4k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
70.4k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
70.4k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
70.4k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
70.4k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
70.4k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
70.4k
    if (range.is_fixed_value_range()) {
842
2.14k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
40
            if (range.is_range_value_convertible()) {
844
40
                range.convert_to_range_value();
845
40
                *exact_value = false;
846
40
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
40
        }
851
68.3k
    } else {
852
68.3k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
68.3k
            !range.is_reject_split_type()) {
854
67.2k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
67.2k
                                                 _end_include);
856
857
67.2k
            if (!(*eos) &&
858
67.6k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
67.6k
                                                 _end_include, max_scan_key_num)) {
860
67.0k
                _has_range_value = true;
861
67.0k
            }
862
67.2k
            return Status::OK();
863
67.2k
        }
864
68.3k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3.22k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.09k
        if (_begin_scan_keys.empty()) {
870
2.06k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.06k
            ConstIterator iter = fixed_value_set.begin();
872
873
5.14k
            for (; iter != fixed_value_set.end(); ++iter) {
874
3.08k
                _begin_scan_keys.emplace_back();
875
3.08k
                _begin_scan_keys.back().add_value(
876
3.08k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
3.08k
                _end_scan_keys.emplace_back();
878
3.08k
                _end_scan_keys.back().add_value(
879
3.08k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
3.08k
            }
881
882
2.06k
            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.06k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
35
        else {
890
35
            auto fixed_value_set = range.get_fixed_value_set();
891
35
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
83
            for (int i = 0; i < original_key_range_size; ++i) {
894
48
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
48
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
48
                ConstIterator iter = fixed_value_set.begin();
898
899
96
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
48
                    if (iter == fixed_value_set.begin()) {
902
48
                        _begin_scan_keys[i].add_value(
903
48
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
48
                        _end_scan_keys[i].add_value(
905
48
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
48
                    } // 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
48
                }
916
917
48
                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
48
            }
924
35
        }
925
926
2.09k
        _begin_include = true;
927
2.09k
        _end_include = true;
928
2.09k
    } // Extend ScanKey with range value
929
1.12k
    else {
930
1.12k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.12k
        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.12k
        } else if (_begin_scan_keys.empty()) {
947
128
            _begin_scan_keys.emplace_back();
948
128
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
128
                                                      range.get_range_min_value(), range.scale()),
950
128
                                              range.contain_null());
951
128
            _end_scan_keys.emplace_back();
952
128
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
128
                    range.get_range_max_value(), range.scale()));
954
1.00k
        } else {
955
8.39k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
7.39k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
7.39k
                                                      range.get_range_min_value(), range.scale()),
958
7.39k
                                              range.contain_null());
959
7.39k
            }
960
961
8.39k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
7.39k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
7.39k
                        range.get_range_max_value(), range.scale()));
964
7.39k
            }
965
1.00k
        }
966
1.12k
        _begin_include = range.is_begin_include();
967
1.12k
        _end_include = range.is_end_include();
968
1.12k
    }
969
970
3.22k
    return Status::OK();
971
70.4k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
81.7k
                                     bool* should_break) {
823
81.7k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
81.7k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
81.7k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
81.7k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
81.7k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
81.7k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
81.7k
    if (range.is_fixed_value_range()) {
842
981
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
80.8k
    } else {
852
80.8k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
80.8k
            !range.is_reject_split_type()) {
854
80.3k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
80.3k
                                                 _end_include);
856
857
80.3k
            if (!(*eos) &&
858
80.4k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
80.4k
                                                 _end_include, max_scan_key_num)) {
860
80.1k
                _has_range_value = true;
861
80.1k
            }
862
80.3k
            return Status::OK();
863
80.3k
        }
864
80.8k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.43k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
982
        if (_begin_scan_keys.empty()) {
870
982
            auto fixed_value_set = range.get_fixed_value_set();
871
982
            ConstIterator iter = fixed_value_set.begin();
872
873
2.06k
            for (; iter != fixed_value_set.end(); ++iter) {
874
1.08k
                _begin_scan_keys.emplace_back();
875
1.08k
                _begin_scan_keys.back().add_value(
876
1.08k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
1.08k
                _end_scan_keys.emplace_back();
878
1.08k
                _end_scan_keys.back().add_value(
879
1.08k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
1.08k
            }
881
882
982
            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
982
        } // 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
981
        _begin_include = true;
927
981
        _end_include = true;
928
981
    } // Extend ScanKey with range value
929
458
    else {
930
458
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
458
        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
458
        } else if (_begin_scan_keys.empty()) {
947
22
            _begin_scan_keys.emplace_back();
948
22
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
22
                                                      range.get_range_min_value(), range.scale()),
950
22
                                              range.contain_null());
951
22
            _end_scan_keys.emplace_back();
952
22
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
22
                    range.get_range_max_value(), range.scale()));
954
436
        } else {
955
1.15k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
718
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
718
                                                      range.get_range_min_value(), range.scale()),
958
718
                                              range.contain_null());
959
718
            }
960
961
1.15k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
720
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
720
                        range.get_range_max_value(), range.scale()));
964
720
            }
965
436
        }
966
458
        _begin_include = range.is_begin_include();
967
458
        _end_include = range.is_end_include();
968
458
    }
969
970
1.43k
    return Status::OK();
971
81.7k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.78k
                                     bool* should_break) {
823
3.78k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.78k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.78k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.78k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
3.78k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
3.78k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.78k
    if (range.is_fixed_value_range()) {
842
139
        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.64k
    } else {
852
3.64k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
3.64k
            !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.64k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3.78k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
139
        if (_begin_scan_keys.empty()) {
870
139
            auto fixed_value_set = range.get_fixed_value_set();
871
139
            ConstIterator iter = fixed_value_set.begin();
872
873
280
            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
139
            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
139
        } // 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
139
        _begin_include = true;
927
139
        _end_include = true;
928
139
    } // Extend ScanKey with range value
929
3.64k
    else {
930
3.64k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
3.64k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
3.64k
        } else if (_begin_scan_keys.empty()) {
947
3.58k
            _begin_scan_keys.emplace_back();
948
3.58k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
3.58k
                                                      range.get_range_min_value(), range.scale()),
950
3.58k
                                              range.contain_null());
951
3.58k
            _end_scan_keys.emplace_back();
952
3.58k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
3.58k
                    range.get_range_max_value(), range.scale()));
954
3.58k
        } else {
955
110
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
56
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
56
                                                      range.get_range_min_value(), range.scale()),
958
56
                                              range.contain_null());
959
56
            }
960
961
110
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
56
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
56
                        range.get_range_max_value(), range.scale()));
964
56
            }
965
54
        }
966
3.64k
        _begin_include = range.is_begin_include();
967
3.64k
        _end_include = range.is_end_include();
968
3.64k
    }
969
970
3.78k
    return Status::OK();
971
3.78k
}
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
478
                                     bool* should_break) {
823
478
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
478
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
478
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
478
    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
478
    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
478
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
478
    if (range.is_fixed_value_range()) {
842
13
        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
465
    } else {
852
465
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
465
            !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
465
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
478
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
12
        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
30
            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
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
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
12
        _begin_include = true;
927
12
        _end_include = true;
928
12
    } // Extend ScanKey with range value
929
466
    else {
930
466
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
466
        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
465
        } else if (_begin_scan_keys.empty()) {
947
459
            _begin_scan_keys.emplace_back();
948
459
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
459
                                                      range.get_range_min_value(), range.scale()),
950
459
                                              range.contain_null());
951
459
            _end_scan_keys.emplace_back();
952
459
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
459
                    range.get_range_max_value(), range.scale()));
954
459
        } else {
955
88
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
82
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
82
                                                      range.get_range_min_value(), range.scale()),
958
82
                                              range.contain_null());
959
82
            }
960
961
88
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
82
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
82
                        range.get_range_max_value(), range.scale()));
964
82
            }
965
6
        }
966
466
        _begin_include = range.is_begin_include();
967
466
        _end_include = range.is_end_include();
968
466
    }
969
970
478
    return Status::OK();
971
478
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
223k
                                     bool* should_break) {
823
223k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
223k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
223k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
223k
    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
223k
    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
223k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
223k
    if (range.is_fixed_value_range()) {
842
160k
        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
160k
    } else {
852
62.8k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
62.8k
            !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
62.8k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
223k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
160k
        if (_begin_scan_keys.empty()) {
870
53.5k
            auto fixed_value_set = range.get_fixed_value_set();
871
53.5k
            ConstIterator iter = fixed_value_set.begin();
872
873
107k
            for (; iter != fixed_value_set.end(); ++iter) {
874
53.7k
                _begin_scan_keys.emplace_back();
875
53.7k
                _begin_scan_keys.back().add_value(
876
53.7k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
53.7k
                _end_scan_keys.emplace_back();
878
53.7k
                _end_scan_keys.back().add_value(
879
53.7k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
53.7k
            }
881
882
53.5k
            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
53.5k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
106k
        else {
890
106k
            auto fixed_value_set = range.get_fixed_value_set();
891
106k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
213k
            for (int i = 0; i < original_key_range_size; ++i) {
894
106k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
106k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
106k
                ConstIterator iter = fixed_value_set.begin();
898
899
214k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
107k
                    if (iter == fixed_value_set.begin()) {
902
106k
                        _begin_scan_keys[i].add_value(
903
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
106k
                        _end_scan_keys[i].add_value(
905
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
106k
                    } // append follow ScanKey
907
455
                    else {
908
455
                        _begin_scan_keys.push_back(start_base_key_range);
909
455
                        _begin_scan_keys.back().add_value(
910
455
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
455
                        _end_scan_keys.push_back(end_base_key_range);
912
455
                        _end_scan_keys.back().add_value(
913
455
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
455
                    }
915
107k
                }
916
917
106k
                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
106k
            }
924
106k
        }
925
926
160k
        _begin_include = true;
927
160k
        _end_include = true;
928
160k
    } // Extend ScanKey with range value
929
63.0k
    else {
930
63.0k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
63.0k
        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.0k
        } else if (_begin_scan_keys.empty()) {
947
8.74k
            _begin_scan_keys.emplace_back();
948
8.74k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
8.74k
                                                      range.get_range_min_value(), range.scale()),
950
8.74k
                                              range.contain_null());
951
8.74k
            _end_scan_keys.emplace_back();
952
8.74k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
8.74k
                    range.get_range_max_value(), range.scale()));
954
54.3k
        } else {
955
108k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
54.4k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
54.4k
                                                      range.get_range_min_value(), range.scale()),
958
54.4k
                                              range.contain_null());
959
54.4k
            }
960
961
108k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
54.5k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
54.5k
                        range.get_range_max_value(), range.scale()));
964
54.5k
            }
965
54.3k
        }
966
63.0k
        _begin_include = range.is_begin_include();
967
63.0k
        _end_include = range.is_end_include();
968
63.0k
    }
969
970
223k
    return Status::OK();
971
223k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE23EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE11EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
18
                                     bool* should_break) {
823
18
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
18
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
18
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
18
    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
18
    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
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
18
    if (range.is_fixed_value_range()) {
842
9
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
9
    } else {
852
9
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
9
            !range.is_reject_split_type()) {
854
8
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
8
                                                 _end_include);
856
857
8
            if (!(*eos) &&
858
8
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
8
                                                 _end_include, max_scan_key_num)) {
860
8
                _has_range_value = true;
861
8
            }
862
8
            return Status::OK();
863
8
        }
864
9
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
10
    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
10
            auto fixed_value_set = range.get_fixed_value_set();
871
10
            ConstIterator iter = fixed_value_set.begin();
872
873
36
            for (; iter != fixed_value_set.end(); ++iter) {
874
26
                _begin_scan_keys.emplace_back();
875
26
                _begin_scan_keys.back().add_value(
876
26
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
26
                _end_scan_keys.emplace_back();
878
26
                _end_scan_keys.back().add_value(
879
26
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
26
            }
881
882
10
            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
10
        } // 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
9
        _begin_include = true;
927
9
        _end_include = true;
928
9
    } // 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
1
            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
1
            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
1
        }
966
1
        _begin_include = range.is_begin_include();
967
1
        _end_include = range.is_end_include();
968
1
    }
969
970
10
    return Status::OK();
971
18
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE25EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.19k
                                     bool* should_break) {
823
3.19k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.19k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.19k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.19k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
3.19k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
3.19k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.19k
    if (range.is_fixed_value_range()) {
842
319
        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.87k
    } else {
852
2.87k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.87k
            !range.is_reject_split_type()) {
854
2.77k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.77k
                                                 _end_include);
856
857
2.77k
            if (!(*eos) &&
858
2.78k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.78k
                                                 _end_include, max_scan_key_num)) {
860
2.71k
                _has_range_value = true;
861
2.71k
            }
862
2.77k
            return Status::OK();
863
2.77k
        }
864
2.87k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
411
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
320
        if (_begin_scan_keys.empty()) {
870
317
            auto fixed_value_set = range.get_fixed_value_set();
871
317
            ConstIterator iter = fixed_value_set.begin();
872
873
685
            for (; iter != fixed_value_set.end(); ++iter) {
874
368
                _begin_scan_keys.emplace_back();
875
368
                _begin_scan_keys.back().add_value(
876
368
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
368
                _end_scan_keys.emplace_back();
878
368
                _end_scan_keys.back().add_value(
879
368
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
368
            }
881
882
317
            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
317
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
3
        else {
890
3
            auto fixed_value_set = range.get_fixed_value_set();
891
3
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
5
            for (int i = 0; i < original_key_range_size; ++i) {
894
2
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
2
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
2
                ConstIterator iter = fixed_value_set.begin();
898
899
4
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
2
                    if (iter == fixed_value_set.begin()) {
902
2
                        _begin_scan_keys[i].add_value(
903
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
2
                        _end_scan_keys[i].add_value(
905
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
2
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
2
                }
916
917
2
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
2
            }
924
3
        }
925
926
320
        _begin_include = true;
927
320
        _end_include = true;
928
320
    } // Extend ScanKey with range value
929
91
    else {
930
91
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
91
        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
91
        } 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
91
        } else {
955
191
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
100
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
100
                                                      range.get_range_min_value(), range.scale()),
958
100
                                              range.contain_null());
959
100
            }
960
961
191
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
100
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
100
                        range.get_range_max_value(), range.scale()));
964
100
            }
965
91
        }
966
91
        _begin_include = range.is_begin_include();
967
91
        _end_include = range.is_end_include();
968
91
    }
969
970
411
    return Status::OK();
971
3.19k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE12EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
13
                                     bool* should_break) {
823
13
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
13
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
13
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
13
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
13
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
13
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
13
    if (range.is_fixed_value_range()) {
842
5
        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
8
    } else {
852
8
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
8
            !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
8
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
13
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
5
        if (_begin_scan_keys.empty()) {
870
5
            auto fixed_value_set = range.get_fixed_value_set();
871
5
            ConstIterator iter = fixed_value_set.begin();
872
873
18
            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
5
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
5
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
5
        _begin_include = true;
927
5
        _end_include = true;
928
5
    } // Extend ScanKey with range value
929
8
    else {
930
8
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
8
        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
8
        } else if (_begin_scan_keys.empty()) {
947
8
            _begin_scan_keys.emplace_back();
948
8
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
8
                                                      range.get_range_min_value(), range.scale()),
950
8
                                              range.contain_null());
951
8
            _end_scan_keys.emplace_back();
952
8
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
8
                    range.get_range_max_value(), range.scale()));
954
8
        } 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
8
        _begin_include = range.is_begin_include();
967
8
        _end_include = range.is_end_include();
968
8
    }
969
970
13
    return Status::OK();
971
13
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE26EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.38k
                                     bool* should_break) {
823
2.38k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.38k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.38k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.38k
    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.38k
    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.38k
    if (range.is_fixed_value_range()) {
842
72
        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.30k
    } else {
852
2.30k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.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
2.30k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.38k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
72
        if (_begin_scan_keys.empty()) {
870
70
            auto fixed_value_set = range.get_fixed_value_set();
871
70
            ConstIterator iter = fixed_value_set.begin();
872
873
144
            for (; iter != fixed_value_set.end(); ++iter) {
874
74
                _begin_scan_keys.emplace_back();
875
74
                _begin_scan_keys.back().add_value(
876
74
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
74
                _end_scan_keys.emplace_back();
878
74
                _end_scan_keys.back().add_value(
879
74
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
74
            }
881
882
70
            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
70
        } // 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
72
        _begin_include = true;
927
72
        _end_include = true;
928
72
    } // Extend ScanKey with range value
929
2.30k
    else {
930
2.30k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.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
2.31k
        } else if (_begin_scan_keys.empty()) {
947
2.31k
            _begin_scan_keys.emplace_back();
948
2.31k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.31k
                                                      range.get_range_min_value(), range.scale()),
950
2.31k
                                              range.contain_null());
951
2.31k
            _end_scan_keys.emplace_back();
952
2.31k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.31k
                    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.30k
        _begin_include = range.is_begin_include();
967
2.30k
        _end_include = range.is_end_include();
968
2.30k
    }
969
970
2.38k
    return Status::OK();
971
2.38k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.66k
                                     bool* should_break) {
823
2.66k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.66k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.66k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.66k
    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.66k
    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.66k
    if (range.is_fixed_value_range()) {
842
117
        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.55k
    } else {
852
2.55k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.55k
            !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.55k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.66k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
118
        if (_begin_scan_keys.empty()) {
870
118
            auto fixed_value_set = range.get_fixed_value_set();
871
118
            ConstIterator iter = fixed_value_set.begin();
872
873
306
            for (; iter != fixed_value_set.end(); ++iter) {
874
188
                _begin_scan_keys.emplace_back();
875
188
                _begin_scan_keys.back().add_value(
876
188
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
188
                _end_scan_keys.emplace_back();
878
188
                _end_scan_keys.back().add_value(
879
188
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
188
            }
881
882
118
            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
118
        } // 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
116
        _begin_include = true;
927
116
        _end_include = true;
928
116
    } // Extend ScanKey with range value
929
2.55k
    else {
930
2.55k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.55k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
9
            CHECK(range.contain_null());
935
9
            if (_begin_scan_keys.empty()) {
936
9
                _begin_scan_keys.emplace_back();
937
9
                _begin_scan_keys.back().add_null();
938
9
                _end_scan_keys.emplace_back();
939
9
                _end_scan_keys.back().add_null();
940
9
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
2.54k
        } else if (_begin_scan_keys.empty()) {
947
2.54k
            _begin_scan_keys.emplace_back();
948
2.54k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.54k
                                                      range.get_range_min_value(), range.scale()),
950
2.54k
                                              range.contain_null());
951
2.54k
            _end_scan_keys.emplace_back();
952
2.54k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.54k
                    range.get_range_max_value(), range.scale()));
954
2.54k
        } else {
955
3
            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
3
            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
3
        }
966
2.55k
        _begin_include = range.is_begin_include();
967
2.55k
        _end_include = range.is_end_include();
968
2.55k
    }
969
970
2.66k
    return Status::OK();
971
2.66k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
111
                                     bool* should_break) {
823
111
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
111
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
111
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
111
    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
111
    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
111
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
111
    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
110
    } else {
852
110
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
110
            !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
110
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
111
    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
110
    else {
930
110
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
110
        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
110
        } else if (_begin_scan_keys.empty()) {
947
109
            _begin_scan_keys.emplace_back();
948
109
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
109
                                                      range.get_range_min_value(), range.scale()),
950
109
                                              range.contain_null());
951
109
            _end_scan_keys.emplace_back();
952
109
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
109
                    range.get_range_max_value(), range.scale()));
954
109
        } 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
110
        _begin_include = range.is_begin_include();
967
110
        _end_include = range.is_end_include();
968
110
    }
969
970
111
    return Status::OK();
971
111
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.58k
                                     bool* should_break) {
823
1.58k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.58k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.58k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.58k
    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.58k
    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.58k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.58k
    if (range.is_fixed_value_range()) {
842
5
        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.58k
    } else {
852
1.58k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.58k
            !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.58k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.58k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
4
        if (_begin_scan_keys.empty()) {
870
4
            auto fixed_value_set = range.get_fixed_value_set();
871
4
            ConstIterator iter = fixed_value_set.begin();
872
873
10
            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
4
            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
4
        } // 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
4
        _begin_include = true;
927
4
        _end_include = true;
928
4
    } // Extend ScanKey with range value
929
1.58k
    else {
930
1.58k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.58k
        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.57k
        } else if (_begin_scan_keys.empty()) {
947
1.57k
            _begin_scan_keys.emplace_back();
948
1.57k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.57k
                                                      range.get_range_min_value(), range.scale()),
950
1.57k
                                              range.contain_null());
951
1.57k
            _end_scan_keys.emplace_back();
952
1.57k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.57k
                    range.get_range_max_value(), range.scale()));
954
1.57k
        } else {
955
31
            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
31
            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
1
        }
966
1.58k
        _begin_include = range.is_begin_include();
967
1.58k
        _end_include = range.is_end_include();
968
1.58k
    }
969
970
1.58k
    return Status::OK();
971
1.58k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
603
                                     bool* should_break) {
823
603
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
603
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
603
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
603
    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
603
    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
603
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
603
    if (range.is_fixed_value_range()) {
842
28
        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
575
    } else {
852
575
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
575
            !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
575
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
603
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
28
        if (_begin_scan_keys.empty()) {
870
26
            auto fixed_value_set = range.get_fixed_value_set();
871
26
            ConstIterator iter = fixed_value_set.begin();
872
873
67
            for (; iter != fixed_value_set.end(); ++iter) {
874
41
                _begin_scan_keys.emplace_back();
875
41
                _begin_scan_keys.back().add_value(
876
41
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
41
                _end_scan_keys.emplace_back();
878
41
                _end_scan_keys.back().add_value(
879
41
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
41
            }
881
882
26
            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
26
        } // 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
28
        _begin_include = true;
927
28
        _end_include = true;
928
28
    } // Extend ScanKey with range value
929
575
    else {
930
575
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
575
        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
575
        } else if (_begin_scan_keys.empty()) {
947
575
            _begin_scan_keys.emplace_back();
948
575
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
575
                                                      range.get_range_min_value(), range.scale()),
950
575
                                              range.contain_null());
951
575
            _end_scan_keys.emplace_back();
952
575
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
575
                    range.get_range_max_value(), range.scale()));
954
575
        } 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
575
        _begin_include = range.is_begin_include();
967
575
        _end_include = range.is_end_include();
968
575
    }
969
970
603
    return Status::OK();
971
603
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
822
                                     bool* should_break) {
823
822
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
822
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
822
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
822
    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
822
    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
822
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
822
    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
802
    } else {
852
802
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
802
            !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
802
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
822
    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
802
    else {
930
802
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
802
        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
802
        } else if (_begin_scan_keys.empty()) {
947
771
            _begin_scan_keys.emplace_back();
948
771
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
771
                                                      range.get_range_min_value(), range.scale()),
950
771
                                              range.contain_null());
951
771
            _end_scan_keys.emplace_back();
952
771
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
771
                    range.get_range_max_value(), range.scale()));
954
771
        } else {
955
77
            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
77
            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
31
        }
966
802
        _begin_include = range.is_begin_include();
967
802
        _end_include = range.is_end_include();
968
802
    }
969
970
822
    return Status::OK();
971
822
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.46k
                                     bool* should_break) {
823
1.46k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.46k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.46k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.46k
    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.46k
    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.46k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.46k
    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.45k
    } else {
852
1.45k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.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
1.45k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.46k
    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.45k
    else {
930
1.45k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.45k
        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.45k
        } else if (_begin_scan_keys.empty()) {
947
1.35k
            _begin_scan_keys.emplace_back();
948
1.35k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.35k
                                                      range.get_range_min_value(), range.scale()),
950
1.35k
                                              range.contain_null());
951
1.35k
            _end_scan_keys.emplace_back();
952
1.35k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.35k
                    range.get_range_max_value(), range.scale()));
954
1.35k
        } else {
955
210
            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
210
            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
102
        }
966
1.45k
        _begin_include = range.is_begin_include();
967
1.45k
        _end_include = range.is_end_include();
968
1.45k
    }
969
970
1.46k
    return Status::OK();
971
1.46k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
881
                                     bool* should_break) {
823
881
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
881
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
881
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
881
    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
881
    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
881
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
881
    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
865
    } else {
852
865
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
865
            !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
865
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
881
    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
865
    else {
930
865
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
865
        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
864
        } else if (_begin_scan_keys.empty()) {
947
802
            _begin_scan_keys.emplace_back();
948
802
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
802
                                                      range.get_range_min_value(), range.scale()),
950
802
                                              range.contain_null());
951
802
            _end_scan_keys.emplace_back();
952
802
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
802
                    range.get_range_max_value(), range.scale()));
954
802
        } else {
955
122
            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
122
            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
62
        }
966
865
        _begin_include = range.is_begin_include();
967
865
        _end_include = range.is_end_include();
968
865
    }
969
970
881
    return Status::OK();
971
881
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris