Coverage Report

Created: 2026-03-23 08:27

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.63M
std::string cast_to_string(T value, int scale) {
61
1.63M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
853
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.36k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.36k
        return ((Decimal<int64_t>)value).to_string(scale);
65
2.81k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.81k
        return ((Decimal<int128_t>)value).to_string(scale);
67
2.81k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.12k
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
197k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
197k
        return std::to_string(static_cast<int>(value));
71
197k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.75k
        return int128_to_string(value);
73
8.75k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.95k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.95k
        char buf[30];
76
4.95k
        datetimev2_val.to_string(buf);
77
4.95k
        std::stringstream ss;
78
4.95k
        ss << buf;
79
4.95k
        return ss.str();
80
6.68k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
6.68k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
6.68k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
0
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
0
        return IPv4Value::to_string(value);
87
4
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
4
        return IPv6Value::to_string(value);
89
4.53k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
4.53k
        return CastToString::from_number(value);
91
1.41M
    } else {
92
1.41M
        return boost::lexical_cast<std::string>(value);
93
1.41M
    }
94
1.63M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
197k
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
197k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
197k
        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
197k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE4EsEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
24.3k
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
24.3k
    } else {
92
24.3k
        return boost::lexical_cast<std::string>(value);
93
24.3k
    }
94
24.3k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE5EiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
162k
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
162k
    } else {
92
162k
        return boost::lexical_cast<std::string>(value);
93
162k
    }
94
162k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
172k
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
172k
    } else {
92
172k
        return boost::lexical_cast<std::string>(value);
93
172k
    }
94
172k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
8.75k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
8.75k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.75k
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
8.75k
}
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
958
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
958
    } else {
92
958
        return boost::lexical_cast<std::string>(value);
93
958
    }
94
958
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
779k
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
779k
    } else {
92
779k
        return boost::lexical_cast<std::string>(value);
93
779k
    }
94
779k
}
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.67k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } 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.67k
    } else {
92
1.67k
        return boost::lexical_cast<std::string>(value);
93
1.67k
    }
94
1.67k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
269k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
269k
    } else {
92
269k
        return boost::lexical_cast<std::string>(value);
93
269k
    }
94
269k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE12ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
79
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
79
    } else {
92
79
        return boost::lexical_cast<std::string>(value);
93
79
    }
94
79
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE26ENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4.95k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
4.95k
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
4.95k
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
4.95k
        char buf[30];
76
4.95k
        datetimev2_val.to_string(buf);
77
4.95k
        std::stringstream ss;
78
4.95k
        ss << buf;
79
4.95k
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
4.95k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE42ENS_16TimestampTzValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
6.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
6.68k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
6.68k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
6.68k
        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
6.68k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE20ENS_14DecimalV2ValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
87
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
87
    } else {
92
87
        return boost::lexical_cast<std::string>(value);
93
87
    }
94
87
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4.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
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
4.53k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
4.53k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
4.53k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE19ENS_9StringRefEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE28ENS_7DecimalIiEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
853
std::string cast_to_string(T value, int scale) {
61
853
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
853
        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
853
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.36k
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.36k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.36k
        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.36k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
2.81k
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.81k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
2.81k
        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.81k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.12k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
1.12k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.12k
        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.12k
}
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
160k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
2.30k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_reject_split_typeEv
Line
Count
Source
139
248
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_reject_split_typeEv
Line
Count
Source
139
67.3k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
83.1k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
4.14k
    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
16
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_reject_split_typeEv
Line
Count
Source
139
2.87k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_reject_split_typeEv
140
141
    void intersection(ColumnValueRange<primitive_type>& range);
142
143
21.9k
    void set_empty_value_range() {
144
21.9k
        _fixed_values.clear();
145
21.9k
        _low_value = TYPE_MAX;
146
21.9k
        _high_value = TYPE_MIN;
147
21.9k
        _contain_null = false;
148
21.9k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
408
    void set_empty_value_range() {
144
408
        _fixed_values.clear();
145
408
        _low_value = TYPE_MAX;
146
408
        _high_value = TYPE_MIN;
147
408
        _contain_null = false;
148
408
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_empty_value_rangeEv
Line
Count
Source
143
94
    void set_empty_value_range() {
144
94
        _fixed_values.clear();
145
94
        _low_value = TYPE_MAX;
146
94
        _high_value = TYPE_MIN;
147
94
        _contain_null = false;
148
94
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_empty_value_rangeEv
Line
Count
Source
143
754
    void set_empty_value_range() {
144
754
        _fixed_values.clear();
145
754
        _low_value = TYPE_MAX;
146
754
        _high_value = TYPE_MIN;
147
754
        _contain_null = false;
148
754
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
19.3k
    void set_empty_value_range() {
144
19.3k
        _fixed_values.clear();
145
19.3k
        _low_value = TYPE_MAX;
146
19.3k
        _high_value = TYPE_MIN;
147
19.3k
        _contain_null = false;
148
19.3k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_empty_value_rangeEv
Line
Count
Source
143
14
    void set_empty_value_range() {
144
14
        _fixed_values.clear();
145
14
        _low_value = TYPE_MAX;
146
14
        _high_value = TYPE_MIN;
147
14
        _contain_null = false;
148
14
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_empty_value_rangeEv
Line
Count
Source
143
71
    void set_empty_value_range() {
144
71
        _fixed_values.clear();
145
71
        _low_value = TYPE_MAX;
146
71
        _high_value = TYPE_MIN;
147
71
        _contain_null = false;
148
71
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_empty_value_rangeEv
Line
Count
Source
143
80
    void set_empty_value_range() {
144
80
        _fixed_values.clear();
145
80
        _low_value = TYPE_MAX;
146
80
        _high_value = TYPE_MIN;
147
80
        _contain_null = false;
148
80
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_empty_value_rangeEv
Line
Count
Source
143
68
    void set_empty_value_range() {
144
68
        _fixed_values.clear();
145
68
        _low_value = TYPE_MAX;
146
68
        _high_value = TYPE_MIN;
147
68
        _contain_null = false;
148
68
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_empty_value_rangeEv
Line
Count
Source
143
411
    void set_empty_value_range() {
144
411
        _fixed_values.clear();
145
411
        _low_value = TYPE_MAX;
146
411
        _high_value = TYPE_MIN;
147
411
        _contain_null = false;
148
411
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_empty_value_rangeEv
Line
Count
Source
143
262
    void set_empty_value_range() {
144
262
        _fixed_values.clear();
145
262
        _low_value = TYPE_MAX;
146
262
        _high_value = TYPE_MIN;
147
262
        _contain_null = false;
148
262
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_empty_value_rangeEv
Line
Count
Source
143
143
    void set_empty_value_range() {
144
143
        _fixed_values.clear();
145
143
        _low_value = TYPE_MAX;
146
143
        _high_value = TYPE_MIN;
147
143
        _contain_null = false;
148
143
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_empty_value_rangeEv
Line
Count
Source
143
70
    void set_empty_value_range() {
144
70
        _fixed_values.clear();
145
70
        _low_value = TYPE_MAX;
146
70
        _high_value = TYPE_MIN;
147
70
        _contain_null = false;
148
70
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_empty_value_rangeEv
Line
Count
Source
143
18
    void set_empty_value_range() {
144
18
        _fixed_values.clear();
145
18
        _low_value = TYPE_MAX;
146
18
        _high_value = TYPE_MIN;
147
18
        _contain_null = false;
148
18
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_empty_value_rangeEv
Line
Count
Source
143
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
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_empty_value_rangeEv
Line
Count
Source
143
8
    void set_empty_value_range() {
144
8
        _fixed_values.clear();
145
8
        _low_value = TYPE_MAX;
146
8
        _high_value = TYPE_MIN;
147
8
        _contain_null = false;
148
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_empty_value_rangeEv
Line
Count
Source
143
136
    void set_empty_value_range() {
144
136
        _fixed_values.clear();
145
136
        _low_value = TYPE_MAX;
146
136
        _high_value = TYPE_MIN;
147
136
        _contain_null = false;
148
136
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_empty_value_rangeEv
Line
Count
Source
143
2
    void set_empty_value_range() {
144
2
        _fixed_values.clear();
145
2
        _low_value = TYPE_MAX;
146
2
        _high_value = TYPE_MIN;
147
2
        _contain_null = false;
148
2
    }
149
150
289k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_fixed_value_setEv
Line
Count
Source
150
8
    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.45k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_fixed_value_setEv
Line
Count
Source
150
715
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
144
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE19get_fixed_value_setEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE19get_fixed_value_setEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE19get_fixed_value_setEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE19get_fixed_value_setEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
14
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
285k
    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
341
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_fixed_value_setEv
Line
Count
Source
150
8
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_fixed_value_setEv
Line
Count
Source
150
67
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_fixed_value_setEv
Line
Count
Source
150
135
    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
8
    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
17
    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
17
    const SetType& get_fixed_value_set() const { return _fixed_values; }
151
152
556k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
2.41k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
667
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
140k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
167k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
8.40k
    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
839
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
210k
    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
17
    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
43
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_max_valueEv
Line
Count
Source
152
4.80k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
6.25k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
85
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
4.46k
    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
806
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.31k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
2.80k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
1.06k
    CppType get_range_max_value() const { return _high_value; }
153
154
556k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.41k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
665
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
140k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
167k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
8.41k
    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
841
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
210k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_range_min_valueB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_range_min_valueEv
Line
Count
Source
154
17
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_min_valueEv
Line
Count
Source
154
3.15k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_min_valueEv
Line
Count
Source
154
44
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_min_valueEv
Line
Count
Source
154
4.80k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
6.23k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
86
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
4.45k
    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
807
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.31k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
2.80k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
1.05k
    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
277k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
2.33k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
314
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
67.9k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
83.8k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
4.14k
    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
387
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
104k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16is_begin_includeEv
Line
Count
Source
168
16
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16is_begin_includeEv
Line
Count
Source
168
2.97k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16is_begin_includeEv
Line
Count
Source
168
21
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16is_begin_includeEv
Line
Count
Source
168
2.40k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
3.15k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
43
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
2.22k
    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
402
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
651
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.38k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
536
    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
314
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
68.0k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
84.0k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
4.16k
    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
387
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
104k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14is_end_includeEv
Line
Count
Source
170
16
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14is_end_includeEv
Line
Count
Source
170
2.97k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14is_end_includeEv
Line
Count
Source
170
21
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14is_end_includeEv
Line
Count
Source
170
2.40k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
3.15k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
43
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
2.22k
    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
403
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
655
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.39k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
536
    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
654k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
4.16k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
931
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
78.2k
    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.40k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
194
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
298
    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
693
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
391k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
4.67k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12contain_nullEv
Line
Count
Source
176
26
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12contain_nullEv
Line
Count
Source
176
3.82k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12contain_nullEv
Line
Count
Source
176
31
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12contain_nullEv
Line
Count
Source
176
2.74k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
3.46k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
43
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
2.45k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
510
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
1.51k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.42k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
582
    bool contain_null() const { return _contain_null; }
177
178
856k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.37k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
319
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
73.6k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
85.2k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.48k
    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
415
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20get_fixed_value_sizeEv
Line
Count
Source
178
674k
    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.66k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20get_fixed_value_sizeEv
Line
Count
Source
178
38
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.54k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20get_fixed_value_sizeEv
Line
Count
Source
178
3.39k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
45
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.24k
    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
440
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
696
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.41k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
566
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
3.68k
    void set_whole_value_range() {
181
3.68k
        _fixed_values.clear();
182
3.68k
        _low_value = TYPE_MIN;
183
3.68k
        _high_value = TYPE_MAX;
184
3.68k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3.68k
        _high_op = FILTER_LESS_OR_EQUAL;
186
3.68k
        _contain_null = _is_nullable_col;
187
3.68k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
282
    void set_whole_value_range() {
181
282
        _fixed_values.clear();
182
282
        _low_value = TYPE_MIN;
183
282
        _high_value = TYPE_MAX;
184
282
        _low_op = FILTER_LARGER_OR_EQUAL;
185
282
        _high_op = FILTER_LESS_OR_EQUAL;
186
282
        _contain_null = _is_nullable_col;
187
282
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_whole_value_rangeEv
Line
Count
Source
180
40
    void set_whole_value_range() {
181
40
        _fixed_values.clear();
182
40
        _low_value = TYPE_MIN;
183
40
        _high_value = TYPE_MAX;
184
40
        _low_op = FILTER_LARGER_OR_EQUAL;
185
40
        _high_op = FILTER_LESS_OR_EQUAL;
186
40
        _contain_null = _is_nullable_col;
187
40
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
656
    void set_whole_value_range() {
181
656
        _fixed_values.clear();
182
656
        _low_value = TYPE_MIN;
183
656
        _high_value = TYPE_MAX;
184
656
        _low_op = FILTER_LARGER_OR_EQUAL;
185
656
        _high_op = FILTER_LESS_OR_EQUAL;
186
656
        _contain_null = _is_nullable_col;
187
656
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_whole_value_rangeEv
Line
Count
Source
180
33
    void set_whole_value_range() {
181
33
        _fixed_values.clear();
182
33
        _low_value = TYPE_MIN;
183
33
        _high_value = TYPE_MAX;
184
33
        _low_op = FILTER_LARGER_OR_EQUAL;
185
33
        _high_op = FILTER_LESS_OR_EQUAL;
186
33
        _contain_null = _is_nullable_col;
187
33
    }
_ZN5doris16ColumnValueRangeILNS_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
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_13PrimitiveTypeE9EE21set_whole_value_rangeEv
Line
Count
Source
180
42
    void set_whole_value_range() {
181
42
        _fixed_values.clear();
182
42
        _low_value = TYPE_MIN;
183
42
        _high_value = TYPE_MAX;
184
42
        _low_op = FILTER_LARGER_OR_EQUAL;
185
42
        _high_op = FILTER_LESS_OR_EQUAL;
186
42
        _contain_null = _is_nullable_col;
187
42
    }
_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
28
    void set_whole_value_range() {
181
28
        _fixed_values.clear();
182
28
        _low_value = TYPE_MIN;
183
28
        _high_value = TYPE_MAX;
184
28
        _low_op = FILTER_LARGER_OR_EQUAL;
185
28
        _high_op = FILTER_LESS_OR_EQUAL;
186
28
        _contain_null = _is_nullable_col;
187
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_whole_value_rangeEv
Line
Count
Source
180
51
    void set_whole_value_range() {
181
51
        _fixed_values.clear();
182
51
        _low_value = TYPE_MIN;
183
51
        _high_value = TYPE_MAX;
184
51
        _low_op = FILTER_LARGER_OR_EQUAL;
185
51
        _high_op = FILTER_LESS_OR_EQUAL;
186
51
        _contain_null = _is_nullable_col;
187
51
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_whole_value_rangeEv
Line
Count
Source
180
2.08k
    void set_whole_value_range() {
181
2.08k
        _fixed_values.clear();
182
2.08k
        _low_value = TYPE_MIN;
183
2.08k
        _high_value = TYPE_MAX;
184
2.08k
        _low_op = FILTER_LARGER_OR_EQUAL;
185
2.08k
        _high_op = FILTER_LESS_OR_EQUAL;
186
2.08k
        _contain_null = _is_nullable_col;
187
2.08k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
36
    void set_whole_value_range() {
181
36
        _fixed_values.clear();
182
36
        _low_value = TYPE_MIN;
183
36
        _high_value = TYPE_MAX;
184
36
        _low_op = FILTER_LARGER_OR_EQUAL;
185
36
        _high_op = FILTER_LESS_OR_EQUAL;
186
36
        _contain_null = _is_nullable_col;
187
36
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_whole_value_rangeEv
Line
Count
Source
180
44
    void set_whole_value_range() {
181
44
        _fixed_values.clear();
182
44
        _low_value = TYPE_MIN;
183
44
        _high_value = TYPE_MAX;
184
44
        _low_op = FILTER_LARGER_OR_EQUAL;
185
44
        _high_op = FILTER_LESS_OR_EQUAL;
186
44
        _contain_null = _is_nullable_col;
187
44
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
50
    void set_whole_value_range() {
181
50
        _fixed_values.clear();
182
50
        _low_value = TYPE_MIN;
183
50
        _high_value = TYPE_MAX;
184
50
        _low_op = FILTER_LARGER_OR_EQUAL;
185
50
        _high_op = FILTER_LESS_OR_EQUAL;
186
50
        _contain_null = _is_nullable_col;
187
50
    }
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
24
    void set_whole_value_range() {
181
24
        _fixed_values.clear();
182
24
        _low_value = TYPE_MIN;
183
24
        _high_value = TYPE_MAX;
184
24
        _low_op = FILTER_LARGER_OR_EQUAL;
185
24
        _high_op = FILTER_LESS_OR_EQUAL;
186
24
        _contain_null = _is_nullable_col;
187
24
    }
_ZN5doris16ColumnValueRangeILNS_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
11
    void set_whole_value_range() {
181
11
        _fixed_values.clear();
182
11
        _low_value = TYPE_MIN;
183
11
        _high_value = TYPE_MAX;
184
11
        _low_op = FILTER_LARGER_OR_EQUAL;
185
11
        _high_op = FILTER_LESS_OR_EQUAL;
186
11
        _contain_null = _is_nullable_col;
187
11
    }
188
189
1.88k
    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.89k
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
1.88k
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
1.88k
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
1.88k
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_whole_value_rangeEv
Line
Count
Source
189
62
    bool is_whole_value_range() const {
190
62
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
64
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
62
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
62
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
62
    }
_ZNK5doris16ColumnValueRangeILNS_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
421
    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
424
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
421
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
421
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
421
    }
_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
67
    bool is_whole_value_range() const {
190
67
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
67
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
67
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
67
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
67
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_whole_value_rangeEv
Line
Count
Source
189
80
    bool is_whole_value_range() const {
190
80
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
80
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
80
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
80
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
80
    }
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
364
    bool is_whole_value_range() const {
190
364
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
364
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
364
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
364
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
364
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_whole_value_rangeEv
Line
Count
Source
189
262
    bool is_whole_value_range() const {
190
262
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
262
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
262
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
262
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
262
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
119
    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
120
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
119
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
119
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
119
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_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_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
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
    }
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.60k
    void set_contain_null(bool contain_null) {
205
5.60k
        if (contain_null) {
206
1.92k
            set_empty_value_range();
207
3.68k
        } else {
208
3.68k
            set_whole_value_range();
209
3.68k
        }
210
5.60k
        _contain_null = _is_nullable_col && contain_null;
211
5.60k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
350
    void set_contain_null(bool contain_null) {
205
350
        if (contain_null) {
206
64
            set_empty_value_range();
207
286
        } else {
208
286
            set_whole_value_range();
209
286
        }
210
350
        _contain_null = _is_nullable_col && contain_null;
211
350
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
106
    void set_contain_null(bool contain_null) {
205
106
        if (contain_null) {
206
66
            set_empty_value_range();
207
66
        } else {
208
40
            set_whole_value_range();
209
40
        }
210
106
        _contain_null = _is_nullable_col && contain_null;
211
106
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
1.08k
    void set_contain_null(bool contain_null) {
205
1.08k
        if (contain_null) {
206
433
            set_empty_value_range();
207
655
        } else {
208
655
            set_whole_value_range();
209
655
        }
210
1.08k
        _contain_null = _is_nullable_col && contain_null;
211
1.08k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
103
    void set_contain_null(bool contain_null) {
205
103
        if (contain_null) {
206
69
            set_empty_value_range();
207
69
        } else {
208
34
            set_whole_value_range();
209
34
        }
210
103
        _contain_null = _is_nullable_col && contain_null;
211
103
    }
_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
84
    void set_contain_null(bool contain_null) {
205
84
        if (contain_null) {
206
71
            set_empty_value_range();
207
71
        } else {
208
13
            set_whole_value_range();
209
13
        }
210
86
        _contain_null = _is_nullable_col && contain_null;
211
84
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
122
    void set_contain_null(bool contain_null) {
205
122
        if (contain_null) {
206
80
            set_empty_value_range();
207
80
        } else {
208
42
            set_whole_value_range();
209
42
        }
210
122
        _contain_null = _is_nullable_col && contain_null;
211
122
    }
_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
96
    void set_contain_null(bool contain_null) {
205
96
        if (contain_null) {
206
68
            set_empty_value_range();
207
68
        } else {
208
28
            set_whole_value_range();
209
28
        }
210
96
        _contain_null = _is_nullable_col && contain_null;
211
96
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16set_contain_nullEb
Line
Count
Source
204
417
    void set_contain_null(bool contain_null) {
205
417
        if (contain_null) {
206
366
            set_empty_value_range();
207
366
        } else {
208
51
            set_whole_value_range();
209
51
        }
210
417
        _contain_null = _is_nullable_col && contain_null;
211
417
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
2.34k
    void set_contain_null(bool contain_null) {
205
2.34k
        if (contain_null) {
206
262
            set_empty_value_range();
207
2.08k
        } else {
208
2.08k
            set_whole_value_range();
209
2.08k
        }
210
2.34k
        _contain_null = _is_nullable_col && contain_null;
211
2.34k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
165
    void set_contain_null(bool contain_null) {
205
165
        if (contain_null) {
206
129
            set_empty_value_range();
207
129
        } else {
208
36
            set_whole_value_range();
209
36
        }
210
165
        _contain_null = _is_nullable_col && contain_null;
211
165
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
113
    void set_contain_null(bool contain_null) {
205
113
        if (contain_null) {
206
68
            set_empty_value_range();
207
68
        } else {
208
45
            set_whole_value_range();
209
45
        }
210
113
        _contain_null = _is_nullable_col && contain_null;
211
113
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
68
    void set_contain_null(bool contain_null) {
205
68
        if (contain_null) {
206
18
            set_empty_value_range();
207
50
        } else {
208
50
            set_whole_value_range();
209
50
        }
210
68
        _contain_null = _is_nullable_col && contain_null;
211
68
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16set_contain_nullEb
Line
Count
Source
204
78
    void set_contain_null(bool contain_null) {
205
78
        if (contain_null) {
206
68
            set_empty_value_range();
207
68
        } else {
208
10
            set_whole_value_range();
209
10
        }
210
78
        _contain_null = _is_nullable_col && contain_null;
211
78
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16set_contain_nullEb
Line
Count
Source
204
32
    void set_contain_null(bool contain_null) {
205
32
        if (contain_null) {
206
8
            set_empty_value_range();
207
24
        } else {
208
24
            set_whole_value_range();
209
24
        }
210
32
        _contain_null = _is_nullable_col && contain_null;
211
32
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16set_contain_nullEb
Line
Count
Source
204
394
    void set_contain_null(bool contain_null) {
205
394
        if (contain_null) {
206
136
            set_empty_value_range();
207
258
        } else {
208
258
            set_whole_value_range();
209
258
        }
210
394
        _contain_null = _is_nullable_col && contain_null;
211
394
    }
_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
13
    void set_contain_null(bool contain_null) {
205
13
        if (contain_null) {
206
2
            set_empty_value_range();
207
11
        } else {
208
11
            set_whole_value_range();
209
11
        }
210
13
        _contain_null = _is_nullable_col && contain_null;
211
13
    }
212
213
564k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
125k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
2.22k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
21.7k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
75.7k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
381
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
274
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
574
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
42
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
40
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.61k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9precisionEv
Line
Count
Source
213
295k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9precisionEv
Line
Count
Source
213
4.18k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9precisionEv
Line
Count
Source
213
81
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
28.9k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
79
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
4.14k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
1.03k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
455
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
216
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
966
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
257
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
165
    int precision() const { return _precision; }
214
215
2.20M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
323k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
26.7k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
187k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
248k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
9.13k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
275
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
575
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
42
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
44
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.57k
    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.19k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
1.76k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
298k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
161
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
9.13k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
7.73k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
89
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
4.98k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.07k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
2.33k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
3.07k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
1.28k
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
507k
                                      const CppType& value) {
219
507k
        static_cast<void>(range.add_fixed_value(value));
220
507k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
122k
                                      const CppType& value) {
219
122k
        static_cast<void>(range.add_fixed_value(value));
220
122k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
335
                                      const CppType& value) {
219
335
        static_cast<void>(range.add_fixed_value(value));
220
335
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
67.5k
                                      const CppType& value) {
219
67.5k
        static_cast<void>(range.add_fixed_value(value));
220
67.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
1.82k
                                      const CppType& value) {
219
1.82k
        static_cast<void>(range.add_fixed_value(value));
220
1.82k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
217
                                      const CppType& value) {
219
217
        static_cast<void>(range.add_fixed_value(value));
220
217
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
53
                                      const CppType& value) {
219
53
        static_cast<void>(range.add_fixed_value(value));
220
53
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
136
                                      const CppType& value) {
219
136
        static_cast<void>(range.add_fixed_value(value));
220
136
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
218
34
                                      const CppType& value) {
219
34
        static_cast<void>(range.add_fixed_value(value));
220
34
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
218
35
                                      const CppType& value) {
219
35
        static_cast<void>(range.add_fixed_value(value));
220
35
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
598
                                      const CppType& value) {
219
598
        static_cast<void>(range.add_fixed_value(value));
220
598
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
302k
                                      const CppType& value) {
219
302k
        static_cast<void>(range.add_fixed_value(value));
220
302k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
1.52k
                                      const CppType& value) {
219
1.52k
        static_cast<void>(range.add_fixed_value(value));
220
1.52k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
73
                                      const CppType& value) {
219
73
        static_cast<void>(range.add_fixed_value(value));
220
73
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
8.40k
                                      const CppType& value) {
219
8.40k
        static_cast<void>(range.add_fixed_value(value));
220
8.40k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
70
                                      const CppType& value) {
219
70
        static_cast<void>(range.add_fixed_value(value));
220
70
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
577
                                      const CppType& value) {
219
577
        static_cast<void>(range.add_fixed_value(value));
220
577
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
195
                                      const CppType& value) {
219
195
        static_cast<void>(range.add_fixed_value(value));
220
195
    }
_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
375
                                      const CppType& value) {
219
375
        static_cast<void>(range.add_fixed_value(value));
220
375
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
218
43
                                      const CppType& value) {
219
43
        static_cast<void>(range.add_fixed_value(value));
220
43
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
218
333
                                      const CppType& value) {
219
333
        static_cast<void>(range.add_fixed_value(value));
220
333
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
116
                                      const CppType& value) {
219
116
        static_cast<void>(range.add_fixed_value(value));
220
116
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
45
                                      const CppType& value) {
219
45
        static_cast<void>(range.add_fixed_value(value));
220
45
    }
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
3.32k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
46
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
33
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
1.44k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14empty_functionERS2_NS_11SQLFilterOpERKl
Line
Count
Source
228
34
                               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
46
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
119
                               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
143
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
475
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
281
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
50
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
24
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
42
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
228
69
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
368
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
12
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
32
                               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
21
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
56
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
100k
                                const CppType& value) {
232
100k
        static_cast<void>(range.add_range(op, value));
233
100k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
1.48k
                                const CppType& value) {
232
1.48k
        static_cast<void>(range.add_range(op, value));
233
1.48k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.96k
                                const CppType& value) {
232
1.96k
        static_cast<void>(range.add_range(op, value));
233
1.96k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
12.6k
                                const CppType& value) {
232
12.6k
        static_cast<void>(range.add_range(op, value));
233
12.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
55.1k
                                const CppType& value) {
232
55.1k
        static_cast<void>(range.add_range(op, value));
233
55.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
168
                                const CppType& value) {
232
168
        static_cast<void>(range.add_range(op, value));
233
168
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
136
                                const CppType& value) {
232
136
        static_cast<void>(range.add_range(op, value));
233
136
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
313
                                const CppType& value) {
232
313
        static_cast<void>(range.add_range(op, value));
233
313
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
8
                                const CppType& value) {
232
8
        static_cast<void>(range.add_range(op, value));
233
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
8
                                const CppType& value) {
232
8
        static_cast<void>(range.add_range(op, value));
233
8
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.01k
                                const CppType& value) {
232
1.01k
        static_cast<void>(range.add_range(op, value));
233
1.01k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.48k
                                const CppType& value) {
232
1.48k
        static_cast<void>(range.add_range(op, value));
233
1.48k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
406
                                const CppType& value) {
232
406
        static_cast<void>(range.add_range(op, value));
233
406
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
231
18
                                const CppType& value) {
232
18
        static_cast<void>(range.add_range(op, value));
233
18
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
20.4k
                                const CppType& value) {
232
20.4k
        static_cast<void>(range.add_range(op, value));
233
20.4k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
231
18
                                const CppType& value) {
232
18
        static_cast<void>(range.add_range(op, value));
233
18
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
3.48k
                                const CppType& value) {
232
3.48k
        static_cast<void>(range.add_range(op, value));
233
3.48k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
631
                                const CppType& value) {
232
631
        static_cast<void>(range.add_range(op, value));
233
631
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
231
50
                                const CppType& value) {
232
50
        static_cast<void>(range.add_range(op, value));
233
50
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
117
                                const CppType& value) {
232
117
        static_cast<void>(range.add_range(op, value));
233
117
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
414
                                const CppType& value) {
232
414
        static_cast<void>(range.add_range(op, value));
233
414
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
231
118
                                const CppType& value) {
232
118
        static_cast<void>(range.add_range(op, value));
233
118
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
231
77
                                const CppType& value) {
232
77
        static_cast<void>(range.add_range(op, value));
233
77
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
562k
                                                                            int scale) {
238
562k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
562k
                                                precision, scale);
240
562k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
124k
                                                                            int scale) {
238
124k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
124k
                                                precision, scale);
240
124k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
2.19k
                                                                            int scale) {
238
2.19k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
2.19k
                                                precision, scale);
240
2.19k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
21.5k
                                                                            int scale) {
238
21.5k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
21.5k
                                                precision, scale);
240
21.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
75.6k
                                                                            int scale) {
238
75.6k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
75.6k
                                                precision, scale);
240
75.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
377
                                                                            int scale) {
238
377
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
377
                                                precision, scale);
240
377
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
272
                                                                            int scale) {
238
272
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
272
                                                precision, scale);
240
272
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
571
                                                                            int scale) {
238
571
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
571
                                                precision, scale);
240
571
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
42
                                                                            int scale) {
238
42
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
42
                                                precision, scale);
240
42
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
40
                                                                            int scale) {
238
40
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
40
                                                precision, scale);
240
40
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.60k
                                                                            int scale) {
238
1.60k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.60k
                                                precision, scale);
240
1.60k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
295k
                                                                            int scale) {
238
295k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
295k
                                                precision, scale);
240
295k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.12k
                                                                            int scale) {
238
4.12k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.12k
                                                precision, scale);
240
4.12k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
81
                                                                            int scale) {
238
81
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
81
                                                precision, scale);
240
81
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
28.8k
                                                                            int scale) {
238
28.8k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
28.8k
                                                precision, scale);
240
28.8k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
79
                                                                            int scale) {
238
79
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
79
                                                precision, scale);
240
79
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
4.12k
                                                                            int scale) {
238
4.12k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
4.12k
                                                precision, scale);
240
4.12k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.02k
                                                                            int scale) {
238
1.02k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.02k
                                                precision, scale);
240
1.02k
    }
_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
454
                                                                            int scale) {
238
454
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
454
                                                precision, scale);
240
454
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
213
                                                                            int scale) {
238
213
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
213
                                                precision, scale);
240
213
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
961
                                                                            int scale) {
238
961
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
961
                                                precision, scale);
240
961
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
256
                                                                            int scale) {
238
256
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
256
                                                precision, scale);
240
256
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
163
                                                                            int scale) {
238
163
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
163
                                                precision, scale);
240
163
    }
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.73k
    std::string debug_string() {
310
1.73k
        std::stringstream ss;
311
1.73k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
1.73k
        ss << "ScanKeys:";
313
314
14.3k
        for (int i = 0; i < _begin_scan_keys.size(); ++i) {
315
12.6k
            ss << "ScanKey=" << (_begin_include ? "[" : "(") << _begin_scan_keys[i] << " : "
316
12.6k
               << _end_scan_keys[i] << (_end_include ? "]" : ")");
317
12.6k
        }
318
1.73k
        return ss.str();
319
1.73k
    }
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
334k
    void set_is_convertible(bool is_convertible) { _is_convertible = is_convertible; }
327
328
private:
329
    std::vector<OlapTuple> _begin_scan_keys;
330
    std::vector<OlapTuple> _end_scan_keys;
331
    bool _has_range_value = false;
332
    bool _begin_include = false;
333
    bool _end_include = false;
334
    bool _is_convertible = false;
335
};
336
337
using ColumnValueRangeType = std::variant<
338
        ColumnValueRange<TYPE_TINYINT>, ColumnValueRange<TYPE_SMALLINT>, ColumnValueRange<TYPE_INT>,
339
        ColumnValueRange<TYPE_BIGINT>, ColumnValueRange<TYPE_LARGEINT>,
340
        ColumnValueRange<TYPE_FLOAT>, ColumnValueRange<TYPE_DOUBLE>, ColumnValueRange<TYPE_IPV4>,
341
        ColumnValueRange<TYPE_IPV6>, ColumnValueRange<TYPE_CHAR>, ColumnValueRange<TYPE_VARCHAR>,
342
        ColumnValueRange<TYPE_STRING>, ColumnValueRange<TYPE_DATE>, ColumnValueRange<TYPE_DATEV2>,
343
        ColumnValueRange<TYPE_DATETIME>, ColumnValueRange<TYPE_DATETIMEV2>,
344
        ColumnValueRange<TYPE_TIMESTAMPTZ>, ColumnValueRange<TYPE_DECIMALV2>,
345
        ColumnValueRange<TYPE_BOOLEAN>, ColumnValueRange<TYPE_HLL>,
346
        ColumnValueRange<TYPE_DECIMAL32>, ColumnValueRange<TYPE_DECIMAL64>,
347
        ColumnValueRange<TYPE_DECIMAL128I>, ColumnValueRange<TYPE_DECIMAL256>>;
348
349
template <PrimitiveType primitive_type>
350
const typename ColumnValueRange<primitive_type>::CppType
351
        ColumnValueRange<primitive_type>::TYPE_MIN =
352
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::min();
353
template <PrimitiveType primitive_type>
354
const typename ColumnValueRange<primitive_type>::CppType
355
        ColumnValueRange<primitive_type>::TYPE_MAX =
356
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::max();
357
358
template <PrimitiveType primitive_type>
359
ColumnValueRange<primitive_type>::ColumnValueRange()
360
2.42M
        : _column_type(INVALID_TYPE), _precision(-1), _scale(-1) {}
361
362
template <PrimitiveType primitive_type>
363
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, const CppType& min,
364
                                                   const CppType& max, bool contain_null)
365
        : _column_name(std::move(col_name)),
366
          _column_type(primitive_type),
367
          _low_value(min),
368
          _high_value(max),
369
          _low_op(FILTER_LARGER_OR_EQUAL),
370
          _high_op(FILTER_LESS_OR_EQUAL),
371
          _is_nullable_col(true),
372
          _contain_null(contain_null),
373
          _precision(-1),
374
          _scale(-1) {}
375
376
template <PrimitiveType primitive_type>
377
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, const CppType& min,
378
                                                   const CppType& max, bool is_nullable_col,
379
                                                   bool contain_null, int precision, int scale)
380
2.98M
        : _column_name(std::move(col_name)),
381
2.98M
          _column_type(primitive_type),
382
1.74M
          _low_value(min),
383
1.74M
          _high_value(max),
384
2.98M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
2.98M
          _high_op(FILTER_LESS_OR_EQUAL),
386
2.98M
          _is_nullable_col(is_nullable_col),
387
2.98M
          _contain_null(is_nullable_col && contain_null),
388
2.98M
          _precision(precision),
389
2.98M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKaSA_bbii
Line
Count
Source
380
273k
        : _column_name(std::move(col_name)),
381
273k
          _column_type(primitive_type),
382
273k
          _low_value(min),
383
273k
          _high_value(max),
384
273k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
273k
          _high_op(FILTER_LESS_OR_EQUAL),
386
273k
          _is_nullable_col(is_nullable_col),
387
273k
          _contain_null(is_nullable_col && contain_null),
388
273k
          _precision(precision),
389
273k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
24.5k
        : _column_name(std::move(col_name)),
381
24.5k
          _column_type(primitive_type),
382
24.5k
          _low_value(min),
383
24.5k
          _high_value(max),
384
24.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
24.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
24.5k
          _is_nullable_col(is_nullable_col),
387
24.5k
          _contain_null(is_nullable_col && contain_null),
388
24.5k
          _precision(precision),
389
24.5k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
274k
        : _column_name(std::move(col_name)),
381
274k
          _column_type(primitive_type),
382
274k
          _low_value(min),
383
274k
          _high_value(max),
384
274k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
274k
          _high_op(FILTER_LESS_OR_EQUAL),
386
274k
          _is_nullable_col(is_nullable_col),
387
274k
          _contain_null(is_nullable_col && contain_null),
388
274k
          _precision(precision),
389
274k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
611k
        : _column_name(std::move(col_name)),
381
611k
          _column_type(primitive_type),
382
611k
          _low_value(min),
383
611k
          _high_value(max),
384
611k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
611k
          _high_op(FILTER_LESS_OR_EQUAL),
386
611k
          _is_nullable_col(is_nullable_col),
387
611k
          _contain_null(is_nullable_col && contain_null),
388
611k
          _precision(precision),
389
611k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_bbii
Line
Count
Source
380
12.0k
        : _column_name(std::move(col_name)),
381
12.0k
          _column_type(primitive_type),
382
12.0k
          _low_value(min),
383
12.0k
          _high_value(max),
384
12.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.0k
          _is_nullable_col(is_nullable_col),
387
12.0k
          _contain_null(is_nullable_col && contain_null),
388
12.0k
          _precision(precision),
389
12.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
13.1k
        : _column_name(std::move(col_name)),
381
13.1k
          _column_type(primitive_type),
382
13.1k
          _low_value(min),
383
13.1k
          _high_value(max),
384
13.1k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.1k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.1k
          _is_nullable_col(is_nullable_col),
387
13.1k
          _contain_null(is_nullable_col && contain_null),
388
13.1k
          _precision(precision),
389
13.1k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
17.8k
        : _column_name(std::move(col_name)),
381
17.8k
          _column_type(primitive_type),
382
17.8k
          _low_value(min),
383
17.8k
          _high_value(max),
384
17.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
17.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
17.8k
          _is_nullable_col(is_nullable_col),
387
17.8k
          _contain_null(is_nullable_col && contain_null),
388
17.8k
          _precision(precision),
389
17.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
467
        : _column_name(std::move(col_name)),
381
467
          _column_type(primitive_type),
382
467
          _low_value(min),
383
467
          _high_value(max),
384
467
          _low_op(FILTER_LARGER_OR_EQUAL),
385
467
          _high_op(FILTER_LESS_OR_EQUAL),
386
467
          _is_nullable_col(is_nullable_col),
387
467
          _contain_null(is_nullable_col && contain_null),
388
467
          _precision(precision),
389
467
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
492
        : _column_name(std::move(col_name)),
381
492
          _column_type(primitive_type),
382
492
          _low_value(min),
383
492
          _high_value(max),
384
492
          _low_op(FILTER_LARGER_OR_EQUAL),
385
492
          _high_op(FILTER_LESS_OR_EQUAL),
386
492
          _is_nullable_col(is_nullable_col),
387
492
          _contain_null(is_nullable_col && contain_null),
388
492
          _precision(precision),
389
492
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
20.5k
        : _column_name(std::move(col_name)),
381
20.5k
          _column_type(primitive_type),
382
20.5k
          _low_value(min),
383
20.5k
          _high_value(max),
384
20.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
20.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
20.5k
          _is_nullable_col(is_nullable_col),
387
20.5k
          _contain_null(is_nullable_col && contain_null),
388
20.5k
          _precision(precision),
389
20.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
555
        : _column_name(std::move(col_name)),
381
555
          _column_type(primitive_type),
382
555
          _low_value(min),
383
555
          _high_value(max),
384
555
          _low_op(FILTER_LARGER_OR_EQUAL),
385
555
          _high_op(FILTER_LESS_OR_EQUAL),
386
555
          _is_nullable_col(is_nullable_col),
387
555
          _contain_null(is_nullable_col && contain_null),
388
555
          _precision(precision),
389
555
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_15DateV2ValueTypeEEESD_bbii
Line
Count
Source
380
124k
        : _column_name(std::move(col_name)),
381
124k
          _column_type(primitive_type),
382
124k
          _low_value(min),
383
124k
          _high_value(max),
384
124k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
124k
          _high_op(FILTER_LESS_OR_EQUAL),
386
124k
          _is_nullable_col(is_nullable_col),
387
124k
          _contain_null(is_nullable_col && contain_null),
388
124k
          _precision(precision),
389
124k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
517
        : _column_name(std::move(col_name)),
381
517
          _column_type(primitive_type),
382
517
          _low_value(min),
383
517
          _high_value(max),
384
517
          _low_op(FILTER_LARGER_OR_EQUAL),
385
517
          _high_op(FILTER_LESS_OR_EQUAL),
386
517
          _is_nullable_col(is_nullable_col),
387
517
          _contain_null(is_nullable_col && contain_null),
388
517
          _precision(precision),
389
517
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
134k
        : _column_name(std::move(col_name)),
381
134k
          _column_type(primitive_type),
382
134k
          _low_value(min),
383
134k
          _high_value(max),
384
134k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
134k
          _high_op(FILTER_LESS_OR_EQUAL),
386
134k
          _is_nullable_col(is_nullable_col),
387
134k
          _contain_null(is_nullable_col && contain_null),
388
134k
          _precision(precision),
389
134k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
8.08k
        : _column_name(std::move(col_name)),
381
8.08k
          _column_type(primitive_type),
382
8.08k
          _low_value(min),
383
8.08k
          _high_value(max),
384
8.08k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
8.08k
          _high_op(FILTER_LESS_OR_EQUAL),
386
8.08k
          _is_nullable_col(is_nullable_col),
387
8.08k
          _contain_null(is_nullable_col && contain_null),
388
8.08k
          _precision(precision),
389
8.08k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
755
        : _column_name(std::move(col_name)),
381
755
          _column_type(primitive_type),
382
755
          _low_value(min),
383
755
          _high_value(max),
384
755
          _low_op(FILTER_LARGER_OR_EQUAL),
385
755
          _high_op(FILTER_LESS_OR_EQUAL),
386
755
          _is_nullable_col(is_nullable_col),
387
755
          _contain_null(is_nullable_col && contain_null),
388
755
          _precision(precision),
389
755
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
11.7k
        : _column_name(std::move(col_name)),
381
11.7k
          _column_type(primitive_type),
382
11.7k
          _low_value(min),
383
11.7k
          _high_value(max),
384
11.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
11.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
11.7k
          _is_nullable_col(is_nullable_col),
387
11.7k
          _contain_null(is_nullable_col && contain_null),
388
11.7k
          _precision(precision),
389
11.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
496
        : _column_name(std::move(col_name)),
381
496
          _column_type(primitive_type),
382
496
          _low_value(min),
383
496
          _high_value(max),
384
496
          _low_op(FILTER_LARGER_OR_EQUAL),
385
496
          _high_op(FILTER_LESS_OR_EQUAL),
386
496
          _is_nullable_col(is_nullable_col),
387
496
          _contain_null(is_nullable_col && contain_null),
388
496
          _precision(precision),
389
496
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
13.0k
        : _column_name(std::move(col_name)),
381
13.0k
          _column_type(primitive_type),
382
13.0k
          _low_value(min),
383
13.0k
          _high_value(max),
384
13.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.0k
          _is_nullable_col(is_nullable_col),
387
13.0k
          _contain_null(is_nullable_col && contain_null),
388
13.0k
          _precision(precision),
389
13.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
30.3k
        : _column_name(std::move(col_name)),
381
30.3k
          _column_type(primitive_type),
382
30.3k
          _low_value(min),
383
30.3k
          _high_value(max),
384
30.3k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
30.3k
          _high_op(FILTER_LESS_OR_EQUAL),
386
30.3k
          _is_nullable_col(is_nullable_col),
387
30.3k
          _contain_null(is_nullable_col && contain_null),
388
30.3k
          _precision(precision),
389
30.3k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
13.2k
        : _column_name(std::move(col_name)),
381
13.2k
          _column_type(primitive_type),
382
13.2k
          _low_value(min),
383
13.2k
          _high_value(max),
384
13.2k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.2k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.2k
          _is_nullable_col(is_nullable_col),
387
13.2k
          _contain_null(is_nullable_col && contain_null),
388
13.2k
          _precision(precision),
389
13.2k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
1.57k
        : _column_name(std::move(col_name)),
381
1.57k
          _column_type(primitive_type),
382
1.57k
          _low_value(min),
383
1.57k
          _high_value(max),
384
1.57k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.57k
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.57k
          _is_nullable_col(is_nullable_col),
387
1.57k
          _contain_null(is_nullable_col && contain_null),
388
1.57k
          _precision(precision),
389
1.57k
          _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.42M
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
2.42M
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
148k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
148k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
22.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
22.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
251k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
251k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
535k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
535k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.6k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.6k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.7k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.7k
                           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.9k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
18.9k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
471
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
471
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
437
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
437
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
95.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
95.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
129k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
129k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
7.03k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
7.03k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
941k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
941k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
157k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
157k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
496
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
496
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.8k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.8k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
29.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
29.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.9k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.9k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
1.40k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.40k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
717
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
717
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
418
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
418
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
446
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
446
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
519k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
519k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
519k
    _fixed_values.insert(value);
404
519k
    _contain_null = false;
405
406
519k
    _high_value = TYPE_MIN;
407
519k
    _low_value = TYPE_MAX;
408
409
519k
    return Status::OK();
410
519k
}
_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
332
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
332
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
332
    _fixed_values.insert(value);
404
332
    _contain_null = false;
405
406
332
    _high_value = TYPE_MIN;
407
332
    _low_value = TYPE_MAX;
408
409
332
    return Status::OK();
410
332
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
68.5k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
68.5k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
68.5k
    _fixed_values.insert(value);
404
68.5k
    _contain_null = false;
405
406
68.5k
    _high_value = TYPE_MIN;
407
68.5k
    _low_value = TYPE_MAX;
408
409
68.5k
    return Status::OK();
410
68.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
12.0k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
12.0k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
12.0k
    _fixed_values.insert(value);
404
12.0k
    _contain_null = false;
405
406
12.0k
    _high_value = TYPE_MIN;
407
12.0k
    _low_value = TYPE_MAX;
408
409
12.0k
    return Status::OK();
410
12.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
228
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
228
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
228
    _fixed_values.insert(value);
404
228
    _contain_null = false;
405
406
228
    _high_value = TYPE_MIN;
407
228
    _low_value = TYPE_MAX;
408
409
228
    return Status::OK();
410
228
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
69
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
69
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
69
    _fixed_values.insert(value);
404
69
    _contain_null = false;
405
406
69
    _high_value = TYPE_MIN;
407
69
    _low_value = TYPE_MAX;
408
409
69
    return Status::OK();
410
69
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
152
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
152
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
152
    _fixed_values.insert(value);
404
152
    _contain_null = false;
405
406
152
    _high_value = TYPE_MIN;
407
152
    _low_value = TYPE_MAX;
408
409
152
    return Status::OK();
410
152
}
_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
601
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
601
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
601
    _fixed_values.insert(value);
404
601
    _contain_null = false;
405
406
601
    _high_value = TYPE_MIN;
407
601
    _low_value = TYPE_MAX;
408
409
601
    return Status::OK();
410
601
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
302k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
302k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
302k
    _fixed_values.insert(value);
404
302k
    _contain_null = false;
405
406
302k
    _high_value = TYPE_MIN;
407
302k
    _low_value = TYPE_MAX;
408
409
302k
    return Status::OK();
410
302k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
1.56k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
1.56k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
1.56k
    _fixed_values.insert(value);
404
1.56k
    _contain_null = false;
405
406
1.56k
    _high_value = TYPE_MIN;
407
1.56k
    _low_value = TYPE_MAX;
408
409
1.56k
    return Status::OK();
410
1.56k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
73
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
73
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
73
    _fixed_values.insert(value);
404
73
    _contain_null = false;
405
406
73
    _high_value = TYPE_MIN;
407
73
    _low_value = TYPE_MAX;
408
409
73
    return Status::OK();
410
73
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
8.47k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
8.47k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
8.47k
    _fixed_values.insert(value);
404
8.47k
    _contain_null = false;
405
406
8.47k
    _high_value = TYPE_MIN;
407
8.47k
    _low_value = TYPE_MAX;
408
409
8.47k
    return Status::OK();
410
8.47k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_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_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
642
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
642
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
642
    _fixed_values.insert(value);
404
642
    _contain_null = false;
405
406
642
    _high_value = TYPE_MIN;
407
642
    _low_value = TYPE_MAX;
408
409
642
    return Status::OK();
410
642
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
263
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
263
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
263
    _fixed_values.insert(value);
404
263
    _contain_null = false;
405
406
263
    _high_value = TYPE_MIN;
407
263
    _low_value = TYPE_MAX;
408
409
263
    return Status::OK();
410
263
}
_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
391
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
391
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
391
    _fixed_values.insert(value);
404
391
    _contain_null = false;
405
406
391
    _high_value = TYPE_MIN;
407
391
    _low_value = TYPE_MAX;
408
409
391
    return Status::OK();
410
391
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
67
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
67
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
67
    _fixed_values.insert(value);
404
67
    _contain_null = false;
405
406
67
    _high_value = TYPE_MIN;
407
67
    _low_value = TYPE_MAX;
408
409
67
    return Status::OK();
410
67
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
385
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
385
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
385
    _fixed_values.insert(value);
404
385
    _contain_null = false;
405
406
385
    _high_value = TYPE_MIN;
407
385
    _low_value = TYPE_MAX;
408
409
385
    return Status::OK();
410
385
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
116
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
116
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
116
    _fixed_values.insert(value);
404
116
    _contain_null = false;
405
406
116
    _high_value = TYPE_MIN;
407
116
    _low_value = TYPE_MAX;
408
409
116
    return Status::OK();
410
116
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
46
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
46
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
46
    _fixed_values.insert(value);
404
46
    _contain_null = false;
405
406
46
    _high_value = TYPE_MIN;
407
46
    _low_value = TYPE_MAX;
408
409
46
    return Status::OK();
410
46
}
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.83M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.83M
    return _fixed_values.size() != 0;
420
7.83M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_fixed_value_rangeEv
Line
Count
Source
418
1.12M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
1.12M
    return _fixed_values.size() != 0;
420
1.12M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
26.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
26.4k
    return _fixed_values.size() != 0;
420
26.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
533k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
533k
    return _fixed_values.size() != 0;
420
533k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
964k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
964k
    return _fixed_values.size() != 0;
420
964k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
30.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
30.3k
    return _fixed_values.size() != 0;
420
30.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
13.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
13.4k
    return _fixed_values.size() != 0;
420
13.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.6k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.6k
    return _fixed_values.size() != 0;
420
18.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
661
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
661
    return _fixed_values.size() != 0;
420
661
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
676
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
676
    return _fixed_values.size() != 0;
420
676
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
25.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
25.0k
    return _fixed_values.size() != 0;
420
25.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_fixed_value_rangeEv
Line
Count
Source
418
4.45M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
4.45M
    return _fixed_values.size() != 0;
420
4.45M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_fixed_value_rangeEv
Line
Count
Source
418
180k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
180k
    return _fixed_values.size() != 0;
420
180k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_fixed_value_rangeEv
Line
Count
Source
418
907
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
907
    return _fixed_values.size() != 0;
420
907
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_fixed_value_rangeEv
Line
Count
Source
418
191k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
191k
    return _fixed_values.size() != 0;
420
191k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_fixed_value_rangeEv
Line
Count
Source
418
912
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
912
    return _fixed_values.size() != 0;
420
912
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
146k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
146k
    return _fixed_values.size() != 0;
420
146k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_fixed_value_rangeEv
Line
Count
Source
418
21.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
21.5k
    return _fixed_values.size() != 0;
420
21.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
908
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
908
    return _fixed_values.size() != 0;
420
908
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
23.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
23.0k
    return _fixed_values.size() != 0;
420
23.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
495
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
495
    return _fixed_values.size() != 0;
420
495
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
15.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
15.0k
    return _fixed_values.size() != 0;
420
15.0k
}
_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.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
19.3k
    return _fixed_values.size() != 0;
420
19.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
3.93k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
3.93k
    return _fixed_values.size() != 0;
420
3.93k
}
421
422
template <PrimitiveType primitive_type>
423
2.73M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
2.73M
    return Compare::greater(_high_value, _low_value);
425
2.73M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
152k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
152k
    return Compare::greater(_high_value, _low_value);
425
152k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
22.4k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
22.4k
    return Compare::greater(_high_value, _low_value);
425
22.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
320k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
320k
    return Compare::greater(_high_value, _low_value);
425
320k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
653k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
653k
    return Compare::greater(_high_value, _low_value);
425
653k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
15.7k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
15.7k
    return Compare::greater(_high_value, _low_value);
425
15.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
12.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.8k
    return Compare::greater(_high_value, _low_value);
425
12.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
17.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
17.1k
    return Compare::greater(_high_value, _low_value);
425
17.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
429
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
429
    return Compare::greater(_high_value, _low_value);
425
429
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
454
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
454
    return Compare::greater(_high_value, _low_value);
425
454
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_scope_value_rangeEv
Line
Count
Source
423
19.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
19.1k
    return Compare::greater(_high_value, _low_value);
425
19.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_scope_value_rangeEv
Line
Count
Source
423
1.04M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.04M
    return Compare::greater(_high_value, _low_value);
425
1.04M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_scope_value_rangeEv
Line
Count
Source
423
161k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
161k
    return Compare::greater(_high_value, _low_value);
425
161k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
486
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
486
    return Compare::greater(_high_value, _low_value);
425
486
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
98.2k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
98.2k
    return Compare::greater(_high_value, _low_value);
425
98.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
460
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
460
    return Compare::greater(_high_value, _low_value);
425
460
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
131k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
131k
    return Compare::greater(_high_value, _low_value);
425
131k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
10.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
10.0k
    return Compare::greater(_high_value, _low_value);
425
10.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
748
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
748
    return Compare::greater(_high_value, _low_value);
425
748
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
13.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.5k
    return Compare::greater(_high_value, _low_value);
425
13.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_scope_value_rangeEv
Line
Count
Source
423
495
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
495
    return Compare::greater(_high_value, _low_value);
425
495
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
13.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
13.1k
    return Compare::greater(_high_value, _low_value);
425
13.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
30.4k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
30.4k
    return Compare::greater(_high_value, _low_value);
425
30.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
14.2k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.2k
    return Compare::greater(_high_value, _low_value);
425
14.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
1.94k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.94k
    return Compare::greater(_high_value, _low_value);
425
1.94k
}
426
427
template <PrimitiveType primitive_type>
428
3.89M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
3.89M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
3.89M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
3.89M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
395k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
395k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
395k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
395k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
22.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
22.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
22.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
22.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
336k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
336k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
336k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
336k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
656k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
656k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
656k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
656k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
16.3k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
16.3k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
16.3k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
16.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
12.8k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
12.8k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
12.8k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
12.8k
}
_ZNK5doris16ColumnValueRangeILNS_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
482
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
482
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
482
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
482
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
504
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
504
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
504
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
504
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_empty_value_rangeEv
Line
Count
Source
428
20.1k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
20.1k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
20.1k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
20.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_empty_value_rangeEv
Line
Count
Source
428
1.91M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.91M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.91M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.91M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
163k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
163k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
163k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
163k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
576
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
576
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
576
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
576
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
115k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
115k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
115k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
115k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
550
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
550
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
550
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
550
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
133k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
133k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
133k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
133k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
10.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
10.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
10.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
10.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_empty_value_rangeEv
Line
Count
Source
428
776
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
776
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
776
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
776
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
14.2k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.2k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.2k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_empty_value_rangeEv
Line
Count
Source
428
494
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
494
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
496
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
494
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
13.3k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
13.3k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
13.3k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
13.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
30.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
30.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
30.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
30.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_empty_value_rangeEv
Line
Count
Source
428
14.4k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.4k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.4k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
2.02k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.02k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.02k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.02k
}
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
20.1k
        return false;
444
20.1k
    }
445
446
160k
    return true;
447
181k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.31k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.31k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.31k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.31k
    return true;
447
2.31k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
251
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
251
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
251
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
251
    return true;
447
251
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_fixed_value_convertibleEv
Line
Count
Source
437
67.8k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
67.8k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
67.8k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
67.8k
    return true;
447
67.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
83.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
83.3k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
83.3k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
83.3k
    return true;
447
83.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
4.15k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
4.15k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
4.15k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
4.15k
    return true;
447
4.15k
}
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
380
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
380
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
380
    if (!is_enumeration_type(_column_type)) {
443
379
        return false;
444
379
    }
445
446
1
    return true;
447
380
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
9.24k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
9.24k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
9.24k
    if (!is_enumeration_type(_column_type)) {
443
9.23k
        return false;
444
9.23k
    }
445
446
7
    return true;
447
9.24k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_fixed_value_convertibleEv
Line
Count
Source
437
17
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
17
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
17
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
17
    return true;
447
17
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.88k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.88k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.88k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.88k
    return true;
447
2.88k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_fixed_value_convertibleEv
Line
Count
Source
437
22
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
22
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
22
    if (!is_enumeration_type(_column_type)) {
443
22
        return false;
444
22
    }
445
446
0
    return true;
447
22
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.40k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.40k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.40k
    if (!is_enumeration_type(_column_type)) {
443
2.40k
        return false;
444
2.40k
    }
445
446
18.4E
    return true;
447
2.40k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
3.09k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
3.09k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
3.10k
    if (!is_enumeration_type(_column_type)) {
443
3.10k
        return false;
444
3.10k
    }
445
446
18.4E
    return true;
447
3.09k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
42
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
42
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
42
    if (!is_enumeration_type(_column_type)) {
443
42
        return false;
444
42
    }
445
446
0
    return true;
447
42
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.21k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.21k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.21k
    if (!is_enumeration_type(_column_type)) {
443
2.20k
        return false;
444
2.20k
    }
445
446
14
    return true;
447
2.21k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
400
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
400
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
401
    if (!is_enumeration_type(_column_type)) {
443
401
        return false;
444
401
    }
445
446
18.4E
    return true;
447
400
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
634
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
634
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
634
    if (!is_enumeration_type(_column_type)) {
443
632
        return false;
444
632
    }
445
446
2
    return true;
447
634
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.27k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.27k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.28k
    if (!is_enumeration_type(_column_type)) {
443
1.28k
        return false;
444
1.28k
    }
445
446
18.4E
    return true;
447
1.27k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
471
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
471
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
471
    if (!is_enumeration_type(_column_type)) {
443
468
        return false;
444
468
    }
445
446
3
    return true;
447
471
}
448
449
template <PrimitiveType primitive_type>
450
183
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
183
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
183
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
182
    return true;
460
183
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
116
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
116
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
116
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
116
    return true;
460
116
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26is_range_value_convertibleEv
Line
Count
Source
450
2
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
2
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
2
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
2
    return true;
460
2
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_range_value_convertibleEv
Line
Count
Source
450
64
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
64
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
64
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
64
    return true;
460
64
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_range_value_convertibleEv
Line
Count
Source
450
1
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
1
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
1
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
0
    return true;
460
1
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_range_value_convertibleEv
461
462
// The return value indicates whether eos.
463
template <PrimitiveType primitive_type>
464
bool ColumnValueRange<primitive_type>::convert_to_close_range(
465
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
466
155k
        bool& begin_include, bool& end_include) {
467
155k
    if constexpr (!_is_reject_split_type) {
468
155k
        begin_include = true;
469
155k
        end_include = true;
470
471
155k
        bool is_empty = false;
472
473
155k
        if (!is_begin_include()) {
474
9.04k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
9.04k
            } else {
477
9.04k
                ++_low_value;
478
9.04k
            }
479
9.04k
        }
480
481
155k
        if (!is_end_include()) {
482
808
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
808
            } else {
485
808
                --_high_value;
486
808
            }
487
808
        }
488
489
155k
        if (Compare::less(_high_value, _low_value)) {
490
29
            is_empty = true;
491
29
        }
492
493
155k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
155k
    }
499
155k
    return false;
500
155k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.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
83
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
83
            } else {
477
83
                ++_low_value;
478
83
            }
479
83
        }
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
251
        bool& begin_include, bool& end_include) {
467
251
    if constexpr (!_is_reject_split_type) {
468
251
        begin_include = true;
469
251
        end_include = true;
470
471
251
        bool is_empty = false;
472
473
251
        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
251
        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
251
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
251
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
251
    }
499
251
    return false;
500
251
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
67.1k
        bool& begin_include, bool& end_include) {
467
67.1k
    if constexpr (!_is_reject_split_type) {
468
67.1k
        begin_include = true;
469
67.1k
        end_include = true;
470
471
67.1k
        bool is_empty = false;
472
473
67.1k
        if (!is_begin_include()) {
474
504
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
504
            } else {
477
504
                ++_low_value;
478
504
            }
479
504
        }
480
481
67.1k
        if (!is_end_include()) {
482
687
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
687
            } else {
485
687
                --_high_value;
486
687
            }
487
687
        }
488
489
67.1k
        if (Compare::less(_high_value, _low_value)) {
490
29
            is_empty = true;
491
29
        }
492
493
67.1k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
67.1k
    }
499
67.1k
    return false;
500
67.1k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
83.1k
        bool& begin_include, bool& end_include) {
467
83.1k
    if constexpr (!_is_reject_split_type) {
468
83.1k
        begin_include = true;
469
83.1k
        end_include = true;
470
471
83.1k
        bool is_empty = false;
472
473
83.1k
        if (!is_begin_include()) {
474
8.44k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
8.44k
            } else {
477
8.44k
                ++_low_value;
478
8.44k
            }
479
8.44k
        }
480
481
83.1k
        if (!is_end_include()) {
482
9
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
9
            } else {
485
9
                --_high_value;
486
9
            }
487
9
        }
488
489
83.1k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
83.1k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
83.1k
    }
499
83.1k
    return false;
500
83.1k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
1
        bool& begin_include, bool& end_include) {
467
1
    if constexpr (!_is_reject_split_type) {
468
1
        begin_include = true;
469
1
        end_include = true;
470
471
1
        bool is_empty = false;
472
473
1
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
1
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
1
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
1
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
1
    }
499
1
    return false;
500
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
16
        bool& begin_include, bool& end_include) {
467
16
    if constexpr (!_is_reject_split_type) {
468
16
        begin_include = true;
469
16
        end_include = true;
470
471
16
        bool is_empty = false;
472
473
16
        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
16
        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
16
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
16
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
16
    }
499
16
    return false;
500
16
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.87k
        bool& begin_include, bool& end_include) {
467
2.87k
    if constexpr (!_is_reject_split_type) {
468
2.87k
        begin_include = true;
469
2.87k
        end_include = true;
470
471
2.87k
        bool is_empty = false;
472
473
2.87k
        if (!is_begin_include()) {
474
18
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
18
            } else {
477
18
                ++_low_value;
478
18
            }
479
18
        }
480
481
2.87k
        if (!is_end_include()) {
482
93
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
93
            } else {
485
93
                --_high_value;
486
93
            }
487
93
        }
488
489
2.87k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
2.87k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
2.87k
    }
499
2.87k
    return false;
500
2.87k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
501
502
// The return value indicates whether the split result is range or fixed value.
503
template <PrimitiveType primitive_type>
504
bool ColumnValueRange<primitive_type>::convert_to_avg_range_value(
505
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
506
157k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
157k
    if constexpr (!_is_reject_split_type) {
508
157k
        CppType min_value = get_range_min_value();
509
157k
        CppType max_value = get_range_max_value();
510
157k
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
17
            min_value.set_type(TimeType::TIME_DATE);
512
17
            max_value.set_type(TimeType::TIME_DATE);
513
17
        }
514
157k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
157k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
29
            DCHECK(contain_null());
518
29
        }
519
520
157k
        auto no_split = [&]() -> bool {
521
149k
            begin_scan_keys.emplace_back();
522
149k
            begin_scan_keys.back().add_value(
523
149k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
149k
                    contain_null());
525
149k
            end_scan_keys.emplace_back();
526
149k
            end_scan_keys.back().add_value(
527
149k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
149k
                    empty_range_only_null ? true : false);
529
149k
            return true;
530
149k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
66.7k
        auto no_split = [&]() -> bool {
521
66.7k
            begin_scan_keys.emplace_back();
522
66.7k
            begin_scan_keys.back().add_value(
523
66.7k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
66.7k
                    contain_null());
525
66.7k
            end_scan_keys.emplace_back();
526
66.7k
            end_scan_keys.back().add_value(
527
66.7k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
66.7k
                    empty_range_only_null ? true : false);
529
66.7k
            return true;
530
66.7k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
82.9k
        auto no_split = [&]() -> bool {
521
82.9k
            begin_scan_keys.emplace_back();
522
82.9k
            begin_scan_keys.back().add_value(
523
82.9k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
82.9k
                    contain_null());
525
82.9k
            end_scan_keys.emplace_back();
526
82.9k
            end_scan_keys.back().add_value(
527
82.9k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
82.9k
                    empty_range_only_null ? true : false);
529
82.9k
            return true;
530
82.9k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
531
157k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
29
            return no_split();
533
29
        }
534
535
414k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
138k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
138k
                return value;
539
275k
            } else {
540
275k
                return (int128_t)value;
541
275k
            }
542
414k
        };
_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
12.2k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
12.2k
            } else {
540
12.2k
                return (int128_t)value;
541
12.2k
            }
542
12.2k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKiE_clESA_
Line
Count
Source
535
75.2k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
75.2k
            } else {
540
75.2k
                return (int128_t)value;
541
75.2k
            }
542
75.2k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
85.1k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
85.1k
            } else {
540
85.1k
                return (int128_t)value;
541
85.1k
            }
542
85.1k
        };
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
844
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
844
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
844
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
844
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
138k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
138k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
138k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
138k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIiEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_7DecimalIlEEE_clESC_
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_12Decimal128V3EE_clESB_
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
157k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
157k
        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
157k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
150k
            return no_split();
552
150k
        }
553
6.23k
        int step_size = cast_set<int>(step_size_may_overflow);
554
6.23k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6.23k
        if (contain_null()) {
558
3.15k
            begin_scan_keys.emplace_back();
559
3.15k
            begin_scan_keys.back().add_null();
560
3.15k
            end_scan_keys.emplace_back();
561
3.15k
            end_scan_keys.back().add_null();
562
3.15k
        }
563
256k
        while (true) {
564
256k
            begin_scan_keys.emplace_back();
565
256k
            begin_scan_keys.back().add_value(
566
256k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
256k
            if (cast(max_value) - min_value < step_size) {
569
5.45k
                min_value = max_value;
570
251k
            } else {
571
251k
                min_value += step_size;
572
251k
            }
573
574
256k
            end_scan_keys.emplace_back();
575
256k
            end_scan_keys.back().add_value(
576
256k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
256k
            if (Compare::equal(min_value, max_value)) {
579
6.33k
                break;
580
6.33k
            }
581
250k
            ++min_value;
582
250k
            ++real_step_size;
583
250k
            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
250k
        }
592
593
6.23k
        return step_size != 0;
594
6.23k
    }
595
0
    return false;
596
157k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.34k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.34k
    if constexpr (!_is_reject_split_type) {
508
2.34k
        CppType min_value = get_range_min_value();
509
2.34k
        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.34k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.34k
        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.34k
        auto no_split = [&]() -> bool {
521
2.34k
            begin_scan_keys.emplace_back();
522
2.34k
            begin_scan_keys.back().add_value(
523
2.34k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.34k
                    contain_null());
525
2.34k
            end_scan_keys.emplace_back();
526
2.34k
            end_scan_keys.back().add_value(
527
2.34k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.34k
                    empty_range_only_null ? true : false);
529
2.34k
            return true;
530
2.34k
        };
531
2.34k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.34k
        auto cast = [](const CppType& value) {
536
2.34k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.34k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.34k
                return value;
539
2.34k
            } else {
540
2.34k
                return (int128_t)value;
541
2.34k
            }
542
2.34k
        };
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.34k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.34k
        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.34k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.34k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.34k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.34k
        if (contain_null()) {
558
1.84k
            begin_scan_keys.emplace_back();
559
1.84k
            begin_scan_keys.back().add_null();
560
1.84k
            end_scan_keys.emplace_back();
561
1.84k
            end_scan_keys.back().add_null();
562
1.84k
        }
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
97.8k
            } else {
571
97.8k
                min_value += step_size;
572
97.8k
            }
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
97.7k
            ++min_value;
582
97.7k
            ++real_step_size;
583
97.7k
            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
97.7k
        }
592
593
2.34k
        return step_size != 0;
594
2.34k
    }
595
0
    return false;
596
2.34k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
248
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
248
    if constexpr (!_is_reject_split_type) {
508
248
        CppType min_value = get_range_min_value();
509
248
        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
248
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
248
        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
248
        auto no_split = [&]() -> bool {
521
248
            begin_scan_keys.emplace_back();
522
248
            begin_scan_keys.back().add_value(
523
248
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
248
                    contain_null());
525
248
            end_scan_keys.emplace_back();
526
248
            end_scan_keys.back().add_value(
527
248
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
248
                    empty_range_only_null ? true : false);
529
248
            return true;
530
248
        };
531
248
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
248
        auto cast = [](const CppType& value) {
536
248
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
248
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
248
                return value;
539
248
            } else {
540
248
                return (int128_t)value;
541
248
            }
542
248
        };
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
248
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
248
        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
248
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
248
        int step_size = cast_set<int>(step_size_may_overflow);
554
248
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
248
        if (contain_null()) {
558
173
            begin_scan_keys.emplace_back();
559
173
            begin_scan_keys.back().add_null();
560
173
            end_scan_keys.emplace_back();
561
173
            end_scan_keys.back().add_null();
562
173
        }
563
11.9k
        while (true) {
564
11.9k
            begin_scan_keys.emplace_back();
565
11.9k
            begin_scan_keys.back().add_value(
566
11.9k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
11.9k
            if (cast(max_value) - min_value < step_size) {
569
251
                min_value = max_value;
570
11.7k
            } else {
571
11.7k
                min_value += step_size;
572
11.7k
            }
573
574
11.9k
            end_scan_keys.emplace_back();
575
11.9k
            end_scan_keys.back().add_value(
576
11.9k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
11.9k
            if (Compare::equal(min_value, max_value)) {
579
251
                break;
580
251
            }
581
11.7k
            ++min_value;
582
11.7k
            ++real_step_size;
583
11.7k
            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
11.7k
        }
592
593
248
        return step_size != 0;
594
248
    }
595
0
    return false;
596
248
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
68.1k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
68.1k
    if constexpr (!_is_reject_split_type) {
508
68.1k
        CppType min_value = get_range_min_value();
509
68.1k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
68.1k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
68.1k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
29
            DCHECK(contain_null());
518
29
        }
519
520
68.1k
        auto no_split = [&]() -> bool {
521
68.1k
            begin_scan_keys.emplace_back();
522
68.1k
            begin_scan_keys.back().add_value(
523
68.1k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
68.1k
                    contain_null());
525
68.1k
            end_scan_keys.emplace_back();
526
68.1k
            end_scan_keys.back().add_value(
527
68.1k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
68.1k
                    empty_range_only_null ? true : false);
529
68.1k
            return true;
530
68.1k
        };
531
68.1k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
29
            return no_split();
533
29
        }
534
535
68.1k
        auto cast = [](const CppType& value) {
536
68.1k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
68.1k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
68.1k
                return value;
539
68.1k
            } else {
540
68.1k
                return (int128_t)value;
541
68.1k
            }
542
68.1k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
68.1k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
68.1k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
68.1k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
67.7k
            return no_split();
552
67.7k
        }
553
460
        int step_size = cast_set<int>(step_size_may_overflow);
554
460
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
460
        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
7.49k
        while (true) {
564
7.49k
            begin_scan_keys.emplace_back();
565
7.49k
            begin_scan_keys.back().add_value(
566
7.49k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
7.49k
            if (cast(max_value) - min_value < step_size) {
569
107
                min_value = max_value;
570
7.38k
            } else {
571
7.38k
                min_value += step_size;
572
7.38k
            }
573
574
7.49k
            end_scan_keys.emplace_back();
575
7.49k
            end_scan_keys.back().add_value(
576
7.49k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
7.49k
            if (Compare::equal(min_value, max_value)) {
579
526
                break;
580
526
            }
581
6.96k
            ++min_value;
582
6.96k
            ++real_step_size;
583
6.96k
            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
6.96k
        }
592
593
460
        return step_size != 0;
594
460
    }
595
0
    return false;
596
68.1k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
83.4k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
83.4k
    if constexpr (!_is_reject_split_type) {
508
83.4k
        CppType min_value = get_range_min_value();
509
83.4k
        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
83.4k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
83.4k
        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
83.4k
        auto no_split = [&]() -> bool {
521
83.4k
            begin_scan_keys.emplace_back();
522
83.4k
            begin_scan_keys.back().add_value(
523
83.4k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
83.4k
                    contain_null());
525
83.4k
            end_scan_keys.emplace_back();
526
83.4k
            end_scan_keys.back().add_value(
527
83.4k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
83.4k
                    empty_range_only_null ? true : false);
529
83.4k
            return true;
530
83.4k
        };
531
83.4k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
83.4k
        auto cast = [](const CppType& value) {
536
83.4k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
83.4k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
83.4k
                return value;
539
83.4k
            } else {
540
83.4k
                return (int128_t)value;
541
83.4k
            }
542
83.4k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
83.4k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
83.4k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
83.4k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
83.1k
            return no_split();
552
83.1k
        }
553
287
        int step_size = cast_set<int>(step_size_may_overflow);
554
287
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
287
        if (contain_null()) {
558
0
            begin_scan_keys.emplace_back();
559
0
            begin_scan_keys.back().add_null();
560
0
            end_scan_keys.emplace_back();
561
0
            end_scan_keys.back().add_null();
562
0
        }
563
1.78k
        while (true) {
564
1.76k
            begin_scan_keys.emplace_back();
565
1.76k
            begin_scan_keys.back().add_value(
566
1.76k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.76k
            if (cast(max_value) - min_value < step_size) {
569
8
                min_value = max_value;
570
1.75k
            } else {
571
1.75k
                min_value += step_size;
572
1.75k
            }
573
574
1.76k
            end_scan_keys.emplace_back();
575
1.76k
            end_scan_keys.back().add_value(
576
1.76k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.76k
            if (Compare::equal(min_value, max_value)) {
579
273
                break;
580
273
            }
581
1.49k
            ++min_value;
582
1.49k
            ++real_step_size;
583
1.49k
            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.49k
        }
592
593
287
        return step_size != 0;
594
287
    }
595
0
    return false;
596
83.4k
}
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
17
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
17
    if constexpr (!_is_reject_split_type) {
508
17
        CppType min_value = get_range_min_value();
509
17
        CppType max_value = get_range_max_value();
510
17
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
17
            min_value.set_type(TimeType::TIME_DATE);
512
17
            max_value.set_type(TimeType::TIME_DATE);
513
17
        }
514
17
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
17
        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
17
        auto no_split = [&]() -> bool {
521
17
            begin_scan_keys.emplace_back();
522
17
            begin_scan_keys.back().add_value(
523
17
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
17
                    contain_null());
525
17
            end_scan_keys.emplace_back();
526
17
            end_scan_keys.back().add_value(
527
17
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
17
                    empty_range_only_null ? true : false);
529
17
            return true;
530
17
        };
531
18
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
17
        auto cast = [](const CppType& value) {
536
17
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
17
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
17
                return value;
539
17
            } else {
540
17
                return (int128_t)value;
541
17
            }
542
17
        };
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
17
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
17
        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
17
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
17
        int step_size = cast_set<int>(step_size_may_overflow);
554
17
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
17
        if (contain_null()) {
558
11
            begin_scan_keys.emplace_back();
559
11
            begin_scan_keys.back().add_null();
560
11
            end_scan_keys.emplace_back();
561
11
            end_scan_keys.back().add_null();
562
11
        }
563
823
        while (true) {
564
823
            begin_scan_keys.emplace_back();
565
823
            begin_scan_keys.back().add_value(
566
823
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
823
            if (cast(max_value) - min_value < step_size) {
569
18
                min_value = max_value;
570
805
            } else {
571
805
                min_value += step_size;
572
805
            }
573
574
823
            end_scan_keys.emplace_back();
575
823
            end_scan_keys.back().add_value(
576
823
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
823
            if (Compare::equal(min_value, max_value)) {
579
18
                break;
580
18
            }
581
805
            ++min_value;
582
805
            ++real_step_size;
583
805
            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
805
        }
592
593
17
        return step_size != 0;
594
17
    }
595
0
    return false;
596
17
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.88k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
2.88k
    if constexpr (!_is_reject_split_type) {
508
2.88k
        CppType min_value = get_range_min_value();
509
2.88k
        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.88k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
2.88k
        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.88k
        auto no_split = [&]() -> bool {
521
2.88k
            begin_scan_keys.emplace_back();
522
2.88k
            begin_scan_keys.back().add_value(
523
2.88k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
2.88k
                    contain_null());
525
2.88k
            end_scan_keys.emplace_back();
526
2.88k
            end_scan_keys.back().add_value(
527
2.88k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
2.88k
                    empty_range_only_null ? true : false);
529
2.88k
            return true;
530
2.88k
        };
531
2.88k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
2.88k
        auto cast = [](const CppType& value) {
536
2.88k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
2.88k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
2.88k
                return value;
539
2.88k
            } else {
540
2.88k
                return (int128_t)value;
541
2.88k
            }
542
2.88k
        };
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.88k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
2.88k
        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.88k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
2.88k
        int step_size = cast_set<int>(step_size_may_overflow);
554
2.88k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
2.88k
        if (contain_null()) {
558
1.12k
            begin_scan_keys.emplace_back();
559
1.12k
            begin_scan_keys.back().add_null();
560
1.12k
            end_scan_keys.emplace_back();
561
1.12k
            end_scan_keys.back().add_null();
562
1.12k
        }
563
134k
        while (true) {
564
134k
            begin_scan_keys.emplace_back();
565
134k
            begin_scan_keys.back().add_value(
566
134k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
134k
            if (cast(max_value) - min_value < step_size) {
569
2.75k
                min_value = max_value;
570
131k
            } else {
571
131k
                min_value += step_size;
572
131k
            }
573
574
134k
            end_scan_keys.emplace_back();
575
134k
            end_scan_keys.back().add_value(
576
134k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
134k
            if (Compare::equal(min_value, max_value)) {
579
2.89k
                break;
580
2.89k
            }
581
131k
            ++min_value;
582
131k
            ++real_step_size;
583
131k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
131k
        }
592
593
2.88k
        return step_size != 0;
594
2.88k
    }
595
0
    return false;
596
2.88k
}
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
91
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
91
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
91
    if (!_fixed_values.empty()) {
605
91
        _low_value = *_fixed_values.begin();
606
91
        _low_op = FILTER_LARGER_OR_EQUAL;
607
91
        _high_value = *_fixed_values.rbegin();
608
91
        _high_op = FILTER_LESS_OR_EQUAL;
609
91
        _fixed_values.clear();
610
91
    }
611
91
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
58
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
58
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
58
    if (!_fixed_values.empty()) {
605
58
        _low_value = *_fixed_values.begin();
606
58
        _low_op = FILTER_LARGER_OR_EQUAL;
607
58
        _high_value = *_fixed_values.rbegin();
608
58
        _high_op = FILTER_LESS_OR_EQUAL;
609
58
        _fixed_values.clear();
610
58
    }
611
58
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_range_valueEv
Line
Count
Source
599
1
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
1
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
1
    if (!_fixed_values.empty()) {
605
1
        _low_value = *_fixed_values.begin();
606
1
        _low_op = FILTER_LARGER_OR_EQUAL;
607
1
        _high_value = *_fixed_values.rbegin();
608
1
        _high_op = FILTER_LESS_OR_EQUAL;
609
1
        _fixed_values.clear();
610
1
    }
611
1
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_range_valueEv
Line
Count
Source
599
32
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
32
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
32
    if (!_fixed_values.empty()) {
605
32
        _low_value = *_fixed_values.begin();
606
32
        _low_op = FILTER_LARGER_OR_EQUAL;
607
32
        _high_value = *_fixed_values.rbegin();
608
32
        _high_op = FILTER_LESS_OR_EQUAL;
609
32
        _fixed_values.clear();
610
32
    }
611
32
}
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
147k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
147k
    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
147k
    _contain_null = false;
621
622
147k
    if (is_fixed_value_range()) {
623
10.4k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
10.4k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
10.2k
        case FILTER_LARGER_OR_EQUAL: {
632
10.2k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
10.2k
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
215
        case FILTER_LESS_OR_EQUAL: {
647
215
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
215
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
10.4k
        }
655
656
10.4k
        _high_value = TYPE_MIN;
657
10.4k
        _low_value = TYPE_MAX;
658
137k
    } else {
659
137k
        if (Compare::greater(_high_value, _low_value)) {
660
80.1k
            switch (op) {
661
32.2k
            case FILTER_LARGER: {
662
32.2k
                if (Compare::greater_equal(value, _low_value)) {
663
32.2k
                    _low_value = value;
664
32.2k
                    _low_op = op;
665
32.2k
                }
666
667
32.2k
                break;
668
0
            }
669
670
19.7k
            case FILTER_LARGER_OR_EQUAL: {
671
19.7k
                if (Compare::greater(value, _low_value)) {
672
15.8k
                    _low_value = value;
673
15.8k
                    _low_op = op;
674
15.8k
                }
675
676
19.7k
                break;
677
0
            }
678
679
6.55k
            case FILTER_LESS: {
680
6.55k
                if (Compare::less_equal(value, _high_value)) {
681
6.53k
                    _high_value = value;
682
6.53k
                    _high_op = op;
683
6.53k
                }
684
685
6.55k
                break;
686
0
            }
687
688
21.6k
            case FILTER_LESS_OR_EQUAL: {
689
21.6k
                if (Compare::less(value, _high_value)) {
690
17.8k
                    _high_value = value;
691
17.8k
                    _high_op = op;
692
17.8k
                }
693
694
21.6k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
80.1k
            }
701
80.1k
        }
702
703
137k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
137k
            Compare::equal(_high_value, _low_value)) {
705
11.7k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
11.7k
            _high_value = TYPE_MIN;
707
11.7k
            _low_value = TYPE_MAX;
708
11.7k
        }
709
137k
    }
710
711
147k
    return Status::OK();
712
147k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
2.73k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2.73k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
2.73k
    _contain_null = false;
621
622
2.73k
    if (is_fixed_value_range()) {
623
58
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
58
        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
54
        case FILTER_LARGER_OR_EQUAL: {
632
54
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
54
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
4
        case FILTER_LESS_OR_EQUAL: {
647
4
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
4
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
58
        }
655
656
58
        _high_value = TYPE_MIN;
657
58
        _low_value = TYPE_MAX;
658
2.68k
    } else {
659
2.68k
        if (Compare::greater(_high_value, _low_value)) {
660
1.97k
            switch (op) {
661
485
            case FILTER_LARGER: {
662
485
                if (Compare::greater_equal(value, _low_value)) {
663
482
                    _low_value = value;
664
482
                    _low_op = op;
665
482
                }
666
667
485
                break;
668
0
            }
669
670
536
            case FILTER_LARGER_OR_EQUAL: {
671
536
                if (Compare::greater(value, _low_value)) {
672
258
                    _low_value = value;
673
258
                    _low_op = op;
674
258
                }
675
676
536
                break;
677
0
            }
678
679
476
            case FILTER_LESS: {
680
476
                if (Compare::less_equal(value, _high_value)) {
681
473
                    _high_value = value;
682
473
                    _high_op = op;
683
473
                }
684
685
476
                break;
686
0
            }
687
688
485
            case FILTER_LESS_OR_EQUAL: {
689
485
                if (Compare::less(value, _high_value)) {
690
209
                    _high_value = value;
691
209
                    _high_op = op;
692
209
                }
693
694
485
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.97k
            }
701
1.97k
        }
702
703
2.68k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
2.68k
            Compare::equal(_high_value, _low_value)) {
705
67
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
67
            _high_value = TYPE_MIN;
707
67
            _low_value = TYPE_MAX;
708
67
        }
709
2.68k
    }
710
711
2.74k
    return Status::OK();
712
2.73k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
2.09k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2.09k
    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.09k
    _contain_null = false;
621
622
2.09k
    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
2.09k
    } else {
659
2.09k
        if (Compare::greater(_high_value, _low_value)) {
660
2.04k
            switch (op) {
661
1.56k
            case FILTER_LARGER: {
662
1.56k
                if (Compare::greater_equal(value, _low_value)) {
663
1.56k
                    _low_value = value;
664
1.56k
                    _low_op = op;
665
1.56k
                }
666
667
1.56k
                break;
668
0
            }
669
670
282
            case FILTER_LARGER_OR_EQUAL: {
671
282
                if (Compare::greater(value, _low_value)) {
672
245
                    _low_value = value;
673
245
                    _low_op = op;
674
245
                }
675
676
282
                break;
677
0
            }
678
679
24
            case FILTER_LESS: {
680
24
                if (Compare::less_equal(value, _high_value)) {
681
24
                    _high_value = value;
682
24
                    _high_op = op;
683
24
                }
684
685
24
                break;
686
0
            }
687
688
172
            case FILTER_LESS_OR_EQUAL: {
689
172
                if (Compare::less(value, _high_value)) {
690
67
                    _high_value = value;
691
67
                    _high_op = op;
692
67
                }
693
694
172
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
2.04k
            }
701
2.04k
        }
702
703
2.08k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
2.08k
            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
2.08k
    }
710
711
2.08k
    return Status::OK();
712
2.09k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
14.6k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
14.6k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
14.6k
    _contain_null = false;
621
622
14.6k
    if (is_fixed_value_range()) {
623
289
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
289
        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
208
        case FILTER_LARGER_OR_EQUAL: {
632
208
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
208
            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
82
        case FILTER_LESS_OR_EQUAL: {
647
82
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
82
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
289
        }
655
656
290
        _high_value = TYPE_MIN;
657
290
        _low_value = TYPE_MAX;
658
14.3k
    } else {
659
14.3k
        if (Compare::greater(_high_value, _low_value)) {
660
13.4k
            switch (op) {
661
2.91k
            case FILTER_LARGER: {
662
2.91k
                if (Compare::greater_equal(value, _low_value)) {
663
2.89k
                    _low_value = value;
664
2.89k
                    _low_op = op;
665
2.89k
                }
666
667
2.91k
                break;
668
0
            }
669
670
4.78k
            case FILTER_LARGER_OR_EQUAL: {
671
4.78k
                if (Compare::greater(value, _low_value)) {
672
4.07k
                    _low_value = value;
673
4.07k
                    _low_op = op;
674
4.07k
                }
675
676
4.78k
                break;
677
0
            }
678
679
1.27k
            case FILTER_LESS: {
680
1.27k
                if (Compare::less_equal(value, _high_value)) {
681
1.26k
                    _high_value = value;
682
1.26k
                    _high_op = op;
683
1.26k
                }
684
685
1.27k
                break;
686
0
            }
687
688
4.49k
            case FILTER_LESS_OR_EQUAL: {
689
4.49k
                if (Compare::less(value, _high_value)) {
690
3.78k
                    _high_value = value;
691
3.78k
                    _high_op = op;
692
3.78k
                }
693
694
4.49k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
13.4k
            }
701
13.4k
        }
702
703
14.3k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
14.3k
            Compare::equal(_high_value, _low_value)) {
705
1.01k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
1.01k
            _high_value = TYPE_MIN;
707
1.01k
            _low_value = TYPE_MAX;
708
1.01k
        }
709
14.3k
    }
710
711
14.6k
    return Status::OK();
712
14.6k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
93.7k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
93.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
93.7k
    _contain_null = false;
621
622
93.7k
    if (is_fixed_value_range()) {
623
10.0k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
10.0k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
9.91k
        case FILTER_LARGER_OR_EQUAL: {
632
9.91k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
9.91k
            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
102
        case FILTER_LESS_OR_EQUAL: {
647
102
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
102
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
10.0k
        }
655
656
10.0k
        _high_value = TYPE_MIN;
657
10.0k
        _low_value = TYPE_MAX;
658
83.6k
    } else {
659
83.6k
        if (Compare::greater(_high_value, _low_value)) {
660
28.5k
            switch (op) {
661
11.5k
            case FILTER_LARGER: {
662
11.5k
                if (Compare::greater_equal(value, _low_value)) {
663
11.5k
                    _low_value = value;
664
11.5k
                    _low_op = op;
665
11.5k
                }
666
667
11.5k
                break;
668
0
            }
669
670
4.53k
            case FILTER_LARGER_OR_EQUAL: {
671
4.53k
                if (Compare::greater(value, _low_value)) {
672
4.51k
                    _low_value = value;
673
4.51k
                    _low_op = op;
674
4.51k
                }
675
676
4.53k
                break;
677
0
            }
678
679
120
            case FILTER_LESS: {
680
120
                if (Compare::less_equal(value, _high_value)) {
681
120
                    _high_value = value;
682
120
                    _high_op = op;
683
120
                }
684
685
120
                break;
686
0
            }
687
688
12.3k
            case FILTER_LESS_OR_EQUAL: {
689
12.3k
                if (Compare::less(value, _high_value)) {
690
12.3k
                    _high_value = value;
691
12.3k
                    _high_op = op;
692
12.3k
                }
693
694
12.3k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
28.5k
            }
701
28.5k
        }
702
703
83.6k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
83.6k
            Compare::equal(_high_value, _low_value)) {
705
10.2k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
10.2k
            _high_value = TYPE_MIN;
707
10.2k
            _low_value = TYPE_MAX;
708
10.2k
        }
709
83.6k
    }
710
711
93.6k
    return Status::OK();
712
93.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
177
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
177
    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
177
    _contain_null = false;
621
622
177
    if (is_fixed_value_range()) {
623
8
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
8
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
4
        case FILTER_LARGER_OR_EQUAL: {
632
4
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
4
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
4
        case FILTER_LESS_OR_EQUAL: {
647
4
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
4
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
8
        }
655
656
8
        _high_value = TYPE_MIN;
657
8
        _low_value = TYPE_MAX;
658
169
    } else {
659
169
        if (Compare::greater(_high_value, _low_value)) {
660
167
            switch (op) {
661
77
            case FILTER_LARGER: {
662
78
                if (Compare::greater_equal(value, _low_value)) {
663
78
                    _low_value = value;
664
78
                    _low_op = op;
665
78
                }
666
667
77
                break;
668
0
            }
669
670
25
            case FILTER_LARGER_OR_EQUAL: {
671
25
                if (Compare::greater(value, _low_value)) {
672
22
                    _low_value = value;
673
22
                    _low_op = op;
674
22
                }
675
676
25
                break;
677
0
            }
678
679
23
            case FILTER_LESS: {
680
23
                if (Compare::less_equal(value, _high_value)) {
681
23
                    _high_value = value;
682
23
                    _high_op = op;
683
23
                }
684
685
23
                break;
686
0
            }
687
688
41
            case FILTER_LESS_OR_EQUAL: {
689
41
                if (Compare::less(value, _high_value)) {
690
38
                    _high_value = value;
691
38
                    _high_op = op;
692
38
                }
693
694
41
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
167
            }
701
167
        }
702
703
168
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
168
            Compare::equal(_high_value, _low_value)) {
705
11
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
11
            _high_value = TYPE_MIN;
707
11
            _low_value = TYPE_MAX;
708
11
        }
709
168
    }
710
711
176
    return Status::OK();
712
177
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
163
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
163
    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
163
    _contain_null = false;
621
622
163
    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
163
    } else {
659
164
        if (Compare::greater(_high_value, _low_value)) {
660
164
            switch (op) {
661
38
            case FILTER_LARGER: {
662
38
                if (Compare::greater_equal(value, _low_value)) {
663
38
                    _low_value = value;
664
38
                    _low_op = op;
665
38
                }
666
667
38
                break;
668
0
            }
669
670
54
            case FILTER_LARGER_OR_EQUAL: {
671
54
                if (Compare::greater(value, _low_value)) {
672
40
                    _low_value = value;
673
40
                    _low_op = op;
674
40
                }
675
676
54
                break;
677
0
            }
678
679
25
            case FILTER_LESS: {
680
25
                if (Compare::less_equal(value, _high_value)) {
681
25
                    _high_value = value;
682
25
                    _high_op = op;
683
25
                }
684
685
25
                break;
686
0
            }
687
688
47
            case FILTER_LESS_OR_EQUAL: {
689
47
                if (Compare::less(value, _high_value)) {
690
34
                    _high_value = value;
691
34
                    _high_op = op;
692
34
                }
693
694
47
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
164
            }
701
164
        }
702
703
162
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
162
            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
162
    }
710
711
162
    return Status::OK();
712
163
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
398
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
398
    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
398
    _contain_null = false;
621
622
398
    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
398
    } else {
659
400
        if (Compare::greater(_high_value, _low_value)) {
660
400
            switch (op) {
661
171
            case FILTER_LARGER: {
662
171
                if (Compare::greater_equal(value, _low_value)) {
663
171
                    _low_value = value;
664
171
                    _low_op = op;
665
171
                }
666
667
171
                break;
668
0
            }
669
670
90
            case FILTER_LARGER_OR_EQUAL: {
671
90
                if (Compare::greater(value, _low_value)) {
672
42
                    _low_value = value;
673
42
                    _low_op = op;
674
42
                }
675
676
90
                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
94
            case FILTER_LESS_OR_EQUAL: {
689
94
                if (Compare::less(value, _high_value)) {
690
44
                    _high_value = value;
691
44
                    _high_op = op;
692
44
                }
693
694
94
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
400
            }
701
400
        }
702
703
394
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
394
            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
394
    }
710
711
394
    return Status::OK();
712
398
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
Line
Count
Source
614
14
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
14
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
14
    _contain_null = false;
621
622
14
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
14
    } else {
659
14
        if (Compare::greater(_high_value, _low_value)) {
660
14
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
7
            case FILTER_LARGER_OR_EQUAL: {
671
7
                if (Compare::greater(value, _low_value)) {
672
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
14
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
14
    }
710
711
14
    return Status::OK();
712
14
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
Line
Count
Source
614
10
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
10
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
10
    _contain_null = false;
621
622
10
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
10
    } else {
659
10
        if (Compare::greater(_high_value, _low_value)) {
660
10
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
5
            case FILTER_LARGER_OR_EQUAL: {
671
5
                if (Compare::greater(value, _low_value)) {
672
4
                    _low_value = value;
673
4
                    _low_op = op;
674
4
                }
675
676
5
                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
1
            case FILTER_LESS_OR_EQUAL: {
689
1
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
1
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
10
            }
701
10
        }
702
703
10
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
10
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
10
    }
710
711
10
    return Status::OK();
712
10
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.06k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.06k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
1.06k
    _contain_null = false;
621
622
1.06k
    if (is_fixed_value_range()) {
623
20
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
20
        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
        case FILTER_LARGER_OR_EQUAL: {
632
10
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
10
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
10
        case FILTER_LESS_OR_EQUAL: {
647
10
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
10
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
20
        }
655
656
20
        _high_value = TYPE_MIN;
657
20
        _low_value = TYPE_MAX;
658
1.04k
    } else {
659
1.04k
        if (Compare::greater(_high_value, _low_value)) {
660
1.03k
            switch (op) {
661
914
            case FILTER_LARGER: {
662
914
                if (Compare::greater_equal(value, _low_value)) {
663
906
                    _low_value = value;
664
906
                    _low_op = op;
665
906
                }
666
667
914
                break;
668
0
            }
669
670
81
            case FILTER_LARGER_OR_EQUAL: {
671
81
                if (Compare::greater(value, _low_value)) {
672
32
                    _low_value = value;
673
32
                    _low_op = op;
674
32
                }
675
676
81
                break;
677
0
            }
678
679
8
            case FILTER_LESS: {
680
8
                if (Compare::less_equal(value, _high_value)) {
681
8
                    _high_value = value;
682
8
                    _high_op = op;
683
8
                }
684
685
8
                break;
686
0
            }
687
688
46
            case FILTER_LESS_OR_EQUAL: {
689
46
                if (Compare::less(value, _high_value)) {
690
19
                    _high_value = value;
691
19
                    _high_op = op;
692
19
                }
693
694
46
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.03k
            }
701
1.03k
        }
702
703
1.05k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.05k
            Compare::equal(_high_value, _low_value)) {
705
2
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
2
            _high_value = TYPE_MIN;
707
2
            _low_value = TYPE_MAX;
708
2
        }
709
1.05k
    }
710
711
1.07k
    return Status::OK();
712
1.06k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.68k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.68k
    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.68k
    _contain_null = false;
621
622
1.68k
    if (is_fixed_value_range()) {
623
9
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
9
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
9
        case FILTER_LARGER_OR_EQUAL: {
632
9
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
9
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
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
9
        }
655
656
9
        _high_value = TYPE_MIN;
657
9
        _low_value = TYPE_MAX;
658
1.67k
    } else {
659
1.67k
        if (Compare::greater(_high_value, _low_value)) {
660
1.58k
            switch (op) {
661
1.00k
            case FILTER_LARGER: {
662
1.00k
                if (Compare::greater_equal(value, _low_value)) {
663
996
                    _low_value = value;
664
996
                    _low_op = op;
665
996
                }
666
667
1.00k
                break;
668
0
            }
669
670
315
            case FILTER_LARGER_OR_EQUAL: {
671
315
                if (Compare::greater(value, _low_value)) {
672
180
                    _low_value = value;
673
180
                    _low_op = op;
674
180
                }
675
676
315
                break;
677
0
            }
678
679
19
            case FILTER_LESS: {
680
19
                if (Compare::less_equal(value, _high_value)) {
681
19
                    _high_value = value;
682
19
                    _high_op = op;
683
19
                }
684
685
19
                break;
686
0
            }
687
688
251
            case FILTER_LESS_OR_EQUAL: {
689
251
                if (Compare::less(value, _high_value)) {
690
201
                    _high_value = value;
691
201
                    _high_op = op;
692
201
                }
693
694
251
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.58k
            }
701
1.58k
        }
702
703
1.67k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.67k
            Compare::equal(_high_value, _low_value)) {
705
39
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
39
            _high_value = TYPE_MIN;
707
39
            _low_value = TYPE_MAX;
708
39
        }
709
1.67k
    }
710
711
1.68k
    return Status::OK();
712
1.68k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
4.49k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
4.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
4.49k
    _contain_null = false;
621
622
4.49k
    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.49k
    } else {
659
4.49k
        if (Compare::greater(_high_value, _low_value)) {
660
4.47k
            switch (op) {
661
37
            case FILTER_LARGER: {
662
37
                if (Compare::greater_equal(value, _low_value)) {
663
37
                    _low_value = value;
664
37
                    _low_op = op;
665
37
                }
666
667
37
                break;
668
0
            }
669
670
2.25k
            case FILTER_LARGER_OR_EQUAL: {
671
2.25k
                if (Compare::greater(value, _low_value)) {
672
161
                    _low_value = value;
673
161
                    _low_op = op;
674
161
                }
675
676
2.25k
                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
2.18k
            case FILTER_LESS_OR_EQUAL: {
689
2.18k
                if (Compare::less(value, _high_value)) {
690
143
                    _high_value = value;
691
143
                    _high_op = op;
692
143
                }
693
694
2.18k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
4.47k
            }
701
4.47k
        }
702
703
4.50k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
4.50k
            Compare::equal(_high_value, _low_value)) {
705
44
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
44
            _high_value = TYPE_MIN;
707
44
            _low_value = TYPE_MAX;
708
44
        }
709
4.50k
    }
710
711
4.50k
    return Status::OK();
712
4.49k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
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
9
                    _low_value = value;
673
9
                    _low_op = op;
674
9
                }
675
676
9
                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
9
            case FILTER_LESS_OR_EQUAL: {
689
9
                if (Compare::less(value, _high_value)) {
690
9
                    _high_value = value;
691
9
                    _high_op = op;
692
9
                }
693
694
9
                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_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
20.6k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
20.6k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
20.6k
    _contain_null = false;
621
622
20.6k
    if (is_fixed_value_range()) {
623
29
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
29
        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
4
        case FILTER_LESS_OR_EQUAL: {
647
4
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
4
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
29
        }
655
656
29
        _high_value = TYPE_MIN;
657
29
        _low_value = TYPE_MAX;
658
20.5k
    } else {
659
20.5k
        if (Compare::greater(_high_value, _low_value)) {
660
20.5k
            switch (op) {
661
12.7k
            case FILTER_LARGER: {
662
12.7k
                if (Compare::greater_equal(value, _low_value)) {
663
12.7k
                    _low_value = value;
664
12.7k
                    _low_op = op;
665
12.7k
                }
666
667
12.7k
                break;
668
0
            }
669
670
4.40k
            case FILTER_LARGER_OR_EQUAL: {
671
4.40k
                if (Compare::greater(value, _low_value)) {
672
4.35k
                    _low_value = value;
673
4.35k
                    _low_op = op;
674
4.35k
                }
675
676
4.40k
                break;
677
0
            }
678
679
2.85k
            case FILTER_LESS: {
680
2.85k
                if (Compare::less_equal(value, _high_value)) {
681
2.84k
                    _high_value = value;
682
2.84k
                    _high_op = op;
683
2.84k
                }
684
685
2.85k
                break;
686
0
            }
687
688
490
            case FILTER_LESS_OR_EQUAL: {
689
490
                if (Compare::less(value, _high_value)) {
690
443
                    _high_value = value;
691
443
                    _high_op = op;
692
443
                }
693
694
490
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
20.5k
            }
701
20.5k
        }
702
703
20.5k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
20.5k
            Compare::equal(_high_value, _low_value)) {
705
71
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
71
            _high_value = TYPE_MIN;
707
71
            _low_value = TYPE_MAX;
708
71
        }
709
20.5k
    }
710
711
20.6k
    return Status::OK();
712
20.6k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
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
9
                    _low_value = value;
673
9
                    _low_op = op;
674
9
                }
675
676
9
                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
9
            case FILTER_LESS_OR_EQUAL: {
689
9
                if (Compare::less(value, _high_value)) {
690
9
                    _high_value = value;
691
9
                    _high_op = op;
692
9
                }
693
694
9
                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_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.57k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.57k
    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.57k
    _contain_null = false;
621
622
3.57k
    if (is_fixed_value_range()) {
623
22
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
22
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
13
        case FILTER_LARGER_OR_EQUAL: {
632
13
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
13
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
9
        case FILTER_LESS_OR_EQUAL: {
647
9
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
9
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
22
        }
655
656
22
        _high_value = TYPE_MIN;
657
22
        _low_value = TYPE_MAX;
658
3.55k
    } else {
659
3.55k
        if (Compare::greater(_high_value, _low_value)) {
660
3.55k
            switch (op) {
661
240
            case FILTER_LARGER: {
662
240
                if (Compare::greater_equal(value, _low_value)) {
663
238
                    _low_value = value;
664
238
                    _low_op = op;
665
238
                }
666
667
240
                break;
668
0
            }
669
670
1.61k
            case FILTER_LARGER_OR_EQUAL: {
671
1.61k
                if (Compare::greater(value, _low_value)) {
672
1.56k
                    _low_value = value;
673
1.56k
                    _low_op = op;
674
1.56k
                }
675
676
1.61k
                break;
677
0
            }
678
679
1.45k
            case FILTER_LESS: {
680
1.45k
                if (Compare::less_equal(value, _high_value)) {
681
1.44k
                    _high_value = value;
682
1.44k
                    _high_op = op;
683
1.44k
                }
684
685
1.45k
                break;
686
0
            }
687
688
252
            case FILTER_LESS_OR_EQUAL: {
689
252
                if (Compare::less(value, _high_value)) {
690
205
                    _high_value = value;
691
205
                    _high_op = op;
692
205
                }
693
694
252
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.55k
            }
701
3.55k
        }
702
703
3.53k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.53k
            Compare::equal(_high_value, _low_value)) {
705
65
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
65
            _high_value = TYPE_MIN;
707
65
            _low_value = TYPE_MAX;
708
65
        }
709
3.53k
    }
710
711
3.55k
    return Status::OK();
712
3.57k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
727
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
727
    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
727
    _contain_null = false;
621
622
727
    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
727
    } else {
659
731
        if (Compare::greater(_high_value, _low_value)) {
660
731
            switch (op) {
661
169
            case FILTER_LARGER: {
662
169
                if (Compare::greater_equal(value, _low_value)) {
663
168
                    _low_value = value;
664
168
                    _low_op = op;
665
168
                }
666
667
169
                break;
668
0
            }
669
670
219
            case FILTER_LARGER_OR_EQUAL: {
671
219
                if (Compare::greater(value, _low_value)) {
672
106
                    _low_value = value;
673
106
                    _low_op = op;
674
106
                }
675
676
219
                break;
677
0
            }
678
679
122
            case FILTER_LESS: {
680
124
                if (Compare::less_equal(value, _high_value)) {
681
124
                    _high_value = value;
682
124
                    _high_op = op;
683
124
                }
684
685
122
                break;
686
0
            }
687
688
221
            case FILTER_LESS_OR_EQUAL: {
689
221
                if (Compare::less(value, _high_value)) {
690
168
                    _high_value = value;
691
168
                    _high_op = op;
692
168
                }
693
694
221
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
731
            }
701
731
        }
702
703
724
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
724
            Compare::equal(_high_value, _low_value)) {
705
68
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
68
            _high_value = TYPE_MIN;
707
68
            _low_value = TYPE_MAX;
708
68
        }
709
724
    }
710
711
724
    return Status::OK();
712
727
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Line
Count
Source
614
70
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
70
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
70
    _contain_null = false;
621
622
70
    if (is_fixed_value_range()) {
623
1
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
1
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
1
        case FILTER_LARGER_OR_EQUAL: {
632
1
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
1
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
1
        }
655
656
1
        _high_value = TYPE_MIN;
657
1
        _low_value = TYPE_MAX;
658
69
    } else {
659
69
        if (Compare::greater(_high_value, _low_value)) {
660
69
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
34
            case FILTER_LARGER_OR_EQUAL: {
671
34
                if (Compare::greater(value, _low_value)) {
672
16
                    _low_value = value;
673
16
                    _low_op = op;
674
16
                }
675
676
34
                break;
677
0
            }
678
679
0
            case FILTER_LESS: {
680
0
                if (Compare::less_equal(value, _high_value)) {
681
0
                    _high_value = value;
682
0
                    _high_op = op;
683
0
                }
684
685
0
                break;
686
0
            }
687
688
35
            case FILTER_LESS_OR_EQUAL: {
689
35
                if (Compare::less(value, _high_value)) {
690
1
                    _high_value = value;
691
1
                    _high_op = op;
692
1
                }
693
694
35
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
69
            }
701
69
        }
702
703
69
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
69
            Compare::equal(_high_value, _low_value)) {
705
17
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
17
            _high_value = TYPE_MIN;
707
17
            _low_value = TYPE_MAX;
708
17
        }
709
69
    }
710
711
70
    return Status::OK();
712
70
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
161
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
161
    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
161
    _contain_null = false;
621
622
161
    if (is_fixed_value_range()) {
623
24
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
24
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
24
        case FILTER_LARGER_OR_EQUAL: {
632
24
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
24
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
24
        }
655
656
24
        _high_value = TYPE_MIN;
657
24
        _low_value = TYPE_MAX;
658
137
    } else {
659
138
        if (Compare::greater(_high_value, _low_value)) {
660
138
            switch (op) {
661
20
            case FILTER_LARGER: {
662
20
                if (Compare::greater_equal(value, _low_value)) {
663
20
                    _low_value = value;
664
20
                    _low_op = op;
665
20
                }
666
667
20
                break;
668
0
            }
669
670
39
            case FILTER_LARGER_OR_EQUAL: {
671
39
                if (Compare::greater(value, _low_value)) {
672
15
                    _low_value = value;
673
15
                    _low_op = op;
674
15
                }
675
676
39
                break;
677
0
            }
678
679
21
            case FILTER_LESS: {
680
21
                if (Compare::less_equal(value, _high_value)) {
681
21
                    _high_value = value;
682
21
                    _high_op = op;
683
21
                }
684
685
21
                break;
686
0
            }
687
688
59
            case FILTER_LESS_OR_EQUAL: {
689
59
                if (Compare::less(value, _high_value)) {
690
37
                    _high_value = value;
691
37
                    _high_op = op;
692
37
                }
693
694
59
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
138
            }
701
138
        }
702
703
139
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
139
            Compare::equal(_high_value, _low_value)) {
705
24
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
24
            _high_value = TYPE_MIN;
707
24
            _low_value = TYPE_MAX;
708
24
        }
709
139
    }
710
711
163
    return Status::OK();
712
161
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
929
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
929
    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
929
    _contain_null = false;
621
622
929
    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
929
    } else {
659
929
        if (Compare::greater(_high_value, _low_value)) {
660
923
            switch (op) {
661
156
            case FILTER_LARGER: {
662
156
                if (Compare::greater_equal(value, _low_value)) {
663
154
                    _low_value = value;
664
154
                    _low_op = op;
665
154
                }
666
667
156
                break;
668
0
            }
669
670
372
            case FILTER_LARGER_OR_EQUAL: {
671
372
                if (Compare::greater(value, _low_value)) {
672
118
                    _low_value = value;
673
118
                    _low_op = op;
674
118
                }
675
676
372
                break;
677
0
            }
678
679
28
            case FILTER_LESS: {
680
28
                if (Compare::less_equal(value, _high_value)) {
681
27
                    _high_value = value;
682
27
                    _high_op = op;
683
27
                }
684
685
28
                break;
686
0
            }
687
688
372
            case FILTER_LESS_OR_EQUAL: {
689
372
                if (Compare::less(value, _high_value)) {
690
115
                    _high_value = value;
691
115
                    _high_op = op;
692
115
                }
693
694
372
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
923
            }
701
923
        }
702
703
926
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
926
            Compare::equal(_high_value, _low_value)) {
705
52
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
52
            _high_value = TYPE_MIN;
707
52
            _low_value = TYPE_MAX;
708
52
        }
709
926
    }
710
711
926
    return Status::OK();
712
929
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9add_rangeENS_11SQLFilterOpENS_12Decimal128V3E
Line
Count
Source
614
135
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
135
    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
135
    _contain_null = false;
621
622
135
    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
135
    } else {
659
135
        if (Compare::greater(_high_value, _low_value)) {
660
135
            switch (op) {
661
89
            case FILTER_LARGER: {
662
89
                if (Compare::greater_equal(value, _low_value)) {
663
89
                    _low_value = value;
664
89
                    _low_op = op;
665
89
                }
666
667
89
                break;
668
0
            }
669
670
20
            case FILTER_LARGER_OR_EQUAL: {
671
20
                if (Compare::greater(value, _low_value)) {
672
12
                    _low_value = value;
673
12
                    _low_op = op;
674
12
                }
675
676
20
                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
16
            case FILTER_LESS_OR_EQUAL: {
689
16
                if (Compare::less(value, _high_value)) {
690
8
                    _high_value = value;
691
8
                    _high_op = op;
692
8
                }
693
694
16
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
135
            }
701
135
        }
702
703
135
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
135
            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
135
    }
710
711
135
    return Status::OK();
712
135
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9add_rangeENS_11SQLFilterOpENS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
614
98
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
98
    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
98
    _contain_null = false;
621
622
98
    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
98
    } else {
659
99
        if (Compare::greater(_high_value, _low_value)) {
660
99
            switch (op) {
661
21
            case FILTER_LARGER: {
662
22
                if (Compare::greater_equal(value, _low_value)) {
663
22
                    _low_value = value;
664
22
                    _low_op = op;
665
22
                }
666
667
21
                break;
668
0
            }
669
670
28
            case FILTER_LARGER_OR_EQUAL: {
671
28
                if (Compare::greater(value, _low_value)) {
672
17
                    _low_value = value;
673
17
                    _low_op = op;
674
17
                }
675
676
28
                break;
677
0
            }
678
679
21
            case FILTER_LESS: {
680
21
                if (Compare::less_equal(value, _high_value)) {
681
21
                    _high_value = value;
682
21
                    _high_op = op;
683
21
                }
684
685
21
                break;
686
0
            }
687
688
28
            case FILTER_LESS_OR_EQUAL: {
689
28
                if (Compare::less(value, _high_value)) {
690
17
                    _high_value = value;
691
17
                    _high_op = op;
692
17
                }
693
694
28
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
99
            }
701
99
        }
702
703
96
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
96
            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
96
    }
710
711
96
    return Status::OK();
712
98
}
713
714
template <PrimitiveType primitive_type>
715
505k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
505k
    switch (_high_op) {
717
88
    case FILTER_LESS: {
718
88
        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
85
        case FILTER_LARGER_OR_EQUAL: {
724
85
            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
88
        }
731
732
0
        break;
733
88
    }
734
735
505k
    case FILTER_LESS_OR_EQUAL: {
736
505k
        switch (_low_op) {
737
28
        case FILTER_LARGER: {
738
28
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
506k
        case FILTER_LARGER_OR_EQUAL: {
742
506k
            return Compare::less_equal(value, _high_value) &&
743
506k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
505k
        }
750
505k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
505k
    }
756
757
0
    return false;
758
505k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
122k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
122k
    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
122k
    case FILTER_LESS_OR_EQUAL: {
736
122k
        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
122k
        case FILTER_LARGER_OR_EQUAL: {
742
122k
            return Compare::less_equal(value, _high_value) &&
743
122k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
122k
        }
750
122k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
122k
    }
756
757
0
    return false;
758
122k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
335
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
335
    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
335
    case FILTER_LESS_OR_EQUAL: {
736
335
        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
335
        case FILTER_LARGER_OR_EQUAL: {
742
335
            return Compare::less_equal(value, _high_value) &&
743
335
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
335
        }
750
335
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
335
    }
756
757
0
    return false;
758
335
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
66.5k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
66.5k
    switch (_high_op) {
717
64
    case FILTER_LESS: {
718
64
        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
64
        case FILTER_LARGER_OR_EQUAL: {
724
64
            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
64
        }
731
732
0
        break;
733
64
    }
734
735
66.5k
    case FILTER_LESS_OR_EQUAL: {
736
66.5k
        switch (_low_op) {
737
1
        case FILTER_LARGER: {
738
1
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
66.5k
        case FILTER_LARGER_OR_EQUAL: {
742
66.5k
            return Compare::less_equal(value, _high_value) &&
743
66.6k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
66.5k
        }
750
66.5k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
66.5k
    }
756
757
0
    return false;
758
66.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
1.77k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.77k
    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.77k
    case FILTER_LESS_OR_EQUAL: {
736
1.77k
        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.76k
        case FILTER_LARGER_OR_EQUAL: {
742
1.76k
            return Compare::less_equal(value, _high_value) &&
743
1.76k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.77k
        }
750
1.77k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.77k
    }
756
757
0
    return false;
758
1.77k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
217
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
217
    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
217
    case FILTER_LESS_OR_EQUAL: {
736
217
        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
217
        case FILTER_LARGER_OR_EQUAL: {
742
217
            return Compare::less_equal(value, _high_value) &&
743
217
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
217
        }
750
217
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
217
    }
756
757
0
    return false;
758
217
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE11is_in_rangeERKf
Line
Count
Source
715
37
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
37
    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
37
    case FILTER_LESS_OR_EQUAL: {
736
37
        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
37
        case FILTER_LARGER_OR_EQUAL: {
742
37
            return Compare::less_equal(value, _high_value) &&
743
37
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
37
        }
750
37
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
37
    }
756
757
0
    return false;
758
37
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE11is_in_rangeERKd
Line
Count
Source
715
131
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
131
    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
131
    case FILTER_LESS_OR_EQUAL: {
736
131
        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
131
        case FILTER_LARGER_OR_EQUAL: {
742
131
            return Compare::less_equal(value, _high_value) &&
743
131
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
131
        }
750
131
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
131
    }
756
757
0
    return false;
758
131
}
_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
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_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
591
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
591
    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
592
    case FILTER_LESS_OR_EQUAL: {
736
592
        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
590
        case FILTER_LARGER_OR_EQUAL: {
742
590
            return Compare::less_equal(value, _high_value) &&
743
592
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
592
        }
750
592
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
591
    }
756
757
0
    return false;
758
591
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
302k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
302k
    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
302k
    case FILTER_LESS_OR_EQUAL: {
736
302k
        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
302k
        case FILTER_LARGER_OR_EQUAL: {
742
302k
            return Compare::less_equal(value, _high_value) &&
743
302k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
302k
        }
750
302k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
302k
    }
756
757
0
    return false;
758
302k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
1.46k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
1.46k
    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.46k
    case FILTER_LESS_OR_EQUAL: {
736
1.46k
        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.47k
        case FILTER_LARGER_OR_EQUAL: {
742
1.47k
            return Compare::less_equal(value, _high_value) &&
743
1.47k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
1.46k
        }
750
1.46k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
1.46k
    }
756
757
0
    return false;
758
1.46k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
73
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
73
    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
73
    case FILTER_LESS_OR_EQUAL: {
736
73
        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
73
        case FILTER_LARGER_OR_EQUAL: {
742
73
            return Compare::less_equal(value, _high_value) &&
743
73
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
73
        }
750
73
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
73
    }
756
757
0
    return false;
758
73
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
8.37k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
8.37k
    switch (_high_op) {
717
3
    case FILTER_LESS: {
718
3
        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
3
        case FILTER_LARGER_OR_EQUAL: {
724
3
            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
8.37k
    case FILTER_LESS_OR_EQUAL: {
736
8.37k
        switch (_low_op) {
737
15
        case FILTER_LARGER: {
738
15
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
8.36k
        case FILTER_LARGER_OR_EQUAL: {
742
8.36k
            return Compare::less_equal(value, _high_value) &&
743
8.36k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
8.37k
        }
750
8.37k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
8.37k
    }
756
757
0
    return false;
758
8.37k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
69
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
69
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
69
    case FILTER_LESS_OR_EQUAL: {
736
69
        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
69
        case FILTER_LARGER_OR_EQUAL: {
742
69
            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
69
        }
750
69
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
69
    }
756
757
0
    return false;
758
69
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
528
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
528
    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
508
    case FILTER_LESS_OR_EQUAL: {
736
508
        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
510
        case FILTER_LARGER_OR_EQUAL: {
742
510
            return Compare::less_equal(value, _high_value) &&
743
512
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
508
        }
750
508
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
528
    }
756
757
0
    return false;
758
528
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
197
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
197
    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
197
    case FILTER_LESS_OR_EQUAL: {
736
197
        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
197
        case FILTER_LARGER_OR_EQUAL: {
742
197
            return Compare::less_equal(value, _high_value) &&
743
197
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
197
        }
750
197
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
197
    }
756
757
0
    return false;
758
197
}
_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
355
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
355
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
355
    case FILTER_LESS_OR_EQUAL: {
736
355
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
356
        case FILTER_LARGER_OR_EQUAL: {
742
356
            return Compare::less_equal(value, _high_value) &&
743
357
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
355
        }
750
355
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
355
    }
756
757
0
    return false;
758
355
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
43
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
43
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
43
    case FILTER_LESS_OR_EQUAL: {
736
43
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
43
        case FILTER_LARGER_OR_EQUAL: {
742
43
            return Compare::less_equal(value, _high_value) &&
743
43
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
43
        }
750
43
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
43
    }
756
757
0
    return false;
758
43
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE11is_in_rangeERKNS_7DecimalIlEE
Line
Count
Source
715
279
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
279
    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
279
    case FILTER_LESS_OR_EQUAL: {
736
279
        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
279
        case FILTER_LARGER_OR_EQUAL: {
742
279
            return Compare::less_equal(value, _high_value) &&
743
280
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
279
        }
750
279
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
279
    }
756
757
0
    return false;
758
279
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE11is_in_rangeERKNS_12Decimal128V3E
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_13PrimitiveTypeE35EE11is_in_rangeERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
715
46
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
46
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
47
    case FILTER_LESS_OR_EQUAL: {
736
47
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
46
        case FILTER_LARGER_OR_EQUAL: {
742
46
            return Compare::less_equal(value, _high_value) &&
743
46
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
47
        }
750
47
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
46
    }
756
757
0
    return false;
758
46
}
759
760
template <PrimitiveType primitive_type>
761
460k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
460k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
460k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
20.0k
        set_empty_value_range();
770
20.0k
    }
771
772
460k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
460k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
433k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
395
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
395
                             range._fixed_values.begin(), range._fixed_values.end(),
778
395
                             std::inserter(result_values, result_values.begin()));
779
433k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
11
            IteratorType iter = _fixed_values.begin();
781
782
41
            while (iter != _fixed_values.end()) {
783
30
                if (range.is_in_range(*iter)) {
784
30
                    result_values.insert(*iter);
785
30
                }
786
30
                ++iter;
787
30
            }
788
433k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
433k
            IteratorType iter = range._fixed_values.begin();
790
938k
            while (iter != range._fixed_values.end()) {
791
505k
                if (this->is_in_range(*iter)) {
792
505k
                    result_values.insert(*iter);
793
505k
                }
794
505k
                ++iter;
795
505k
            }
796
433k
        }
797
798
436k
        if (!result_values.empty()) {
799
436k
            _fixed_values = std::move(result_values);
800
436k
            _contain_null = false;
801
436k
            _high_value = TYPE_MIN;
802
436k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
433k
    } else {
807
26.9k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
955
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
955
                set_contain_null(true);
811
955
            }
812
25.9k
        } else {
813
25.9k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
25.9k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
25.9k
        }
816
26.9k
    }
817
460k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
123k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
123k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
123k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
346
        set_empty_value_range();
770
346
    }
771
772
123k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
123k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
121k
        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
121k
        } 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
121k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
121k
            IteratorType iter = range._fixed_values.begin();
790
242k
            while (iter != range._fixed_values.end()) {
791
122k
                if (this->is_in_range(*iter)) {
792
122k
                    result_values.insert(*iter);
793
122k
                }
794
121k
                ++iter;
795
121k
            }
796
121k
        }
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
121k
    } else {
807
1.92k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
32
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
32
                set_contain_null(true);
811
32
            }
812
1.89k
        } else {
813
1.89k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.89k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.89k
        }
816
1.92k
    }
817
123k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
Line
Count
Source
761
220
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
220
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
220
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
28
        set_empty_value_range();
770
28
    }
771
772
220
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
220
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
119
        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
119
        } 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
119
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
119
            IteratorType iter = range._fixed_values.begin();
790
455
            while (iter != range._fixed_values.end()) {
791
336
                if (this->is_in_range(*iter)) {
792
335
                    result_values.insert(*iter);
793
335
                }
794
336
                ++iter;
795
336
            }
796
119
        }
797
798
120
        if (!result_values.empty()) {
799
120
            _fixed_values = std::move(result_values);
800
120
            _contain_null = false;
801
120
            _high_value = TYPE_MIN;
802
120
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
119
    } else {
807
101
        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
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
101
    }
817
220
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
7.68k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
7.68k
    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.68k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
322
        set_empty_value_range();
770
322
    }
771
772
7.68k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
7.68k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
6.46k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
106
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
106
                             range._fixed_values.begin(), range._fixed_values.end(),
778
106
                             std::inserter(result_values, result_values.begin()));
779
6.35k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
6.35k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
6.35k
            IteratorType iter = range._fixed_values.begin();
790
73.5k
            while (iter != range._fixed_values.end()) {
791
67.2k
                if (this->is_in_range(*iter)) {
792
66.6k
                    result_values.insert(*iter);
793
66.6k
                }
794
67.2k
                ++iter;
795
67.2k
            }
796
6.35k
        }
797
798
6.51k
        if (!result_values.empty()) {
799
6.51k
            _fixed_values = std::move(result_values);
800
6.51k
            _contain_null = false;
801
6.51k
            _high_value = TYPE_MIN;
802
6.51k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
6.46k
    } else {
807
1.22k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
213
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
213
                set_contain_null(true);
811
213
            }
812
1.01k
        } else {
813
1.01k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.01k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.01k
        }
816
1.22k
    }
817
7.68k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
20.5k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
20.5k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
20.5k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
19.2k
        set_empty_value_range();
770
19.2k
    }
771
772
20.5k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
20.5k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.20k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
75
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
75
                             range._fixed_values.begin(), range._fixed_values.end(),
778
75
                             std::inserter(result_values, result_values.begin()));
779
1.12k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
11
            IteratorType iter = _fixed_values.begin();
781
782
41
            while (iter != _fixed_values.end()) {
783
30
                if (range.is_in_range(*iter)) {
784
30
                    result_values.insert(*iter);
785
30
                }
786
30
                ++iter;
787
30
            }
788
1.11k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.11k
            IteratorType iter = range._fixed_values.begin();
790
2.85k
            while (iter != range._fixed_values.end()) {
791
1.74k
                if (this->is_in_range(*iter)) {
792
1.74k
                    result_values.insert(*iter);
793
1.74k
                }
794
1.74k
                ++iter;
795
1.74k
            }
796
1.11k
        }
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
19.3k
    } else {
807
19.3k
        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
19.2k
        } else {
813
19.2k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
19.2k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
19.2k
        }
816
19.3k
    }
817
20.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
210
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
210
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
210
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
210
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
210
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
200
        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
200
        } 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
200
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
200
            IteratorType iter = range._fixed_values.begin();
790
417
            while (iter != range._fixed_values.end()) {
791
217
                if (this->is_in_range(*iter)) {
792
217
                    result_values.insert(*iter);
793
217
                }
794
217
                ++iter;
795
217
            }
796
200
        }
797
798
200
        if (!result_values.empty()) {
799
200
            _fixed_values = std::move(result_values);
800
200
            _contain_null = false;
801
200
            _high_value = TYPE_MIN;
802
200
            _low_value = TYPE_MAX;
803
200
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
200
    } else {
807
10
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
7
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
7
                set_contain_null(true);
811
7
            }
812
7
        } else {
813
3
            static_cast<void>(add_range(range._high_op, range._high_value));
814
3
            static_cast<void>(add_range(range._low_op, range._low_value));
815
3
        }
816
10
    }
817
210
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
89
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
89
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
93
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
89
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
89
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
43
        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
27
        } 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
27
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
27
            IteratorType iter = range._fixed_values.begin();
790
64
            while (iter != range._fixed_values.end()) {
791
37
                if (this->is_in_range(*iter)) {
792
37
                    result_values.insert(*iter);
793
37
                }
794
37
                ++iter;
795
37
            }
796
27
        }
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
46
    } else {
807
46
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
36
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
34
                set_contain_null(true);
811
34
            }
812
32
        } else {
813
14
            static_cast<void>(add_range(range._high_op, range._high_value));
814
14
            static_cast<void>(add_range(range._low_op, range._low_value));
815
14
        }
816
46
    }
817
89
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
177
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
177
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
179
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
177
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
177
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
95
        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
95
        } 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
96
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
96
            IteratorType iter = range._fixed_values.begin();
790
227
            while (iter != range._fixed_values.end()) {
791
132
                if (this->is_in_range(*iter)) {
792
132
                    result_values.insert(*iter);
793
132
                }
794
131
                ++iter;
795
131
            }
796
96
        }
797
798
95
        if (!result_values.empty()) {
799
95
            _fixed_values = std::move(result_values);
800
95
            _contain_null = false;
801
95
            _high_value = TYPE_MIN;
802
95
            _low_value = TYPE_MAX;
803
95
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
95
    } else {
807
82
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
40
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
40
                set_contain_null(true);
811
40
            }
812
42
        } else {
813
42
            static_cast<void>(add_range(range._high_op, range._high_value));
814
42
            static_cast<void>(add_range(range._low_op, range._low_value));
815
42
        }
816
82
    }
817
177
}
_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
26
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
26
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
27
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
26
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
26
    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
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
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
26
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
483
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
483
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
485
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
483
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
483
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
419
        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
417
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
418
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
418
            IteratorType iter = range._fixed_values.begin();
790
1.00k
            while (iter != range._fixed_values.end()) {
791
591
                if (this->is_in_range(*iter)) {
792
591
                    result_values.insert(*iter);
793
591
                }
794
591
                ++iter;
795
591
            }
796
418
        }
797
798
422
        if (!result_values.empty()) {
799
422
            _fixed_values = std::move(result_values);
800
422
            _contain_null = false;
801
422
            _high_value = TYPE_MIN;
802
422
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
419
    } else {
807
64
        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
30
            static_cast<void>(add_range(range._high_op, range._high_value));
814
30
            static_cast<void>(add_range(range._low_op, range._low_value));
815
30
        }
816
64
    }
817
483
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
294k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
294k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
294k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
45
        set_empty_value_range();
770
45
    }
771
772
294k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
294k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
292k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
19
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
19
                             range._fixed_values.begin(), range._fixed_values.end(),
778
19
                             std::inserter(result_values, result_values.begin()));
779
292k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
292k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
292k
            IteratorType iter = range._fixed_values.begin();
790
594k
            while (iter != range._fixed_values.end()) {
791
302k
                if (this->is_in_range(*iter)) {
792
302k
                    result_values.insert(*iter);
793
302k
                }
794
302k
                ++iter;
795
302k
            }
796
292k
        }
797
798
294k
        if (!result_values.empty()) {
799
294k
            _fixed_values = std::move(result_values);
800
294k
            _contain_null = false;
801
294k
            _high_value = TYPE_MIN;
802
294k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
292k
    } else {
807
1.25k
        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.07k
        } else {
813
1.07k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.07k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.07k
        }
816
1.25k
    }
817
294k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
3.48k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
3.48k
    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.51k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
3.48k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
3.48k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
1.30k
        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.26k
        } 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.26k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
1.26k
            IteratorType iter = range._fixed_values.begin();
790
2.72k
            while (iter != range._fixed_values.end()) {
791
1.47k
                if (this->is_in_range(*iter)) {
792
1.47k
                    result_values.insert(*iter);
793
1.47k
                }
794
1.46k
                ++iter;
795
1.46k
            }
796
1.26k
        }
797
798
1.32k
        if (!result_values.empty()) {
799
1.32k
            _fixed_values = std::move(result_values);
800
1.32k
            _contain_null = false;
801
1.32k
            _high_value = TYPE_MIN;
802
1.32k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
2.18k
    } else {
807
2.18k
        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.05k
        } else {
813
2.05k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2.05k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2.05k
        }
816
2.18k
    }
817
3.48k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
40
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
40
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
40
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
40
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
40
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
40
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
40
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
40
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
40
            IteratorType iter = range._fixed_values.begin();
790
114
            while (iter != range._fixed_values.end()) {
791
74
                if (this->is_in_range(*iter)) {
792
73
                    result_values.insert(*iter);
793
73
                }
794
74
                ++iter;
795
74
            }
796
40
        }
797
798
40
        if (!result_values.empty()) {
799
40
            _fixed_values = std::move(result_values);
800
40
            _contain_null = false;
801
40
            _high_value = TYPE_MIN;
802
40
            _low_value = TYPE_MAX;
803
40
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
40
    } else {
807
0
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
0
        } else {
813
0
            static_cast<void>(add_range(range._high_op, range._high_value));
814
0
            static_cast<void>(add_range(range._low_op, range._low_value));
815
0
        }
816
0
    }
817
40
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
8.39k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
8.39k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
8.40k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
16
        set_empty_value_range();
770
16
    }
771
772
8.39k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
8.39k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
8.24k
        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
8.22k
        } 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
8.23k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
8.23k
            IteratorType iter = range._fixed_values.begin();
790
16.5k
            while (iter != range._fixed_values.end()) {
791
8.37k
                if (this->is_in_range(*iter)) {
792
8.37k
                    result_values.insert(*iter);
793
8.37k
                }
794
8.35k
                ++iter;
795
8.35k
            }
796
8.23k
        }
797
798
8.29k
        if (!result_values.empty()) {
799
8.29k
            _fixed_values = std::move(result_values);
800
8.29k
            _contain_null = false;
801
8.29k
            _high_value = TYPE_MIN;
802
8.29k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
8.24k
    } else {
807
146
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
62
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
62
                set_contain_null(true);
811
62
            }
812
87
        } else {
813
87
            static_cast<void>(add_range(range._high_op, range._high_value));
814
87
            static_cast<void>(add_range(range._low_op, range._low_value));
815
87
        }
816
146
    }
817
8.39k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12intersectionERS2_
Line
Count
Source
761
43
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
43
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
43
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
43
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
43
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
42
        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
42
        } 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
114
            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
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
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
42
    } 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
43
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12intersectionERS2_
Line
Count
Source
761
576
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
576
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
578
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
576
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
576
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
487
        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
439
        } 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
442
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
441
            IteratorType iter = range._fixed_values.begin();
790
957
            while (iter != range._fixed_values.end()) {
791
528
                if (this->is_in_range(*iter)) {
792
528
                    result_values.insert(*iter);
793
528
                }
794
516
                ++iter;
795
516
            }
796
441
        }
797
798
504
        if (!result_values.empty()) {
799
504
            _fixed_values = std::move(result_values);
800
504
            _contain_null = false;
801
504
            _high_value = TYPE_MIN;
802
504
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
487
    } else {
807
89
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
36
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
36
                set_contain_null(true);
811
36
            }
812
56
        } else {
813
56
            static_cast<void>(add_range(range._high_op, range._high_value));
814
56
            static_cast<void>(add_range(range._low_op, range._low_value));
815
56
        }
816
89
    }
817
576
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
149
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
149
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
149
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
149
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
149
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
90
        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
90
        } 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
90
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
90
            IteratorType iter = range._fixed_values.begin();
790
286
            while (iter != range._fixed_values.end()) {
791
196
                if (this->is_in_range(*iter)) {
792
196
                    result_values.insert(*iter);
793
196
                }
794
196
                ++iter;
795
196
            }
796
90
        }
797
798
91
        if (!result_values.empty()) {
799
91
            _fixed_values = std::move(result_values);
800
91
            _contain_null = false;
801
91
            _high_value = TYPE_MIN;
802
91
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
90
    } else {
807
59
        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
50
        } else {
813
50
            static_cast<void>(add_range(range._high_op, range._high_value));
814
50
            static_cast<void>(add_range(range._low_op, range._low_value));
815
50
        }
816
59
    }
817
149
}
_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
400
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
400
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
400
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
400
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
400
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
356
        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
339
        } 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
340
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
340
            IteratorType iter = range._fixed_values.begin();
790
695
            while (iter != range._fixed_values.end()) {
791
356
                if (this->is_in_range(*iter)) {
792
356
                    result_values.insert(*iter);
793
356
                }
794
355
                ++iter;
795
355
            }
796
340
        }
797
798
358
        if (!result_values.empty()) {
799
358
            _fixed_values = std::move(result_values);
800
358
            _contain_null = false;
801
358
            _high_value = TYPE_MIN;
802
358
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
356
    } else {
807
44
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
35
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
33
                set_contain_null(true);
811
33
            }
812
33
        } else {
813
11
            static_cast<void>(add_range(range._high_op, range._high_value));
814
11
            static_cast<void>(add_range(range._low_op, range._low_value));
815
11
        }
816
44
    }
817
400
}
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
0
        set_empty_value_range();
770
0
    }
771
772
68
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
68
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
39
        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
39
        } 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
39
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
39
            IteratorType iter = range._fixed_values.begin();
790
83
            while (iter != range._fixed_values.end()) {
791
44
                if (this->is_in_range(*iter)) {
792
43
                    result_values.insert(*iter);
793
43
                }
794
44
                ++iter;
795
44
            }
796
39
        }
797
798
39
        if (!result_values.empty()) {
799
38
            _fixed_values = std::move(result_values);
800
38
            _contain_null = false;
801
38
            _high_value = TYPE_MIN;
802
38
            _low_value = TYPE_MAX;
803
38
        } else {
804
1
            set_empty_value_range();
805
1
        }
806
39
    } else {
807
29
        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
25
        } else {
813
25
            static_cast<void>(add_range(range._high_op, range._high_value));
814
25
            static_cast<void>(add_range(range._low_op, range._low_value));
815
25
        }
816
29
    }
817
68
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
550
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
550
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
552
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
550
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
550
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
228
        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
176
        } 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
176
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
173
            IteratorType iter = range._fixed_values.begin();
790
449
            while (iter != range._fixed_values.end()) {
791
279
                if (this->is_in_range(*iter)) {
792
279
                    result_values.insert(*iter);
793
279
                }
794
276
                ++iter;
795
276
            }
796
173
        }
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
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
550
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
118
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
118
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
118
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
118
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
118
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
110
        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
110
        } 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
110
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
110
            IteratorType iter = range._fixed_values.begin();
790
226
            while (iter != range._fixed_values.end()) {
791
116
                if (this->is_in_range(*iter)) {
792
116
                    result_values.insert(*iter);
793
116
                }
794
116
                ++iter;
795
116
            }
796
110
        }
797
798
110
        if (!result_values.empty()) {
799
110
            _fixed_values = std::move(result_values);
800
110
            _contain_null = false;
801
110
            _high_value = TYPE_MIN;
802
110
            _low_value = TYPE_MAX;
803
110
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
110
    } 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
118
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
46
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
46
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
46
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
46
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
46
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
32
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
32
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
32
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
31
            IteratorType iter = range._fixed_values.begin();
790
76
            while (iter != range._fixed_values.end()) {
791
47
                if (this->is_in_range(*iter)) {
792
47
                    result_values.insert(*iter);
793
47
                }
794
45
                ++iter;
795
45
            }
796
31
        }
797
798
33
        if (!result_values.empty()) {
799
33
            _fixed_values = std::move(result_values);
800
33
            _contain_null = false;
801
33
            _high_value = TYPE_MIN;
802
33
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
32
    } else {
807
14
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
1
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
1
                set_contain_null(true);
811
1
            }
812
13
        } else {
813
13
            static_cast<void>(add_range(range._high_op, range._high_value));
814
13
            static_cast<void>(add_range(range._low_op, range._low_value));
815
13
        }
816
14
    }
817
46
}
818
819
template <PrimitiveType primitive_type>
820
Status OlapScanKeys::extend_scan_key(ColumnValueRange<primitive_type>& range,
821
                                     int32_t max_scan_key_num, bool* exact_value, bool* eos,
822
568k
                                     bool* should_break) {
823
568k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
568k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
568k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
568k
    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
568k
    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
568k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
568k
    if (range.is_fixed_value_range()) {
842
289k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
92
            if (range.is_range_value_convertible()) {
844
91
                range.convert_to_range_value();
845
91
                *exact_value = false;
846
91
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
92
        }
851
289k
    } else {
852
279k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
279k
            !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
156k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
156k
                                                 _end_include, max_scan_key_num)) {
860
156k
                _has_range_value = true;
861
156k
            }
862
155k
            return Status::OK();
863
155k
        }
864
279k
    }
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
289k
        if (_begin_scan_keys.empty()) {
870
99.1k
            auto fixed_value_set = range.get_fixed_value_set();
871
99.1k
            ConstIterator iter = fixed_value_set.begin();
872
873
199k
            for (; iter != fixed_value_set.end(); ++iter) {
874
100k
                _begin_scan_keys.emplace_back();
875
100k
                _begin_scan_keys.back().add_value(
876
100k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
100k
                _end_scan_keys.emplace_back();
878
100k
                _end_scan_keys.back().add_value(
879
100k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
100k
            }
881
882
99.1k
            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
99.1k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
190k
        else {
890
190k
            auto fixed_value_set = range.get_fixed_value_set();
891
190k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
380k
            for (int i = 0; i < original_key_range_size; ++i) {
894
190k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
190k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
190k
                ConstIterator iter = fixed_value_set.begin();
898
899
381k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
190k
                    if (iter == fixed_value_set.begin()) {
902
190k
                        _begin_scan_keys[i].add_value(
903
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
190k
                        _end_scan_keys[i].add_value(
905
190k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
190k
                    } // append follow ScanKey
907
399
                    else {
908
399
                        _begin_scan_keys.push_back(start_base_key_range);
909
399
                        _begin_scan_keys.back().add_value(
910
399
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
399
                        _end_scan_keys.push_back(end_base_key_range);
912
399
                        _end_scan_keys.back().add_value(
913
399
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
399
                    }
915
190k
                }
916
917
190k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
190k
            }
924
190k
        }
925
926
289k
        _begin_include = true;
927
289k
        _end_include = true;
928
289k
    } // Extend ScanKey with range value
929
123k
    else {
930
123k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
123k
        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
123k
        } else if (_begin_scan_keys.empty()) {
947
24.5k
            _begin_scan_keys.emplace_back();
948
24.5k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
24.5k
                                                      range.get_range_min_value(), range.scale()),
950
24.5k
                                              range.contain_null());
951
24.5k
            _end_scan_keys.emplace_back();
952
24.5k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
24.5k
                    range.get_range_max_value(), range.scale()));
954
98.7k
        } else {
955
200k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
101k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
101k
                                                      range.get_range_min_value(), range.scale()),
958
101k
                                              range.contain_null());
959
101k
            }
960
961
200k
            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
98.7k
        }
966
123k
        _begin_include = range.is_begin_include();
967
123k
        _end_include = range.is_end_include();
968
123k
    }
969
970
412k
    return Status::OK();
971
568k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.35k
                                     bool* should_break) {
823
2.35k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.35k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.35k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.35k
    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.35k
    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.35k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.35k
    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
2.34k
    } else {
852
2.34k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.34k
            !range.is_reject_split_type()) {
854
2.30k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.30k
                                                 _end_include);
856
857
2.30k
            if (!(*eos) &&
858
2.32k
                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.30k
            return Status::OK();
863
2.30k
        }
864
2.34k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
49
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
8
        if (_begin_scan_keys.empty()) {
870
8
            auto fixed_value_set = range.get_fixed_value_set();
871
8
            ConstIterator iter = fixed_value_set.begin();
872
873
20
            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
8
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
8
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
8
        _begin_include = true;
927
8
        _end_include = true;
928
8
    } // Extend ScanKey with range value
929
41
    else {
930
41
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
41
        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
41
        } 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
39
        } else {
955
79
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
40
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
40
                                                      range.get_range_min_value(), range.scale()),
958
40
                                              range.contain_null());
959
40
            }
960
961
79
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
40
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
40
                        range.get_range_max_value(), range.scale()));
964
40
            }
965
39
        }
966
41
        _begin_include = range.is_begin_include();
967
41
        _end_include = range.is_end_include();
968
41
    }
969
970
49
    return Status::OK();
971
2.35k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
317
                                     bool* should_break) {
823
317
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
317
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
317
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
317
    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
317
    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
317
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
317
    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
314
    } else {
852
314
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
314
            !range.is_reject_split_type()) {
854
248
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
248
                                                 _end_include);
856
857
248
            if (!(*eos) &&
858
251
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
251
                                                 _end_include, max_scan_key_num)) {
860
251
                _has_range_value = true;
861
251
            }
862
248
            return Status::OK();
863
248
        }
864
314
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
69
    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
66
    else {
930
66
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
66
        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
66
        } 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
66
        } else {
955
419
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
353
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
353
                                                      range.get_range_min_value(), range.scale()),
958
353
                                              range.contain_null());
959
353
            }
960
961
422
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
356
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
356
                        range.get_range_max_value(), range.scale()));
964
356
            }
965
66
        }
966
66
        _begin_include = range.is_begin_include();
967
66
        _end_include = range.is_end_include();
968
66
    }
969
970
69
    return Status::OK();
971
317
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
71.2k
                                     bool* should_break) {
823
71.2k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
71.2k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
71.2k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
71.2k
    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
71.2k
    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
71.2k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
71.2k
    if (range.is_fixed_value_range()) {
842
2.50k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
58
            if (range.is_range_value_convertible()) {
844
58
                range.convert_to_range_value();
845
58
                *exact_value = false;
846
58
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
58
        }
851
68.7k
    } else {
852
68.7k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
68.7k
            !range.is_reject_split_type()) {
854
67.2k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
67.2k
                                                 _end_include);
856
857
67.2k
            if (!(*eos) &&
858
67.7k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
67.8k
                                                 _end_include, max_scan_key_num)) {
860
67.8k
                _has_range_value = true;
861
67.8k
            }
862
67.2k
            return Status::OK();
863
67.2k
        }
864
68.7k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.02k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.44k
        if (_begin_scan_keys.empty()) {
870
2.36k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.36k
            ConstIterator iter = fixed_value_set.begin();
872
873
5.62k
            for (; iter != fixed_value_set.end(); ++iter) {
874
3.25k
                _begin_scan_keys.emplace_back();
875
3.25k
                _begin_scan_keys.back().add_value(
876
3.25k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
3.25k
                _end_scan_keys.emplace_back();
878
3.25k
                _end_scan_keys.back().add_value(
879
3.25k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
3.25k
            }
881
882
2.36k
            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.36k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
81
        else {
890
81
            auto fixed_value_set = range.get_fixed_value_set();
891
81
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
189
            for (int i = 0; i < original_key_range_size; ++i) {
894
108
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
108
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
108
                ConstIterator iter = fixed_value_set.begin();
898
899
214
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
107
                    if (iter == fixed_value_set.begin()) {
902
107
                        _begin_scan_keys[i].add_value(
903
107
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
107
                        _end_scan_keys[i].add_value(
905
107
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
107
                    } // append follow ScanKey
907
18.4E
                    else {
908
18.4E
                        _begin_scan_keys.push_back(start_base_key_range);
909
18.4E
                        _begin_scan_keys.back().add_value(
910
18.4E
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
18.4E
                        _end_scan_keys.push_back(end_base_key_range);
912
18.4E
                        _end_scan_keys.back().add_value(
913
18.4E
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
18.4E
                    }
915
106
                }
916
917
108
                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
108
            }
924
81
        }
925
926
2.44k
        _begin_include = true;
927
2.44k
        _end_include = true;
928
2.44k
    } // Extend ScanKey with range value
929
1.58k
    else {
930
1.58k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.58k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
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.58k
        } else if (_begin_scan_keys.empty()) {
947
140
            _begin_scan_keys.emplace_back();
948
140
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
140
                                                      range.get_range_min_value(), range.scale()),
950
140
                                              range.contain_null());
951
140
            _end_scan_keys.emplace_back();
952
140
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
140
                    range.get_range_max_value(), range.scale()));
954
1.44k
        } else {
955
5.25k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
3.80k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
3.80k
                                                      range.get_range_min_value(), range.scale()),
958
3.80k
                                              range.contain_null());
959
3.80k
            }
960
961
5.25k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
3.81k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
3.81k
                        range.get_range_max_value(), range.scale()));
964
3.81k
            }
965
1.44k
        }
966
1.58k
        _begin_include = range.is_begin_include();
967
1.58k
        _end_include = range.is_end_include();
968
1.58k
    }
969
970
4.02k
    return Status::OK();
971
71.2k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
84.3k
                                     bool* should_break) {
823
84.3k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
84.3k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
84.3k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
84.3k
    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
84.3k
    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
84.3k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
84.3k
    if (range.is_fixed_value_range()) {
842
714
        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
83.6k
    } else {
852
83.6k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
83.6k
            !range.is_reject_split_type()) {
854
83.1k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
83.1k
                                                 _end_include);
856
857
83.1k
            if (!(*eos) &&
858
83.4k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
83.4k
                                                 _end_include, max_scan_key_num)) {
860
83.0k
                _has_range_value = true;
861
83.0k
            }
862
83.1k
            return Status::OK();
863
83.1k
        }
864
83.6k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.20k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
716
        if (_begin_scan_keys.empty()) {
870
716
            auto fixed_value_set = range.get_fixed_value_set();
871
716
            ConstIterator iter = fixed_value_set.begin();
872
873
1.51k
            for (; iter != fixed_value_set.end(); ++iter) {
874
803
                _begin_scan_keys.emplace_back();
875
803
                _begin_scan_keys.back().add_value(
876
803
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
803
                _end_scan_keys.emplace_back();
878
803
                _end_scan_keys.back().add_value(
879
803
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
803
            }
881
882
716
            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
716
        } // 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
715
        _begin_include = true;
927
715
        _end_include = true;
928
715
    } // Extend ScanKey with range value
929
487
    else {
930
487
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
487
        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
487
        } 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
465
        } else {
955
1.20k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
738
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
738
                                                      range.get_range_min_value(), range.scale()),
958
738
                                              range.contain_null());
959
738
            }
960
961
1.20k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
738
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
738
                        range.get_range_max_value(), range.scale()));
964
738
            }
965
465
        }
966
487
        _begin_include = range.is_begin_include();
967
487
        _end_include = range.is_end_include();
968
487
    }
969
970
1.20k
    return Status::OK();
971
84.3k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.36k
                                     bool* should_break) {
823
4.36k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.36k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.36k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.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
4.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
4.36k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.36k
    if (range.is_fixed_value_range()) {
842
144
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
4.21k
    } else {
852
4.21k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
4.21k
            !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.21k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.36k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
144
        if (_begin_scan_keys.empty()) {
870
144
            auto fixed_value_set = range.get_fixed_value_set();
871
144
            ConstIterator iter = fixed_value_set.begin();
872
873
303
            for (; iter != fixed_value_set.end(); ++iter) {
874
159
                _begin_scan_keys.emplace_back();
875
159
                _begin_scan_keys.back().add_value(
876
159
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
159
                _end_scan_keys.emplace_back();
878
159
                _end_scan_keys.back().add_value(
879
159
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
159
            }
881
882
144
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
144
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
144
        _begin_include = true;
927
144
        _end_include = true;
928
144
    } // Extend ScanKey with range value
929
4.21k
    else {
930
4.21k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
4.21k
        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.21k
        } else if (_begin_scan_keys.empty()) {
947
4.15k
            _begin_scan_keys.emplace_back();
948
4.15k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
4.15k
                                                      range.get_range_min_value(), range.scale()),
950
4.15k
                                              range.contain_null());
951
4.15k
            _end_scan_keys.emplace_back();
952
4.15k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
4.15k
                    range.get_range_max_value(), range.scale()));
954
4.15k
        } else {
955
125
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
68
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
68
                                                      range.get_range_min_value(), range.scale()),
958
68
                                              range.contain_null());
959
68
            }
960
961
125
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
68
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
68
                        range.get_range_max_value(), range.scale()));
964
68
            }
965
57
        }
966
4.21k
        _begin_include = range.is_begin_include();
967
4.21k
        _end_include = range.is_end_include();
968
4.21k
    }
969
970
4.36k
    return Status::OK();
971
4.36k
}
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
400
                                     bool* should_break) {
823
400
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
400
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
400
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
400
    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
400
    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
400
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
400
    if (range.is_fixed_value_range()) {
842
15
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
1
                range.convert_to_range_value();
845
1
                *exact_value = false;
846
1
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
1
        }
851
385
    } else {
852
385
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
385
            !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
385
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
400
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
14
        if (_begin_scan_keys.empty()) {
870
13
            auto fixed_value_set = range.get_fixed_value_set();
871
13
            ConstIterator iter = fixed_value_set.begin();
872
873
38
            for (; iter != fixed_value_set.end(); ++iter) {
874
25
                _begin_scan_keys.emplace_back();
875
25
                _begin_scan_keys.back().add_value(
876
25
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
25
                _end_scan_keys.emplace_back();
878
25
                _end_scan_keys.back().add_value(
879
25
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
25
            }
881
882
13
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
13
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
1
        else {
890
1
            auto fixed_value_set = range.get_fixed_value_set();
891
1
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
2
            for (int i = 0; i < original_key_range_size; ++i) {
894
1
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
1
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
1
                ConstIterator iter = fixed_value_set.begin();
898
899
2
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
1
                    if (iter == fixed_value_set.begin()) {
902
1
                        _begin_scan_keys[i].add_value(
903
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
1
                        _end_scan_keys[i].add_value(
905
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
1
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
1
                }
916
917
1
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
1
            }
924
1
        }
925
926
14
        _begin_include = true;
927
14
        _end_include = true;
928
14
    } // Extend ScanKey with range value
929
386
    else {
930
386
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
386
        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
385
        } else if (_begin_scan_keys.empty()) {
947
379
            _begin_scan_keys.emplace_back();
948
379
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
379
                                                      range.get_range_min_value(), range.scale()),
950
379
                                              range.contain_null());
951
379
            _end_scan_keys.emplace_back();
952
379
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
379
                    range.get_range_max_value(), range.scale()));
954
379
        } else {
955
80
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
74
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
74
                                                      range.get_range_min_value(), range.scale()),
958
74
                                              range.contain_null());
959
74
            }
960
961
80
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
74
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
74
                        range.get_range_max_value(), range.scale()));
964
74
            }
965
6
        }
966
386
        _begin_include = range.is_begin_include();
967
386
        _end_include = range.is_end_include();
968
386
    }
969
970
400
    return Status::OK();
971
400
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
391k
                                     bool* should_break) {
823
391k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
391k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
391k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
391k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
391k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
391k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
391k
    if (range.is_fixed_value_range()) {
842
285k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
32
            if (range.is_range_value_convertible()) {
844
32
                range.convert_to_range_value();
845
32
                *exact_value = false;
846
32
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
32
        }
851
285k
    } else {
852
105k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
105k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
105k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
391k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
285k
        if (_begin_scan_keys.empty()) {
870
95.2k
            auto fixed_value_set = range.get_fixed_value_set();
871
95.2k
            ConstIterator iter = fixed_value_set.begin();
872
873
190k
            for (; iter != fixed_value_set.end(); ++iter) {
874
95.4k
                _begin_scan_keys.emplace_back();
875
95.4k
                _begin_scan_keys.back().add_value(
876
95.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
95.4k
                _end_scan_keys.emplace_back();
878
95.4k
                _end_scan_keys.back().add_value(
879
95.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
95.4k
            }
881
882
95.2k
            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
95.2k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
190k
        else {
890
190k
            auto fixed_value_set = range.get_fixed_value_set();
891
190k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
380k
            for (int i = 0; i < original_key_range_size; ++i) {
894
190k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
190k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
190k
                ConstIterator iter = fixed_value_set.begin();
898
899
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
400
                    else {
908
400
                        _begin_scan_keys.push_back(start_base_key_range);
909
400
                        _begin_scan_keys.back().add_value(
910
400
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
400
                        _end_scan_keys.push_back(end_base_key_range);
912
400
                        _end_scan_keys.back().add_value(
913
400
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
400
                    }
915
190k
                }
916
917
190k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
190k
            }
924
190k
        }
925
926
285k
        _begin_include = true;
927
285k
        _end_include = true;
928
285k
    } // Extend ScanKey with range value
929
105k
    else {
930
105k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
105k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
105k
        } else if (_begin_scan_keys.empty()) {
947
9.26k
            _begin_scan_keys.emplace_back();
948
9.26k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
9.26k
                                                      range.get_range_min_value(), range.scale()),
950
9.26k
                                              range.contain_null());
951
9.26k
            _end_scan_keys.emplace_back();
952
9.26k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
9.26k
                    range.get_range_max_value(), range.scale()));
954
96.3k
        } else {
955
192k
            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
192k
            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.3k
        }
966
105k
        _begin_include = range.is_begin_include();
967
105k
        _end_include = range.is_end_include();
968
105k
    }
969
970
391k
    return Status::OK();
971
391k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE23EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE11EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
25
                                     bool* should_break) {
823
25
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
25
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
25
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
25
    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
25
    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
25
    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
16
    } else {
852
16
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
16
            !range.is_reject_split_type()) {
854
16
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
16
                                                 _end_include);
856
857
16
            if (!(*eos) &&
858
17
                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
16
            return Status::OK();
863
16
        }
864
16
    }
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
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
0
    else {
930
0
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
0
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
0
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
0
        } else {
955
0
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
0
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
0
                                                      range.get_range_min_value(), range.scale()),
958
0
                                              range.contain_null());
959
0
            }
960
961
0
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
0
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
0
                        range.get_range_max_value(), range.scale()));
964
0
            }
965
0
        }
966
0
        _begin_include = range.is_begin_include();
967
0
        _end_include = range.is_end_include();
968
0
    }
969
970
9
    return Status::OK();
971
25
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE25EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.32k
                                     bool* should_break) {
823
3.32k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.32k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.32k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.32k
    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.32k
    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.32k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.32k
    if (range.is_fixed_value_range()) {
842
342
        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.98k
    } else {
852
2.98k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.98k
            !range.is_reject_split_type()) {
854
2.87k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.87k
                                                 _end_include);
856
857
2.87k
            if (!(*eos) &&
858
2.88k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
2.88k
                                                 _end_include, max_scan_key_num)) {
860
2.75k
                _has_range_value = true;
861
2.75k
            }
862
2.87k
            return Status::OK();
863
2.87k
        }
864
2.98k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
454
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
342
        if (_begin_scan_keys.empty()) {
870
340
            auto fixed_value_set = range.get_fixed_value_set();
871
340
            ConstIterator iter = fixed_value_set.begin();
872
873
735
            for (; iter != fixed_value_set.end(); ++iter) {
874
395
                _begin_scan_keys.emplace_back();
875
395
                _begin_scan_keys.back().add_value(
876
395
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
395
                _end_scan_keys.emplace_back();
878
395
                _end_scan_keys.back().add_value(
879
395
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
395
            }
881
882
340
            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
340
        } // 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
342
        _begin_include = true;
927
342
        _end_include = true;
928
342
    } // Extend ScanKey with range value
929
112
    else {
930
112
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
112
        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
112
        } 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
112
        } else {
955
285
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
173
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
173
                                                      range.get_range_min_value(), range.scale()),
958
173
                                              range.contain_null());
959
173
            }
960
961
285
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
173
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
173
                        range.get_range_max_value(), range.scale()));
964
173
            }
965
112
        }
966
112
        _begin_include = range.is_begin_include();
967
112
        _end_include = range.is_end_include();
968
112
    }
969
970
454
    return Status::OK();
971
3.32k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE12EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
30
                                     bool* should_break) {
823
30
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
30
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
30
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
30
    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
30
    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
30
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
30
    if (range.is_fixed_value_range()) {
842
7
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
23
    } else {
852
23
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
23
            !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
23
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
30
    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
28
            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
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
23
    else {
930
23
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
23
        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
23
        } 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
22
        } 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
23
        _begin_include = range.is_begin_include();
967
23
        _end_include = range.is_end_include();
968
23
    }
969
970
30
    return Status::OK();
971
30
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE26EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.47k
                                     bool* should_break) {
823
2.47k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.47k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.47k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.47k
    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.47k
    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.47k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.47k
    if (range.is_fixed_value_range()) {
842
67
        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.40k
    } else {
852
2.40k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.40k
            !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.40k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.47k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
67
        if (_begin_scan_keys.empty()) {
870
65
            auto fixed_value_set = range.get_fixed_value_set();
871
65
            ConstIterator iter = fixed_value_set.begin();
872
873
140
            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
65
            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
65
        } // 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
67
        _begin_include = true;
927
67
        _end_include = true;
928
67
    } // Extend ScanKey with range value
929
2.40k
    else {
930
2.40k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.40k
        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.40k
        } else if (_begin_scan_keys.empty()) {
947
2.39k
            _begin_scan_keys.emplace_back();
948
2.39k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.39k
                                                      range.get_range_min_value(), range.scale()),
950
2.39k
                                              range.contain_null());
951
2.39k
            _end_scan_keys.emplace_back();
952
2.39k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.39k
                    range.get_range_max_value(), range.scale()));
954
2.39k
        } else {
955
7
            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
7
            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
5
        }
966
2.40k
        _begin_include = range.is_begin_include();
967
2.40k
        _end_include = range.is_end_include();
968
2.40k
    }
969
970
2.47k
    return Status::OK();
971
2.47k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.23k
                                     bool* should_break) {
823
3.23k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.23k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.23k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.23k
    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.23k
    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.23k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.23k
    if (range.is_fixed_value_range()) {
842
135
        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.09k
    } else {
852
3.09k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
3.09k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
3.09k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3.23k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
136
        if (_begin_scan_keys.empty()) {
870
136
            auto fixed_value_set = range.get_fixed_value_set();
871
136
            ConstIterator iter = fixed_value_set.begin();
872
873
358
            for (; iter != fixed_value_set.end(); ++iter) {
874
222
                _begin_scan_keys.emplace_back();
875
222
                _begin_scan_keys.back().add_value(
876
222
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
222
                _end_scan_keys.emplace_back();
878
222
                _end_scan_keys.back().add_value(
879
222
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
222
            }
881
882
136
            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
136
        } // 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
135
        _begin_include = true;
927
135
        _end_include = true;
928
135
    } // Extend ScanKey with range value
929
3.09k
    else {
930
3.09k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
3.09k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
9
            CHECK(range.contain_null());
935
9
            if (_begin_scan_keys.empty()) {
936
9
                _begin_scan_keys.emplace_back();
937
9
                _begin_scan_keys.back().add_null();
938
9
                _end_scan_keys.emplace_back();
939
9
                _end_scan_keys.back().add_null();
940
9
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
3.09k
        } else if (_begin_scan_keys.empty()) {
947
3.09k
            _begin_scan_keys.emplace_back();
948
3.09k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
3.09k
                                                      range.get_range_min_value(), range.scale()),
950
3.09k
                                              range.contain_null());
951
3.09k
            _end_scan_keys.emplace_back();
952
3.09k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
3.09k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
0
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
0
                                                      range.get_range_min_value(), range.scale()),
958
0
                                              range.contain_null());
959
0
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
0
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
0
                        range.get_range_max_value(), range.scale()));
964
0
            }
965
18.4E
        }
966
3.09k
        _begin_include = range.is_begin_include();
967
3.09k
        _end_include = range.is_end_include();
968
3.09k
    }
969
970
3.23k
    return Status::OK();
971
3.23k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
44
                                     bool* should_break) {
823
44
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
44
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
44
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
44
    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
44
    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
44
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
44
    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
43
    } else {
852
43
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
43
            !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
43
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
44
    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
43
    else {
930
43
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
43
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
43
        } else if (_begin_scan_keys.empty()) {
947
42
            _begin_scan_keys.emplace_back();
948
42
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
42
                                                      range.get_range_min_value(), range.scale()),
950
42
                                              range.contain_null());
951
42
            _end_scan_keys.emplace_back();
952
42
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
42
                    range.get_range_max_value(), range.scale()));
954
42
        } 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
43
        _begin_include = range.is_begin_include();
967
43
        _end_include = range.is_end_include();
968
43
    }
969
970
44
    return Status::OK();
971
44
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.24k
                                     bool* should_break) {
823
2.24k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.24k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.24k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.24k
    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.24k
    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.24k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.24k
    if (range.is_fixed_value_range()) {
842
9
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
1
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
1
        }
851
2.23k
    } else {
852
2.23k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.23k
            !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.23k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.24k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
8
        if (_begin_scan_keys.empty()) {
870
8
            auto fixed_value_set = range.get_fixed_value_set();
871
8
            ConstIterator iter = fixed_value_set.begin();
872
873
22
            for (; iter != fixed_value_set.end(); ++iter) {
874
14
                _begin_scan_keys.emplace_back();
875
14
                _begin_scan_keys.back().add_value(
876
14
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
14
                _end_scan_keys.emplace_back();
878
14
                _end_scan_keys.back().add_value(
879
14
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
14
            }
881
882
8
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
8
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
8
        _begin_include = true;
927
8
        _end_include = true;
928
8
    } // Extend ScanKey with range value
929
2.23k
    else {
930
2.23k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.23k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
3
            CHECK(range.contain_null());
935
3
            if (_begin_scan_keys.empty()) {
936
3
                _begin_scan_keys.emplace_back();
937
3
                _begin_scan_keys.back().add_null();
938
3
                _end_scan_keys.emplace_back();
939
3
                _end_scan_keys.back().add_null();
940
3
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
2.23k
        } else if (_begin_scan_keys.empty()) {
947
2.22k
            _begin_scan_keys.emplace_back();
948
2.22k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.22k
                                                      range.get_range_min_value(), range.scale()),
950
2.22k
                                              range.contain_null());
951
2.22k
            _end_scan_keys.emplace_back();
952
2.22k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.22k
                    range.get_range_max_value(), range.scale()));
954
2.22k
        } else {
955
32
            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
32
            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
2
        }
966
2.23k
        _begin_include = range.is_begin_include();
967
2.23k
        _end_include = range.is_end_include();
968
2.23k
    }
969
970
2.24k
    return Status::OK();
971
2.24k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
415
                                     bool* should_break) {
823
415
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
415
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
415
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
415
    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
415
    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
415
    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
397
    } else {
852
400
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
397
            !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
397
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
415
    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
16
            auto fixed_value_set = range.get_fixed_value_set();
871
16
            ConstIterator iter = fixed_value_set.begin();
872
873
38
            for (; iter != fixed_value_set.end(); ++iter) {
874
22
                _begin_scan_keys.emplace_back();
875
22
                _begin_scan_keys.back().add_value(
876
22
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
22
                _end_scan_keys.emplace_back();
878
22
                _end_scan_keys.back().add_value(
879
22
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
22
            }
881
882
16
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
16
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
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
18
        _begin_include = true;
927
18
        _end_include = true;
928
18
    } // 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
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
400
        } else if (_begin_scan_keys.empty()) {
947
400
            _begin_scan_keys.emplace_back();
948
400
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
400
                                                      range.get_range_min_value(), range.scale()),
950
400
                                              range.contain_null());
951
400
            _end_scan_keys.emplace_back();
952
400
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
400
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
1
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
1
                                                      range.get_range_min_value(), range.scale()),
958
1
                                              range.contain_null());
959
1
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
1
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
1
                        range.get_range_max_value(), range.scale()));
964
1
            }
965
18.4E
        }
966
397
        _begin_include = range.is_begin_include();
967
397
        _end_include = range.is_end_include();
968
397
    }
969
970
415
    return Status::OK();
971
415
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
671
                                     bool* should_break) {
823
671
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
671
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
671
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
671
    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
671
    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
671
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
671
    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
651
    } else {
852
651
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
651
            !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
651
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
671
    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
651
    else {
930
651
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
651
        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
651
        } else if (_begin_scan_keys.empty()) {
947
633
            _begin_scan_keys.emplace_back();
948
633
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
633
                                                      range.get_range_min_value(), range.scale()),
950
633
                                              range.contain_null());
951
633
            _end_scan_keys.emplace_back();
952
633
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
633
                    range.get_range_max_value(), range.scale()));
954
633
        } else {
955
42
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
24
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
24
                                                      range.get_range_min_value(), range.scale()),
958
24
                                              range.contain_null());
959
24
            }
960
961
43
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
25
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
25
                        range.get_range_max_value(), range.scale()));
964
25
            }
965
18
        }
966
651
        _begin_include = range.is_begin_include();
967
651
        _end_include = range.is_end_include();
968
651
    }
969
970
671
    return Status::OK();
971
671
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.39k
                                     bool* should_break) {
823
1.39k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.39k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.39k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.39k
    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.39k
    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.39k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.39k
    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.39k
    } else {
852
1.39k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.39k
            !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.39k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.39k
    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.39k
    else {
930
1.39k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.39k
        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.39k
        } else if (_begin_scan_keys.empty()) {
947
1.28k
            _begin_scan_keys.emplace_back();
948
1.28k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.28k
                                                      range.get_range_min_value(), range.scale()),
950
1.28k
                                              range.contain_null());
951
1.28k
            _end_scan_keys.emplace_back();
952
1.28k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.28k
                    range.get_range_max_value(), range.scale()));
954
1.28k
        } else {
955
215
            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
215
            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
107
        }
966
1.39k
        _begin_include = range.is_begin_include();
967
1.39k
        _end_include = range.is_end_include();
968
1.39k
    }
969
970
1.39k
    return Status::OK();
971
1.39k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
545
                                     bool* should_break) {
823
545
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
545
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
545
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
545
    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
545
    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
545
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
545
    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
527
    } else {
852
527
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
527
            !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
527
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
545
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
17
        if (_begin_scan_keys.empty()) {
870
16
            auto fixed_value_set = range.get_fixed_value_set();
871
16
            ConstIterator iter = fixed_value_set.begin();
872
873
46
            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
16
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
16
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
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
1
            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
1
        }
925
926
17
        _begin_include = true;
927
17
        _end_include = true;
928
17
    } // Extend ScanKey with range value
929
528
    else {
930
528
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
528
        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
527
        } else if (_begin_scan_keys.empty()) {
947
469
            _begin_scan_keys.emplace_back();
948
469
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
469
                                                      range.get_range_min_value(), range.scale()),
950
469
                                              range.contain_null());
951
469
            _end_scan_keys.emplace_back();
952
469
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
469
                    range.get_range_max_value(), range.scale()));
954
469
        } 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
528
        _begin_include = range.is_begin_include();
967
528
        _end_include = range.is_end_include();
968
528
    }
969
970
545
    return Status::OK();
971
545
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris