Coverage Report

Created: 2026-03-25 04:29

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/storage/olap_scan_common.h
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
18
#pragma once
19
20
#include <gen_cpp/Metrics_types.h>
21
#include <gen_cpp/PaloInternalService_types.h>
22
#include <glog/logging.h>
23
#include <stddef.h>
24
25
#include <boost/container/detail/std_fwd.hpp>
26
#include <boost/lexical_cast.hpp>
27
#include <cstdint>
28
#include <iterator>
29
#include <limits>
30
#include <memory>
31
#include <set>
32
#include <sstream>
33
#include <string>
34
#include <utility>
35
#include <variant>
36
#include <vector>
37
38
#include "common/compare.h"
39
#include "common/status.h"
40
#include "core/data_type/define_primitive_type.h"
41
#include "core/data_type/primitive_type.h"
42
#include "core/type_limit.h"
43
#include "core/types.h"
44
#include "core/value/ipv4_value.h"
45
#include "core/value/ipv6_value.h"
46
#include "core/value/time_value.h"
47
#include "core/value/vdatetime_value.h"
48
#include "exprs/function/cast/cast_to_string.h"
49
#include "runtime/runtime_profile.h"
50
#include "storage/olap_common.h"
51
#include "storage/olap_tuple.h"
52
#include "storage/olap_utils.h"
53
#include "storage/predicate/filter_olap_param.h"
54
#include "util/io_helper.h"
55
56
namespace doris {
57
#include "common/compile_check_begin.h"
58
59
template <PrimitiveType primitive_type, class T>
60
1.64M
std::string cast_to_string(T value, int scale) {
61
1.64M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
937
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.53k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.53k
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.73k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.73k
        return ((Decimal<int128_t>)value).to_string(scale);
67
2.73k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.33k
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
198k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
198k
        return std::to_string(static_cast<int>(value));
71
198k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
9.58k
        return int128_to_string(value);
73
9.58k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
5.48k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
5.48k
        char buf[30];
76
5.48k
        datetimev2_val.to_string(buf);
77
5.48k
        std::stringstream ss;
78
5.48k
        ss << buf;
79
5.48k
        return ss.str();
80
8.79k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
8.79k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
8.79k
        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.57k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.57k
        return CastToString::from_number(value);
91
1.41M
    } else {
92
1.41M
        return boost::lexical_cast<std::string>(value);
93
1.41M
    }
94
1.64M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
198k
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
198k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
198k
        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
198k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE4EsEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
22.4k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
22.4k
    } else {
92
22.4k
        return boost::lexical_cast<std::string>(value);
93
22.4k
    }
94
22.4k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE5EiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
156k
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
156k
    } else {
92
156k
        return boost::lexical_cast<std::string>(value);
93
156k
    }
94
156k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
179k
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
179k
    } else {
92
179k
        return boost::lexical_cast<std::string>(value);
93
179k
    }
94
179k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
9.58k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
9.58k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
9.58k
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
9.58k
}
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
973
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
973
    } else {
92
973
        return boost::lexical_cast<std::string>(value);
93
973
    }
94
973
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
777k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
777k
    } else {
92
777k
        return boost::lexical_cast<std::string>(value);
93
777k
    }
94
777k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE23ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE11ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
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
    } 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.68k
    } else {
92
1.68k
        return boost::lexical_cast<std::string>(value);
93
1.68k
    }
94
1.68k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
275k
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
275k
    } else {
92
275k
        return boost::lexical_cast<std::string>(value);
93
275k
    }
94
275k
}
_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
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
5.48k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
5.48k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
5.48k
        char buf[30];
76
5.48k
        datetimev2_val.to_string(buf);
77
5.48k
        std::stringstream ss;
78
5.48k
        ss << buf;
79
5.48k
        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
5.48k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE42ENS_16TimestampTzValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
8.79k
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
8.79k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
8.79k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
8.79k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
8.79k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE20ENS_14DecimalV2ValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
100
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
100
    } else {
92
100
        return boost::lexical_cast<std::string>(value);
93
100
    }
94
100
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.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
    } 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.57k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.57k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
3.57k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE19ENS_9StringRefEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE28ENS_7DecimalIiEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
937
std::string cast_to_string(T value, int scale) {
61
937
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
937
        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
937
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.53k
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.53k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.53k
        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.53k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
2.73k
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.73k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.73k
        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.73k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.33k
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.33k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.33k
        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.33k
}
95
96
/**
97
 * @brief Column's value range
98
 **/
99
template <PrimitiveType primitive_type>
100
class ColumnValueRange {
101
public:
102
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
103
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
104
    using SetType = std::set<CppType, doris::Less<CppType>>;
105
    using IteratorType = typename SetType::iterator;
106
107
    ColumnValueRange();
108
109
    ColumnValueRange(std::string col_name, bool is_nullable_col, int precision, int scale);
110
111
    // should add fixed value before add range
112
    Status add_fixed_value(const CppType& value);
113
114
    // should remove fixed value after add fixed value
115
    void remove_fixed_value(const CppType& value);
116
117
    Status add_range(SQLFilterOp op, CppType value);
118
119
    bool is_fixed_value_range() const;
120
121
    bool is_scope_value_range() const;
122
123
    bool is_empty_value_range() const;
124
125
    bool is_fixed_value_convertible() const;
126
127
    bool is_range_value_convertible() const;
128
129
    void convert_to_range_value();
130
131
    bool convert_to_avg_range_value(std::vector<OlapTuple>& begin_scan_keys,
132
                                    std::vector<OlapTuple>& end_scan_keys, bool& begin_include,
133
                                    bool& end_include, int32_t max_scan_key_num);
134
135
    bool convert_to_close_range(std::vector<OlapTuple>& begin_scan_keys,
136
                                std::vector<OlapTuple>& end_scan_keys, bool& begin_include,
137
                                bool& end_include);
138
139
159k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
2.31k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_reject_split_typeEv
Line
Count
Source
139
229
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_reject_split_typeEv
Line
Count
Source
139
63.0k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
86.7k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
4.54k
    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
18
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_reject_split_typeEv
Line
Count
Source
139
2.90k
    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
20.0k
    void set_empty_value_range() {
144
20.0k
        _fixed_values.clear();
145
20.0k
        _low_value = TYPE_MAX;
146
20.0k
        _high_value = TYPE_MIN;
147
20.0k
        _contain_null = false;
148
20.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
183
    void set_empty_value_range() {
144
183
        _fixed_values.clear();
145
183
        _low_value = TYPE_MAX;
146
183
        _high_value = TYPE_MIN;
147
183
        _contain_null = false;
148
183
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_empty_value_rangeEv
Line
Count
Source
143
74
    void set_empty_value_range() {
144
74
        _fixed_values.clear();
145
74
        _low_value = TYPE_MAX;
146
74
        _high_value = TYPE_MIN;
147
74
        _contain_null = false;
148
74
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_empty_value_rangeEv
Line
Count
Source
143
630
    void set_empty_value_range() {
144
630
        _fixed_values.clear();
145
630
        _low_value = TYPE_MAX;
146
630
        _high_value = TYPE_MIN;
147
630
        _contain_null = false;
148
630
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
17.7k
    void set_empty_value_range() {
144
17.7k
        _fixed_values.clear();
145
17.7k
        _low_value = TYPE_MAX;
146
17.7k
        _high_value = TYPE_MIN;
147
17.7k
        _contain_null = false;
148
17.7k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_empty_value_rangeEv
Line
Count
Source
143
15
    void set_empty_value_range() {
144
15
        _fixed_values.clear();
145
15
        _low_value = TYPE_MAX;
146
15
        _high_value = TYPE_MIN;
147
15
        _contain_null = false;
148
15
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_empty_value_rangeEv
Line
Count
Source
143
76
    void set_empty_value_range() {
144
76
        _fixed_values.clear();
145
76
        _low_value = TYPE_MAX;
146
76
        _high_value = TYPE_MIN;
147
76
        _contain_null = false;
148
76
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_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_13PrimitiveTypeE36EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_empty_value_rangeEv
Line
Count
Source
143
66
    void set_empty_value_range() {
144
66
        _fixed_values.clear();
145
66
        _low_value = TYPE_MAX;
146
66
        _high_value = TYPE_MIN;
147
66
        _contain_null = false;
148
66
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_empty_value_rangeEv
Line
Count
Source
143
384
    void set_empty_value_range() {
144
384
        _fixed_values.clear();
145
384
        _low_value = TYPE_MAX;
146
384
        _high_value = TYPE_MIN;
147
384
        _contain_null = false;
148
384
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_empty_value_rangeEv
Line
Count
Source
143
264
    void set_empty_value_range() {
144
264
        _fixed_values.clear();
145
264
        _low_value = TYPE_MAX;
146
264
        _high_value = TYPE_MIN;
147
264
        _contain_null = false;
148
264
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_empty_value_rangeEv
Line
Count
Source
143
148
    void set_empty_value_range() {
144
148
        _fixed_values.clear();
145
148
        _low_value = TYPE_MAX;
146
148
        _high_value = TYPE_MIN;
147
148
        _contain_null = false;
148
148
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_empty_value_rangeEv
Line
Count
Source
143
76
    void set_empty_value_range() {
144
76
        _fixed_values.clear();
145
76
        _low_value = TYPE_MAX;
146
76
        _high_value = TYPE_MIN;
147
76
        _contain_null = false;
148
76
    }
_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
70
    void set_empty_value_range() {
144
70
        _fixed_values.clear();
145
70
        _low_value = TYPE_MAX;
146
70
        _high_value = TYPE_MIN;
147
70
        _contain_null = false;
148
70
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_empty_value_rangeEv
Line
Count
Source
143
9
    void set_empty_value_range() {
144
9
        _fixed_values.clear();
145
9
        _low_value = TYPE_MAX;
146
9
        _high_value = TYPE_MIN;
147
9
        _contain_null = false;
148
9
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_empty_value_rangeEv
Line
Count
Source
143
136
    void set_empty_value_range() {
144
136
        _fixed_values.clear();
145
136
        _low_value = TYPE_MAX;
146
136
        _high_value = TYPE_MIN;
147
136
        _contain_null = false;
148
136
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_empty_value_rangeEv
Line
Count
Source
143
2
    void set_empty_value_range() {
144
2
        _fixed_values.clear();
145
2
        _low_value = TYPE_MAX;
146
2
        _high_value = TYPE_MIN;
147
2
        _contain_null = false;
148
2
    }
149
150
288k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_fixed_value_setEv
Line
Count
Source
150
9
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_fixed_value_setEv
Line
Count
Source
150
3
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_fixed_value_setEv
Line
Count
Source
150
2.32k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_fixed_value_setEv
Line
Count
Source
150
724
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
145
    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
284k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_fixed_value_setB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_fixed_value_setEv
Line
Count
Source
150
9
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_fixed_value_setEv
Line
Count
Source
150
370
    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
68
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_fixed_value_setEv
Line
Count
Source
150
173
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_fixed_value_setEv
Line
Count
Source
150
1
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_fixed_value_setEv
Line
Count
Source
150
7
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_fixed_value_setEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_fixed_value_setEv
Line
Count
Source
150
19
    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
18
    const SetType& get_fixed_value_set() const { return _fixed_values; }
151
152
555k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
2.38k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
632
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
129k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
174k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
9.21k
    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
867
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
211k
    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
18
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_max_valueEv
Line
Count
Source
152
3.15k
    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
5.34k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
8.28k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
98
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
3.51k
    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
886
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.48k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
2.72k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
1.28k
    CppType get_range_max_value() const { return _high_value; }
153
154
555k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.38k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
632
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
129k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
174k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
9.21k
    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
866
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
211k
    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
18
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_min_valueEv
Line
Count
Source
154
3.16k
    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
5.34k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
8.28k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
98
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
3.54k
    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
887
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.49k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
2.73k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
1.27k
    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
278k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
2.34k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
287
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
63.3k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
87.1k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
4.56k
    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
397
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
105k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16is_begin_includeEv
Line
Count
Source
168
18
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16is_begin_includeEv
Line
Count
Source
168
3.01k
    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.66k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
4.15k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
49
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
1.75k
    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
444
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
734
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.35k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
645
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
169
170
278k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14is_end_includeEv
Line
Count
Source
170
2.34k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14is_end_includeEv
Line
Count
Source
170
287
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
63.3k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
87.1k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
4.58k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE14is_end_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14is_end_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14is_end_includeEv
Line
Count
Source
170
2
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14is_end_includeEv
Line
Count
Source
170
397
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
105k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14is_end_includeEv
Line
Count
Source
170
18
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14is_end_includeEv
Line
Count
Source
170
3.00k
    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.66k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
4.15k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
49
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
1.75k
    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
444
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
737
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.35k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
645
    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
647k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
3.50k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
814
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
71.9k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12contain_nullEv
Line
Count
Source
176
152k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12contain_nullEv
Line
Count
Source
176
4.84k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
214
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
312
    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
681
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
390k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
4.69k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12contain_nullEv
Line
Count
Source
176
27
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12contain_nullEv
Line
Count
Source
176
3.86k
    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
3.02k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
4.57k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
50
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
1.97k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
523
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
1.60k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.38k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
713
    bool contain_null() const { return _contain_null; }
177
178
855k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.39k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
294
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
69.2k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
88.7k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.92k
    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
421
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20get_fixed_value_sizeEv
Line
Count
Source
178
673k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20get_fixed_value_sizeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20get_fixed_value_sizeEv
Line
Count
Source
178
34
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20get_fixed_value_sizeEv
Line
Count
Source
178
3.76k
    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.80k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.49k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
51
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.77k
    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
481
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
782
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.37k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
668
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
3.56k
    void set_whole_value_range() {
181
3.56k
        _fixed_values.clear();
182
3.56k
        _low_value = TYPE_MIN;
183
3.56k
        _high_value = TYPE_MAX;
184
3.56k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3.56k
        _high_op = FILTER_LESS_OR_EQUAL;
186
3.56k
        _contain_null = _is_nullable_col;
187
3.56k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
170
    void set_whole_value_range() {
181
170
        _fixed_values.clear();
182
170
        _low_value = TYPE_MIN;
183
170
        _high_value = TYPE_MAX;
184
170
        _low_op = FILTER_LARGER_OR_EQUAL;
185
170
        _high_op = FILTER_LESS_OR_EQUAL;
186
170
        _contain_null = _is_nullable_col;
187
170
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_whole_value_rangeEv
Line
Count
Source
180
29
    void set_whole_value_range() {
181
29
        _fixed_values.clear();
182
29
        _low_value = TYPE_MIN;
183
29
        _high_value = TYPE_MAX;
184
29
        _low_op = FILTER_LARGER_OR_EQUAL;
185
29
        _high_op = FILTER_LESS_OR_EQUAL;
186
29
        _contain_null = _is_nullable_col;
187
29
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
677
    void set_whole_value_range() {
181
677
        _fixed_values.clear();
182
677
        _low_value = TYPE_MIN;
183
677
        _high_value = TYPE_MAX;
184
677
        _low_op = FILTER_LARGER_OR_EQUAL;
185
677
        _high_op = FILTER_LESS_OR_EQUAL;
186
677
        _contain_null = _is_nullable_col;
187
677
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_whole_value_rangeEv
Line
Count
Source
180
48
    void set_whole_value_range() {
181
48
        _fixed_values.clear();
182
48
        _low_value = TYPE_MIN;
183
48
        _high_value = TYPE_MAX;
184
48
        _low_op = FILTER_LARGER_OR_EQUAL;
185
48
        _high_op = FILTER_LESS_OR_EQUAL;
186
48
        _contain_null = _is_nullable_col;
187
48
    }
_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
14
    void set_whole_value_range() {
181
14
        _fixed_values.clear();
182
14
        _low_value = TYPE_MIN;
183
14
        _high_value = TYPE_MAX;
184
14
        _low_op = FILTER_LARGER_OR_EQUAL;
185
14
        _high_op = FILTER_LESS_OR_EQUAL;
186
14
        _contain_null = _is_nullable_col;
187
14
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_whole_value_rangeEv
Line
Count
Source
180
45
    void set_whole_value_range() {
181
45
        _fixed_values.clear();
182
45
        _low_value = TYPE_MIN;
183
45
        _high_value = TYPE_MAX;
184
45
        _low_op = FILTER_LARGER_OR_EQUAL;
185
45
        _high_op = FILTER_LESS_OR_EQUAL;
186
45
        _contain_null = _is_nullable_col;
187
45
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_whole_value_rangeEv
Line
Count
Source
180
3
    void set_whole_value_range() {
181
3
        _fixed_values.clear();
182
3
        _low_value = TYPE_MIN;
183
3
        _high_value = TYPE_MAX;
184
3
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3
        _high_op = FILTER_LESS_OR_EQUAL;
186
3
        _contain_null = _is_nullable_col;
187
3
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_whole_value_rangeEv
Line
Count
Source
180
1
    void set_whole_value_range() {
181
1
        _fixed_values.clear();
182
1
        _low_value = TYPE_MIN;
183
1
        _high_value = TYPE_MAX;
184
1
        _low_op = FILTER_LARGER_OR_EQUAL;
185
1
        _high_op = FILTER_LESS_OR_EQUAL;
186
1
        _contain_null = _is_nullable_col;
187
1
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_whole_value_rangeEv
Line
Count
Source
180
13
    void set_whole_value_range() {
181
13
        _fixed_values.clear();
182
13
        _low_value = TYPE_MIN;
183
13
        _high_value = TYPE_MAX;
184
13
        _low_op = FILTER_LARGER_OR_EQUAL;
185
13
        _high_op = FILTER_LESS_OR_EQUAL;
186
13
        _contain_null = _is_nullable_col;
187
13
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_whole_value_rangeEv
Line
Count
Source
180
38
    void set_whole_value_range() {
181
38
        _fixed_values.clear();
182
38
        _low_value = TYPE_MIN;
183
38
        _high_value = TYPE_MAX;
184
38
        _low_op = FILTER_LARGER_OR_EQUAL;
185
38
        _high_op = FILTER_LESS_OR_EQUAL;
186
38
        _contain_null = _is_nullable_col;
187
38
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_whole_value_rangeEv
Line
Count
Source
180
2.05k
    void set_whole_value_range() {
181
2.05k
        _fixed_values.clear();
182
2.05k
        _low_value = TYPE_MIN;
183
2.05k
        _high_value = TYPE_MAX;
184
2.05k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
2.05k
        _high_op = FILTER_LESS_OR_EQUAL;
186
2.05k
        _contain_null = _is_nullable_col;
187
2.05k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
32
    void set_whole_value_range() {
181
32
        _fixed_values.clear();
182
32
        _low_value = TYPE_MIN;
183
32
        _high_value = TYPE_MAX;
184
32
        _low_op = FILTER_LARGER_OR_EQUAL;
185
32
        _high_op = FILTER_LESS_OR_EQUAL;
186
32
        _contain_null = _is_nullable_col;
187
32
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_whole_value_rangeEv
Line
Count
Source
180
49
    void set_whole_value_range() {
181
49
        _fixed_values.clear();
182
49
        _low_value = TYPE_MIN;
183
49
        _high_value = TYPE_MAX;
184
49
        _low_op = FILTER_LARGER_OR_EQUAL;
185
49
        _high_op = FILTER_LESS_OR_EQUAL;
186
49
        _contain_null = _is_nullable_col;
187
49
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
68
    void set_whole_value_range() {
181
68
        _fixed_values.clear();
182
68
        _low_value = TYPE_MIN;
183
68
        _high_value = TYPE_MAX;
184
68
        _low_op = FILTER_LARGER_OR_EQUAL;
185
68
        _high_op = FILTER_LESS_OR_EQUAL;
186
68
        _contain_null = _is_nullable_col;
187
68
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_whole_value_rangeEv
Line
Count
Source
180
10
    void set_whole_value_range() {
181
10
        _fixed_values.clear();
182
10
        _low_value = TYPE_MIN;
183
10
        _high_value = TYPE_MAX;
184
10
        _low_op = FILTER_LARGER_OR_EQUAL;
185
10
        _high_op = FILTER_LESS_OR_EQUAL;
186
10
        _contain_null = _is_nullable_col;
187
10
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_whole_value_rangeEv
Line
Count
Source
180
20
    void set_whole_value_range() {
181
20
        _fixed_values.clear();
182
20
        _low_value = TYPE_MIN;
183
20
        _high_value = TYPE_MAX;
184
20
        _low_op = FILTER_LARGER_OR_EQUAL;
185
20
        _high_op = FILTER_LESS_OR_EQUAL;
186
20
        _contain_null = _is_nullable_col;
187
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_whole_value_rangeEv
Line
Count
Source
180
258
    void set_whole_value_range() {
181
258
        _fixed_values.clear();
182
258
        _low_value = TYPE_MIN;
183
258
        _high_value = TYPE_MAX;
184
258
        _low_op = FILTER_LARGER_OR_EQUAL;
185
258
        _high_op = FILTER_LESS_OR_EQUAL;
186
258
        _contain_null = _is_nullable_col;
187
258
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_whole_value_rangeEv
Line
Count
Source
180
8
    void set_whole_value_range() {
181
8
        _fixed_values.clear();
182
8
        _low_value = TYPE_MIN;
183
8
        _high_value = TYPE_MAX;
184
8
        _low_op = FILTER_LARGER_OR_EQUAL;
185
8
        _high_op = FILTER_LESS_OR_EQUAL;
186
8
        _contain_null = _is_nullable_col;
187
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_whole_value_rangeEv
Line
Count
Source
180
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
    }
188
189
1.91k
    bool is_whole_value_range() const {
190
18.4E
        DCHECK(_is_nullable_col || !contain_null())
191
18.4E
                << "Non-nullable column cannot contains null value";
192
193
1.91k
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
1.91k
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
1.91k
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
1.91k
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_whole_value_rangeEv
Line
Count
Source
189
58
    bool is_whole_value_range() const {
190
18.4E
        DCHECK(_is_nullable_col || !contain_null())
191
18.4E
                << "Non-nullable column cannot contains null value";
192
193
60
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
58
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
58
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
58
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_whole_value_rangeEv
Line
Count
Source
189
66
    bool is_whole_value_range() const {
190
66
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
66
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
66
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
66
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
66
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_whole_value_rangeEv
Line
Count
Source
189
423
    bool is_whole_value_range() const {
190
423
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
423
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
423
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
423
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
423
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_whole_value_rangeEv
Line
Count
Source
189
68
    bool is_whole_value_range() const {
190
68
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
68
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
68
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
68
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
68
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_whole_value_rangeEv
Line
Count
Source
189
14
    bool is_whole_value_range() const {
190
14
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
14
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
14
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
14
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
14
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_whole_value_rangeEv
Line
Count
Source
189
74
    bool is_whole_value_range() const {
190
74
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
74
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
74
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
74
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
74
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_whole_value_rangeEv
Line
Count
Source
189
84
    bool is_whole_value_range() const {
190
84
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
84
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
84
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
84
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
84
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_whole_value_rangeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_whole_value_rangeEv
Line
Count
Source
189
68
    bool is_whole_value_range() const {
190
68
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
68
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
68
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
68
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
68
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_whole_value_rangeEv
Line
Count
Source
189
366
    bool is_whole_value_range() const {
190
366
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
366
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
366
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
366
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
366
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_whole_value_rangeEv
Line
Count
Source
189
258
    bool is_whole_value_range() const {
190
18.4E
        DCHECK(_is_nullable_col || !contain_null())
191
18.4E
                << "Non-nullable column cannot contains null value";
192
193
261
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
258
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
258
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
258
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
127
    bool is_whole_value_range() const {
190
127
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
127
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
127
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
127
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
127
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_whole_value_rangeEv
Line
Count
Source
189
76
    bool is_whole_value_range() const {
190
76
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
76
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
76
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
76
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
76
    }
_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
68
    bool is_whole_value_range() const {
190
68
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
68
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
68
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
68
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
68
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_whole_value_rangeEv
Line
Count
Source
189
8
    bool is_whole_value_range() const {
190
8
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
8
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
8
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
8
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
8
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_whole_value_rangeEv
Line
Count
Source
189
136
    bool is_whole_value_range() const {
190
136
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
136
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
136
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
136
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
136
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_whole_value_rangeEv
Line
Count
Source
189
2
    bool is_whole_value_range() const {
190
2
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
2
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
2
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
2
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
2
    }
197
198
    // only two case will set range contain null, call by temp_range in olap scan node
199
    // 'is null' and 'is not null'
200
    // 1. if the pred is 'is null' means the range should be
201
    // empty in fixed_range and _high_value < _low_value
202
    // 2. if the pred is 'is not null' means the range should be whole range and
203
    // 'is not null' be effective
204
5.50k
    void set_contain_null(bool contain_null) {
205
5.50k
        if (contain_null) {
206
1.93k
            set_empty_value_range();
207
3.56k
        } else {
208
3.56k
            set_whole_value_range();
209
3.56k
        }
210
5.50k
        _contain_null = _is_nullable_col && contain_null;
211
5.50k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
232
    void set_contain_null(bool contain_null) {
205
232
        if (contain_null) {
206
60
            set_empty_value_range();
207
172
        } else {
208
172
            set_whole_value_range();
209
172
        }
210
232
        _contain_null = _is_nullable_col && contain_null;
211
232
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
95
    void set_contain_null(bool contain_null) {
205
95
        if (contain_null) {
206
66
            set_empty_value_range();
207
66
        } else {
208
29
            set_whole_value_range();
209
29
        }
210
95
        _contain_null = _is_nullable_col && contain_null;
211
95
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
1.10k
    void set_contain_null(bool contain_null) {
205
1.10k
        if (contain_null) {
206
431
            set_empty_value_range();
207
673
        } else {
208
673
            set_whole_value_range();
209
673
        }
210
1.10k
        _contain_null = _is_nullable_col && contain_null;
211
1.10k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
117
    void set_contain_null(bool contain_null) {
205
117
        if (contain_null) {
206
69
            set_empty_value_range();
207
69
        } else {
208
48
            set_whole_value_range();
209
48
        }
210
117
        _contain_null = _is_nullable_col && contain_null;
211
117
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16set_contain_nullEb
Line
Count
Source
204
17
    void set_contain_null(bool contain_null) {
205
17
        if (contain_null) {
206
14
            set_empty_value_range();
207
14
        } else {
208
3
            set_whole_value_range();
209
3
        }
210
17
        _contain_null = _is_nullable_col && contain_null;
211
17
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE16set_contain_nullEb
Line
Count
Source
204
90
    void set_contain_null(bool contain_null) {
205
90
        if (contain_null) {
206
76
            set_empty_value_range();
207
76
        } else {
208
14
            set_whole_value_range();
209
14
        }
210
90
        _contain_null = _is_nullable_col && contain_null;
211
90
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
130
    void set_contain_null(bool contain_null) {
205
130
        if (contain_null) {
206
85
            set_empty_value_range();
207
85
        } else {
208
45
            set_whole_value_range();
209
45
        }
210
130
        _contain_null = _is_nullable_col && contain_null;
211
130
    }
_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
79
    void set_contain_null(bool contain_null) {
205
79
        if (contain_null) {
206
66
            set_empty_value_range();
207
66
        } else {
208
13
            set_whole_value_range();
209
13
        }
210
79
        _contain_null = _is_nullable_col && contain_null;
211
79
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16set_contain_nullEb
Line
Count
Source
204
403
    void set_contain_null(bool contain_null) {
205
403
        if (contain_null) {
206
366
            set_empty_value_range();
207
366
        } else {
208
37
            set_whole_value_range();
209
37
        }
210
403
        _contain_null = _is_nullable_col && contain_null;
211
403
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
2.32k
    void set_contain_null(bool contain_null) {
205
2.32k
        if (contain_null) {
206
264
            set_empty_value_range();
207
2.06k
        } else {
208
2.06k
            set_whole_value_range();
209
2.06k
        }
210
2.32k
        _contain_null = _is_nullable_col && contain_null;
211
2.32k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
161
    void set_contain_null(bool contain_null) {
205
161
        if (contain_null) {
206
128
            set_empty_value_range();
207
128
        } else {
208
33
            set_whole_value_range();
209
33
        }
210
161
        _contain_null = _is_nullable_col && contain_null;
211
161
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
125
    void set_contain_null(bool contain_null) {
205
125
        if (contain_null) {
206
76
            set_empty_value_range();
207
76
        } else {
208
49
            set_whole_value_range();
209
49
        }
210
125
        _contain_null = _is_nullable_col && contain_null;
211
125
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
85
    void set_contain_null(bool contain_null) {
205
85
        if (contain_null) {
206
18
            set_empty_value_range();
207
67
        } else {
208
67
            set_whole_value_range();
209
67
        }
210
85
        _contain_null = _is_nullable_col && contain_null;
211
85
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16set_contain_nullEb
Line
Count
Source
204
80
    void set_contain_null(bool contain_null) {
205
80
        if (contain_null) {
206
70
            set_empty_value_range();
207
70
        } else {
208
10
            set_whole_value_range();
209
10
        }
210
80
        _contain_null = _is_nullable_col && contain_null;
211
80
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16set_contain_nullEb
Line
Count
Source
204
28
    void set_contain_null(bool contain_null) {
205
28
        if (contain_null) {
206
8
            set_empty_value_range();
207
20
        } else {
208
20
            set_whole_value_range();
209
20
        }
210
28
        _contain_null = _is_nullable_col && contain_null;
211
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16set_contain_nullEb
Line
Count
Source
204
392
    void set_contain_null(bool contain_null) {
205
392
        if (contain_null) {
206
136
            set_empty_value_range();
207
256
        } else {
208
256
            set_whole_value_range();
209
256
        }
210
392
        _contain_null = _is_nullable_col && contain_null;
211
392
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16set_contain_nullEb
Line
Count
Source
204
8
    void set_contain_null(bool contain_null) {
205
8
        if (contain_null) {
206
0
            set_empty_value_range();
207
8
        } else {
208
8
            set_whole_value_range();
209
8
        }
210
8
        _contain_null = _is_nullable_col && contain_null;
211
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16set_contain_nullEb
Line
Count
Source
204
25
    void set_contain_null(bool contain_null) {
205
25
        if (contain_null) {
206
2
            set_empty_value_range();
207
23
        } else {
208
23
            set_whole_value_range();
209
23
        }
210
25
        _contain_null = _is_nullable_col && contain_null;
211
25
    }
212
213
553k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
125k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
1.64k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
18.0k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
69.0k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
393
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
298
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
655
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
46
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
45
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.15k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9precisionEv
Line
Count
Source
213
295k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9precisionEv
Line
Count
Source
213
4.08k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9precisionEv
Line
Count
Source
213
57
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
30.1k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
48
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
4.21k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
1.40k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
334
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
244
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
1.02k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
286
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
365
    int precision() const { return _precision; }
214
215
2.20M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
324k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
24.2k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
176k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
249k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
10.0k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
298
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
655
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
46
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
48
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.12k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE5scaleEv
Line
Count
Source
215
1.07M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE5scaleEv
Line
Count
Source
215
4.08k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
1.80k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
305k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
90
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
9.70k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
10.2k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
101
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
3.91k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.18k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
2.56k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
3.03k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
1.70k
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
468k
                                      const CppType& value) {
219
468k
        static_cast<void>(range.add_fixed_value(value));
220
468k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
121k
                                      const CppType& value) {
219
121k
        static_cast<void>(range.add_fixed_value(value));
220
121k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
118
                                      const CppType& value) {
219
118
        static_cast<void>(range.add_fixed_value(value));
220
118
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
36.8k
                                      const CppType& value) {
219
36.8k
        static_cast<void>(range.add_fixed_value(value));
220
36.8k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
2.04k
                                      const CppType& value) {
219
2.04k
        static_cast<void>(range.add_fixed_value(value));
220
2.04k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
221
                                      const CppType& value) {
219
221
        static_cast<void>(range.add_fixed_value(value));
220
221
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
59
                                      const CppType& value) {
219
59
        static_cast<void>(range.add_fixed_value(value));
220
59
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
166
                                      const CppType& value) {
219
166
        static_cast<void>(range.add_fixed_value(value));
220
166
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
218
35
                                      const CppType& value) {
219
35
        static_cast<void>(range.add_fixed_value(value));
220
35
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
218
36
                                      const CppType& value) {
219
36
        static_cast<void>(range.add_fixed_value(value));
220
36
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
528
                                      const CppType& value) {
219
528
        static_cast<void>(range.add_fixed_value(value));
220
528
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
293k
                                      const CppType& value) {
219
293k
        static_cast<void>(range.add_fixed_value(value));
220
293k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
1.47k
                                      const CppType& value) {
219
1.47k
        static_cast<void>(range.add_fixed_value(value));
220
1.47k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
71
                                      const CppType& value) {
219
71
        static_cast<void>(range.add_fixed_value(value));
220
71
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
9.73k
                                      const CppType& value) {
219
9.73k
        static_cast<void>(range.add_fixed_value(value));
220
9.73k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
57
                                      const CppType& value) {
219
57
        static_cast<void>(range.add_fixed_value(value));
220
57
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
625
                                      const CppType& value) {
219
625
        static_cast<void>(range.add_fixed_value(value));
220
625
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
206
                                      const CppType& value) {
219
206
        static_cast<void>(range.add_fixed_value(value));
220
206
    }
_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
241
                                      const CppType& value) {
219
241
        static_cast<void>(range.add_fixed_value(value));
220
241
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
218
50
                                      const CppType& value) {
219
50
        static_cast<void>(range.add_fixed_value(value));
220
50
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
218
312
                                      const CppType& value) {
219
312
        static_cast<void>(range.add_fixed_value(value));
220
312
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
137
                                      const CppType& value) {
219
137
        static_cast<void>(range.add_fixed_value(value));
220
137
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
93
                                      const CppType& value) {
219
93
        static_cast<void>(range.add_fixed_value(value));
220
93
    }
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.91k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
55
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
47
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
881
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14empty_functionERS2_NS_11SQLFilterOpERKl
Line
Count
Source
228
33
                               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
65
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
154
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14empty_functionERS2_NS_11SQLFilterOpERKj
Line
Count
Source
228
10
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14empty_functionERS2_NS_11SQLFilterOpERKo
Line
Count
Source
228
10
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
129
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
404
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
243
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
47
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
29
                               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
52
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
547
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
10
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
46
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
228
4
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14empty_functionERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
228
18
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
94
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
93.0k
                                const CppType& value) {
232
93.0k
        static_cast<void>(range.add_range(op, value));
233
93.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
2.22k
                                const CppType& value) {
232
2.22k
        static_cast<void>(range.add_range(op, value));
233
2.22k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.42k
                                const CppType& value) {
232
1.42k
        static_cast<void>(range.add_range(op, value));
233
1.42k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
10.1k
                                const CppType& value) {
232
10.1k
        static_cast<void>(range.add_range(op, value));
233
10.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
49.9k
                                const CppType& value) {
232
49.9k
        static_cast<void>(range.add_range(op, value));
233
49.9k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
186
                                const CppType& value) {
232
186
        static_cast<void>(range.add_range(op, value));
233
186
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
131
                                const CppType& value) {
232
131
        static_cast<void>(range.add_range(op, value));
233
131
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
338
                                const CppType& value) {
232
338
        static_cast<void>(range.add_range(op, value));
233
338
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
12
                                const CppType& value) {
232
12
        static_cast<void>(range.add_range(op, value));
233
12
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
11
                                const CppType& value) {
232
11
        static_cast<void>(range.add_range(op, value));
233
11
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
615
                                const CppType& value) {
232
615
        static_cast<void>(range.add_range(op, value));
233
615
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.62k
                                const CppType& value) {
232
1.62k
        static_cast<void>(range.add_range(op, value));
233
1.62k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
399
                                const CppType& value) {
232
399
        static_cast<void>(range.add_range(op, value));
233
399
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
20.6k
                                const CppType& value) {
232
20.6k
        static_cast<void>(range.add_range(op, value));
233
20.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
231
6
                                const CppType& value) {
232
6
        static_cast<void>(range.add_range(op, value));
233
6
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
3.51k
                                const CppType& value) {
232
3.51k
        static_cast<void>(range.add_range(op, value));
233
3.51k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
835
                                const CppType& value) {
232
835
        static_cast<void>(range.add_range(op, value));
233
835
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
231
56
                                const CppType& value) {
232
56
        static_cast<void>(range.add_range(op, value));
233
56
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
127
                                const CppType& value) {
232
127
        static_cast<void>(range.add_range(op, value));
233
127
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
450
                                const CppType& value) {
232
450
        static_cast<void>(range.add_range(op, value));
233
450
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
231
132
                                const CppType& value) {
232
132
        static_cast<void>(range.add_range(op, value));
233
132
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
231
184
                                const CppType& value) {
232
184
        static_cast<void>(range.add_range(op, value));
233
184
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
552k
                                                                            int scale) {
238
552k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
552k
                                                precision, scale);
240
552k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
124k
                                                                            int scale) {
238
124k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
124k
                                                precision, scale);
240
124k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.63k
                                                                            int scale) {
238
1.63k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.63k
                                                precision, scale);
240
1.63k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
17.9k
                                                                            int scale) {
238
17.9k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
17.9k
                                                precision, scale);
240
17.9k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
68.9k
                                                                            int scale) {
238
68.9k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
68.9k
                                                precision, scale);
240
68.9k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
389
                                                                            int scale) {
238
389
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
389
                                                precision, scale);
240
389
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
291
                                                                            int scale) {
238
291
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
291
                                                precision, scale);
240
291
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
655
                                                                            int scale) {
238
655
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
655
                                                precision, scale);
240
655
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
46
                                                                            int scale) {
238
46
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
46
                                                precision, scale);
240
46
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
43
                                                                            int scale) {
238
43
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
43
                                                precision, scale);
240
43
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.13k
                                                                            int scale) {
238
1.13k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.13k
                                                precision, scale);
240
1.13k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
294k
                                                                            int scale) {
238
294k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
294k
                                                precision, scale);
240
294k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.04k
                                                                            int scale) {
238
4.04k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.04k
                                                precision, scale);
240
4.04k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
57
                                                                            int scale) {
238
57
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
57
                                                precision, scale);
240
57
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
29.9k
                                                                            int scale) {
238
29.9k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
29.9k
                                                precision, scale);
240
29.9k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
47
                                                                            int scale) {
238
47
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
47
                                                precision, scale);
240
47
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.19k
                                                                            int scale) {
238
4.19k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.19k
                                                precision, scale);
240
4.19k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.38k
                                                                            int scale) {
238
1.38k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.38k
                                                precision, scale);
240
1.38k
    }
_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
334
                                                                            int scale) {
238
334
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
334
                                                precision, scale);
240
334
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
237
                                                                            int scale) {
238
237
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
237
                                                precision, scale);
240
237
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.00k
                                                                            int scale) {
238
1.00k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.00k
                                                precision, scale);
240
1.00k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
285
                                                                            int scale) {
238
285
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
285
                                                precision, scale);
240
285
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
365
                                                                            int scale) {
238
365
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
365
                                                precision, scale);
240
365
    }
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
839k
    bool has_range_value() const { return _has_range_value; }
302
303
0
    void clear() {
304
0
        _has_range_value = false;
305
0
        _begin_scan_keys.clear();
306
0
        _end_scan_keys.clear();
307
0
    }
308
309
1.66k
    std::string debug_string() {
310
1.66k
        std::stringstream ss;
311
1.66k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
1.66k
        ss << "ScanKeys:";
313
314
13.6k
        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
11.9k
        }
318
1.66k
        return ss.str();
319
1.66k
    }
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
331k
    void set_is_convertible(bool is_convertible) { _is_convertible = is_convertible; }
327
328
private:
329
    std::vector<OlapTuple> _begin_scan_keys;
330
    std::vector<OlapTuple> _end_scan_keys;
331
    bool _has_range_value = false;
332
    bool _begin_include = false;
333
    bool _end_include = false;
334
    bool _is_convertible = false;
335
};
336
337
using ColumnValueRangeType = std::variant<
338
        ColumnValueRange<TYPE_TINYINT>, ColumnValueRange<TYPE_SMALLINT>, ColumnValueRange<TYPE_INT>,
339
        ColumnValueRange<TYPE_BIGINT>, ColumnValueRange<TYPE_LARGEINT>,
340
        ColumnValueRange<TYPE_FLOAT>, ColumnValueRange<TYPE_DOUBLE>, ColumnValueRange<TYPE_IPV4>,
341
        ColumnValueRange<TYPE_IPV6>, ColumnValueRange<TYPE_CHAR>, ColumnValueRange<TYPE_VARCHAR>,
342
        ColumnValueRange<TYPE_STRING>, ColumnValueRange<TYPE_DATE>, ColumnValueRange<TYPE_DATEV2>,
343
        ColumnValueRange<TYPE_DATETIME>, ColumnValueRange<TYPE_DATETIMEV2>,
344
        ColumnValueRange<TYPE_TIMESTAMPTZ>, ColumnValueRange<TYPE_DECIMALV2>,
345
        ColumnValueRange<TYPE_BOOLEAN>, ColumnValueRange<TYPE_HLL>,
346
        ColumnValueRange<TYPE_DECIMAL32>, ColumnValueRange<TYPE_DECIMAL64>,
347
        ColumnValueRange<TYPE_DECIMAL128I>, ColumnValueRange<TYPE_DECIMAL256>>;
348
349
template <PrimitiveType primitive_type>
350
const typename ColumnValueRange<primitive_type>::CppType
351
        ColumnValueRange<primitive_type>::TYPE_MIN =
352
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::min();
353
template <PrimitiveType primitive_type>
354
const typename ColumnValueRange<primitive_type>::CppType
355
        ColumnValueRange<primitive_type>::TYPE_MAX =
356
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::max();
357
358
template <PrimitiveType primitive_type>
359
ColumnValueRange<primitive_type>::ColumnValueRange()
360
2.41M
        : _column_type(INVALID_TYPE), _precision(-1), _scale(-1) {}
361
362
template <PrimitiveType primitive_type>
363
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, const CppType& min,
364
                                                   const CppType& max, bool contain_null)
365
        : _column_name(std::move(col_name)),
366
          _column_type(primitive_type),
367
          _low_value(min),
368
          _high_value(max),
369
          _low_op(FILTER_LARGER_OR_EQUAL),
370
          _high_op(FILTER_LESS_OR_EQUAL),
371
          _is_nullable_col(true),
372
          _contain_null(contain_null),
373
          _precision(-1),
374
          _scale(-1) {}
375
376
template <PrimitiveType primitive_type>
377
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, const CppType& min,
378
                                                   const CppType& max, bool is_nullable_col,
379
                                                   bool contain_null, int precision, int scale)
380
2.97M
        : _column_name(std::move(col_name)),
381
2.97M
          _column_type(primitive_type),
382
1.75M
          _low_value(min),
383
1.75M
          _high_value(max),
384
2.97M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.97M
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.97M
          _is_nullable_col(is_nullable_col),
387
2.97M
          _contain_null(is_nullable_col && contain_null),
388
2.97M
          _precision(precision),
389
2.97M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKaSA_bbii
Line
Count
Source
380
269k
        : _column_name(std::move(col_name)),
381
269k
          _column_type(primitive_type),
382
269k
          _low_value(min),
383
269k
          _high_value(max),
384
269k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
269k
          _high_op(FILTER_LESS_OR_EQUAL),
386
269k
          _is_nullable_col(is_nullable_col),
387
269k
          _contain_null(is_nullable_col && contain_null),
388
269k
          _precision(precision),
389
269k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
20.9k
        : _column_name(std::move(col_name)),
381
20.9k
          _column_type(primitive_type),
382
20.9k
          _low_value(min),
383
20.9k
          _high_value(max),
384
20.9k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
20.9k
          _high_op(FILTER_LESS_OR_EQUAL),
386
20.9k
          _is_nullable_col(is_nullable_col),
387
20.9k
          _contain_null(is_nullable_col && contain_null),
388
20.9k
          _precision(precision),
389
20.9k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
267k
        : _column_name(std::move(col_name)),
381
267k
          _column_type(primitive_type),
382
267k
          _low_value(min),
383
267k
          _high_value(max),
384
267k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
267k
          _high_op(FILTER_LESS_OR_EQUAL),
386
267k
          _is_nullable_col(is_nullable_col),
387
267k
          _contain_null(is_nullable_col && contain_null),
388
267k
          _precision(precision),
389
267k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
605k
        : _column_name(std::move(col_name)),
381
605k
          _column_type(primitive_type),
382
605k
          _low_value(min),
383
605k
          _high_value(max),
384
605k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
605k
          _high_op(FILTER_LESS_OR_EQUAL),
386
605k
          _is_nullable_col(is_nullable_col),
387
605k
          _contain_null(is_nullable_col && contain_null),
388
605k
          _precision(precision),
389
605k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_bbii
Line
Count
Source
380
12.6k
        : _column_name(std::move(col_name)),
381
12.6k
          _column_type(primitive_type),
382
12.6k
          _low_value(min),
383
12.6k
          _high_value(max),
384
12.6k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.6k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.6k
          _is_nullable_col(is_nullable_col),
387
12.6k
          _contain_null(is_nullable_col && contain_null),
388
12.6k
          _precision(precision),
389
12.6k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
12.4k
        : _column_name(std::move(col_name)),
381
12.4k
          _column_type(primitive_type),
382
12.4k
          _low_value(min),
383
12.4k
          _high_value(max),
384
12.4k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.4k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.4k
          _is_nullable_col(is_nullable_col),
387
12.4k
          _contain_null(is_nullable_col && contain_null),
388
12.4k
          _precision(precision),
389
12.4k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
17.9k
        : _column_name(std::move(col_name)),
381
17.9k
          _column_type(primitive_type),
382
17.9k
          _low_value(min),
383
17.9k
          _high_value(max),
384
17.9k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
17.9k
          _high_op(FILTER_LESS_OR_EQUAL),
386
17.9k
          _is_nullable_col(is_nullable_col),
387
17.9k
          _contain_null(is_nullable_col && contain_null),
388
17.9k
          _precision(precision),
389
17.9k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
504
        : _column_name(std::move(col_name)),
381
504
          _column_type(primitive_type),
382
504
          _low_value(min),
383
504
          _high_value(max),
384
504
          _low_op(FILTER_LARGER_OR_EQUAL),
385
504
          _high_op(FILTER_LESS_OR_EQUAL),
386
504
          _is_nullable_col(is_nullable_col),
387
504
          _contain_null(is_nullable_col && contain_null),
388
504
          _precision(precision),
389
504
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
574
        : _column_name(std::move(col_name)),
381
574
          _column_type(primitive_type),
382
574
          _low_value(min),
383
574
          _high_value(max),
384
574
          _low_op(FILTER_LARGER_OR_EQUAL),
385
574
          _high_op(FILTER_LESS_OR_EQUAL),
386
574
          _is_nullable_col(is_nullable_col),
387
574
          _contain_null(is_nullable_col && contain_null),
388
574
          _precision(precision),
389
574
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
19.5k
        : _column_name(std::move(col_name)),
381
19.5k
          _column_type(primitive_type),
382
19.5k
          _low_value(min),
383
19.5k
          _high_value(max),
384
19.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
19.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
19.5k
          _is_nullable_col(is_nullable_col),
387
19.5k
          _contain_null(is_nullable_col && contain_null),
388
19.5k
          _precision(precision),
389
19.5k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
1.23M
        : _column_name(std::move(col_name)),
381
1.23M
          _column_type(primitive_type),
382
1.23M
          _low_value(min),
383
1.23M
          _high_value(max),
384
1.23M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.23M
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.23M
          _is_nullable_col(is_nullable_col),
387
1.23M
          _contain_null(is_nullable_col && contain_null),
388
1.23M
          _precision(precision),
389
1.23M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
161k
        : _column_name(std::move(col_name)),
381
161k
          _column_type(primitive_type),
382
161k
          _low_value(min),
383
161k
          _high_value(max),
384
161k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
161k
          _high_op(FILTER_LESS_OR_EQUAL),
386
161k
          _is_nullable_col(is_nullable_col),
387
161k
          _contain_null(is_nullable_col && contain_null),
388
161k
          _precision(precision),
389
161k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
513
        : _column_name(std::move(col_name)),
381
513
          _column_type(primitive_type),
382
513
          _low_value(min),
383
513
          _high_value(max),
384
513
          _low_op(FILTER_LARGER_OR_EQUAL),
385
513
          _high_op(FILTER_LESS_OR_EQUAL),
386
513
          _is_nullable_col(is_nullable_col),
387
513
          _contain_null(is_nullable_col && contain_null),
388
513
          _precision(precision),
389
513
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_15DateV2ValueTypeEEESD_bbii
Line
Count
Source
380
128k
        : _column_name(std::move(col_name)),
381
128k
          _column_type(primitive_type),
382
128k
          _low_value(min),
383
128k
          _high_value(max),
384
128k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
128k
          _high_op(FILTER_LESS_OR_EQUAL),
386
128k
          _is_nullable_col(is_nullable_col),
387
128k
          _contain_null(is_nullable_col && contain_null),
388
128k
          _precision(precision),
389
128k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
471
        : _column_name(std::move(col_name)),
381
471
          _column_type(primitive_type),
382
471
          _low_value(min),
383
471
          _high_value(max),
384
471
          _low_op(FILTER_LARGER_OR_EQUAL),
385
471
          _high_op(FILTER_LESS_OR_EQUAL),
386
471
          _is_nullable_col(is_nullable_col),
387
471
          _contain_null(is_nullable_col && contain_null),
388
471
          _precision(precision),
389
471
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
135k
        : _column_name(std::move(col_name)),
381
135k
          _column_type(primitive_type),
382
135k
          _low_value(min),
383
135k
          _high_value(max),
384
135k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
135k
          _high_op(FILTER_LESS_OR_EQUAL),
386
135k
          _is_nullable_col(is_nullable_col),
387
135k
          _contain_null(is_nullable_col && contain_null),
388
135k
          _precision(precision),
389
135k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
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_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
701
        : _column_name(std::move(col_name)),
381
701
          _column_type(primitive_type),
382
701
          _low_value(min),
383
701
          _high_value(max),
384
701
          _low_op(FILTER_LARGER_OR_EQUAL),
385
701
          _high_op(FILTER_LESS_OR_EQUAL),
386
701
          _is_nullable_col(is_nullable_col),
387
701
          _contain_null(is_nullable_col && contain_null),
388
701
          _precision(precision),
389
701
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
11.6k
        : _column_name(std::move(col_name)),
381
11.6k
          _column_type(primitive_type),
382
11.6k
          _low_value(min),
383
11.6k
          _high_value(max),
384
11.6k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.6k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.6k
          _is_nullable_col(is_nullable_col),
387
11.6k
          _contain_null(is_nullable_col && contain_null),
388
11.6k
          _precision(precision),
389
11.6k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
603
        : _column_name(std::move(col_name)),
381
603
          _column_type(primitive_type),
382
603
          _low_value(min),
383
603
          _high_value(max),
384
603
          _low_op(FILTER_LARGER_OR_EQUAL),
385
603
          _high_op(FILTER_LESS_OR_EQUAL),
386
603
          _is_nullable_col(is_nullable_col),
387
603
          _contain_null(is_nullable_col && contain_null),
388
603
          _precision(precision),
389
603
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
12.6k
        : _column_name(std::move(col_name)),
381
12.6k
          _column_type(primitive_type),
382
12.6k
          _low_value(min),
383
12.6k
          _high_value(max),
384
12.6k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.6k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.6k
          _is_nullable_col(is_nullable_col),
387
12.6k
          _contain_null(is_nullable_col && contain_null),
388
12.6k
          _precision(precision),
389
12.6k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
29.8k
        : _column_name(std::move(col_name)),
381
29.8k
          _column_type(primitive_type),
382
29.8k
          _low_value(min),
383
29.8k
          _high_value(max),
384
29.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
29.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
29.8k
          _is_nullable_col(is_nullable_col),
387
29.8k
          _contain_null(is_nullable_col && contain_null),
388
29.8k
          _precision(precision),
389
29.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
13.6k
        : _column_name(std::move(col_name)),
381
13.6k
          _column_type(primitive_type),
382
13.6k
          _low_value(min),
383
13.6k
          _high_value(max),
384
13.6k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.6k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.6k
          _is_nullable_col(is_nullable_col),
387
13.6k
          _contain_null(is_nullable_col && contain_null),
388
13.6k
          _precision(precision),
389
13.6k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
2.31k
        : _column_name(std::move(col_name)),
381
2.31k
          _column_type(primitive_type),
382
2.31k
          _low_value(min),
383
2.31k
          _high_value(max),
384
2.31k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.31k
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.31k
          _is_nullable_col(is_nullable_col),
387
2.31k
          _contain_null(is_nullable_col && contain_null),
388
2.31k
          _precision(precision),
389
2.31k
          _scale(scale) {}
390
391
template <PrimitiveType primitive_type>
392
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, bool is_nullable_col,
393
                                                   int precision, int scale)
394
2.41M
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
2.41M
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
144k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
144k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
19.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
19.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
248k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
248k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
535k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
535k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.0k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.0k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
17.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
17.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
18.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
18.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
455
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
455
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
423
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
423
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
98.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
98.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
130k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
130k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
8.59k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
8.59k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
942k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
942k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
156k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
156k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
598
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
598
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
28.6k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
28.6k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
13.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
13.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
1.94k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.94k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
676
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
676
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
455
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
455
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
528
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
528
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
480k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
480k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
480k
    _fixed_values.insert(value);
404
480k
    _contain_null = false;
405
406
480k
    _high_value = TYPE_MIN;
407
480k
    _low_value = TYPE_MAX;
408
409
480k
    return Status::OK();
410
480k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_fixed_valueERKa
Line
Count
Source
398
122k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
122k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
122k
    _fixed_values.insert(value);
404
122k
    _contain_null = false;
405
406
122k
    _high_value = TYPE_MIN;
407
122k
    _low_value = TYPE_MAX;
408
409
122k
    return Status::OK();
410
122k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_fixed_valueERKs
Line
Count
Source
398
121
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
121
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
121
    _fixed_values.insert(value);
404
121
    _contain_null = false;
405
406
121
    _high_value = TYPE_MIN;
407
121
    _low_value = TYPE_MAX;
408
409
121
    return Status::OK();
410
121
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
37.2k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
37.2k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
37.2k
    _fixed_values.insert(value);
404
37.2k
    _contain_null = false;
405
406
37.2k
    _high_value = TYPE_MIN;
407
37.2k
    _low_value = TYPE_MAX;
408
409
37.2k
    return Status::OK();
410
37.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
13.0k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
13.0k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
13.0k
    _fixed_values.insert(value);
404
13.0k
    _contain_null = false;
405
406
13.0k
    _high_value = TYPE_MIN;
407
13.0k
    _low_value = TYPE_MAX;
408
409
13.0k
    return Status::OK();
410
13.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
236
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
236
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
236
    _fixed_values.insert(value);
404
236
    _contain_null = false;
405
406
236
    _high_value = TYPE_MIN;
407
236
    _low_value = TYPE_MAX;
408
409
236
    return Status::OK();
410
236
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
75
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
75
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
75
    _fixed_values.insert(value);
404
75
    _contain_null = false;
405
406
75
    _high_value = TYPE_MIN;
407
75
    _low_value = TYPE_MAX;
408
409
75
    return Status::OK();
410
75
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
180
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
180
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
180
    _fixed_values.insert(value);
404
180
    _contain_null = false;
405
406
180
    _high_value = TYPE_MIN;
407
180
    _low_value = TYPE_MAX;
408
409
180
    return Status::OK();
410
180
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_fixed_valueERKj
Line
Count
Source
398
35
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
35
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
35
    _fixed_values.insert(value);
404
35
    _contain_null = false;
405
406
35
    _high_value = TYPE_MIN;
407
35
    _low_value = TYPE_MAX;
408
409
35
    return Status::OK();
410
35
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_fixed_valueERKo
Line
Count
Source
398
35
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
35
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
35
    _fixed_values.insert(value);
404
35
    _contain_null = false;
405
406
35
    _high_value = TYPE_MIN;
407
35
    _low_value = TYPE_MAX;
408
409
35
    return Status::OK();
410
35
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
537
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
537
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
537
    _fixed_values.insert(value);
404
537
    _contain_null = false;
405
406
537
    _high_value = TYPE_MIN;
407
537
    _low_value = TYPE_MAX;
408
409
537
    return Status::OK();
410
537
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
293k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
293k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
293k
    _fixed_values.insert(value);
404
293k
    _contain_null = false;
405
406
293k
    _high_value = TYPE_MIN;
407
293k
    _low_value = TYPE_MAX;
408
409
293k
    return Status::OK();
410
293k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
1.53k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
1.53k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
1.53k
    _fixed_values.insert(value);
404
1.53k
    _contain_null = false;
405
406
1.53k
    _high_value = TYPE_MIN;
407
1.53k
    _low_value = TYPE_MAX;
408
409
1.53k
    return Status::OK();
410
1.53k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
71
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
71
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
71
    _fixed_values.insert(value);
404
71
    _contain_null = false;
405
406
71
    _high_value = TYPE_MIN;
407
71
    _low_value = TYPE_MAX;
408
409
71
    return Status::OK();
410
71
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
9.80k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
9.80k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
9.80k
    _fixed_values.insert(value);
404
9.80k
    _contain_null = false;
405
406
9.80k
    _high_value = TYPE_MIN;
407
9.80k
    _low_value = TYPE_MAX;
408
409
9.80k
    return Status::OK();
410
9.80k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
57
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
57
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
57
    _fixed_values.insert(value);
404
57
    _contain_null = false;
405
406
57
    _high_value = TYPE_MIN;
407
57
    _low_value = TYPE_MAX;
408
409
57
    return Status::OK();
410
57
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
699
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
699
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
699
    _fixed_values.insert(value);
404
699
    _contain_null = false;
405
406
699
    _high_value = TYPE_MIN;
407
699
    _low_value = TYPE_MAX;
408
409
699
    return Status::OK();
410
699
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
297
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
297
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
297
    _fixed_values.insert(value);
404
297
    _contain_null = false;
405
406
297
    _high_value = TYPE_MIN;
407
297
    _low_value = TYPE_MAX;
408
409
297
    return Status::OK();
410
297
}
_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
258
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
258
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
258
    _fixed_values.insert(value);
404
258
    _contain_null = false;
405
406
258
    _high_value = TYPE_MIN;
407
258
    _low_value = TYPE_MAX;
408
409
258
    return Status::OK();
410
258
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
50
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
50
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
50
    _fixed_values.insert(value);
404
50
    _contain_null = false;
405
406
50
    _high_value = TYPE_MIN;
407
50
    _low_value = TYPE_MAX;
408
409
50
    return Status::OK();
410
50
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
381
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
381
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
381
    _fixed_values.insert(value);
404
381
    _contain_null = false;
405
406
381
    _high_value = TYPE_MIN;
407
381
    _low_value = TYPE_MAX;
408
409
381
    return Status::OK();
410
381
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
137
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
137
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
137
    _fixed_values.insert(value);
404
137
    _contain_null = false;
405
406
137
    _high_value = TYPE_MIN;
407
137
    _low_value = TYPE_MAX;
408
409
137
    return Status::OK();
410
137
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
93
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
93
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
93
    _fixed_values.insert(value);
404
93
    _contain_null = false;
405
406
93
    _high_value = TYPE_MIN;
407
93
    _low_value = TYPE_MAX;
408
409
93
    return Status::OK();
410
93
}
411
412
template <PrimitiveType primitive_type>
413
3
void ColumnValueRange<primitive_type>::remove_fixed_value(const CppType& value) {
414
3
    _fixed_values.erase(value);
415
3
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE18remove_fixed_valueERKa
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE18remove_fixed_valueERKs
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE18remove_fixed_valueERKi
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE18remove_fixed_valueERKl
Line
Count
Source
413
3
void ColumnValueRange<primitive_type>::remove_fixed_value(const CppType& value) {
414
3
    _fixed_values.erase(value);
415
3
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE18remove_fixed_valueERKn
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE18remove_fixed_valueERKf
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE18remove_fixed_valueERKd
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE18remove_fixed_valueERKj
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE18remove_fixed_valueERKo
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE18remove_fixed_valueERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE18remove_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE18remove_fixed_valueERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE18remove_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE18remove_fixed_valueERKNS_16TimestampTzValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE18remove_fixed_valueERKNS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE18remove_fixed_valueERKh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE18remove_fixed_valueERKNS_9StringRefE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE18remove_fixed_valueERKNS_7DecimalIiEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE18remove_fixed_valueERKNS_7DecimalIlEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE18remove_fixed_valueERKNS_12Decimal128V3E
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE18remove_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
416
417
template <PrimitiveType primitive_type>
418
7.80M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.80M
    return _fixed_values.size() != 0;
420
7.80M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_fixed_value_rangeEv
Line
Count
Source
418
1.11M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
1.11M
    return _fixed_values.size() != 0;
420
1.11M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
22.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
22.5k
    return _fixed_values.size() != 0;
420
22.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
507k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
507k
    return _fixed_values.size() != 0;
420
507k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
959k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
959k
    return _fixed_values.size() != 0;
420
959k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
32.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
32.4k
    return _fixed_values.size() != 0;
420
32.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
12.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
12.7k
    return _fixed_values.size() != 0;
420
12.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.9k
    return _fixed_values.size() != 0;
420
18.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
694
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
694
    return _fixed_values.size() != 0;
420
694
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
758
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
758
    return _fixed_values.size() != 0;
420
758
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
23.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
23.5k
    return _fixed_values.size() != 0;
420
23.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_fixed_value_rangeEv
Line
Count
Source
418
4.44M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
4.44M
    return _fixed_values.size() != 0;
420
4.44M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_fixed_value_rangeEv
Line
Count
Source
418
179k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
179k
    return _fixed_values.size() != 0;
420
179k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_fixed_value_rangeEv
Line
Count
Source
418
849
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
849
    return _fixed_values.size() != 0;
420
849
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_fixed_value_rangeEv
Line
Count
Source
418
202k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
202k
    return _fixed_values.size() != 0;
420
202k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_fixed_value_rangeEv
Line
Count
Source
418
720
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
720
    return _fixed_values.size() != 0;
420
720
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
149k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
149k
    return _fixed_values.size() != 0;
420
149k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_fixed_value_rangeEv
Line
Count
Source
418
27.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
27.9k
    return _fixed_values.size() != 0;
420
27.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
898
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
898
    return _fixed_values.size() != 0;
420
898
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
20.1k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
20.1k
    return _fixed_values.size() != 0;
420
20.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
599
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
599
    return _fixed_values.size() != 0;
420
599
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
14.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
14.7k
    return _fixed_values.size() != 0;
420
14.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_fixed_value_rangeEv
Line
Count
Source
418
35.6k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
35.6k
    return _fixed_values.size() != 0;
420
35.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_fixed_value_rangeEv
Line
Count
Source
418
19.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
19.7k
    return _fixed_values.size() != 0;
420
19.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
5.48k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
5.48k
    return _fixed_values.size() != 0;
420
5.48k
}
421
422
template <PrimitiveType primitive_type>
423
2.72M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
2.72M
    return Compare::greater(_high_value, _low_value);
425
2.72M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
147k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
147k
    return Compare::greater(_high_value, _low_value);
425
147k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
19.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
19.3k
    return Compare::greater(_high_value, _low_value);
425
19.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
312k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
312k
    return Compare::greater(_high_value, _low_value);
425
312k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
652k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
652k
    return Compare::greater(_high_value, _low_value);
425
652k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
16.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
16.5k
    return Compare::greater(_high_value, _low_value);
425
16.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
12.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.1k
    return Compare::greater(_high_value, _low_value);
425
12.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
17.2k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
17.2k
    return Compare::greater(_high_value, _low_value);
425
17.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
459
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
459
    return Compare::greater(_high_value, _low_value);
425
459
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
525
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
525
    return Compare::greater(_high_value, _low_value);
425
525
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_scope_value_rangeEv
Line
Count
Source
423
18.3k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
18.3k
    return Compare::greater(_high_value, _low_value);
425
18.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_scope_value_rangeEv
Line
Count
Source
423
1.04M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.04M
    return Compare::greater(_high_value, _low_value);
425
1.04M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_scope_value_rangeEv
Line
Count
Source
423
160k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
160k
    return Compare::greater(_high_value, _low_value);
425
160k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
472
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
472
    return Compare::greater(_high_value, _low_value);
425
472
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
101k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
101k
    return Compare::greater(_high_value, _low_value);
425
101k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
430
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
430
    return Compare::greater(_high_value, _low_value);
425
430
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
133k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
133k
    return Compare::greater(_high_value, _low_value);
425
133k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
12.7k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.7k
    return Compare::greater(_high_value, _low_value);
425
12.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
690
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
690
    return Compare::greater(_high_value, _low_value);
425
690
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
13.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.0k
    return Compare::greater(_high_value, _low_value);
425
13.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_scope_value_rangeEv
Line
Count
Source
423
600
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
600
    return Compare::greater(_high_value, _low_value);
425
600
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
12.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.8k
    return Compare::greater(_high_value, _low_value);
425
12.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
29.9k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
29.9k
    return Compare::greater(_high_value, _low_value);
425
29.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
14.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.5k
    return Compare::greater(_high_value, _low_value);
425
14.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
2.60k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
2.60k
    return Compare::greater(_high_value, _low_value);
425
2.60k
}
426
427
template <PrimitiveType primitive_type>
428
3.87M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
3.87M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
3.87M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
3.87M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
390k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
390k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
390k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
390k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
19.7k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
19.7k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
19.7k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
19.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
326k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
326k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
326k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
326k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
655k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
655k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
655k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
655k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
17.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
17.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
17.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
17.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
12.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_empty_value_rangeEv
Line
Count
Source
428
17.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
17.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
17.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
17.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_empty_value_rangeEv
Line
Count
Source
428
512
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
512
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
512
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
512
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
583
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
583
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
583
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
583
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_empty_value_rangeEv
Line
Count
Source
428
19.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
19.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
19.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
19.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_empty_value_rangeEv
Line
Count
Source
428
1.90M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.90M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.90M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.90M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
162k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
162k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
162k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
162k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
556
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
556
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
556
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
556
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
120k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
120k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
120k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
120k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
493
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
493
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
493
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
493
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
134k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
134k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
134k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
134k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
13.1k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
13.1k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
13.1k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
13.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_empty_value_rangeEv
Line
Count
Source
428
749
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
749
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
749
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
749
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
13.5k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
13.5k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
13.5k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
13.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_empty_value_rangeEv
Line
Count
Source
428
599
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
599
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
600
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
599
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
12.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
30.5k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
30.5k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
30.5k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
30.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_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_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
2.79k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.79k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.79k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.79k
}
435
436
template <PrimitiveType primitive_type>
437
181k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
181k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
181k
    if (!is_enumeration_type(_column_type)) {
443
21.7k
        return false;
444
21.7k
    }
445
446
160k
    return true;
447
181k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.32k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.32k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.32k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.32k
    return true;
447
2.32k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
229
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
229
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
229
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
229
    return true;
447
229
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_fixed_value_convertibleEv
Line
Count
Source
437
63.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
63.2k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
63.2k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
63.2k
    return true;
447
63.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
86.8k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
86.8k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
86.8k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
86.8k
    return true;
447
86.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
4.51k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
4.51k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
4.51k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
4.51k
    return true;
447
4.51k
}
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
387
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
387
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
388
    if (!is_enumeration_type(_column_type)) {
443
388
        return false;
444
388
    }
445
446
18.4E
    return true;
447
387
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
9.77k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
9.77k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
9.79k
    if (!is_enumeration_type(_column_type)) {
443
9.79k
        return false;
444
9.79k
    }
445
446
18.4E
    return true;
447
9.77k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_fixed_value_convertibleEv
Line
Count
Source
437
18
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
18
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
18
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
18
    return true;
447
18
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.90k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.90k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.90k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.90k
    return true;
447
2.90k
}
_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.66k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.66k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.66k
    if (!is_enumeration_type(_column_type)) {
443
2.66k
        return false;
444
2.66k
    }
445
446
18.4E
    return true;
447
2.66k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
4.12k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
4.12k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
4.12k
    if (!is_enumeration_type(_column_type)) {
443
4.11k
        return false;
444
4.11k
    }
445
446
6
    return true;
447
4.12k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
48
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
48
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
48
    if (!is_enumeration_type(_column_type)) {
443
48
        return false;
444
48
    }
445
446
0
    return true;
447
48
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.72k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.72k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.73k
    if (!is_enumeration_type(_column_type)) {
443
1.73k
        return false;
444
1.73k
    }
445
446
18.4E
    return true;
447
1.72k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
442
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
442
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
442
    if (!is_enumeration_type(_column_type)) {
443
442
        return false;
444
442
    }
445
446
0
    return true;
447
442
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
718
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
718
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
718
    if (!is_enumeration_type(_column_type)) {
443
718
        return false;
444
718
    }
445
446
0
    return true;
447
718
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.25k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.25k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.25k
    if (!is_enumeration_type(_column_type)) {
443
1.25k
        return false;
444
1.25k
    }
445
446
18.4E
    return true;
447
1.25k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
577
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
577
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
577
    if (!is_enumeration_type(_column_type)) {
443
571
        return false;
444
571
    }
445
446
6
    return true;
447
577
}
448
449
template <PrimitiveType primitive_type>
450
25
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
25
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
25
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
24
    return true;
460
25
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
22
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
22
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
22
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
22
    return true;
460
22
}
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
154k
        bool& begin_include, bool& end_include) {
467
154k
    if constexpr (!_is_reject_split_type) {
468
154k
        begin_include = true;
469
154k
        end_include = true;
470
471
154k
        bool is_empty = false;
472
473
154k
        if (!is_begin_include()) {
474
8.54k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
8.54k
            } else {
477
8.54k
                ++_low_value;
478
8.54k
            }
479
8.54k
        }
480
481
154k
        if (!is_end_include()) {
482
806
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
806
            } else {
485
806
                --_high_value;
486
806
            }
487
806
        }
488
489
154k
        if (Compare::less(_high_value, _low_value)) {
490
26
            is_empty = true;
491
26
        }
492
493
154k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
154k
    }
499
154k
    return false;
500
154k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.30k
        bool& begin_include, bool& end_include) {
467
2.30k
    if constexpr (!_is_reject_split_type) {
468
2.30k
        begin_include = true;
469
2.30k
        end_include = true;
470
471
2.30k
        bool is_empty = false;
472
473
2.30k
        if (!is_begin_include()) {
474
98
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
98
            } else {
477
98
                ++_low_value;
478
98
            }
479
98
        }
480
481
2.30k
        if (!is_end_include()) {
482
19
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
19
            } else {
485
19
                --_high_value;
486
19
            }
487
19
        }
488
489
2.30k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.30k
        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.30k
    }
499
2.30k
    return false;
500
2.30k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
227
        bool& begin_include, bool& end_include) {
467
227
    if constexpr (!_is_reject_split_type) {
468
227
        begin_include = true;
469
227
        end_include = true;
470
471
227
        bool is_empty = false;
472
473
227
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
227
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
227
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
227
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
227
    }
499
227
    return false;
500
227
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
62.7k
        bool& begin_include, bool& end_include) {
467
62.7k
    if constexpr (!_is_reject_split_type) {
468
62.7k
        begin_include = true;
469
62.7k
        end_include = true;
470
471
62.7k
        bool is_empty = false;
472
473
62.7k
        if (!is_begin_include()) {
474
586
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
586
            } else {
477
586
                ++_low_value;
478
586
            }
479
586
        }
480
481
62.7k
        if (!is_end_include()) {
482
703
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
703
            } else {
485
703
                --_high_value;
486
703
            }
487
703
        }
488
489
62.7k
        if (Compare::less(_high_value, _low_value)) {
490
26
            is_empty = true;
491
26
        }
492
493
62.7k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
62.7k
    }
499
62.7k
    return false;
500
62.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
86.6k
        bool& begin_include, bool& end_include) {
467
86.6k
    if constexpr (!_is_reject_split_type) {
468
86.6k
        begin_include = true;
469
86.6k
        end_include = true;
470
471
86.6k
        bool is_empty = false;
472
473
86.6k
        if (!is_begin_include()) {
474
7.81k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
7.81k
            } else {
477
7.81k
                ++_low_value;
478
7.81k
            }
479
7.81k
        }
480
481
86.6k
        if (!is_end_include()) {
482
7
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
7
            } else {
485
7
                --_high_value;
486
7
            }
487
7
        }
488
489
86.6k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
86.6k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
86.6k
    }
499
86.6k
    return false;
500
86.6k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
1
        bool& begin_include, bool& end_include) {
467
1
    if constexpr (!_is_reject_split_type) {
468
1
        begin_include = true;
469
1
        end_include = true;
470
471
1
        bool is_empty = false;
472
473
1
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
1
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
1
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
1
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
1
    }
499
1
    return false;
500
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
18
        bool& begin_include, bool& end_include) {
467
18
    if constexpr (!_is_reject_split_type) {
468
18
        begin_include = true;
469
18
        end_include = true;
470
471
18
        bool is_empty = false;
472
473
18
        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
18
        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
18
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
18
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
18
    }
499
18
    return false;
500
18
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.90k
        bool& begin_include, bool& end_include) {
467
2.90k
    if constexpr (!_is_reject_split_type) {
468
2.90k
        begin_include = true;
469
2.90k
        end_include = true;
470
471
2.90k
        bool is_empty = false;
472
473
2.90k
        if (!is_begin_include()) {
474
43
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
43
            } else {
477
43
                ++_low_value;
478
43
            }
479
43
        }
480
481
2.90k
        if (!is_end_include()) {
482
77
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
77
            } else {
485
77
                --_high_value;
486
77
            }
487
77
        }
488
489
2.90k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.90k
        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.90k
    }
499
2.90k
    return false;
500
2.90k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
501
502
// The return value indicates whether the split result is range or fixed value.
503
template <PrimitiveType primitive_type>
504
bool ColumnValueRange<primitive_type>::convert_to_avg_range_value(
505
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
506
155k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
155k
    if constexpr (!_is_reject_split_type) {
508
155k
        CppType min_value = get_range_min_value();
509
155k
        CppType max_value = get_range_max_value();
510
155k
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
18
            min_value.set_type(TimeType::TIME_DATE);
512
18
            max_value.set_type(TimeType::TIME_DATE);
513
18
        }
514
155k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
155k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
26
            DCHECK(contain_null());
518
26
        }
519
520
155k
        auto no_split = [&]() -> bool {
521
147k
            begin_scan_keys.emplace_back();
522
147k
            begin_scan_keys.back().add_value(
523
147k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
147k
                    contain_null());
525
147k
            end_scan_keys.emplace_back();
526
147k
            end_scan_keys.back().add_value(
527
147k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
147k
                    empty_range_only_null ? true : false);
529
147k
            return true;
530
147k
        };
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
61.6k
        auto no_split = [&]() -> bool {
521
61.6k
            begin_scan_keys.emplace_back();
522
61.6k
            begin_scan_keys.back().add_value(
523
61.6k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
61.6k
                    contain_null());
525
61.6k
            end_scan_keys.emplace_back();
526
61.6k
            end_scan_keys.back().add_value(
527
61.6k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
61.6k
                    empty_range_only_null ? true : false);
529
61.6k
            return true;
530
61.6k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
86.1k
        auto no_split = [&]() -> bool {
521
86.1k
            begin_scan_keys.emplace_back();
522
86.1k
            begin_scan_keys.back().add_value(
523
86.1k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
86.1k
                    contain_null());
525
86.1k
            end_scan_keys.emplace_back();
526
86.1k
            end_scan_keys.back().add_value(
527
86.1k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
86.1k
                    empty_range_only_null ? true : false);
529
86.1k
            return true;
530
86.1k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
531
155k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
26
            return no_split();
533
26
        }
534
535
417k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
141k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
141k
                return value;
539
276k
            } else {
540
276k
                return (int128_t)value;
541
276k
            }
542
417k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKaE_clESA_
Line
Count
Source
535
102k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
102k
            } else {
540
102k
                return (int128_t)value;
541
102k
            }
542
102k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKsE_clESA_
Line
Count
Source
535
11.3k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
11.3k
            } else {
540
11.3k
                return (int128_t)value;
541
11.3k
            }
542
11.3k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKiE_clESA_
Line
Count
Source
535
73.2k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
73.2k
            } else {
540
73.2k
                return (int128_t)value;
541
73.2k
            }
542
73.2k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
88.7k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
88.7k
            } else {
540
88.7k
                return (int128_t)value;
541
88.7k
            }
542
88.7k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKjE_clESA_
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKoE_clESA_
Line
Count
Source
535
1
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
1
            } else {
540
1
                return (int128_t)value;
541
1
            }
542
1
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_16VecDateTimeValueEE_clESB_
Line
Count
Source
535
877
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
877
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
877
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
877
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
140k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
140k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
140k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
140k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIiEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIlEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_12Decimal128V3EE_clESB_
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
155k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
155k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
155k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
148k
            return no_split();
552
148k
        }
553
6.68k
        int step_size = cast_set<int>(step_size_may_overflow);
554
6.68k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6.68k
        if (contain_null()) {
558
3.16k
            begin_scan_keys.emplace_back();
559
3.16k
            begin_scan_keys.back().add_null();
560
3.16k
            end_scan_keys.emplace_back();
561
3.16k
            end_scan_keys.back().add_null();
562
3.16k
        }
563
262k
        while (true) {
564
262k
            begin_scan_keys.emplace_back();
565
262k
            begin_scan_keys.back().add_value(
566
262k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
262k
            if (cast(max_value) - min_value < step_size) {
569
5.52k
                min_value = max_value;
570
256k
            } else {
571
256k
                min_value += step_size;
572
256k
            }
573
574
262k
            end_scan_keys.emplace_back();
575
262k
            end_scan_keys.back().add_value(
576
262k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
262k
            if (Compare::equal(min_value, max_value)) {
579
6.83k
                break;
580
6.83k
            }
581
255k
            ++min_value;
582
255k
            ++real_step_size;
583
255k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
255k
        }
592
593
6.68k
        return step_size != 0;
594
6.68k
    }
595
0
    return false;
596
155k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.31k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.31k
    if constexpr (!_is_reject_split_type) {
508
2.31k
        CppType min_value = get_range_min_value();
509
2.31k
        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.31k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.31k
        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.31k
        auto no_split = [&]() -> bool {
521
2.31k
            begin_scan_keys.emplace_back();
522
2.31k
            begin_scan_keys.back().add_value(
523
2.31k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.31k
                    contain_null());
525
2.31k
            end_scan_keys.emplace_back();
526
2.31k
            end_scan_keys.back().add_value(
527
2.31k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.31k
                    empty_range_only_null ? true : false);
529
2.31k
            return true;
530
2.31k
        };
531
2.31k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.31k
        auto cast = [](const CppType& value) {
536
2.31k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.31k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.31k
                return value;
539
2.31k
            } else {
540
2.31k
                return (int128_t)value;
541
2.31k
            }
542
2.31k
        };
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.31k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.31k
        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.31k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.31k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.31k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.31k
        if (contain_null()) {
558
1.88k
            begin_scan_keys.emplace_back();
559
1.88k
            begin_scan_keys.back().add_null();
560
1.88k
            end_scan_keys.emplace_back();
561
1.88k
            end_scan_keys.back().add_null();
562
1.88k
        }
563
100k
        while (true) {
564
100k
            begin_scan_keys.emplace_back();
565
100k
            begin_scan_keys.back().add_value(
566
100k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
100k
            if (cast(max_value) - min_value < step_size) {
569
2.31k
                min_value = max_value;
570
98.1k
            } else {
571
98.1k
                min_value += step_size;
572
98.1k
            }
573
574
100k
            end_scan_keys.emplace_back();
575
100k
            end_scan_keys.back().add_value(
576
100k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
100k
            if (Compare::equal(min_value, max_value)) {
579
2.37k
                break;
580
2.37k
            }
581
98.1k
            ++min_value;
582
98.1k
            ++real_step_size;
583
98.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
98.1k
        }
592
593
2.31k
        return step_size != 0;
594
2.31k
    }
595
0
    return false;
596
2.31k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
228
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
228
    if constexpr (!_is_reject_split_type) {
508
228
        CppType min_value = get_range_min_value();
509
228
        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
228
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
228
        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
228
        auto no_split = [&]() -> bool {
521
228
            begin_scan_keys.emplace_back();
522
228
            begin_scan_keys.back().add_value(
523
228
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
228
                    contain_null());
525
228
            end_scan_keys.emplace_back();
526
228
            end_scan_keys.back().add_value(
527
228
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
228
                    empty_range_only_null ? true : false);
529
228
            return true;
530
228
        };
531
228
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
228
        auto cast = [](const CppType& value) {
536
228
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
228
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
228
                return value;
539
228
            } else {
540
228
                return (int128_t)value;
541
228
            }
542
228
        };
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
228
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
228
        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
228
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
228
        int step_size = cast_set<int>(step_size_may_overflow);
554
228
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
228
        if (contain_null()) {
558
155
            begin_scan_keys.emplace_back();
559
155
            begin_scan_keys.back().add_null();
560
155
            end_scan_keys.emplace_back();
561
155
            end_scan_keys.back().add_null();
562
155
        }
563
11.1k
        while (true) {
564
11.1k
            begin_scan_keys.emplace_back();
565
11.1k
            begin_scan_keys.back().add_value(
566
11.1k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
11.1k
            if (cast(max_value) - min_value < step_size) {
569
233
                min_value = max_value;
570
10.8k
            } else {
571
10.8k
                min_value += step_size;
572
10.8k
            }
573
574
11.1k
            end_scan_keys.emplace_back();
575
11.1k
            end_scan_keys.back().add_value(
576
11.1k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
11.1k
            if (Compare::equal(min_value, max_value)) {
579
233
                break;
580
233
            }
581
10.8k
            ++min_value;
582
10.8k
            ++real_step_size;
583
10.8k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
10.8k
        }
592
593
228
        return step_size != 0;
594
228
    }
595
0
    return false;
596
228
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
63.2k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
63.2k
    if constexpr (!_is_reject_split_type) {
508
63.2k
        CppType min_value = get_range_min_value();
509
63.2k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
63.2k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
63.2k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
26
            DCHECK(contain_null());
518
26
        }
519
520
63.2k
        auto no_split = [&]() -> bool {
521
63.2k
            begin_scan_keys.emplace_back();
522
63.2k
            begin_scan_keys.back().add_value(
523
63.2k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
63.2k
                    contain_null());
525
63.2k
            end_scan_keys.emplace_back();
526
63.2k
            end_scan_keys.back().add_value(
527
63.2k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
63.2k
                    empty_range_only_null ? true : false);
529
63.2k
            return true;
530
63.2k
        };
531
63.2k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
26
            return no_split();
533
26
        }
534
535
63.2k
        auto cast = [](const CppType& value) {
536
63.2k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
63.2k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
63.2k
                return value;
539
63.2k
            } else {
540
63.2k
                return (int128_t)value;
541
63.2k
            }
542
63.2k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
63.2k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
63.2k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
63.2k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
62.3k
            return no_split();
552
62.3k
        }
553
901
        int step_size = cast_set<int>(step_size_may_overflow);
554
901
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
901
        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
10.4k
        while (true) {
564
10.3k
            begin_scan_keys.emplace_back();
565
10.3k
            begin_scan_keys.back().add_value(
566
10.3k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
10.3k
            if (cast(max_value) - min_value < step_size) {
569
127
                min_value = max_value;
570
10.1k
            } else {
571
10.1k
                min_value += step_size;
572
10.1k
            }
573
574
10.3k
            end_scan_keys.emplace_back();
575
10.3k
            end_scan_keys.back().add_value(
576
10.3k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
10.3k
            if (Compare::equal(min_value, max_value)) {
579
815
                break;
580
815
            }
581
9.50k
            ++min_value;
582
9.50k
            ++real_step_size;
583
9.50k
            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
9.50k
        }
592
593
901
        return step_size != 0;
594
901
    }
595
0
    return false;
596
63.2k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
86.7k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
86.7k
    if constexpr (!_is_reject_split_type) {
508
86.7k
        CppType min_value = get_range_min_value();
509
86.7k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
86.7k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
86.7k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
86.7k
        auto no_split = [&]() -> bool {
521
86.7k
            begin_scan_keys.emplace_back();
522
86.7k
            begin_scan_keys.back().add_value(
523
86.7k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
86.7k
                    contain_null());
525
86.7k
            end_scan_keys.emplace_back();
526
86.7k
            end_scan_keys.back().add_value(
527
86.7k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
86.7k
                    empty_range_only_null ? true : false);
529
86.7k
            return true;
530
86.7k
        };
531
86.7k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
86.7k
        auto cast = [](const CppType& value) {
536
86.7k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
86.7k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
86.7k
                return value;
539
86.7k
            } else {
540
86.7k
                return (int128_t)value;
541
86.7k
            }
542
86.7k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
86.7k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
86.7k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
86.7k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
86.4k
            return no_split();
552
86.4k
        }
553
327
        int step_size = cast_set<int>(step_size_may_overflow);
554
327
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
327
        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
2.06k
        while (true) {
564
2.06k
            begin_scan_keys.emplace_back();
565
2.06k
            begin_scan_keys.back().add_value(
566
2.06k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
2.06k
            if (cast(max_value) - min_value < step_size) {
569
2
                min_value = max_value;
570
2.06k
            } else {
571
2.06k
                min_value += step_size;
572
2.06k
            }
573
574
2.06k
            end_scan_keys.emplace_back();
575
2.06k
            end_scan_keys.back().add_value(
576
2.06k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
2.06k
            if (Compare::equal(min_value, max_value)) {
579
463
                break;
580
463
            }
581
1.60k
            ++min_value;
582
1.60k
            ++real_step_size;
583
1.60k
            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.60k
        }
592
593
327
        return step_size != 0;
594
327
    }
595
0
    return false;
596
86.7k
}
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
18
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
18
    if constexpr (!_is_reject_split_type) {
508
18
        CppType min_value = get_range_min_value();
509
18
        CppType max_value = get_range_max_value();
510
18
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
18
            min_value.set_type(TimeType::TIME_DATE);
512
18
            max_value.set_type(TimeType::TIME_DATE);
513
18
        }
514
18
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
18
        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
18
        auto no_split = [&]() -> bool {
521
18
            begin_scan_keys.emplace_back();
522
18
            begin_scan_keys.back().add_value(
523
18
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
18
                    contain_null());
525
18
            end_scan_keys.emplace_back();
526
18
            end_scan_keys.back().add_value(
527
18
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
18
                    empty_range_only_null ? true : false);
529
18
            return true;
530
18
        };
531
18
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
18
        auto cast = [](const CppType& value) {
536
18
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
18
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
18
                return value;
539
18
            } else {
540
18
                return (int128_t)value;
541
18
            }
542
18
        };
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
18
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
18
        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
18
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
18
        int step_size = cast_set<int>(step_size_may_overflow);
554
18
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
18
        if (contain_null()) {
558
18
            begin_scan_keys.emplace_back();
559
18
            begin_scan_keys.back().add_null();
560
18
            end_scan_keys.emplace_back();
561
18
            end_scan_keys.back().add_null();
562
18
        }
563
857
        while (true) {
564
857
            begin_scan_keys.emplace_back();
565
857
            begin_scan_keys.back().add_value(
566
857
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
857
            if (cast(max_value) - min_value < step_size) {
569
18
                min_value = max_value;
570
839
            } else {
571
839
                min_value += step_size;
572
839
            }
573
574
857
            end_scan_keys.emplace_back();
575
857
            end_scan_keys.back().add_value(
576
857
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
857
            if (Compare::equal(min_value, max_value)) {
579
18
                break;
580
18
            }
581
839
            ++min_value;
582
839
            ++real_step_size;
583
839
            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
839
        }
592
593
18
        return step_size != 0;
594
18
    }
595
0
    return false;
596
18
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.89k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.89k
    if constexpr (!_is_reject_split_type) {
508
2.89k
        CppType min_value = get_range_min_value();
509
2.89k
        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.89k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.89k
        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.89k
        auto no_split = [&]() -> bool {
521
2.89k
            begin_scan_keys.emplace_back();
522
2.89k
            begin_scan_keys.back().add_value(
523
2.89k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.89k
                    contain_null());
525
2.89k
            end_scan_keys.emplace_back();
526
2.89k
            end_scan_keys.back().add_value(
527
2.89k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.89k
                    empty_range_only_null ? true : false);
529
2.89k
            return true;
530
2.89k
        };
531
2.90k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.89k
        auto cast = [](const CppType& value) {
536
2.89k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.89k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.89k
                return value;
539
2.89k
            } else {
540
2.89k
                return (int128_t)value;
541
2.89k
            }
542
2.89k
        };
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.89k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.89k
        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.89k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.89k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.89k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.89k
        if (contain_null()) {
558
1.10k
            begin_scan_keys.emplace_back();
559
1.10k
            begin_scan_keys.back().add_null();
560
1.10k
            end_scan_keys.emplace_back();
561
1.10k
            end_scan_keys.back().add_null();
562
1.10k
        }
563
137k
        while (true) {
564
137k
            begin_scan_keys.emplace_back();
565
137k
            begin_scan_keys.back().add_value(
566
137k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
137k
            if (cast(max_value) - min_value < step_size) {
569
2.83k
                min_value = max_value;
570
134k
            } else {
571
134k
                min_value += step_size;
572
134k
            }
573
574
137k
            end_scan_keys.emplace_back();
575
137k
            end_scan_keys.back().add_value(
576
137k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
137k
            if (Compare::equal(min_value, max_value)) {
579
2.92k
                break;
580
2.92k
            }
581
134k
            ++min_value;
582
134k
            ++real_step_size;
583
134k
            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
134k
        }
592
593
2.89k
        return step_size != 0;
594
2.89k
    }
595
0
    return false;
596
2.89k
}
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
12
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
12
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
12
    if (!_fixed_values.empty()) {
605
12
        _low_value = *_fixed_values.begin();
606
12
        _low_op = FILTER_LARGER_OR_EQUAL;
607
12
        _high_value = *_fixed_values.rbegin();
608
12
        _high_op = FILTER_LESS_OR_EQUAL;
609
12
        _fixed_values.clear();
610
12
    }
611
12
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
11
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
11
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
11
    if (!_fixed_values.empty()) {
605
11
        _low_value = *_fixed_values.begin();
606
11
        _low_op = FILTER_LARGER_OR_EQUAL;
607
11
        _high_value = *_fixed_values.rbegin();
608
11
        _high_op = FILTER_LESS_OR_EQUAL;
609
11
        _fixed_values.clear();
610
11
    }
611
11
}
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
136k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
136k
    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
136k
    _contain_null = false;
621
622
136k
    if (is_fixed_value_range()) {
623
11.2k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
11.2k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
11.1k
        case FILTER_LARGER_OR_EQUAL: {
632
11.1k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
11.1k
            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
148
        case FILTER_LESS_OR_EQUAL: {
647
148
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
148
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
11.2k
        }
655
656
11.2k
        _high_value = TYPE_MIN;
657
11.2k
        _low_value = TYPE_MAX;
658
124k
    } else {
659
124k
        if (Compare::greater(_high_value, _low_value)) {
660
80.0k
            switch (op) {
661
31.9k
            case FILTER_LARGER: {
662
31.9k
                if (Compare::greater_equal(value, _low_value)) {
663
31.8k
                    _low_value = value;
664
31.8k
                    _low_op = op;
665
31.8k
                }
666
667
31.9k
                break;
668
0
            }
669
670
18.7k
            case FILTER_LARGER_OR_EQUAL: {
671
18.7k
                if (Compare::greater(value, _low_value)) {
672
14.9k
                    _low_value = value;
673
14.9k
                    _low_op = op;
674
14.9k
                }
675
676
18.7k
                break;
677
0
            }
678
679
6.39k
            case FILTER_LESS: {
680
6.39k
                if (Compare::less_equal(value, _high_value)) {
681
6.37k
                    _high_value = value;
682
6.37k
                    _high_op = op;
683
6.37k
                }
684
685
6.39k
                break;
686
0
            }
687
688
23.0k
            case FILTER_LESS_OR_EQUAL: {
689
23.0k
                if (Compare::less(value, _high_value)) {
690
19.4k
                    _high_value = value;
691
19.4k
                    _high_op = op;
692
19.4k
                }
693
694
23.0k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
80.0k
            }
701
80.0k
        }
702
703
124k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
124k
            Compare::equal(_high_value, _low_value)) {
705
12.3k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
12.3k
            _high_value = TYPE_MIN;
707
12.3k
            _low_value = TYPE_MAX;
708
12.3k
        }
709
124k
    }
710
711
136k
    return Status::OK();
712
136k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
2.80k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2.80k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
2.80k
    _contain_null = false;
621
622
2.80k
    if (is_fixed_value_range()) {
623
327
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
327
        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
323
        case FILTER_LARGER_OR_EQUAL: {
632
323
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
323
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
3
        case FILTER_LESS_OR_EQUAL: {
647
3
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
3
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
327
        }
655
656
327
        _high_value = TYPE_MIN;
657
327
        _low_value = TYPE_MAX;
658
2.47k
    } else {
659
2.47k
        if (Compare::greater(_high_value, _low_value)) {
660
2.22k
            switch (op) {
661
317
            case FILTER_LARGER: {
662
317
                if (Compare::greater_equal(value, _low_value)) {
663
317
                    _low_value = value;
664
317
                    _low_op = op;
665
317
                }
666
667
317
                break;
668
0
            }
669
670
684
            case FILTER_LARGER_OR_EQUAL: {
671
684
                if (Compare::greater(value, _low_value)) {
672
514
                    _low_value = value;
673
514
                    _low_op = op;
674
514
                }
675
676
684
                break;
677
0
            }
678
679
304
            case FILTER_LESS: {
680
304
                if (Compare::less_equal(value, _high_value)) {
681
302
                    _high_value = value;
682
302
                    _high_op = op;
683
302
                }
684
685
304
                break;
686
0
            }
687
688
925
            case FILTER_LESS_OR_EQUAL: {
689
925
                if (Compare::less(value, _high_value)) {
690
754
                    _high_value = value;
691
754
                    _high_op = op;
692
754
                }
693
694
925
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
2.22k
            }
701
2.22k
        }
702
703
2.47k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
2.47k
            Compare::equal(_high_value, _low_value)) {
705
439
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
439
            _high_value = TYPE_MIN;
707
439
            _low_value = TYPE_MAX;
708
439
        }
709
2.47k
    }
710
711
2.80k
    return Status::OK();
712
2.80k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
1.49k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.49k
    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.49k
    _contain_null = false;
621
622
1.49k
    if (is_fixed_value_range()) {
623
2
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
2
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
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
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
2
        }
655
656
2
        _high_value = TYPE_MIN;
657
2
        _low_value = TYPE_MAX;
658
1.49k
    } else {
659
1.49k
        if (Compare::greater(_high_value, _low_value)) {
660
1.48k
            switch (op) {
661
992
            case FILTER_LARGER: {
662
992
                if (Compare::greater_equal(value, _low_value)) {
663
986
                    _low_value = value;
664
986
                    _low_op = op;
665
986
                }
666
667
992
                break;
668
0
            }
669
670
279
            case FILTER_LARGER_OR_EQUAL: {
671
279
                if (Compare::greater(value, _low_value)) {
672
252
                    _low_value = value;
673
252
                    _low_op = op;
674
252
                }
675
676
279
                break;
677
0
            }
678
679
26
            case FILTER_LESS: {
680
26
                if (Compare::less_equal(value, _high_value)) {
681
26
                    _high_value = value;
682
26
                    _high_op = op;
683
26
                }
684
685
26
                break;
686
0
            }
687
688
188
            case FILTER_LESS_OR_EQUAL: {
689
188
                if (Compare::less(value, _high_value)) {
690
140
                    _high_value = value;
691
140
                    _high_op = op;
692
140
                }
693
694
188
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.48k
            }
701
1.48k
        }
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
4
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
4
            _high_value = TYPE_MIN;
707
4
            _low_value = TYPE_MAX;
708
4
        }
709
1.48k
    }
710
711
1.49k
    return Status::OK();
712
1.49k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
11.8k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
11.8k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
11.8k
    _contain_null = false;
621
622
11.8k
    if (is_fixed_value_range()) {
623
323
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
323
        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
224
        case FILTER_LARGER_OR_EQUAL: {
632
224
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
224
            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
99
        case FILTER_LESS_OR_EQUAL: {
647
99
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
99
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
323
        }
655
656
324
        _high_value = TYPE_MIN;
657
324
        _low_value = TYPE_MAX;
658
11.5k
    } else {
659
11.5k
        if (Compare::greater(_high_value, _low_value)) {
660
11.0k
            switch (op) {
661
2.78k
            case FILTER_LARGER: {
662
2.78k
                if (Compare::greater_equal(value, _low_value)) {
663
2.76k
                    _low_value = value;
664
2.76k
                    _low_op = op;
665
2.76k
                }
666
667
2.78k
                break;
668
0
            }
669
670
3.57k
            case FILTER_LARGER_OR_EQUAL: {
671
3.57k
                if (Compare::greater(value, _low_value)) {
672
2.86k
                    _low_value = value;
673
2.86k
                    _low_op = op;
674
2.86k
                }
675
676
3.57k
                break;
677
0
            }
678
679
1.36k
            case FILTER_LESS: {
680
1.36k
                if (Compare::less_equal(value, _high_value)) {
681
1.36k
                    _high_value = value;
682
1.36k
                    _high_op = op;
683
1.36k
                }
684
685
1.36k
                break;
686
0
            }
687
688
3.36k
            case FILTER_LESS_OR_EQUAL: {
689
3.36k
                if (Compare::less(value, _high_value)) {
690
2.65k
                    _high_value = value;
691
2.65k
                    _high_op = op;
692
2.65k
                }
693
694
3.36k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
11.0k
            }
701
11.0k
        }
702
703
11.5k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
11.5k
            Compare::equal(_high_value, _low_value)) {
705
432
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
432
            _high_value = TYPE_MIN;
707
432
            _low_value = TYPE_MAX;
708
432
        }
709
11.5k
    }
710
711
11.8k
    return Status::OK();
712
11.8k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
85.3k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
85.3k
    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
85.3k
    _contain_null = false;
621
622
85.3k
    if (is_fixed_value_range()) {
623
10.5k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
10.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
10.5k
        case FILTER_LARGER_OR_EQUAL: {
632
10.5k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
10.5k
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
24
        case FILTER_LESS_OR_EQUAL: {
647
24
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
24
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
10.5k
        }
655
656
10.5k
        _high_value = TYPE_MIN;
657
10.5k
        _low_value = TYPE_MAX;
658
74.7k
    } else {
659
74.7k
        if (Compare::greater(_high_value, _low_value)) {
660
30.9k
            switch (op) {
661
11.5k
            case FILTER_LARGER: {
662
11.5k
                if (Compare::greater_equal(value, _low_value)) {
663
11.5k
                    _low_value = value;
664
11.5k
                    _low_op = op;
665
11.5k
                }
666
667
11.5k
                break;
668
0
            }
669
670
4.91k
            case FILTER_LARGER_OR_EQUAL: {
671
4.91k
                if (Compare::greater(value, _low_value)) {
672
4.87k
                    _low_value = value;
673
4.87k
                    _low_op = op;
674
4.87k
                }
675
676
4.91k
                break;
677
0
            }
678
679
114
            case FILTER_LESS: {
680
115
                if (Compare::less_equal(value, _high_value)) {
681
115
                    _high_value = value;
682
115
                    _high_op = op;
683
115
                }
684
685
114
                break;
686
0
            }
687
688
14.3k
            case FILTER_LESS_OR_EQUAL: {
689
14.3k
                if (Compare::less(value, _high_value)) {
690
14.3k
                    _high_value = value;
691
14.3k
                    _high_op = op;
692
14.3k
                }
693
694
14.3k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
30.9k
            }
701
30.9k
        }
702
703
74.7k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
74.7k
            Compare::equal(_high_value, _low_value)) {
705
10.9k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
10.9k
            _high_value = TYPE_MIN;
707
10.9k
            _low_value = TYPE_MAX;
708
10.9k
        }
709
74.7k
    }
710
711
85.3k
    return Status::OK();
712
85.3k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
193
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
193
    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
193
    _contain_null = false;
621
622
193
    if (is_fixed_value_range()) {
623
3
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
3
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
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
1
        case FILTER_LESS_OR_EQUAL: {
647
1
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
1
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
3
        }
655
656
3
        _high_value = TYPE_MIN;
657
3
        _low_value = TYPE_MAX;
658
190
    } else {
659
190
        if (Compare::greater(_high_value, _low_value)) {
660
188
            switch (op) {
661
63
            case FILTER_LARGER: {
662
63
                if (Compare::greater_equal(value, _low_value)) {
663
63
                    _low_value = value;
664
63
                    _low_op = op;
665
63
                }
666
667
63
                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
27
            case FILTER_LESS: {
680
27
                if (Compare::less_equal(value, _high_value)) {
681
25
                    _high_value = value;
682
25
                    _high_op = op;
683
25
                }
684
685
27
                break;
686
0
            }
687
688
64
            case FILTER_LESS_OR_EQUAL: {
689
64
                if (Compare::less(value, _high_value)) {
690
59
                    _high_value = value;
691
59
                    _high_op = op;
692
59
                }
693
694
64
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
188
            }
701
188
        }
702
703
189
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
189
            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
189
    }
710
711
192
    return Status::OK();
712
193
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
159
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
159
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
159
    _contain_null = false;
621
622
159
    if (is_fixed_value_range()) {
623
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
159
    } else {
659
159
        if (Compare::greater(_high_value, _low_value)) {
660
159
            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
59
            case FILTER_LARGER_OR_EQUAL: {
671
59
                if (Compare::greater(value, _low_value)) {
672
45
                    _low_value = value;
673
45
                    _low_op = op;
674
45
                }
675
676
59
                break;
677
0
            }
678
679
27
            case FILTER_LESS: {
680
27
                if (Compare::less_equal(value, _high_value)) {
681
27
                    _high_value = value;
682
27
                    _high_op = op;
683
27
                }
684
685
27
                break;
686
0
            }
687
688
50
            case FILTER_LESS_OR_EQUAL: {
689
50
                if (Compare::less(value, _high_value)) {
690
36
                    _high_value = value;
691
36
                    _high_op = op;
692
36
                }
693
694
50
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
159
            }
701
159
        }
702
703
160
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
160
            Compare::equal(_high_value, _low_value)) {
705
16
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
16
            _high_value = TYPE_MIN;
707
16
            _low_value = TYPE_MAX;
708
16
        }
709
160
    }
710
711
160
    return Status::OK();
712
159
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
426
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
426
    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
426
    _contain_null = false;
621
622
426
    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
426
    } else {
659
428
        if (Compare::greater(_high_value, _low_value)) {
660
428
            switch (op) {
661
176
            case FILTER_LARGER: {
662
176
                if (Compare::greater_equal(value, _low_value)) {
663
176
                    _low_value = value;
664
176
                    _low_op = op;
665
176
                }
666
667
176
                break;
668
0
            }
669
670
97
            case FILTER_LARGER_OR_EQUAL: {
671
97
                if (Compare::greater(value, _low_value)) {
672
46
                    _low_value = value;
673
46
                    _low_op = op;
674
46
                }
675
676
97
                break;
677
0
            }
678
679
56
            case FILTER_LESS: {
680
56
                if (Compare::less_equal(value, _high_value)) {
681
55
                    _high_value = value;
682
55
                    _high_op = op;
683
55
                }
684
685
56
                break;
686
0
            }
687
688
99
            case FILTER_LESS_OR_EQUAL: {
689
99
                if (Compare::less(value, _high_value)) {
690
48
                    _high_value = value;
691
48
                    _high_op = op;
692
48
                }
693
694
99
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
428
            }
701
428
        }
702
703
425
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
425
            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
425
    }
710
711
425
    return Status::OK();
712
426
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
Line
Count
Source
614
18
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
18
    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
18
    _contain_null = false;
621
622
18
    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
18
    } else {
659
18
        if (Compare::greater(_high_value, _low_value)) {
660
18
            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
9
            case FILTER_LARGER_OR_EQUAL: {
671
9
                if (Compare::greater(value, _low_value)) {
672
4
                    _low_value = value;
673
4
                    _low_op = op;
674
4
                }
675
676
9
                break;
677
0
            }
678
679
4
            case FILTER_LESS: {
680
4
                if (Compare::less_equal(value, _high_value)) {
681
4
                    _high_value = value;
682
4
                    _high_op = op;
683
4
                }
684
685
4
                break;
686
0
            }
687
688
5
            case FILTER_LESS_OR_EQUAL: {
689
5
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
5
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
18
            }
701
18
        }
702
703
18
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
18
            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
18
    }
710
711
18
    return Status::OK();
712
18
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
Line
Count
Source
614
14
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
14
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
14
    _contain_null = false;
621
622
14
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
14
    } else {
659
14
        if (Compare::greater(_high_value, _low_value)) {
660
14
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
7
            case FILTER_LARGER_OR_EQUAL: {
671
7
                if (Compare::greater(value, _low_value)) {
672
4
                    _low_value = value;
673
4
                    _low_op = op;
674
4
                }
675
676
7
                break;
677
0
            }
678
679
4
            case FILTER_LESS: {
680
4
                if (Compare::less_equal(value, _high_value)) {
681
4
                    _high_value = value;
682
4
                    _high_op = op;
683
4
                }
684
685
4
                break;
686
0
            }
687
688
3
            case FILTER_LESS_OR_EQUAL: {
689
3
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
3
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
14
            }
701
14
        }
702
703
14
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
13
            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
13
    }
710
711
13
    return Status::OK();
712
14
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
646
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
646
    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
646
    _contain_null = false;
621
622
646
    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
642
    } else {
659
642
        if (Compare::greater(_high_value, _low_value)) {
660
637
            switch (op) {
661
449
            case FILTER_LARGER: {
662
449
                if (Compare::greater_equal(value, _low_value)) {
663
442
                    _low_value = value;
664
442
                    _low_op = op;
665
442
                }
666
667
449
                break;
668
0
            }
669
670
77
            case FILTER_LARGER_OR_EQUAL: {
671
77
                if (Compare::greater(value, _low_value)) {
672
54
                    _low_value = value;
673
54
                    _low_op = op;
674
54
                }
675
676
77
                break;
677
0
            }
678
679
31
            case FILTER_LESS: {
680
31
                if (Compare::less_equal(value, _high_value)) {
681
30
                    _high_value = value;
682
30
                    _high_op = op;
683
30
                }
684
685
31
                break;
686
0
            }
687
688
79
            case FILTER_LESS_OR_EQUAL: {
689
79
                if (Compare::less(value, _high_value)) {
690
68
                    _high_value = value;
691
68
                    _high_op = op;
692
68
                }
693
694
79
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
637
            }
701
637
        }
702
703
642
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
642
            Compare::equal(_high_value, _low_value)) {
705
10
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
10
            _high_value = TYPE_MIN;
707
10
            _low_value = TYPE_MAX;
708
10
        }
709
642
    }
710
711
646
    return Status::OK();
712
646
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.75k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.75k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
1.75k
    _contain_null = false;
621
622
1.75k
    if (is_fixed_value_range()) {
623
32
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
32
        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
25
        case FILTER_LARGER_OR_EQUAL: {
632
25
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
25
            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
32
        }
655
656
32
        _high_value = TYPE_MIN;
657
32
        _low_value = TYPE_MAX;
658
1.72k
    } else {
659
1.72k
        if (Compare::greater(_high_value, _low_value)) {
660
1.68k
            switch (op) {
661
1.10k
            case FILTER_LARGER: {
662
1.10k
                if (Compare::greater_equal(value, _low_value)) {
663
1.10k
                    _low_value = value;
664
1.10k
                    _low_op = op;
665
1.10k
                }
666
667
1.10k
                break;
668
0
            }
669
670
258
            case FILTER_LARGER_OR_EQUAL: {
671
258
                if (Compare::greater(value, _low_value)) {
672
182
                    _low_value = value;
673
182
                    _low_op = op;
674
182
                }
675
676
258
                break;
677
0
            }
678
679
59
            case FILTER_LESS: {
680
59
                if (Compare::less_equal(value, _high_value)) {
681
54
                    _high_value = value;
682
54
                    _high_op = op;
683
54
                }
684
685
59
                break;
686
0
            }
687
688
257
            case FILTER_LESS_OR_EQUAL: {
689
257
                if (Compare::less(value, _high_value)) {
690
221
                    _high_value = value;
691
221
                    _high_op = op;
692
221
                }
693
694
257
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.68k
            }
701
1.68k
        }
702
703
1.72k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.72k
            Compare::equal(_high_value, _low_value)) {
705
101
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
101
            _high_value = TYPE_MIN;
707
101
            _low_value = TYPE_MAX;
708
101
        }
709
1.72k
    }
710
711
1.76k
    return Status::OK();
712
1.75k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
4.44k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
4.44k
    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.44k
    _contain_null = false;
621
622
4.44k
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
4.44k
    } else {
659
4.44k
        if (Compare::greater(_high_value, _low_value)) {
660
4.42k
            switch (op) {
661
74
            case FILTER_LARGER: {
662
75
                if (Compare::greater_equal(value, _low_value)) {
663
75
                    _low_value = value;
664
75
                    _low_op = op;
665
75
                }
666
667
74
                break;
668
0
            }
669
670
2.16k
            case FILTER_LARGER_OR_EQUAL: {
671
2.16k
                if (Compare::greater(value, _low_value)) {
672
111
                    _low_value = value;
673
111
                    _low_op = op;
674
111
                }
675
676
2.16k
                break;
677
0
            }
678
679
57
            case FILTER_LESS: {
680
57
                if (Compare::less_equal(value, _high_value)) {
681
54
                    _high_value = value;
682
54
                    _high_op = op;
683
54
                }
684
685
57
                break;
686
0
            }
687
688
2.15k
            case FILTER_LESS_OR_EQUAL: {
689
2.15k
                if (Compare::less(value, _high_value)) {
690
129
                    _high_value = value;
691
129
                    _high_op = op;
692
129
                }
693
694
2.15k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
4.42k
            }
701
4.42k
        }
702
703
4.42k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
4.42k
            Compare::equal(_high_value, _low_value)) {
705
58
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
58
            _high_value = TYPE_MIN;
707
58
            _low_value = TYPE_MAX;
708
58
        }
709
4.42k
    }
710
711
4.42k
    return Status::OK();
712
4.44k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
20.7k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
20.7k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
20.7k
    _contain_null = false;
621
622
20.7k
    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
19
        case FILTER_LARGER_OR_EQUAL: {
632
19
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
19
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
5
        case FILTER_LESS_OR_EQUAL: {
647
5
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
5
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
24
        }
655
656
24
        _high_value = TYPE_MIN;
657
24
        _low_value = TYPE_MAX;
658
20.7k
    } else {
659
20.7k
        if (Compare::greater(_high_value, _low_value)) {
660
20.6k
            switch (op) {
661
13.5k
            case FILTER_LARGER: {
662
13.5k
                if (Compare::greater_equal(value, _low_value)) {
663
13.5k
                    _low_value = value;
664
13.5k
                    _low_op = op;
665
13.5k
                }
666
667
13.5k
                break;
668
0
            }
669
670
4.08k
            case FILTER_LARGER_OR_EQUAL: {
671
4.08k
                if (Compare::greater(value, _low_value)) {
672
4.02k
                    _low_value = value;
673
4.02k
                    _low_op = op;
674
4.02k
                }
675
676
4.08k
                break;
677
0
            }
678
679
2.60k
            case FILTER_LESS: {
680
2.60k
                if (Compare::less_equal(value, _high_value)) {
681
2.59k
                    _high_value = value;
682
2.59k
                    _high_op = op;
683
2.59k
                }
684
685
2.60k
                break;
686
0
            }
687
688
435
            case FILTER_LESS_OR_EQUAL: {
689
435
                if (Compare::less(value, _high_value)) {
690
384
                    _high_value = value;
691
384
                    _high_op = op;
692
384
                }
693
694
435
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
20.6k
            }
701
20.6k
        }
702
703
20.7k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
20.7k
            Compare::equal(_high_value, _low_value)) {
705
72
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
72
            _high_value = TYPE_MIN;
707
72
            _low_value = TYPE_MAX;
708
72
        }
709
20.7k
    }
710
711
20.7k
    return Status::OK();
712
20.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
Line
Count
Source
614
6
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
6
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
6
    _contain_null = false;
621
622
6
    if (is_fixed_value_range()) {
623
6
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
6
        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
3
        case FILTER_LARGER_OR_EQUAL: {
632
3
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
3
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
3
        case FILTER_LESS_OR_EQUAL: {
647
3
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
3
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
6
        }
655
656
6
        _high_value = TYPE_MIN;
657
6
        _low_value = TYPE_MAX;
658
6
    } else {
659
0
        if (Compare::greater(_high_value, _low_value)) {
660
0
            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
0
            case FILTER_LARGER_OR_EQUAL: {
671
0
                if (Compare::greater(value, _low_value)) {
672
0
                    _low_value = value;
673
0
                    _low_op = op;
674
0
                }
675
676
0
                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
0
            case FILTER_LESS_OR_EQUAL: {
689
0
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
0
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
0
            }
701
0
        }
702
703
0
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
0
            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
0
    }
710
711
6
    return Status::OK();
712
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.62k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.62k
    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.62k
    _contain_null = false;
621
622
3.62k
    if (is_fixed_value_range()) {
623
6
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
6
        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
3
        case FILTER_LARGER_OR_EQUAL: {
632
3
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
3
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
3
        case FILTER_LESS_OR_EQUAL: {
647
3
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
3
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
6
        }
655
656
6
        _high_value = TYPE_MIN;
657
6
        _low_value = TYPE_MAX;
658
3.61k
    } else {
659
3.61k
        if (Compare::greater(_high_value, _low_value)) {
660
3.59k
            switch (op) {
661
259
            case FILTER_LARGER: {
662
259
                if (Compare::greater_equal(value, _low_value)) {
663
258
                    _low_value = value;
664
258
                    _low_op = op;
665
258
                }
666
667
259
                break;
668
0
            }
669
670
1.63k
            case FILTER_LARGER_OR_EQUAL: {
671
1.63k
                if (Compare::greater(value, _low_value)) {
672
1.58k
                    _low_value = value;
673
1.58k
                    _low_op = op;
674
1.58k
                }
675
676
1.63k
                break;
677
0
            }
678
679
1.43k
            case FILTER_LESS: {
680
1.43k
                if (Compare::less_equal(value, _high_value)) {
681
1.43k
                    _high_value = value;
682
1.43k
                    _high_op = op;
683
1.43k
                }
684
685
1.43k
                break;
686
0
            }
687
688
277
            case FILTER_LESS_OR_EQUAL: {
689
277
                if (Compare::less(value, _high_value)) {
690
227
                    _high_value = value;
691
227
                    _high_op = op;
692
227
                }
693
694
277
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.59k
            }
701
3.59k
        }
702
703
3.61k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.61k
            Compare::equal(_high_value, _low_value)) {
705
70
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
70
            _high_value = TYPE_MIN;
707
70
            _low_value = TYPE_MAX;
708
70
        }
709
3.61k
    }
710
711
3.62k
    return Status::OK();
712
3.62k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
965
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
965
    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
965
    _contain_null = false;
621
622
965
    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
965
    } else {
659
965
        if (Compare::greater(_high_value, _low_value)) {
660
965
            switch (op) {
661
225
            case FILTER_LARGER: {
662
225
                if (Compare::greater_equal(value, _low_value)) {
663
223
                    _low_value = value;
664
223
                    _low_op = op;
665
223
                }
666
667
225
                break;
668
0
            }
669
670
284
            case FILTER_LARGER_OR_EQUAL: {
671
284
                if (Compare::greater(value, _low_value)) {
672
138
                    _low_value = value;
673
138
                    _low_op = op;
674
138
                }
675
676
284
                break;
677
0
            }
678
679
171
            case FILTER_LESS: {
680
171
                if (Compare::less_equal(value, _high_value)) {
681
171
                    _high_value = value;
682
171
                    _high_op = op;
683
171
                }
684
685
171
                break;
686
0
            }
687
688
285
            case FILTER_LESS_OR_EQUAL: {
689
285
                if (Compare::less(value, _high_value)) {
690
199
                    _high_value = value;
691
199
                    _high_op = op;
692
199
                }
693
694
285
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
965
            }
701
965
        }
702
703
956
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
956
            Compare::equal(_high_value, _low_value)) {
705
91
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
91
            _high_value = TYPE_MIN;
707
91
            _low_value = TYPE_MAX;
708
91
        }
709
956
    }
710
711
956
    return Status::OK();
712
965
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Line
Count
Source
614
76
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
76
    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
76
    _contain_null = false;
621
622
76
    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
75
    } else {
659
75
        if (Compare::greater(_high_value, _low_value)) {
660
75
            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
37
            case FILTER_LARGER_OR_EQUAL: {
671
37
                if (Compare::greater(value, _low_value)) {
672
16
                    _low_value = value;
673
16
                    _low_op = op;
674
16
                }
675
676
37
                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
38
            case FILTER_LESS_OR_EQUAL: {
689
38
                if (Compare::less(value, _high_value)) {
690
1
                    _high_value = value;
691
1
                    _high_op = op;
692
1
                }
693
694
38
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
75
            }
701
75
        }
702
703
75
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
75
            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
75
    }
710
711
76
    return Status::OK();
712
76
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
169
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
169
    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
169
    _contain_null = false;
621
622
169
    if (is_fixed_value_range()) {
623
2
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
2
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
1
        case FILTER_LARGER_OR_EQUAL: {
632
1
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
1
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
1
        case FILTER_LESS_OR_EQUAL: {
647
1
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
1
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
2
        }
655
656
2
        _high_value = TYPE_MIN;
657
2
        _low_value = TYPE_MAX;
658
167
    } else {
659
167
        if (Compare::greater(_high_value, _low_value)) {
660
162
            switch (op) {
661
16
            case FILTER_LARGER: {
662
16
                if (Compare::greater_equal(value, _low_value)) {
663
16
                    _low_value = value;
664
16
                    _low_op = op;
665
16
                }
666
667
16
                break;
668
0
            }
669
670
63
            case FILTER_LARGER_OR_EQUAL: {
671
63
                if (Compare::greater(value, _low_value)) {
672
43
                    _low_value = value;
673
43
                    _low_op = op;
674
43
                }
675
676
63
                break;
677
0
            }
678
679
24
            case FILTER_LESS: {
680
24
                if (Compare::less_equal(value, _high_value)) {
681
23
                    _high_value = value;
682
23
                    _high_op = op;
683
23
                }
684
685
24
                break;
686
0
            }
687
688
61
            case FILTER_LESS_OR_EQUAL: {
689
61
                if (Compare::less(value, _high_value)) {
690
38
                    _high_value = value;
691
38
                    _high_op = op;
692
38
                }
693
694
61
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
162
            }
701
162
        }
702
703
165
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
165
            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
165
    }
710
711
167
    return Status::OK();
712
169
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
951
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
951
    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
951
    _contain_null = false;
621
622
951
    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
951
    } else {
659
951
        if (Compare::greater(_high_value, _low_value)) {
660
951
            switch (op) {
661
146
            case FILTER_LARGER: {
662
148
                if (Compare::greater_equal(value, _low_value)) {
663
148
                    _low_value = value;
664
148
                    _low_op = op;
665
148
                }
666
667
146
                break;
668
0
            }
669
670
386
            case FILTER_LARGER_OR_EQUAL: {
671
386
                if (Compare::greater(value, _low_value)) {
672
134
                    _low_value = value;
673
134
                    _low_op = op;
674
134
                }
675
676
386
                break;
677
0
            }
678
679
34
            case FILTER_LESS: {
680
34
                if (Compare::less_equal(value, _high_value)) {
681
32
                    _high_value = value;
682
32
                    _high_op = op;
683
32
                }
684
685
34
                break;
686
0
            }
687
688
384
            case FILTER_LESS_OR_EQUAL: {
689
384
                if (Compare::less(value, _high_value)) {
690
132
                    _high_value = value;
691
132
                    _high_op = op;
692
132
                }
693
694
384
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
951
            }
701
951
        }
702
703
950
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
950
            Compare::equal(_high_value, _low_value)) {
705
69
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
69
            _high_value = TYPE_MIN;
707
69
            _low_value = TYPE_MAX;
708
69
        }
709
950
    }
710
711
950
    return Status::OK();
712
951
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9add_rangeENS_11SQLFilterOpENS_12Decimal128V3E
Line
Count
Source
614
148
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
148
    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
148
    _contain_null = false;
621
622
148
    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
148
    } else {
659
148
        if (Compare::greater(_high_value, _low_value)) {
660
148
            switch (op) {
661
100
            case FILTER_LARGER: {
662
100
                if (Compare::greater_equal(value, _low_value)) {
663
99
                    _low_value = value;
664
99
                    _low_op = op;
665
99
                }
666
667
100
                break;
668
0
            }
669
670
21
            case FILTER_LARGER_OR_EQUAL: {
671
21
                if (Compare::greater(value, _low_value)) {
672
13
                    _low_value = value;
673
13
                    _low_op = op;
674
13
                }
675
676
21
                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
17
            case FILTER_LESS_OR_EQUAL: {
689
17
                if (Compare::less(value, _high_value)) {
690
9
                    _high_value = value;
691
9
                    _high_op = op;
692
9
                }
693
694
17
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
148
            }
701
148
        }
702
703
147
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
147
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
147
    }
710
711
147
    return Status::OK();
712
148
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9add_rangeENS_11SQLFilterOpENS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
614
230
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
230
    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
230
    _contain_null = false;
621
622
230
    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
230
    } else {
659
230
        if (Compare::greater(_high_value, _low_value)) {
660
229
            switch (op) {
661
58
            case FILTER_LARGER: {
662
58
                if (Compare::greater_equal(value, _low_value)) {
663
58
                    _low_value = value;
664
58
                    _low_op = op;
665
58
                }
666
667
58
                break;
668
0
            }
669
670
62
            case FILTER_LARGER_OR_EQUAL: {
671
62
                if (Compare::greater(value, _low_value)) {
672
40
                    _low_value = value;
673
40
                    _low_op = op;
674
40
                }
675
676
62
                break;
677
0
            }
678
679
45
            case FILTER_LESS: {
680
45
                if (Compare::less_equal(value, _high_value)) {
681
45
                    _high_value = value;
682
45
                    _high_op = op;
683
45
                }
684
685
45
                break;
686
0
            }
687
688
63
            case FILTER_LESS_OR_EQUAL: {
689
63
                if (Compare::less(value, _high_value)) {
690
40
                    _high_value = value;
691
40
                    _high_op = op;
692
40
                }
693
694
63
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
229
            }
701
229
        }
702
703
230
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
230
            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
230
    }
710
711
230
    return Status::OK();
712
230
}
713
714
template <PrimitiveType primitive_type>
715
467k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
467k
    switch (_high_op) {
717
95
    case FILTER_LESS: {
718
95
        switch (_low_op) {
719
3
        case FILTER_LARGER: {
720
3
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
92
        case FILTER_LARGER_OR_EQUAL: {
724
92
            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
95
        }
731
732
0
        break;
733
95
    }
734
735
467k
    case FILTER_LESS_OR_EQUAL: {
736
467k
        switch (_low_op) {
737
26
        case FILTER_LARGER: {
738
26
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
467k
        case FILTER_LARGER_OR_EQUAL: {
742
467k
            return Compare::less_equal(value, _high_value) &&
743
467k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
467k
        }
750
467k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
467k
    }
756
757
0
    return false;
758
467k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
121k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
121k
    switch (_high_op) {
717
3
    case FILTER_LESS: {
718
3
        switch (_low_op) {
719
3
        case FILTER_LARGER: {
720
3
            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
3
        }
731
732
0
        break;
733
3
    }
734
735
121k
    case FILTER_LESS_OR_EQUAL: {
736
121k
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
121k
        case FILTER_LARGER_OR_EQUAL: {
742
121k
            return Compare::less_equal(value, _high_value) &&
743
121k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
121k
        }
750
121k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
121k
    }
756
757
0
    return false;
758
121k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
116
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
116
    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
116
    case FILTER_LESS_OR_EQUAL: {
736
116
        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
116
        case FILTER_LARGER_OR_EQUAL: {
742
116
            return Compare::less_equal(value, _high_value) &&
743
116
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
116
        }
750
116
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
116
    }
756
757
0
    return false;
758
116
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
36.5k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
36.5k
    switch (_high_op) {
717
70
    case FILTER_LESS: {
718
70
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
70
        case FILTER_LARGER_OR_EQUAL: {
724
70
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
70
        }
731
732
0
        break;
733
70
    }
734
735
36.4k
    case FILTER_LESS_OR_EQUAL: {
736
36.4k
        switch (_low_op) {
737
2
        case FILTER_LARGER: {
738
2
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
36.4k
        case FILTER_LARGER_OR_EQUAL: {
742
36.4k
            return Compare::less_equal(value, _high_value) &&
743
36.5k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
36.4k
        }
750
36.4k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
36.5k
    }
756
757
0
    return false;
758
36.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
2.00k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
2.00k
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
2.00k
    case FILTER_LESS_OR_EQUAL: {
736
2.00k
        switch (_low_op) {
737
12
        case FILTER_LARGER: {
738
12
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
1.99k
        case FILTER_LARGER_OR_EQUAL: {
742
1.99k
            return Compare::less_equal(value, _high_value) &&
743
1.99k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
2.00k
        }
750
2.00k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
2.00k
    }
756
757
0
    return false;
758
2.00k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
221
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
221
    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
221
    case FILTER_LESS_OR_EQUAL: {
736
221
        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
221
        case FILTER_LARGER_OR_EQUAL: {
742
221
            return Compare::less_equal(value, _high_value) &&
743
221
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
221
        }
750
221
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
221
    }
756
757
0
    return false;
758
221
}
_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
44
        case FILTER_LARGER_OR_EQUAL: {
742
44
            return Compare::less_equal(value, _high_value) &&
743
44
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
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
160
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
160
    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
161
    case FILTER_LESS_OR_EQUAL: {
736
161
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
161
        case FILTER_LARGER_OR_EQUAL: {
742
161
            return Compare::less_equal(value, _high_value) &&
743
161
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
161
        }
750
161
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
160
    }
756
757
0
    return false;
758
160
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE11is_in_rangeERKj
Line
Count
Source
715
35
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
35
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
35
    case FILTER_LESS_OR_EQUAL: {
736
35
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
35
        case FILTER_LARGER_OR_EQUAL: {
742
35
            return Compare::less_equal(value, _high_value) &&
743
35
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
35
        }
750
35
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
35
    }
756
757
0
    return false;
758
35
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE11is_in_rangeERKo
Line
Count
Source
715
35
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
35
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
35
    case FILTER_LESS_OR_EQUAL: {
736
35
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
36
        case FILTER_LARGER_OR_EQUAL: {
742
36
            return Compare::less_equal(value, _high_value) &&
743
36
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
35
        }
750
35
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
35
    }
756
757
0
    return false;
758
35
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
513
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
513
    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
515
    case FILTER_LESS_OR_EQUAL: {
736
515
        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
517
        case FILTER_LARGER_OR_EQUAL: {
742
517
            return Compare::less_equal(value, _high_value) &&
743
517
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
515
        }
750
515
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
513
    }
756
757
0
    return false;
758
513
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
293k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
293k
    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
293k
    case FILTER_LESS_OR_EQUAL: {
736
293k
        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
293k
        case FILTER_LARGER_OR_EQUAL: {
742
293k
            return Compare::less_equal(value, _high_value) &&
743
293k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
293k
        }
750
293k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
293k
    }
756
757
0
    return false;
758
293k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
1.43k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.43k
    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.43k
    case FILTER_LESS_OR_EQUAL: {
736
1.43k
        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.43k
        case FILTER_LARGER_OR_EQUAL: {
742
1.43k
            return Compare::less_equal(value, _high_value) &&
743
1.43k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.43k
        }
750
1.43k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.43k
    }
756
757
0
    return false;
758
1.43k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
71
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
71
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
71
    case FILTER_LESS_OR_EQUAL: {
736
71
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
71
        case FILTER_LARGER_OR_EQUAL: {
742
71
            return Compare::less_equal(value, _high_value) &&
743
71
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
71
        }
750
71
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
71
    }
756
757
0
    return false;
758
71
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
9.68k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
9.68k
    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.68k
    case FILTER_LESS_OR_EQUAL: {
736
9.68k
        switch (_low_op) {
737
12
        case FILTER_LARGER: {
738
12
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
9.67k
        case FILTER_LARGER_OR_EQUAL: {
742
9.67k
            return Compare::less_equal(value, _high_value) &&
743
9.67k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
9.68k
        }
750
9.68k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
9.68k
    }
756
757
0
    return false;
758
9.68k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
57
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
57
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
57
    case FILTER_LESS_OR_EQUAL: {
736
57
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
56
        case FILTER_LARGER_OR_EQUAL: {
742
56
            return Compare::less_equal(value, _high_value) &&
743
57
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
57
        }
750
57
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
57
    }
756
757
0
    return false;
758
57
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
570
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
570
    switch (_high_op) {
717
18
    case FILTER_LESS: {
718
18
        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
18
        case FILTER_LARGER_OR_EQUAL: {
724
18
            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
18
        }
731
732
0
        break;
733
18
    }
734
735
552
    case FILTER_LESS_OR_EQUAL: {
736
552
        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
550
        case FILTER_LARGER_OR_EQUAL: {
742
550
            return Compare::less_equal(value, _high_value) &&
743
550
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
552
        }
750
552
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
570
    }
756
757
0
    return false;
758
570
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
206
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
206
    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
206
    case FILTER_LESS_OR_EQUAL: {
736
206
        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
206
        case FILTER_LARGER_OR_EQUAL: {
742
206
            return Compare::less_equal(value, _high_value) &&
743
206
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
206
        }
750
206
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
206
    }
756
757
0
    return false;
758
206
}
_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
225
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
225
    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
225
    case FILTER_LESS_OR_EQUAL: {
736
225
        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
225
        case FILTER_LARGER_OR_EQUAL: {
742
225
            return Compare::less_equal(value, _high_value) &&
743
225
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
225
        }
750
225
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
225
    }
756
757
0
    return false;
758
225
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
50
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
50
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
50
    case FILTER_LESS_OR_EQUAL: {
736
50
        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
50
        case FILTER_LARGER_OR_EQUAL: {
742
50
            return Compare::less_equal(value, _high_value) &&
743
50
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
50
        }
750
50
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
50
    }
756
757
0
    return false;
758
50
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE11is_in_rangeERKNS_7DecimalIlEE
Line
Count
Source
715
259
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
259
    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
259
    case FILTER_LESS_OR_EQUAL: {
736
259
        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
260
        case FILTER_LARGER_OR_EQUAL: {
742
260
            return Compare::less_equal(value, _high_value) &&
743
260
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
259
        }
750
259
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
259
    }
756
757
0
    return false;
758
259
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE11is_in_rangeERKNS_12Decimal128V3E
Line
Count
Source
715
137
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
137
    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
137
    case FILTER_LESS_OR_EQUAL: {
736
137
        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
137
        case FILTER_LARGER_OR_EQUAL: {
742
137
            return Compare::less_equal(value, _high_value) &&
743
137
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
137
        }
750
137
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
137
    }
756
757
0
    return false;
758
137
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE11is_in_rangeERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
715
95
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
95
    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
95
    case FILTER_LESS_OR_EQUAL: {
736
95
        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
95
        case FILTER_LARGER_OR_EQUAL: {
742
95
            return Compare::less_equal(value, _high_value) &&
743
95
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
95
        }
750
95
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
95
    }
756
757
0
    return false;
758
95
}
759
760
template <PrimitiveType primitive_type>
761
457k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
457k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
457k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
18.0k
        set_empty_value_range();
770
18.0k
    }
771
772
457k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
457k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
432k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
365
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
365
                             range._fixed_values.begin(), range._fixed_values.end(),
778
365
                             std::inserter(result_values, result_values.begin()));
779
432k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
8
            IteratorType iter = _fixed_values.begin();
781
782
33
            while (iter != _fixed_values.end()) {
783
25
                if (range.is_in_range(*iter)) {
784
24
                    result_values.insert(*iter);
785
24
                }
786
25
                ++iter;
787
25
            }
788
432k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
431k
            IteratorType iter = range._fixed_values.begin();
790
897k
            while (iter != range._fixed_values.end()) {
791
467k
                if (this->is_in_range(*iter)) {
792
467k
                    result_values.insert(*iter);
793
467k
                }
794
465k
                ++iter;
795
465k
            }
796
431k
        }
797
798
435k
        if (!result_values.empty()) {
799
435k
            _fixed_values = std::move(result_values);
800
435k
            _contain_null = false;
801
435k
            _high_value = TYPE_MIN;
802
435k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
432k
    } else {
807
25.1k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
964
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
964
                set_contain_null(true);
811
964
            }
812
24.1k
        } else {
813
24.1k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
24.1k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
24.1k
        }
816
25.1k
    }
817
457k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
122k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
122k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
122k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
123
        set_empty_value_range();
770
123
    }
771
772
122k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
122k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
120k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
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
120k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
120k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
120k
            IteratorType iter = range._fixed_values.begin();
790
240k
            while (iter != range._fixed_values.end()) {
791
121k
                if (this->is_in_range(*iter)) {
792
121k
                    result_values.insert(*iter);
793
121k
                }
794
120k
                ++iter;
795
120k
            }
796
120k
        }
797
798
122k
        if (!result_values.empty()) {
799
122k
            _fixed_values = std::move(result_values);
800
122k
            _contain_null = false;
801
122k
            _high_value = TYPE_MIN;
802
122k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
120k
    } else {
807
1.78k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
30
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
30
                set_contain_null(true);
811
30
            }
812
1.75k
        } else {
813
1.75k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.75k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.75k
        }
816
1.78k
    }
817
122k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
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
8
        set_empty_value_range();
770
8
    }
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
97
        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
97
        } 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
97
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
97
            IteratorType iter = range._fixed_values.begin();
790
213
            while (iter != range._fixed_values.end()) {
791
117
                if (this->is_in_range(*iter)) {
792
117
                    result_values.insert(*iter);
793
117
                }
794
116
                ++iter;
795
116
            }
796
97
        }
797
798
98
        if (!result_values.empty()) {
799
98
            _fixed_values = std::move(result_values);
800
98
            _contain_null = false;
801
98
            _high_value = TYPE_MIN;
802
98
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
97
    } else {
807
68
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
33
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
33
                set_contain_null(true);
811
33
            }
812
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
68
    }
817
165
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
7.12k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
7.12k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
7.12k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
200
        set_empty_value_range();
770
200
    }
771
772
7.12k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
7.12k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
6.02k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
101
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
101
                             range._fixed_values.begin(), range._fixed_values.end(),
778
101
                             std::inserter(result_values, result_values.begin()));
779
5.92k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
5.92k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
5.91k
            IteratorType iter = range._fixed_values.begin();
790
42.8k
            while (iter != range._fixed_values.end()) {
791
36.9k
                if (this->is_in_range(*iter)) {
792
36.6k
                    result_values.insert(*iter);
793
36.6k
                }
794
36.9k
                ++iter;
795
36.9k
            }
796
5.91k
        }
797
798
6.05k
        if (!result_values.empty()) {
799
6.05k
            _fixed_values = std::move(result_values);
800
6.05k
            _contain_null = false;
801
6.05k
            _high_value = TYPE_MIN;
802
6.05k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
6.02k
    } else {
807
1.09k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
212
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
212
                set_contain_null(true);
811
212
            }
812
887
        } else {
813
887
            static_cast<void>(add_range(range._high_op, range._high_value));
814
887
            static_cast<void>(add_range(range._low_op, range._low_value));
815
887
        }
816
1.09k
    }
817
7.12k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
18.9k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
18.9k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
18.9k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
17.6k
        set_empty_value_range();
770
17.6k
    }
771
772
18.9k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
18.9k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.20k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
59
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
59
                             range._fixed_values.begin(), range._fixed_values.end(),
778
59
                             std::inserter(result_values, result_values.begin()));
779
1.14k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
8
            IteratorType iter = _fixed_values.begin();
781
782
33
            while (iter != _fixed_values.end()) {
783
25
                if (range.is_in_range(*iter)) {
784
24
                    result_values.insert(*iter);
785
24
                }
786
25
                ++iter;
787
25
            }
788
1.13k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.13k
            IteratorType iter = range._fixed_values.begin();
790
3.12k
            while (iter != range._fixed_values.end()) {
791
1.98k
                if (this->is_in_range(*iter)) {
792
1.98k
                    result_values.insert(*iter);
793
1.98k
                }
794
1.98k
                ++iter;
795
1.98k
            }
796
1.13k
        }
797
798
1.20k
        if (!result_values.empty()) {
799
1.20k
            _fixed_values = std::move(result_values);
800
1.20k
            _contain_null = false;
801
1.20k
            _high_value = TYPE_MIN;
802
1.20k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
17.7k
    } else {
807
17.7k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
34
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
34
                set_contain_null(true);
811
34
            }
812
17.7k
        } else {
813
17.7k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
17.7k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
17.7k
        }
816
17.7k
    }
817
18.9k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
207
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
207
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
207
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
1
        set_empty_value_range();
770
1
    }
771
772
207
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
207
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
196
        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
196
        } 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
196
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
196
            IteratorType iter = range._fixed_values.begin();
790
417
            while (iter != range._fixed_values.end()) {
791
221
                if (this->is_in_range(*iter)) {
792
221
                    result_values.insert(*iter);
793
221
                }
794
221
                ++iter;
795
221
            }
796
196
        }
797
798
197
        if (!result_values.empty()) {
799
197
            _fixed_values = std::move(result_values);
800
197
            _contain_null = false;
801
197
            _high_value = TYPE_MIN;
802
197
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
196
    } else {
807
11
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
7
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
7
                set_contain_null(true);
811
7
            }
812
7
        } else {
813
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
11
    }
817
207
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
101
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
101
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
103
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
101
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
101
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
47
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
16
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
16
                             range._fixed_values.begin(), range._fixed_values.end(),
778
16
                             std::inserter(result_values, result_values.begin()));
779
31
        } 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
31
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
31
            IteratorType iter = range._fixed_values.begin();
790
73
            while (iter != range._fixed_values.end()) {
791
43
                if (this->is_in_range(*iter)) {
792
43
                    result_values.insert(*iter);
793
43
                }
794
42
                ++iter;
795
42
            }
796
31
        }
797
798
49
        if (!result_values.empty()) {
799
49
            _fixed_values = std::move(result_values);
800
49
            _contain_null = false;
801
49
            _high_value = TYPE_MIN;
802
49
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
54
    } else {
807
54
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
38
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
38
                set_contain_null(true);
811
38
            }
812
38
        } else {
813
16
            static_cast<void>(add_range(range._high_op, range._high_value));
814
16
            static_cast<void>(add_range(range._low_op, range._low_value));
815
16
        }
816
54
    }
817
101
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
206
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
206
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
207
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
206
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
206
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
118
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
118
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
118
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
118
            IteratorType iter = range._fixed_values.begin();
790
278
            while (iter != range._fixed_values.end()) {
791
160
                if (this->is_in_range(*iter)) {
792
160
                    result_values.insert(*iter);
793
160
                }
794
160
                ++iter;
795
160
            }
796
118
        }
797
798
119
        if (!result_values.empty()) {
799
119
            _fixed_values = std::move(result_values);
800
119
            _contain_null = false;
801
119
            _high_value = TYPE_MIN;
802
119
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
118
    } else {
807
88
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
42
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
42
                set_contain_null(true);
811
42
            }
812
46
        } else {
813
46
            static_cast<void>(add_range(range._high_op, range._high_value));
814
46
            static_cast<void>(add_range(range._low_op, range._low_value));
815
46
        }
816
88
    }
817
206
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE12intersectionERS2_
Line
Count
Source
761
29
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
29
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
29
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
29
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
29
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
26
        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
26
        } 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
26
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
26
            IteratorType iter = range._fixed_values.begin();
790
61
            while (iter != range._fixed_values.end()) {
791
35
                if (this->is_in_range(*iter)) {
792
35
                    result_values.insert(*iter);
793
35
                }
794
35
                ++iter;
795
35
            }
796
26
        }
797
798
26
        if (!result_values.empty()) {
799
26
            _fixed_values = std::move(result_values);
800
26
            _contain_null = false;
801
26
            _high_value = TYPE_MIN;
802
26
            _low_value = TYPE_MAX;
803
26
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
26
    } 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
29
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE12intersectionERS2_
Line
Count
Source
761
28
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
28
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
28
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
28
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
28
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
26
        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
26
        } 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
26
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
26
            IteratorType iter = range._fixed_values.begin();
790
61
            while (iter != range._fixed_values.end()) {
791
35
                if (this->is_in_range(*iter)) {
792
35
                    result_values.insert(*iter);
793
35
                }
794
35
                ++iter;
795
35
            }
796
26
        }
797
798
27
        if (!result_values.empty()) {
799
27
            _fixed_values = std::move(result_values);
800
27
            _contain_null = false;
801
27
            _high_value = TYPE_MIN;
802
27
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
26
    } else {
807
2
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
2
        } else {
813
2
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2
        }
816
2
    }
817
28
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
431
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
431
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
431
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
431
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
431
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
377
        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
375
        } 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
378
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
378
            IteratorType iter = range._fixed_values.begin();
790
893
            while (iter != range._fixed_values.end()) {
791
515
                if (this->is_in_range(*iter)) {
792
515
                    result_values.insert(*iter);
793
515
                }
794
515
                ++iter;
795
515
            }
796
378
        }
797
798
385
        if (!result_values.empty()) {
799
385
            _fixed_values = std::move(result_values);
800
385
            _contain_null = false;
801
385
            _high_value = TYPE_MIN;
802
385
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
377
    } else {
807
54
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
34
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
34
                set_contain_null(true);
811
34
            }
812
34
        } else {
813
20
            static_cast<void>(add_range(range._high_op, range._high_value));
814
20
            static_cast<void>(add_range(range._low_op, range._low_value));
815
20
        }
816
54
    }
817
431
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
293k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
293k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
293k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
18
        set_empty_value_range();
770
18
    }
771
772
293k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
293k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
291k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
10
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
10
                             range._fixed_values.begin(), range._fixed_values.end(),
778
10
                             std::inserter(result_values, result_values.begin()));
779
291k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
291k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
291k
            IteratorType iter = range._fixed_values.begin();
790
584k
            while (iter != range._fixed_values.end()) {
791
293k
                if (this->is_in_range(*iter)) {
792
293k
                    result_values.insert(*iter);
793
293k
                }
794
292k
                ++iter;
795
292k
            }
796
291k
        }
797
798
293k
        if (!result_values.empty()) {
799
293k
            _fixed_values = std::move(result_values);
800
293k
            _contain_null = false;
801
293k
            _high_value = TYPE_MIN;
802
293k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
291k
    } else {
807
1.30k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
183
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
183
                set_contain_null(true);
811
183
            }
812
1.12k
        } else {
813
1.12k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.12k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.12k
        }
816
1.30k
    }
817
293k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
3.46k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
3.46k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
3.49k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
3.46k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
3.46k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.29k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
40
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
40
                             range._fixed_values.begin(), range._fixed_values.end(),
778
40
                             std::inserter(result_values, result_values.begin()));
779
1.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
1.25k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.25k
            IteratorType iter = range._fixed_values.begin();
790
2.68k
            while (iter != range._fixed_values.end()) {
791
1.43k
                if (this->is_in_range(*iter)) {
792
1.43k
                    result_values.insert(*iter);
793
1.43k
                }
794
1.43k
                ++iter;
795
1.43k
            }
796
1.25k
        }
797
798
1.29k
        if (!result_values.empty()) {
799
1.29k
            _fixed_values = std::move(result_values);
800
1.29k
            _contain_null = false;
801
1.29k
            _high_value = TYPE_MIN;
802
1.29k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
2.17k
    } else {
807
2.17k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
132
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
132
                set_contain_null(true);
811
132
            }
812
2.04k
        } else {
813
2.04k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2.04k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2.04k
        }
816
2.17k
    }
817
3.46k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
37
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
37
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
37
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
37
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
37
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
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
108
            while (iter != range._fixed_values.end()) {
791
71
                if (this->is_in_range(*iter)) {
792
71
                    result_values.insert(*iter);
793
71
                }
794
71
                ++iter;
795
71
            }
796
37
        }
797
798
37
        if (!result_values.empty()) {
799
37
            _fixed_values = std::move(result_values);
800
37
            _contain_null = false;
801
37
            _high_value = TYPE_MIN;
802
37
            _low_value = TYPE_MAX;
803
37
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
37
    } 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
37
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
9.37k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
9.37k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
9.38k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
20
        set_empty_value_range();
770
20
    }
771
772
9.37k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
9.37k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
9.22k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
20
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
20
                             range._fixed_values.begin(), range._fixed_values.end(),
778
20
                             std::inserter(result_values, result_values.begin()));
779
9.20k
        } 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.20k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
9.20k
            IteratorType iter = range._fixed_values.begin();
790
18.8k
            while (iter != range._fixed_values.end()) {
791
9.69k
                if (this->is_in_range(*iter)) {
792
9.69k
                    result_values.insert(*iter);
793
9.69k
                }
794
9.67k
                ++iter;
795
9.67k
            }
796
9.20k
        }
797
798
9.28k
        if (!result_values.empty()) {
799
9.28k
            _fixed_values = std::move(result_values);
800
9.28k
            _contain_null = false;
801
9.28k
            _high_value = TYPE_MIN;
802
9.28k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
9.22k
    } else {
807
153
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
64
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
64
                set_contain_null(true);
811
64
            }
812
92
        } else {
813
92
            static_cast<void>(add_range(range._high_op, range._high_value));
814
92
            static_cast<void>(add_range(range._low_op, range._low_value));
815
92
        }
816
153
    }
817
9.37k
}
_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
29
        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
29
        } 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
29
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
29
            IteratorType iter = range._fixed_values.begin();
790
85
            while (iter != range._fixed_values.end()) {
791
56
                if (this->is_in_range(*iter)) {
792
56
                    result_values.insert(*iter);
793
56
                }
794
56
                ++iter;
795
56
            }
796
29
        }
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
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
29
    } else {
807
1
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
1
        } else {
813
1
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1
        }
816
1
    }
817
30
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12intersectionERS2_
Line
Count
Source
761
626
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
626
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
628
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
626
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
626
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
528
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
48
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
48
                             range._fixed_values.begin(), range._fixed_values.end(),
778
48
                             std::inserter(result_values, result_values.begin()));
779
480
        } 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
480
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
476
            IteratorType iter = range._fixed_values.begin();
790
1.03k
            while (iter != range._fixed_values.end()) {
791
561
                if (this->is_in_range(*iter)) {
792
561
                    result_values.insert(*iter);
793
561
                }
794
555
                ++iter;
795
555
            }
796
476
        }
797
798
544
        if (!result_values.empty()) {
799
544
            _fixed_values = std::move(result_values);
800
544
            _contain_null = false;
801
544
            _high_value = TYPE_MIN;
802
544
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
528
    } else {
807
98
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
38
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
38
                set_contain_null(true);
811
38
            }
812
60
        } else {
813
60
            static_cast<void>(add_range(range._high_op, range._high_value));
814
60
            static_cast<void>(add_range(range._low_op, range._low_value));
815
60
        }
816
98
    }
817
626
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
183
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
183
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
183
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
183
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
183
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
106
        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
106
        } 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
106
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
106
            IteratorType iter = range._fixed_values.begin();
790
312
            while (iter != range._fixed_values.end()) {
791
206
                if (this->is_in_range(*iter)) {
792
206
                    result_values.insert(*iter);
793
206
                }
794
206
                ++iter;
795
206
            }
796
106
        }
797
798
106
        if (!result_values.empty()) {
799
106
            _fixed_values = std::move(result_values);
800
106
            _contain_null = false;
801
106
            _high_value = TYPE_MIN;
802
106
            _low_value = TYPE_MAX;
803
106
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
106
    } else {
807
77
        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
68
        } else {
813
68
            static_cast<void>(add_range(range._high_op, range._high_value));
814
68
            static_cast<void>(add_range(range._low_op, range._low_value));
815
68
        }
816
77
    }
817
183
}
_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
271
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
271
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
271
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
271
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
271
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
228
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
17
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
17
                             range._fixed_values.begin(), range._fixed_values.end(),
778
17
                             std::inserter(result_values, result_values.begin()));
779
211
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
211
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
211
            IteratorType iter = range._fixed_values.begin();
790
436
            while (iter != range._fixed_values.end()) {
791
225
                if (this->is_in_range(*iter)) {
792
224
                    result_values.insert(*iter);
793
224
                }
794
225
                ++iter;
795
225
            }
796
211
        }
797
798
228
        if (!result_values.empty()) {
799
228
            _fixed_values = std::move(result_values);
800
228
            _contain_null = false;
801
228
            _high_value = TYPE_MIN;
802
228
            _low_value = TYPE_MAX;
803
228
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
228
    } else {
807
43
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
35
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
35
                set_contain_null(true);
811
35
            }
812
33
        } else {
813
10
            static_cast<void>(add_range(range._high_op, range._high_value));
814
10
            static_cast<void>(add_range(range._low_op, range._low_value));
815
10
        }
816
43
    }
817
271
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12intersectionERS2_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12intersectionERS2_
Line
Count
Source
761
68
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
68
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
68
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
1
        set_empty_value_range();
770
1
    }
771
772
68
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
68
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
43
        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
43
        } 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
43
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
43
            IteratorType iter = range._fixed_values.begin();
790
93
            while (iter != range._fixed_values.end()) {
791
50
                if (this->is_in_range(*iter)) {
792
50
                    result_values.insert(*iter);
793
50
                }
794
50
                ++iter;
795
50
            }
796
43
        }
797
798
43
        if (!result_values.empty()) {
799
43
            _fixed_values = std::move(result_values);
800
43
            _contain_null = false;
801
43
            _high_value = TYPE_MIN;
802
43
            _low_value = TYPE_MAX;
803
43
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
43
    } else {
807
25
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
4
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
4
                set_contain_null(true);
811
4
            }
812
21
        } else {
813
21
            static_cast<void>(add_range(range._high_op, range._high_value));
814
21
            static_cast<void>(add_range(range._low_op, range._low_value));
815
21
        }
816
25
    }
817
68
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
567
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
567
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
569
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
567
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
567
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
245
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
52
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
52
                             range._fixed_values.begin(), range._fixed_values.end(),
778
52
                             std::inserter(result_values, result_values.begin()));
779
193
        } 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
193
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
193
            IteratorType iter = range._fixed_values.begin();
790
451
            while (iter != range._fixed_values.end()) {
791
259
                if (this->is_in_range(*iter)) {
792
259
                    result_values.insert(*iter);
793
259
                }
794
258
                ++iter;
795
258
            }
796
193
        }
797
798
247
        if (!result_values.empty()) {
799
247
            _fixed_values = std::move(result_values);
800
247
            _contain_null = false;
801
247
            _high_value = TYPE_MIN;
802
247
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
322
    } else {
807
322
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
68
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
68
                set_contain_null(true);
811
68
            }
812
254
        } else {
813
254
            static_cast<void>(add_range(range._high_op, range._high_value));
814
254
            static_cast<void>(add_range(range._low_op, range._low_value));
815
254
        }
816
322
    }
817
567
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
138
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
138
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
138
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
138
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
138
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
130
        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
130
        } 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
130
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
130
            IteratorType iter = range._fixed_values.begin();
790
267
            while (iter != range._fixed_values.end()) {
791
137
                if (this->is_in_range(*iter)) {
792
137
                    result_values.insert(*iter);
793
137
                }
794
137
                ++iter;
795
137
            }
796
130
        }
797
798
130
        if (!result_values.empty()) {
799
130
            _fixed_values = std::move(result_values);
800
130
            _contain_null = false;
801
130
            _high_value = TYPE_MIN;
802
130
            _low_value = TYPE_MAX;
803
130
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
130
    } else {
807
8
        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
8
        } else {
813
8
            static_cast<void>(add_range(range._high_op, range._high_value));
814
8
            static_cast<void>(add_range(range._low_op, range._low_value));
815
8
        }
816
8
    }
817
138
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
106
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
106
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
106
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
106
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
106
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
79
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
79
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
79
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
79
            IteratorType iter = range._fixed_values.begin();
790
172
            while (iter != range._fixed_values.end()) {
791
96
                if (this->is_in_range(*iter)) {
792
96
                    result_values.insert(*iter);
793
96
                }
794
93
                ++iter;
795
93
            }
796
79
        }
797
798
81
        if (!result_values.empty()) {
799
81
            _fixed_values = std::move(result_values);
800
81
            _contain_null = false;
801
81
            _high_value = TYPE_MIN;
802
81
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
79
    } else {
807
27
        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
26
        } else {
813
26
            static_cast<void>(add_range(range._high_op, range._high_value));
814
26
            static_cast<void>(add_range(range._low_op, range._low_value));
815
26
        }
816
27
    }
817
106
}
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
567k
                                     bool* should_break) {
823
567k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
567k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
567k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
567k
    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
567k
    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
567k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
567k
    if (range.is_fixed_value_range()) {
842
288k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
13
            if (range.is_range_value_convertible()) {
844
12
                range.convert_to_range_value();
845
12
                *exact_value = false;
846
12
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
13
        }
851
288k
    } else {
852
278k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
278k
            !range.is_reject_split_type()) {
854
155k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
155k
                                                 _end_include);
856
857
155k
            if (!(*eos) &&
858
155k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
155k
                                                 _end_include, max_scan_key_num)) {
860
154k
                _has_range_value = true;
861
154k
            }
862
155k
            return Status::OK();
863
155k
        }
864
278k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
412k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
288k
        if (_begin_scan_keys.empty()) {
870
98.6k
            auto fixed_value_set = range.get_fixed_value_set();
871
98.6k
            ConstIterator iter = fixed_value_set.begin();
872
873
198k
            for (; iter != fixed_value_set.end(); ++iter) {
874
99.9k
                _begin_scan_keys.emplace_back();
875
99.9k
                _begin_scan_keys.back().add_value(
876
99.9k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
99.9k
                _end_scan_keys.emplace_back();
878
99.9k
                _end_scan_keys.back().add_value(
879
99.9k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
99.9k
            }
881
882
98.6k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
98.6k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
189k
        else {
890
189k
            auto fixed_value_set = range.get_fixed_value_set();
891
189k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
379k
            for (int i = 0; i < original_key_range_size; ++i) {
894
190k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
190k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
190k
                ConstIterator iter = fixed_value_set.begin();
898
899
380k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
190k
                        _begin_scan_keys[i].add_value(
903
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
190k
                        _end_scan_keys[i].add_value(
905
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
190k
                    } // append follow ScanKey
907
128
                    else {
908
128
                        _begin_scan_keys.push_back(start_base_key_range);
909
128
                        _begin_scan_keys.back().add_value(
910
128
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
128
                        _end_scan_keys.push_back(end_base_key_range);
912
128
                        _end_scan_keys.back().add_value(
913
128
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
128
                    }
915
190k
                }
916
917
190k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
190k
            }
924
189k
        }
925
926
288k
        _begin_include = true;
927
288k
        _end_include = true;
928
288k
    } // Extend ScanKey with range value
929
124k
    else {
930
124k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
124k
        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
124k
        } else if (_begin_scan_keys.empty()) {
947
26.4k
            _begin_scan_keys.emplace_back();
948
26.4k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
26.4k
                                                      range.get_range_min_value(), range.scale()),
950
26.4k
                                              range.contain_null());
951
26.4k
            _end_scan_keys.emplace_back();
952
26.4k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
26.4k
                    range.get_range_max_value(), range.scale()));
954
97.7k
        } else {
955
198k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
100k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
100k
                                                      range.get_range_min_value(), range.scale()),
958
100k
                                              range.contain_null());
959
100k
            }
960
961
198k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
101k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
101k
                        range.get_range_max_value(), range.scale()));
964
101k
            }
965
97.7k
        }
966
124k
        _begin_include = range.is_begin_include();
967
124k
        _end_include = range.is_end_include();
968
124k
    }
969
970
412k
    return Status::OK();
971
567k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.36k
                                     bool* should_break) {
823
2.36k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.36k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.36k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.36k
    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.36k
    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.36k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.36k
    if (range.is_fixed_value_range()) {
842
9
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.35k
    } else {
852
2.35k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.35k
            !range.is_reject_split_type()) {
854
2.31k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.31k
                                                 _end_include);
856
857
2.31k
            if (!(*eos) &&
858
2.31k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.34k
                                                 _end_include, max_scan_key_num)) {
860
2.34k
                _has_range_value = true;
861
2.34k
            }
862
2.31k
            return Status::OK();
863
2.31k
        }
864
2.35k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
48
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
9
        if (_begin_scan_keys.empty()) {
870
9
            auto fixed_value_set = range.get_fixed_value_set();
871
9
            ConstIterator iter = fixed_value_set.begin();
872
873
20
            for (; iter != fixed_value_set.end(); ++iter) {
874
11
                _begin_scan_keys.emplace_back();
875
11
                _begin_scan_keys.back().add_value(
876
11
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
11
                _end_scan_keys.emplace_back();
878
11
                _end_scan_keys.back().add_value(
879
11
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
11
            }
881
882
9
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
9
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
9
        _begin_include = true;
927
9
        _end_include = true;
928
9
    } // Extend ScanKey with range value
929
39
    else {
930
39
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
39
        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
39
        } 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
37
        } else {
955
74
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
37
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
37
                                                      range.get_range_min_value(), range.scale()),
958
37
                                              range.contain_null());
959
37
            }
960
961
75
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
38
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
38
                        range.get_range_max_value(), range.scale()));
964
38
            }
965
37
        }
966
39
        _begin_include = range.is_begin_include();
967
39
        _end_include = range.is_end_include();
968
39
    }
969
970
48
    return Status::OK();
971
2.36k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
288
                                     bool* should_break) {
823
288
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
288
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
288
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
288
    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
288
    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
288
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
288
    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
285
    } else {
852
285
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
285
            !range.is_reject_split_type()) {
854
227
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
227
                                                 _end_include);
856
857
227
            if (!(*eos) &&
858
227
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
233
                                                 _end_include, max_scan_key_num)) {
860
233
                _has_range_value = true;
861
233
            }
862
227
            return Status::OK();
863
227
        }
864
285
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
61
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
3
        if (_begin_scan_keys.empty()) {
870
2
            auto fixed_value_set = range.get_fixed_value_set();
871
2
            ConstIterator iter = fixed_value_set.begin();
872
873
5
            for (; iter != fixed_value_set.end(); ++iter) {
874
3
                _begin_scan_keys.emplace_back();
875
3
                _begin_scan_keys.back().add_value(
876
3
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
3
                _end_scan_keys.emplace_back();
878
3
                _end_scan_keys.back().add_value(
879
3
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
3
            }
881
882
2
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
2
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
1
        else {
890
1
            auto fixed_value_set = range.get_fixed_value_set();
891
1
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
3
            for (int i = 0; i < original_key_range_size; ++i) {
894
2
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
2
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
2
                ConstIterator iter = fixed_value_set.begin();
898
899
4
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
2
                    if (iter == fixed_value_set.begin()) {
902
2
                        _begin_scan_keys[i].add_value(
903
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
2
                        _end_scan_keys[i].add_value(
905
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
2
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
2
                }
916
917
2
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
2
            }
924
1
        }
925
926
3
        _begin_include = true;
927
3
        _end_include = true;
928
3
    } // Extend ScanKey with range value
929
58
    else {
930
58
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
58
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
58
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
58
        } else {
955
400
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
342
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
342
                                                      range.get_range_min_value(), range.scale()),
958
342
                                              range.contain_null());
959
342
            }
960
961
400
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
342
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
342
                        range.get_range_max_value(), range.scale()));
964
342
            }
965
58
        }
966
58
        _begin_include = range.is_begin_include();
967
58
        _end_include = range.is_end_include();
968
58
    }
969
970
61
    return Status::OK();
971
288
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
65.4k
                                     bool* should_break) {
823
65.4k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
65.4k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
65.4k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
65.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
65.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
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
65.4k
    if (range.is_fixed_value_range()) {
842
2.34k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
11
            if (range.is_range_value_convertible()) {
844
11
                range.convert_to_range_value();
845
11
                *exact_value = false;
846
11
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
11
        }
851
63.1k
    } else {
852
63.2k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
63.1k
            !range.is_reject_split_type()) {
854
62.8k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
62.8k
                                                 _end_include);
856
857
62.8k
            if (!(*eos) &&
858
62.9k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
63.1k
                                                 _end_include, max_scan_key_num)) {
860
63.1k
                _has_range_value = true;
861
63.1k
            }
862
62.8k
            return Status::OK();
863
62.8k
        }
864
63.1k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.58k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.32k
        if (_begin_scan_keys.empty()) {
870
2.27k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.27k
            ConstIterator iter = fixed_value_set.begin();
872
873
5.39k
            for (; iter != fixed_value_set.end(); ++iter) {
874
3.11k
                _begin_scan_keys.emplace_back();
875
3.11k
                _begin_scan_keys.back().add_value(
876
3.11k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
3.11k
                _end_scan_keys.emplace_back();
878
3.11k
                _end_scan_keys.back().add_value(
879
3.11k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
3.11k
            }
881
882
2.27k
            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.27k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
49
        else {
890
49
            auto fixed_value_set = range.get_fixed_value_set();
891
49
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
112
            for (int i = 0; i < original_key_range_size; ++i) {
894
63
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
63
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
63
                ConstIterator iter = fixed_value_set.begin();
898
899
127
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
64
                    if (iter == fixed_value_set.begin()) {
902
64
                        _begin_scan_keys[i].add_value(
903
64
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
64
                        _end_scan_keys[i].add_value(
905
64
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
64
                    } // 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
64
                }
916
917
63
                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
63
            }
924
49
        }
925
926
2.32k
        _begin_include = true;
927
2.32k
        _end_include = true;
928
2.32k
    } // Extend ScanKey with range value
929
253
    else {
930
253
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
253
        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
253
        } else if (_begin_scan_keys.empty()) {
947
104
            _begin_scan_keys.emplace_back();
948
104
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
104
                                                      range.get_range_min_value(), range.scale()),
950
104
                                              range.contain_null());
951
104
            _end_scan_keys.emplace_back();
952
104
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
104
                    range.get_range_max_value(), range.scale()));
954
149
        } else {
955
3.08k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
2.93k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
2.93k
                                                      range.get_range_min_value(), range.scale()),
958
2.93k
                                              range.contain_null());
959
2.93k
            }
960
961
3.09k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
2.94k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
2.94k
                        range.get_range_max_value(), range.scale()));
964
2.94k
            }
965
149
        }
966
253
        _begin_include = range.is_begin_include();
967
253
        _end_include = range.is_end_include();
968
253
    }
969
970
2.58k
    return Status::OK();
971
65.4k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
87.8k
                                     bool* should_break) {
823
87.8k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
87.8k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
87.8k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
87.8k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
87.8k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
87.8k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
87.8k
    if (range.is_fixed_value_range()) {
842
723
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
87.0k
    } else {
852
87.0k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
87.0k
            !range.is_reject_split_type()) {
854
86.7k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
86.7k
                                                 _end_include);
856
857
86.7k
            if (!(*eos) &&
858
86.7k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
86.7k
                                                 _end_include, max_scan_key_num)) {
860
86.3k
                _has_range_value = true;
861
86.3k
            }
862
86.7k
            return Status::OK();
863
86.7k
        }
864
87.0k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.09k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
724
        if (_begin_scan_keys.empty()) {
870
722
            auto fixed_value_set = range.get_fixed_value_set();
871
722
            ConstIterator iter = fixed_value_set.begin();
872
873
1.53k
            for (; iter != fixed_value_set.end(); ++iter) {
874
817
                _begin_scan_keys.emplace_back();
875
817
                _begin_scan_keys.back().add_value(
876
817
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
817
                _end_scan_keys.emplace_back();
878
817
                _end_scan_keys.back().add_value(
879
817
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
817
            }
881
882
722
            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
722
        } // 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
2
            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
2
        }
925
926
724
        _begin_include = true;
927
724
        _end_include = true;
928
724
    } // Extend ScanKey with range value
929
372
    else {
930
372
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
372
        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
372
        } 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
350
        } else {
955
1.09k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
748
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
748
                                                      range.get_range_min_value(), range.scale()),
958
748
                                              range.contain_null());
959
748
            }
960
961
1.09k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
748
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
748
                        range.get_range_max_value(), range.scale()));
964
748
            }
965
350
        }
966
372
        _begin_include = range.is_begin_include();
967
372
        _end_include = range.is_end_include();
968
372
    }
969
970
1.09k
    return Status::OK();
971
87.8k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.73k
                                     bool* should_break) {
823
4.73k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.73k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.73k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.73k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
4.73k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
4.73k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.73k
    if (range.is_fixed_value_range()) {
842
145
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
4.59k
    } else {
852
4.59k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
4.59k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
4.59k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.73k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
145
        if (_begin_scan_keys.empty()) {
870
145
            auto fixed_value_set = range.get_fixed_value_set();
871
145
            ConstIterator iter = fixed_value_set.begin();
872
873
313
            for (; iter != fixed_value_set.end(); ++iter) {
874
168
                _begin_scan_keys.emplace_back();
875
168
                _begin_scan_keys.back().add_value(
876
168
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
168
                _end_scan_keys.emplace_back();
878
168
                _end_scan_keys.back().add_value(
879
168
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
168
            }
881
882
145
            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
145
        } // 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
145
        _begin_include = true;
927
145
        _end_include = true;
928
145
    } // Extend ScanKey with range value
929
4.59k
    else {
930
4.59k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
4.59k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
4.59k
        } else if (_begin_scan_keys.empty()) {
947
4.56k
            _begin_scan_keys.emplace_back();
948
4.56k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
4.56k
                                                      range.get_range_min_value(), range.scale()),
950
4.56k
                                              range.contain_null());
951
4.56k
            _end_scan_keys.emplace_back();
952
4.56k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
4.56k
                    range.get_range_max_value(), range.scale()));
954
4.56k
        } else {
955
115
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
84
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
84
                                                      range.get_range_min_value(), range.scale()),
958
84
                                              range.contain_null());
959
84
            }
960
961
115
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
84
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
84
                        range.get_range_max_value(), range.scale()));
964
84
            }
965
31
        }
966
4.59k
        _begin_include = range.is_begin_include();
967
4.59k
        _end_include = range.is_end_include();
968
4.59k
    }
969
970
4.73k
    return Status::OK();
971
4.73k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE8EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE9EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE36EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE37EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2
                                     bool* should_break) {
823
2
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
2
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2
    if (range.is_fixed_value_range()) {
842
0
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2
    } else {
852
2
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2
            !range.is_reject_split_type()) {
854
1
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
1
                                                 _end_include);
856
857
1
            if (!(*eos) &&
858
1
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
1
                                                 _end_include, max_scan_key_num)) {
860
1
                _has_range_value = true;
861
1
            }
862
1
            return Status::OK();
863
1
        }
864
2
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
0
        if (_begin_scan_keys.empty()) {
870
0
            auto fixed_value_set = range.get_fixed_value_set();
871
0
            ConstIterator iter = fixed_value_set.begin();
872
873
0
            for (; iter != fixed_value_set.end(); ++iter) {
874
0
                _begin_scan_keys.emplace_back();
875
0
                _begin_scan_keys.back().add_value(
876
0
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
0
                _end_scan_keys.emplace_back();
878
0
                _end_scan_keys.back().add_value(
879
0
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
0
            }
881
882
0
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
0
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
0
        _begin_include = true;
927
0
        _end_include = true;
928
0
    } // Extend ScanKey with range value
929
1
    else {
930
1
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
1
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
1
        } else {
955
2
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
1
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
1
                                                      range.get_range_min_value(), range.scale()),
958
1
                                              range.contain_null());
959
1
            }
960
961
2
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
1
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
1
                        range.get_range_max_value(), range.scale()));
964
1
            }
965
1
        }
966
1
        _begin_include = range.is_begin_include();
967
1
        _end_include = range.is_end_include();
968
1
    }
969
970
1
    return Status::OK();
971
2
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE15EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
409
                                     bool* should_break) {
823
409
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
409
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
409
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
409
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
409
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
409
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
409
    if (range.is_fixed_value_range()) {
842
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
396
    } else {
852
396
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
396
            !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
396
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
409
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
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
397
    else {
930
397
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
397
        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
396
        } else if (_begin_scan_keys.empty()) {
947
388
            _begin_scan_keys.emplace_back();
948
388
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
388
                                                      range.get_range_min_value(), range.scale()),
950
388
                                              range.contain_null());
951
388
            _end_scan_keys.emplace_back();
952
388
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
388
                    range.get_range_max_value(), range.scale()));
954
388
        } else {
955
87
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
79
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
79
                                                      range.get_range_min_value(), range.scale()),
958
79
                                              range.contain_null());
959
79
            }
960
961
87
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
79
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
79
                        range.get_range_max_value(), range.scale()));
964
79
            }
965
8
        }
966
397
        _begin_include = range.is_begin_include();
967
397
        _end_include = range.is_end_include();
968
397
    }
969
970
409
    return Status::OK();
971
409
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
390k
                                     bool* should_break) {
823
390k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
390k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
390k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
390k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
390k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
390k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
390k
    if (range.is_fixed_value_range()) {
842
284k
        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
284k
    } else {
852
106k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
106k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
106k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
390k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
284k
        if (_begin_scan_keys.empty()) {
870
94.7k
            auto fixed_value_set = range.get_fixed_value_set();
871
94.7k
            ConstIterator iter = fixed_value_set.begin();
872
873
189k
            for (; iter != fixed_value_set.end(); ++iter) {
874
94.9k
                _begin_scan_keys.emplace_back();
875
94.9k
                _begin_scan_keys.back().add_value(
876
94.9k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
94.9k
                _end_scan_keys.emplace_back();
878
94.9k
                _end_scan_keys.back().add_value(
879
94.9k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
94.9k
            }
881
882
94.7k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
94.7k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
189k
        else {
890
189k
            auto fixed_value_set = range.get_fixed_value_set();
891
189k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
379k
            for (int i = 0; i < original_key_range_size; ++i) {
894
190k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
190k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
190k
                ConstIterator iter = fixed_value_set.begin();
898
899
380k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
190k
                        _begin_scan_keys[i].add_value(
903
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
190k
                        _end_scan_keys[i].add_value(
905
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
190k
                    } // append follow ScanKey
907
128
                    else {
908
128
                        _begin_scan_keys.push_back(start_base_key_range);
909
128
                        _begin_scan_keys.back().add_value(
910
128
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
128
                        _end_scan_keys.push_back(end_base_key_range);
912
128
                        _end_scan_keys.back().add_value(
913
128
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
128
                    }
915
190k
                }
916
917
190k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
190k
            }
924
189k
        }
925
926
284k
        _begin_include = true;
927
284k
        _end_include = true;
928
284k
    } // Extend ScanKey with range value
929
106k
    else {
930
106k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
106k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
106k
        } else if (_begin_scan_keys.empty()) {
947
9.81k
            _begin_scan_keys.emplace_back();
948
9.81k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
9.81k
                                                      range.get_range_min_value(), range.scale()),
950
9.81k
                                              range.contain_null());
951
9.81k
            _end_scan_keys.emplace_back();
952
9.81k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
9.81k
                    range.get_range_max_value(), range.scale()));
954
96.8k
        } else {
955
193k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
96.3k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
96.3k
                                                      range.get_range_min_value(), range.scale()),
958
96.3k
                                              range.contain_null());
959
96.3k
            }
960
961
193k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
96.3k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
96.3k
                        range.get_range_max_value(), range.scale()));
964
96.3k
            }
965
96.8k
        }
966
106k
        _begin_include = range.is_begin_include();
967
106k
        _end_include = range.is_end_include();
968
106k
    }
969
970
390k
    return Status::OK();
971
390k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE23EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE11EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
27
                                     bool* should_break) {
823
27
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
27
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
27
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
27
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
27
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
27
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
27
    if (range.is_fixed_value_range()) {
842
8
        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
19
    } else {
852
19
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
19
            !range.is_reject_split_type()) {
854
18
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
18
                                                 _end_include);
856
857
18
            if (!(*eos) &&
858
18
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
18
                                                 _end_include, max_scan_key_num)) {
860
18
                _has_range_value = true;
861
18
            }
862
18
            return Status::OK();
863
18
        }
864
19
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
9
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
9
        if (_begin_scan_keys.empty()) {
870
9
            auto fixed_value_set = range.get_fixed_value_set();
871
9
            ConstIterator iter = fixed_value_set.begin();
872
873
30
            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
9
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
9
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
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
8
        _begin_include = true;
927
8
        _end_include = true;
928
8
    } // 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
9
    return Status::OK();
971
27
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE25EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.38k
                                     bool* should_break) {
823
3.38k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.38k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.38k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.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
3.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
3.38k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.38k
    if (range.is_fixed_value_range()) {
842
372
        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.01k
    } else {
852
3.01k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
3.01k
            !range.is_reject_split_type()) {
854
2.90k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.90k
                                                 _end_include);
856
857
2.90k
            if (!(*eos) &&
858
2.90k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.90k
                                                 _end_include, max_scan_key_num)) {
860
2.83k
                _has_range_value = true;
861
2.83k
            }
862
2.90k
            return Status::OK();
863
2.90k
        }
864
3.01k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
484
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
371
        if (_begin_scan_keys.empty()) {
870
369
            auto fixed_value_set = range.get_fixed_value_set();
871
369
            ConstIterator iter = fixed_value_set.begin();
872
873
791
            for (; iter != fixed_value_set.end(); ++iter) {
874
422
                _begin_scan_keys.emplace_back();
875
422
                _begin_scan_keys.back().add_value(
876
422
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
422
                _end_scan_keys.emplace_back();
878
422
                _end_scan_keys.back().add_value(
879
422
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
422
            }
881
882
369
            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
369
        } // 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
371
        _begin_include = true;
927
371
        _end_include = true;
928
371
    } // Extend ScanKey with range value
929
113
    else {
930
113
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
113
        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
113
        } 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
113
        } else {
955
276
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
163
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
163
                                                      range.get_range_min_value(), range.scale()),
958
163
                                              range.contain_null());
959
163
            }
960
961
277
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
164
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
164
                        range.get_range_max_value(), range.scale()));
964
164
            }
965
113
        }
966
113
        _begin_include = range.is_begin_include();
967
113
        _end_include = range.is_end_include();
968
113
    }
969
970
484
    return Status::OK();
971
3.38k
}
_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.72k
                                     bool* should_break) {
823
2.72k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.72k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.72k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.72k
    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.72k
    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.72k
    if (range.is_fixed_value_range()) {
842
68
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.65k
    } else {
852
2.66k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.65k
            !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.65k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.72k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
68
        if (_begin_scan_keys.empty()) {
870
66
            auto fixed_value_set = range.get_fixed_value_set();
871
66
            ConstIterator iter = fixed_value_set.begin();
872
873
141
            for (; iter != fixed_value_set.end(); ++iter) {
874
75
                _begin_scan_keys.emplace_back();
875
75
                _begin_scan_keys.back().add_value(
876
75
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
75
                _end_scan_keys.emplace_back();
878
75
                _end_scan_keys.back().add_value(
879
75
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
75
            }
881
882
66
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
66
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
2
        else {
890
2
            auto fixed_value_set = range.get_fixed_value_set();
891
2
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
6
            for (int i = 0; i < original_key_range_size; ++i) {
894
4
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
4
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
4
                ConstIterator iter = fixed_value_set.begin();
898
899
8
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
4
                    if (iter == fixed_value_set.begin()) {
902
4
                        _begin_scan_keys[i].add_value(
903
4
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
4
                        _end_scan_keys[i].add_value(
905
4
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
4
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
4
                }
916
917
4
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
4
            }
924
2
        }
925
926
68
        _begin_include = true;
927
68
        _end_include = true;
928
68
    } // Extend ScanKey with range value
929
2.65k
    else {
930
2.65k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.65k
        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.66k
        } else if (_begin_scan_keys.empty()) {
947
2.66k
            _begin_scan_keys.emplace_back();
948
2.66k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.66k
                                                      range.get_range_min_value(), range.scale()),
950
2.66k
                                              range.contain_null());
951
2.66k
            _end_scan_keys.emplace_back();
952
2.66k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.66k
                    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.65k
        _begin_include = range.is_begin_include();
967
2.65k
        _end_include = range.is_end_include();
968
2.65k
    }
969
970
2.72k
    return Status::OK();
971
2.72k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.30k
                                     bool* should_break) {
823
4.30k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.30k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.30k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.30k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
4.30k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
4.30k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.30k
    if (range.is_fixed_value_range()) {
842
174
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
4.13k
    } else {
852
4.13k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
4.13k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
4.13k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.30k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
174
        if (_begin_scan_keys.empty()) {
870
174
            auto fixed_value_set = range.get_fixed_value_set();
871
174
            ConstIterator iter = fixed_value_set.begin();
872
873
436
            for (; iter != fixed_value_set.end(); ++iter) {
874
262
                _begin_scan_keys.emplace_back();
875
262
                _begin_scan_keys.back().add_value(
876
262
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
262
                _end_scan_keys.emplace_back();
878
262
                _end_scan_keys.back().add_value(
879
262
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
262
            }
881
882
174
            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
174
        } // 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
174
        _begin_include = true;
927
174
        _end_include = true;
928
174
    } // Extend ScanKey with range value
929
4.13k
    else {
930
4.13k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
4.13k
        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
4.12k
        } else if (_begin_scan_keys.empty()) {
947
4.10k
            _begin_scan_keys.emplace_back();
948
4.10k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
4.10k
                                                      range.get_range_min_value(), range.scale()),
950
4.10k
                                              range.contain_null());
951
4.10k
            _end_scan_keys.emplace_back();
952
4.10k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
4.10k
                    range.get_range_max_value(), range.scale()));
954
4.10k
        } else {
955
21
            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
21
            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
21
        }
966
4.13k
        _begin_include = range.is_begin_include();
967
4.13k
        _end_include = range.is_end_include();
968
4.13k
    }
969
970
4.30k
    return Status::OK();
971
4.30k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
50
                                     bool* should_break) {
823
50
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
50
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
50
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
50
    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
50
    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
50
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
50
    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
49
    } else {
852
49
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
49
            !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
49
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
50
    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
49
    else {
930
49
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
49
        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
49
        } else if (_begin_scan_keys.empty()) {
947
48
            _begin_scan_keys.emplace_back();
948
48
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
48
                                                      range.get_range_min_value(), range.scale()),
950
48
                                              range.contain_null());
951
48
            _end_scan_keys.emplace_back();
952
48
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
48
                    range.get_range_max_value(), range.scale()));
954
48
        } 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
49
        _begin_include = range.is_begin_include();
967
49
        _end_include = range.is_end_include();
968
49
    }
969
970
50
    return Status::OK();
971
50
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.73k
                                     bool* should_break) {
823
1.73k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.73k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.73k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.73k
    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.73k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.73k
    if (range.is_fixed_value_range()) {
842
8
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
1
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
1
        }
851
1.72k
    } else {
852
1.73k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.72k
            !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.72k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.73k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
7
        if (_begin_scan_keys.empty()) {
870
7
            auto fixed_value_set = range.get_fixed_value_set();
871
7
            ConstIterator iter = fixed_value_set.begin();
872
873
19
            for (; iter != fixed_value_set.end(); ++iter) {
874
12
                _begin_scan_keys.emplace_back();
875
12
                _begin_scan_keys.back().add_value(
876
12
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
12
                _end_scan_keys.emplace_back();
878
12
                _end_scan_keys.back().add_value(
879
12
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
12
            }
881
882
7
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
7
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
7
        _begin_include = true;
927
7
        _end_include = true;
928
7
    } // Extend ScanKey with range value
929
1.72k
    else {
930
1.72k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.72k
        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.74k
        } else if (_begin_scan_keys.empty()) {
947
1.74k
            _begin_scan_keys.emplace_back();
948
1.74k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.74k
                                                      range.get_range_min_value(), range.scale()),
950
1.74k
                                              range.contain_null());
951
1.74k
            _end_scan_keys.emplace_back();
952
1.74k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.74k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
30
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
30
                                                      range.get_range_min_value(), range.scale()),
958
30
                                              range.contain_null());
959
30
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
30
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
30
                        range.get_range_max_value(), range.scale()));
964
30
            }
965
18.4E
        }
966
1.72k
        _begin_include = range.is_begin_include();
967
1.72k
        _end_include = range.is_end_include();
968
1.72k
    }
969
970
1.73k
    return Status::OK();
971
1.73k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
460
                                     bool* should_break) {
823
460
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
460
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
460
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
460
    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
460
    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
460
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
460
    if (range.is_fixed_value_range()) {
842
19
        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
441
    } else {
852
443
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
441
            !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
441
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
460
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
19
        if (_begin_scan_keys.empty()) {
870
17
            auto fixed_value_set = range.get_fixed_value_set();
871
17
            ConstIterator iter = fixed_value_set.begin();
872
873
41
            for (; iter != fixed_value_set.end(); ++iter) {
874
24
                _begin_scan_keys.emplace_back();
875
24
                _begin_scan_keys.back().add_value(
876
24
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
24
                _end_scan_keys.emplace_back();
878
24
                _end_scan_keys.back().add_value(
879
24
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
24
            }
881
882
17
            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
17
        } // 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
19
        _begin_include = true;
927
19
        _end_include = true;
928
19
    } // Extend ScanKey with range value
929
441
    else {
930
441
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
441
        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
441
        } else if (_begin_scan_keys.empty()) {
947
441
            _begin_scan_keys.emplace_back();
948
441
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
441
                                                      range.get_range_min_value(), range.scale()),
950
441
                                              range.contain_null());
951
441
            _end_scan_keys.emplace_back();
952
441
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
441
                    range.get_range_max_value(), range.scale()));
954
441
        } 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
441
        _begin_include = range.is_begin_include();
967
441
        _end_include = range.is_end_include();
968
441
    }
969
970
460
    return Status::OK();
971
460
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
759
                                     bool* should_break) {
823
759
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
759
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
759
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
759
    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
759
    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
759
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
759
    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
739
    } else {
852
739
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
739
            !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
739
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
759
    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
739
    else {
930
739
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
739
        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
739
        } else if (_begin_scan_keys.empty()) {
947
716
            _begin_scan_keys.emplace_back();
948
716
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
716
                                                      range.get_range_min_value(), range.scale()),
950
716
                                              range.contain_null());
951
716
            _end_scan_keys.emplace_back();
952
716
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
716
                    range.get_range_max_value(), range.scale()));
954
716
        } else {
955
50
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
27
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
27
                                                      range.get_range_min_value(), range.scale()),
958
27
                                              range.contain_null());
959
27
            }
960
961
50
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
27
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
27
                        range.get_range_max_value(), range.scale()));
964
27
            }
965
23
        }
966
739
        _begin_include = range.is_begin_include();
967
739
        _end_include = range.is_end_include();
968
739
    }
969
970
759
    return Status::OK();
971
759
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.36k
                                     bool* should_break) {
823
1.36k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.36k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.36k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.36k
    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.36k
    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.36k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.36k
    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.35k
    } else {
852
1.35k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.35k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
1.35k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.36k
    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.35k
    else {
930
1.35k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.35k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
1.35k
        } else if (_begin_scan_keys.empty()) {
947
1.25k
            _begin_scan_keys.emplace_back();
948
1.25k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.25k
                                                      range.get_range_min_value(), range.scale()),
950
1.25k
                                              range.contain_null());
951
1.25k
            _end_scan_keys.emplace_back();
952
1.25k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.25k
                    range.get_range_max_value(), range.scale()));
954
1.25k
        } else {
955
206
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
108
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
108
                                                      range.get_range_min_value(), range.scale()),
958
108
                                              range.contain_null());
959
108
            }
960
961
206
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
108
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
108
                        range.get_range_max_value(), range.scale()));
964
108
            }
965
98
        }
966
1.35k
        _begin_include = range.is_begin_include();
967
1.35k
        _end_include = range.is_end_include();
968
1.35k
    }
969
970
1.36k
    return Status::OK();
971
1.36k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
651
                                     bool* should_break) {
823
651
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
651
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
651
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
651
    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
651
    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
651
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
651
    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
633
    } else {
852
633
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
633
            !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
633
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
651
    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
48
            for (; iter != fixed_value_set.end(); ++iter) {
874
30
                _begin_scan_keys.emplace_back();
875
30
                _begin_scan_keys.back().add_value(
876
30
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
30
                _end_scan_keys.emplace_back();
878
30
                _end_scan_keys.back().add_value(
879
30
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
30
            }
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
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
18
        _begin_include = true;
927
18
        _end_include = true;
928
18
    } // Extend ScanKey with range value
929
633
    else {
930
633
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
633
        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
632
        } else if (_begin_scan_keys.empty()) {
947
574
            _begin_scan_keys.emplace_back();
948
574
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
574
                                                      range.get_range_min_value(), range.scale()),
950
574
                                              range.contain_null());
951
574
            _end_scan_keys.emplace_back();
952
574
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
574
                    range.get_range_max_value(), range.scale()));
954
574
        } else {
955
118
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
60
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
60
                                                      range.get_range_min_value(), range.scale()),
958
60
                                              range.contain_null());
959
60
            }
960
961
118
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
60
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
60
                        range.get_range_max_value(), range.scale()));
964
60
            }
965
58
        }
966
633
        _begin_include = range.is_begin_include();
967
633
        _end_include = range.is_end_include();
968
633
    }
969
970
651
    return Status::OK();
971
651
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris