Coverage Report

Created: 2026-03-20 06:04

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.24M
std::string cast_to_string(T value, int scale) {
61
1.24M
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
896
        return ((Decimal<int32_t>)value).to_string(scale);
63
1.21k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.21k
        return ((Decimal<int64_t>)value).to_string(scale);
65
3.26k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
3.26k
        return ((Decimal<int128_t>)value).to_string(scale);
67
3.26k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.02k
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
166k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
166k
        return std::to_string(static_cast<int>(value));
71
166k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.28k
        return int128_to_string(value);
73
8.28k
    } 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
8.91k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
8.91k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
8.91k
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
0
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
0
        return IPv4Value::to_string(value);
87
4
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
4
        return IPv6Value::to_string(value);
89
3.13k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.13k
        return CastToString::from_number(value);
91
1.04M
    } else {
92
1.04M
        return boost::lexical_cast<std::string>(value);
93
1.04M
    }
94
1.24M
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE3EaEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
166k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
166k
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
166k
        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
166k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE4EsEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
10.0k
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
10.0k
    } else {
92
10.0k
        return boost::lexical_cast<std::string>(value);
93
10.0k
    }
94
10.0k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE5EiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
152k
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
152k
    } else {
92
152k
        return boost::lexical_cast<std::string>(value);
93
152k
    }
94
152k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE6ElEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
166k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
166k
    } else {
92
166k
        return boost::lexical_cast<std::string>(value);
93
166k
    }
94
166k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE7EnEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
8.28k
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.28k
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
8.28k
        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.28k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE8EfEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE9EdEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE36EjEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE37EoEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
4
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
4
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
4
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
4
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE15ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
1.27k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
        return CastToString::from_number(value);
91
1.27k
    } else {
92
1.27k
        return boost::lexical_cast<std::string>(value);
93
1.27k
    }
94
1.27k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE10ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
Line
Count
Source
60
441k
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
441k
    } else {
92
441k
        return boost::lexical_cast<std::string>(value);
93
441k
    }
94
441k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE23ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEES7_T0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE11ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
590
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
590
    } else {
92
590
        return boost::lexical_cast<std::string>(value);
93
590
    }
94
590
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE25ENS_11DateV2ValueINS_15DateV2ValueTypeEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
272k
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
272k
    } else {
92
272k
        return boost::lexical_cast<std::string>(value);
93
272k
    }
94
272k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE12ENS_16VecDateTimeValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
85
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
85
    } else {
92
85
        return boost::lexical_cast<std::string>(value);
93
85
    }
94
85
}
_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
8.91k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
8.91k
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
8.91k
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
8.91k
        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.91k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE20ENS_14DecimalV2ValueEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
314
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
314
    } else {
92
314
        return boost::lexical_cast<std::string>(value);
93
314
    }
94
314
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE2EhEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.13k
std::string cast_to_string(T value, int scale) {
61
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
        return ((Decimal<int32_t>)value).to_string(scale);
63
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
        return ((Decimal<int64_t>)value).to_string(scale);
65
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
        return ((Decimal<int128_t>)value).to_string(scale);
67
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
        return ((Decimal<wide::Int256>)value).to_string(scale);
69
    } else if constexpr (primitive_type == TYPE_TINYINT) {
70
        return std::to_string(static_cast<int>(value));
71
    } else if constexpr (primitive_type == TYPE_LARGEINT) {
72
        return int128_to_string(value);
73
    } else if constexpr (primitive_type == TYPE_DATETIMEV2) {
74
        auto datetimev2_val = static_cast<DateV2Value<DateTimeV2ValueType>>(value);
75
        char buf[30];
76
        datetimev2_val.to_string(buf);
77
        std::stringstream ss;
78
        ss << buf;
79
        return ss.str();
80
    } else if constexpr (primitive_type == TYPE_TIMESTAMPTZ) {
81
        auto timestamptz_val = static_cast<TimestampTzValue>(value);
82
        return timestamptz_val.to_string(cctz::utc_time_zone(), scale);
83
    } else if constexpr (primitive_type == TYPE_TIMEV2) {
84
        return TimeValue::to_string(value, scale);
85
    } else if constexpr (primitive_type == TYPE_IPV4) {
86
        return IPv4Value::to_string(value);
87
    } else if constexpr (primitive_type == TYPE_IPV6) {
88
        return IPv6Value::to_string(value);
89
3.13k
    } else if constexpr (primitive_type == TYPE_BOOLEAN) {
90
3.13k
        return CastToString::from_number(value);
91
    } else {
92
        return boost::lexical_cast<std::string>(value);
93
    }
94
3.13k
}
Unexecuted instantiation: _ZN5doris14cast_to_stringILNS_13PrimitiveTypeE19ENS_9StringRefEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE28ENS_7DecimalIiEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
896
std::string cast_to_string(T value, int scale) {
61
896
    if constexpr (primitive_type == TYPE_DECIMAL32) {
62
896
        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
896
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE29ENS_7DecimalIlEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.21k
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.21k
    } else if constexpr (primitive_type == TYPE_DECIMAL64) {
64
1.21k
        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.21k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE30ENS_12Decimal128V3EEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
3.26k
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
3.26k
    } else if constexpr (primitive_type == TYPE_DECIMAL128I) {
66
3.26k
        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
3.26k
}
_ZN5doris14cast_to_stringILNS_13PrimitiveTypeE35ENS_7DecimalIN4wide7integerILm256EiEEEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET0_i
Line
Count
Source
60
1.02k
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.02k
    } else if constexpr (primitive_type == TYPE_DECIMAL256) {
68
1.02k
        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.02k
}
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
150k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_reject_split_typeEv
Line
Count
Source
139
1.91k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_reject_split_typeEv
Line
Count
Source
139
98
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_reject_split_typeEv
Line
Count
Source
139
61.4k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_reject_split_typeEv
Line
Count
Source
139
80.4k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_reject_split_typeEv
Line
Count
Source
139
3.89k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_reject_split_typeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_reject_split_typeEv
Line
Count
Source
139
1
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_reject_split_typeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_reject_split_typeEv
Line
Count
Source
139
6
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_reject_split_typeEv
Line
Count
Source
139
2.88k
    constexpr bool is_reject_split_type() const { return _is_reject_split_type; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_reject_split_typeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_reject_split_typeEv
140
141
    void intersection(ColumnValueRange<primitive_type>& range);
142
143
22.5k
    void set_empty_value_range() {
144
22.5k
        _fixed_values.clear();
145
22.5k
        _low_value = TYPE_MAX;
146
22.5k
        _high_value = TYPE_MIN;
147
22.5k
        _contain_null = false;
148
22.5k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_empty_value_rangeEv
Line
Count
Source
143
12
    void set_empty_value_range() {
144
12
        _fixed_values.clear();
145
12
        _low_value = TYPE_MAX;
146
12
        _high_value = TYPE_MIN;
147
12
        _contain_null = false;
148
12
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_empty_value_rangeEv
Line
Count
Source
143
6
    void set_empty_value_range() {
144
6
        _fixed_values.clear();
145
6
        _low_value = TYPE_MAX;
146
6
        _high_value = TYPE_MIN;
147
6
        _contain_null = false;
148
6
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21set_empty_value_rangeEv
Line
Count
Source
143
425
    void set_empty_value_range() {
144
425
        _fixed_values.clear();
145
425
        _low_value = TYPE_MAX;
146
425
        _high_value = TYPE_MIN;
147
425
        _contain_null = false;
148
425
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_empty_value_rangeEv
Line
Count
Source
143
21.6k
    void set_empty_value_range() {
144
21.6k
        _fixed_values.clear();
145
21.6k
        _low_value = TYPE_MAX;
146
21.6k
        _high_value = TYPE_MIN;
147
21.6k
        _contain_null = false;
148
21.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_empty_value_rangeEv
Line
Count
Source
143
22
    void set_empty_value_range() {
144
22
        _fixed_values.clear();
145
22
        _low_value = TYPE_MAX;
146
22
        _high_value = TYPE_MIN;
147
22
        _contain_null = false;
148
22
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_empty_value_rangeEv
Line
Count
Source
143
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_13PrimitiveTypeE9EE21set_empty_value_rangeEv
Line
Count
Source
143
27
    void set_empty_value_range() {
144
27
        _fixed_values.clear();
145
27
        _low_value = TYPE_MAX;
146
27
        _high_value = TYPE_MIN;
147
27
        _contain_null = false;
148
27
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21set_empty_value_rangeEv
Line
Count
Source
143
4
    void set_empty_value_range() {
144
4
        _fixed_values.clear();
145
4
        _low_value = TYPE_MAX;
146
4
        _high_value = TYPE_MIN;
147
4
        _contain_null = false;
148
4
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_empty_value_rangeEv
Line
Count
Source
143
289
    void set_empty_value_range() {
144
289
        _fixed_values.clear();
145
289
        _low_value = TYPE_MAX;
146
289
        _high_value = TYPE_MIN;
147
289
        _contain_null = false;
148
289
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_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_13PrimitiveTypeE11EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_empty_value_rangeEv
Line
Count
Source
143
72
    void set_empty_value_range() {
144
72
        _fixed_values.clear();
145
72
        _low_value = TYPE_MAX;
146
72
        _high_value = TYPE_MIN;
147
72
        _contain_null = false;
148
72
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_empty_value_rangeEv
Line
Count
Source
143
10
    void set_empty_value_range() {
144
10
        _fixed_values.clear();
145
10
        _low_value = TYPE_MAX;
146
10
        _high_value = TYPE_MIN;
147
10
        _contain_null = false;
148
10
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21set_empty_value_rangeEv
Line
Count
Source
143
18
    void set_empty_value_range() {
144
18
        _fixed_values.clear();
145
18
        _low_value = TYPE_MAX;
146
18
        _high_value = TYPE_MIN;
147
18
        _contain_null = false;
148
18
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_empty_value_rangeEv
Line
Count
Source
143
6
    void set_empty_value_range() {
144
6
        _fixed_values.clear();
145
6
        _low_value = TYPE_MAX;
146
6
        _high_value = TYPE_MIN;
147
6
        _contain_null = false;
148
6
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_empty_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_empty_value_rangeEv
Line
Count
Source
143
4
    void set_empty_value_range() {
144
4
        _fixed_values.clear();
145
4
        _low_value = TYPE_MAX;
146
4
        _high_value = TYPE_MIN;
147
4
        _contain_null = false;
148
4
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_empty_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_empty_value_rangeEv
Line
Count
Source
143
2
    void set_empty_value_range() {
144
2
        _fixed_values.clear();
145
2
        _low_value = TYPE_MAX;
146
2
        _high_value = TYPE_MIN;
147
2
        _contain_null = false;
148
2
    }
149
150
163k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_fixed_value_setEv
Line
Count
Source
150
11
    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
859
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_fixed_value_setEv
Line
Count
Source
150
140
    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
25
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_fixed_value_setB5cxx11Ev
Line
Count
Source
150
159k
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_fixed_value_setB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_fixed_value_setEv
Line
Count
Source
150
3
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_fixed_value_setEv
Line
Count
Source
150
322
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_fixed_value_setEv
Line
Count
Source
150
9
    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
189
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_fixed_value_setEv
Line
Count
Source
150
1
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_fixed_value_setEv
Line
Count
Source
150
7
    const SetType& get_fixed_value_set() const { return _fixed_values; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE19get_fixed_value_setEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE19get_fixed_value_setEv
Line
Count
Source
150
19
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_fixed_value_setEv
Line
Count
Source
150
20
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_fixed_value_setEv
Line
Count
Source
150
6
    const SetType& get_fixed_value_set() const { return _fixed_values; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_fixed_value_setEv
Line
Count
Source
150
18
    const SetType& get_fixed_value_set() const { return _fixed_values; }
151
152
449k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_max_valueEv
Line
Count
Source
152
1.99k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_max_valueEv
Line
Count
Source
152
482
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_max_valueEv
Line
Count
Source
152
126k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_max_valueEv
Line
Count
Source
152
162k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_max_valueEv
Line
Count
Source
152
7.96k
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE19get_range_max_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE19get_range_max_valueEv
Line
Count
Source
152
18
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE19get_range_max_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE19get_range_max_valueEv
Line
Count
Source
152
4
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
1.00k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_max_valueB5cxx11Ev
Line
Count
Source
152
123k
    CppType get_range_max_value() const { return _high_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_range_max_valueB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_range_max_valueEv
Line
Count
Source
152
6
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_max_valueEv
Line
Count
Source
152
3.06k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_max_valueEv
Line
Count
Source
152
41
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_max_valueEv
Line
Count
Source
152
4.81k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_max_valueEv
Line
Count
Source
152
8.25k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_max_valueEv
Line
Count
Source
152
315
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_max_valueEv
Line
Count
Source
152
3.04k
    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
849
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_max_valueEv
Line
Count
Source
152
1.14k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_max_valueEv
Line
Count
Source
152
3.25k
    CppType get_range_max_value() const { return _high_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_max_valueEv
Line
Count
Source
152
967
    CppType get_range_max_value() const { return _high_value; }
153
154
449k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE19get_range_min_valueEv
Line
Count
Source
154
2.00k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE19get_range_min_valueEv
Line
Count
Source
154
476
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE19get_range_min_valueEv
Line
Count
Source
154
126k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE19get_range_min_valueEv
Line
Count
Source
154
162k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE19get_range_min_valueEv
Line
Count
Source
154
7.97k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE19get_range_min_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE19get_range_min_valueEv
Line
Count
Source
154
18
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE19get_range_min_valueEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE19get_range_min_valueEv
Line
Count
Source
154
4
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
1.00k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE19get_range_min_valueB5cxx11Ev
Line
Count
Source
154
123k
    CppType get_range_min_value() const { return _low_value; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE19get_range_min_valueB5cxx11Ev
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE19get_range_min_valueEv
Line
Count
Source
154
6
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE19get_range_min_valueEv
Line
Count
Source
154
3.07k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE19get_range_min_valueEv
Line
Count
Source
154
42
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE19get_range_min_valueEv
Line
Count
Source
154
4.82k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE19get_range_min_valueEv
Line
Count
Source
154
8.24k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE19get_range_min_valueEv
Line
Count
Source
154
316
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE19get_range_min_valueEv
Line
Count
Source
154
3.05k
    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
850
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE19get_range_min_valueEv
Line
Count
Source
154
1.15k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE19get_range_min_valueEv
Line
Count
Source
154
3.24k
    CppType get_range_min_value() const { return _low_value; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE19get_range_min_valueEv
Line
Count
Source
154
949
    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
225k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16is_begin_includeEv
Line
Count
Source
168
1.93k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16is_begin_includeEv
Line
Count
Source
168
157
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16is_begin_includeEv
Line
Count
Source
168
62.1k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16is_begin_includeEv
Line
Count
Source
168
80.9k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16is_begin_includeEv
Line
Count
Source
168
3.91k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE16is_begin_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16is_begin_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE16is_begin_includeEv
Line
Count
Source
168
2
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE16is_begin_includeEv
Line
Count
Source
168
431
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16is_begin_includeEv
Line
Count
Source
168
61.5k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16is_begin_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16is_begin_includeEv
Line
Count
Source
168
6
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16is_begin_includeEv
Line
Count
Source
168
2.97k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16is_begin_includeEv
Line
Count
Source
168
20
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16is_begin_includeEv
Line
Count
Source
168
2.39k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16is_begin_includeEv
Line
Count
Source
168
4.18k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16is_begin_includeEv
Line
Count
Source
168
159
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16is_begin_includeEv
Line
Count
Source
168
1.52k
    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
424
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16is_begin_includeEv
Line
Count
Source
168
575
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16is_begin_includeEv
Line
Count
Source
168
1.61k
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16is_begin_includeEv
Line
Count
Source
168
487
    bool is_begin_include() const { return _low_op == FILTER_LARGER_OR_EQUAL; }
169
170
225k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14is_end_includeEv
Line
Count
Source
170
1.93k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14is_end_includeEv
Line
Count
Source
170
157
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14is_end_includeEv
Line
Count
Source
170
62.2k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14is_end_includeEv
Line
Count
Source
170
81.0k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE14is_end_includeEv
Line
Count
Source
170
3.94k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE14is_end_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14is_end_includeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14is_end_includeEv
Line
Count
Source
170
2
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14is_end_includeEv
Line
Count
Source
170
431
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14is_end_includeEv
Line
Count
Source
170
61.6k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14is_end_includeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14is_end_includeEv
Line
Count
Source
170
6
    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
20
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14is_end_includeEv
Line
Count
Source
170
2.39k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14is_end_includeEv
Line
Count
Source
170
4.18k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14is_end_includeEv
Line
Count
Source
170
161
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14is_end_includeEv
Line
Count
Source
170
1.52k
    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
424
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14is_end_includeEv
Line
Count
Source
170
574
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14is_end_includeEv
Line
Count
Source
170
1.62k
    bool is_end_include() const { return _high_op == FILTER_LESS_OR_EQUAL; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14is_end_includeEv
Line
Count
Source
170
487
    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
474k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12contain_nullEv
Line
Count
Source
176
2.56k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12contain_nullEv
Line
Count
Source
176
499
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12contain_nullEv
Line
Count
Source
176
69.0k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12contain_nullEv
Line
Count
Source
176
159k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12contain_nullEv
Line
Count
Source
176
4.22k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12contain_nullEv
Line
Count
Source
176
53
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12contain_nullEv
Line
Count
Source
176
149
    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
658
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12contain_nullEv
Line
Count
Source
176
222k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12contain_nullEv
Line
Count
Source
176
257
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12contain_nullEv
Line
Count
Source
176
9
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12contain_nullEv
Line
Count
Source
176
3.52k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12contain_nullEv
Line
Count
Source
176
30
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12contain_nullEv
Line
Count
Source
176
2.58k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12contain_nullEv
Line
Count
Source
176
4.56k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE12contain_nullEv
Line
Count
Source
176
159
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE12contain_nullEv
Line
Count
Source
176
1.57k
    bool contain_null() const { return _contain_null; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12contain_nullEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12contain_nullEv
Line
Count
Source
176
493
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12contain_nullEv
Line
Count
Source
176
618
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12contain_nullEv
Line
Count
Source
176
1.63k
    bool contain_null() const { return _contain_null; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12contain_nullEv
Line
Count
Source
176
533
    bool contain_null() const { return _contain_null; }
177
178
552k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20get_fixed_value_sizeEv
Line
Count
Source
178
2.01k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20get_fixed_value_sizeEv
Line
Count
Source
178
161
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20get_fixed_value_sizeEv
Line
Count
Source
178
67.6k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20get_fixed_value_sizeEv
Line
Count
Source
178
82.7k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20get_fixed_value_sizeEv
Line
Count
Source
178
4.27k
    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
482
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20get_fixed_value_sizeEv
Line
Count
Source
178
379k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20get_fixed_value_sizeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20get_fixed_value_sizeEv
Line
Count
Source
178
12
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20get_fixed_value_sizeEv
Line
Count
Source
178
3.63k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20get_fixed_value_sizeEv
Line
Count
Source
178
39
    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
4.50k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20get_fixed_value_sizeEv
Line
Count
Source
178
160
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.54k
    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
463
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20get_fixed_value_sizeEv
Line
Count
Source
178
622
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20get_fixed_value_sizeEv
Line
Count
Source
178
1.64k
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20get_fixed_value_sizeEv
Line
Count
Source
178
517
    size_t get_fixed_value_size() const { return _fixed_values.size(); }
179
180
994
    void set_whole_value_range() {
181
994
        _fixed_values.clear();
182
994
        _low_value = TYPE_MIN;
183
994
        _high_value = TYPE_MAX;
184
994
        _low_op = FILTER_LARGER_OR_EQUAL;
185
994
        _high_op = FILTER_LESS_OR_EQUAL;
186
994
        _contain_null = _is_nullable_col;
187
994
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21set_whole_value_rangeEv
Line
Count
Source
180
166
    void set_whole_value_range() {
181
166
        _fixed_values.clear();
182
166
        _low_value = TYPE_MIN;
183
166
        _high_value = TYPE_MAX;
184
166
        _low_op = FILTER_LARGER_OR_EQUAL;
185
166
        _high_op = FILTER_LESS_OR_EQUAL;
186
166
        _contain_null = _is_nullable_col;
187
166
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21set_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_13PrimitiveTypeE5EE21set_whole_value_rangeEv
Line
Count
Source
180
458
    void set_whole_value_range() {
181
458
        _fixed_values.clear();
182
458
        _low_value = TYPE_MIN;
183
458
        _high_value = TYPE_MAX;
184
458
        _low_op = FILTER_LARGER_OR_EQUAL;
185
458
        _high_op = FILTER_LESS_OR_EQUAL;
186
458
        _contain_null = _is_nullable_col;
187
458
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21set_whole_value_rangeEv
Line
Count
Source
180
21
    void set_whole_value_range() {
181
21
        _fixed_values.clear();
182
21
        _low_value = TYPE_MIN;
183
21
        _high_value = TYPE_MAX;
184
21
        _low_op = FILTER_LARGER_OR_EQUAL;
185
21
        _high_op = FILTER_LESS_OR_EQUAL;
186
21
        _contain_null = _is_nullable_col;
187
21
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21set_whole_value_rangeEv
Line
Count
Source
180
3
    void set_whole_value_range() {
181
3
        _fixed_values.clear();
182
3
        _low_value = TYPE_MIN;
183
3
        _high_value = TYPE_MAX;
184
3
        _low_op = FILTER_LARGER_OR_EQUAL;
185
3
        _high_op = FILTER_LESS_OR_EQUAL;
186
3
        _contain_null = _is_nullable_col;
187
3
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21set_whole_value_rangeEv
Line
Count
Source
180
11
    void set_whole_value_range() {
181
11
        _fixed_values.clear();
182
11
        _low_value = TYPE_MIN;
183
11
        _high_value = TYPE_MAX;
184
11
        _low_op = FILTER_LARGER_OR_EQUAL;
185
11
        _high_op = FILTER_LESS_OR_EQUAL;
186
11
        _contain_null = _is_nullable_col;
187
11
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21set_whole_value_rangeEv
Line
Count
Source
180
39
    void set_whole_value_range() {
181
39
        _fixed_values.clear();
182
39
        _low_value = TYPE_MIN;
183
39
        _high_value = TYPE_MAX;
184
39
        _low_op = FILTER_LARGER_OR_EQUAL;
185
39
        _high_op = FILTER_LESS_OR_EQUAL;
186
39
        _contain_null = _is_nullable_col;
187
39
    }
_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
16
    void set_whole_value_range() {
181
16
        _fixed_values.clear();
182
16
        _low_value = TYPE_MIN;
183
16
        _high_value = TYPE_MAX;
184
16
        _low_op = FILTER_LARGER_OR_EQUAL;
185
16
        _high_op = FILTER_LESS_OR_EQUAL;
186
16
        _contain_null = _is_nullable_col;
187
16
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21set_whole_value_rangeEv
Line
Count
Source
180
26
    void set_whole_value_range() {
181
26
        _fixed_values.clear();
182
26
        _low_value = TYPE_MIN;
183
26
        _high_value = TYPE_MAX;
184
26
        _low_op = FILTER_LARGER_OR_EQUAL;
185
26
        _high_op = FILTER_LESS_OR_EQUAL;
186
26
        _contain_null = _is_nullable_col;
187
26
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21set_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_13PrimitiveTypeE11EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21set_whole_value_rangeEv
Line
Count
Source
180
38
    void set_whole_value_range() {
181
38
        _fixed_values.clear();
182
38
        _low_value = TYPE_MIN;
183
38
        _high_value = TYPE_MAX;
184
38
        _low_op = FILTER_LARGER_OR_EQUAL;
185
38
        _high_op = FILTER_LESS_OR_EQUAL;
186
38
        _contain_null = _is_nullable_col;
187
38
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21set_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_13PrimitiveTypeE42EE21set_whole_value_rangeEv
Line
Count
Source
180
72
    void set_whole_value_range() {
181
72
        _fixed_values.clear();
182
72
        _low_value = TYPE_MIN;
183
72
        _high_value = TYPE_MAX;
184
72
        _low_op = FILTER_LARGER_OR_EQUAL;
185
72
        _high_op = FILTER_LESS_OR_EQUAL;
186
72
        _contain_null = _is_nullable_col;
187
72
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE21set_whole_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE21set_whole_value_rangeEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21set_whole_value_rangeEv
Line
Count
Source
180
25
    void set_whole_value_range() {
181
25
        _fixed_values.clear();
182
25
        _low_value = TYPE_MIN;
183
25
        _high_value = TYPE_MAX;
184
25
        _low_op = FILTER_LARGER_OR_EQUAL;
185
25
        _high_op = FILTER_LESS_OR_EQUAL;
186
25
        _contain_null = _is_nullable_col;
187
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21set_whole_value_rangeEv
Line
Count
Source
180
2
    void set_whole_value_range() {
181
2
        _fixed_values.clear();
182
2
        _low_value = TYPE_MIN;
183
2
        _high_value = TYPE_MAX;
184
2
        _low_op = FILTER_LARGER_OR_EQUAL;
185
2
        _high_op = FILTER_LESS_OR_EQUAL;
186
2
        _contain_null = _is_nullable_col;
187
2
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21set_whole_value_rangeEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21set_whole_value_rangeEv
Line
Count
Source
180
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
612
    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
613
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
612
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
612
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
612
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_whole_value_rangeEv
Line
Count
Source
189
2
    bool is_whole_value_range() const {
190
2
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
2
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
2
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
2
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
2
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_whole_value_rangeEv
Line
Count
Source
189
117
    bool is_whole_value_range() const {
190
117
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
117
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
117
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
117
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
117
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_whole_value_rangeEv
Line
Count
Source
189
21
    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
21
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
21
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
21
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
21
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_whole_value_rangeEv
Line
Count
Source
189
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_13PrimitiveTypeE9EE20is_whole_value_rangeEv
Line
Count
Source
189
27
    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
27
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
27
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
27
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
27
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_whole_value_rangeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_whole_value_rangeEv
Line
Count
Source
189
4
    bool is_whole_value_range() const {
190
4
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
4
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
4
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
4
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
4
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_whole_value_rangeEv
Line
Count
Source
189
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
    }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_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_13PrimitiveTypeE11EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_whole_value_rangeEv
Line
Count
Source
189
61
    bool is_whole_value_range() const {
190
61
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
62
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
61
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
61
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
61
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_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_13PrimitiveTypeE42EE20is_whole_value_rangeEv
Line
Count
Source
189
18
    bool is_whole_value_range() const {
190
18
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
18
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
18
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
18
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
18
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_whole_value_rangeEv
Line
Count
Source
189
6
    bool is_whole_value_range() const {
190
6
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
6
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
6
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
6
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
6
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_whole_value_rangeEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_whole_value_rangeEv
Line
Count
Source
189
4
    bool is_whole_value_range() const {
190
4
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
4
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
4
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
4
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
4
    }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_whole_value_rangeEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_whole_value_rangeEv
Line
Count
Source
189
2
    bool is_whole_value_range() const {
190
2
        DCHECK(_is_nullable_col || !contain_null())
191
0
                << "Non-nullable column cannot contains null value";
192
193
2
        return _fixed_values.empty() && Compare::equal(_low_value, TYPE_MIN) &&
194
2
               Compare::equal(_high_value, TYPE_MAX) && _low_op == FILTER_LARGER_OR_EQUAL &&
195
2
               _high_op == FILTER_LESS_OR_EQUAL && _is_nullable_col == contain_null();
196
2
    }
197
198
    // only two case will set range contain null, call by temp_range in olap scan node
199
    // 'is null' and 'is not null'
200
    // 1. if the pred is 'is null' means the range should be
201
    // empty in fixed_range and _high_value < _low_value
202
    // 2. if the pred is 'is not null' means the range should be whole range and
203
    // 'is not null' be effective
204
1.61k
    void set_contain_null(bool contain_null) {
205
1.61k
        if (contain_null) {
206
623
            set_empty_value_range();
207
991
        } else {
208
991
            set_whole_value_range();
209
991
        }
210
1.61k
        _contain_null = _is_nullable_col && contain_null;
211
1.61k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE16set_contain_nullEb
Line
Count
Source
204
166
    void set_contain_null(bool contain_null) {
205
166
        if (contain_null) {
206
0
            set_empty_value_range();
207
166
        } else {
208
166
            set_whole_value_range();
209
166
        }
210
166
        _contain_null = _is_nullable_col && contain_null;
211
166
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE16set_contain_nullEb
Line
Count
Source
204
29
    void set_contain_null(bool contain_null) {
205
29
        if (contain_null) {
206
2
            set_empty_value_range();
207
27
        } else {
208
27
            set_whole_value_range();
209
27
        }
210
29
        _contain_null = _is_nullable_col && contain_null;
211
29
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE16set_contain_nullEb
Line
Count
Source
204
578
    void set_contain_null(bool contain_null) {
205
578
        if (contain_null) {
206
121
            set_empty_value_range();
207
457
        } else {
208
457
            set_whole_value_range();
209
457
        }
210
578
        _contain_null = _is_nullable_col && contain_null;
211
578
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE16set_contain_nullEb
Line
Count
Source
204
22
    void set_contain_null(bool contain_null) {
205
22
        if (contain_null) {
206
1
            set_empty_value_range();
207
21
        } else {
208
21
            set_whole_value_range();
209
21
        }
210
22
        _contain_null = _is_nullable_col && contain_null;
211
22
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE16set_contain_nullEb
Line
Count
Source
204
25
    void set_contain_null(bool contain_null) {
205
25
        if (contain_null) {
206
22
            set_empty_value_range();
207
22
        } else {
208
3
            set_whole_value_range();
209
3
        }
210
25
        _contain_null = _is_nullable_col && contain_null;
211
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE16set_contain_nullEb
Line
Count
Source
204
25
    void set_contain_null(bool contain_null) {
205
25
        if (contain_null) {
206
14
            set_empty_value_range();
207
14
        } else {
208
11
            set_whole_value_range();
209
11
        }
210
25
        _contain_null = _is_nullable_col && contain_null;
211
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE16set_contain_nullEb
Line
Count
Source
204
65
    void set_contain_null(bool contain_null) {
205
65
        if (contain_null) {
206
27
            set_empty_value_range();
207
38
        } else {
208
38
            set_whole_value_range();
209
38
        }
210
65
        _contain_null = _is_nullable_col && contain_null;
211
65
    }
_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
20
    void set_contain_null(bool contain_null) {
205
20
        if (contain_null) {
206
4
            set_empty_value_range();
207
16
        } else {
208
16
            set_whole_value_range();
209
16
        }
210
20
        _contain_null = _is_nullable_col && contain_null;
211
20
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE16set_contain_nullEb
Line
Count
Source
204
288
    void set_contain_null(bool contain_null) {
205
288
        if (contain_null) {
206
262
            set_empty_value_range();
207
262
        } else {
208
26
            set_whole_value_range();
209
26
        }
210
288
        _contain_null = _is_nullable_col && contain_null;
211
288
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE16set_contain_nullEb
Line
Count
Source
204
102
    void set_contain_null(bool contain_null) {
205
102
        if (contain_null) {
206
66
            set_empty_value_range();
207
66
        } else {
208
36
            set_whole_value_range();
209
36
        }
210
103
        _contain_null = _is_nullable_col && contain_null;
211
102
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE16set_contain_nullEb
Line
Count
Source
204
97
    void set_contain_null(bool contain_null) {
205
97
        if (contain_null) {
206
64
            set_empty_value_range();
207
64
        } else {
208
33
            set_whole_value_range();
209
33
        }
210
99
        _contain_null = _is_nullable_col && contain_null;
211
97
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE16set_contain_nullEb
Line
Count
Source
204
52
    void set_contain_null(bool contain_null) {
205
52
        if (contain_null) {
206
10
            set_empty_value_range();
207
42
        } else {
208
42
            set_whole_value_range();
209
42
        }
210
52
        _contain_null = _is_nullable_col && contain_null;
211
52
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE16set_contain_nullEb
Line
Count
Source
204
91
    void set_contain_null(bool contain_null) {
205
91
        if (contain_null) {
206
18
            set_empty_value_range();
207
73
        } else {
208
73
            set_whole_value_range();
209
73
        }
210
91
        _contain_null = _is_nullable_col && contain_null;
211
91
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE16set_contain_nullEb
Line
Count
Source
204
6
    void set_contain_null(bool contain_null) {
205
6
        if (contain_null) {
206
6
            set_empty_value_range();
207
6
        } else {
208
0
            set_whole_value_range();
209
0
        }
210
6
        _contain_null = _is_nullable_col && contain_null;
211
6
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE16set_contain_nullEb
Line
Count
Source
204
25
    void set_contain_null(bool contain_null) {
205
25
        if (contain_null) {
206
0
            set_empty_value_range();
207
25
        } else {
208
25
            set_whole_value_range();
209
25
        }
210
25
        _contain_null = _is_nullable_col && contain_null;
211
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE16set_contain_nullEb
Line
Count
Source
204
6
    void set_contain_null(bool contain_null) {
205
6
        if (contain_null) {
206
4
            set_empty_value_range();
207
4
        } else {
208
2
            set_whole_value_range();
209
2
        }
210
6
        _contain_null = _is_nullable_col && contain_null;
211
6
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE16set_contain_nullEb
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE16set_contain_nullEb
Line
Count
Source
204
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
394k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9precisionEv
Line
Count
Source
213
81.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9precisionEv
Line
Count
Source
213
1.58k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9precisionEv
Line
Count
Source
213
14.5k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9precisionEv
Line
Count
Source
213
89.9k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9precisionEv
Line
Count
Source
213
452
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9precisionEv
Line
Count
Source
213
146
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9precisionEv
Line
Count
Source
213
407
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9precisionEv
Line
Count
Source
213
28
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9precisionEv
Line
Count
Source
213
28
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9precisionEv
Line
Count
Source
213
1.08k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9precisionEv
Line
Count
Source
213
169k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9precisionEv
Line
Count
Source
213
611
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9precisionEv
Line
Count
Source
213
42
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9precisionEv
Line
Count
Source
213
28.7k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9precisionEv
Line
Count
Source
213
59
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9precisionEv
Line
Count
Source
213
3.49k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9precisionEv
Line
Count
Source
213
1.48k
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9precisionEv
Line
Count
Source
213
1
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9precisionEv
Line
Count
Source
213
198
    int precision() const { return _precision; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9precisionEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9precisionEv
Line
Count
Source
213
212
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9precisionEv
Line
Count
Source
213
357
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9precisionEv
Line
Count
Source
213
219
    int precision() const { return _precision; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE9precisionEv
Line
Count
Source
213
161
    int precision() const { return _precision; }
214
215
1.64M
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE5scaleEv
Line
Count
Source
215
247k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE5scaleEv
Line
Count
Source
215
11.6k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE5scaleEv
Line
Count
Source
215
168k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE5scaleEv
Line
Count
Source
215
257k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE5scaleEv
Line
Count
Source
215
8.74k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE5scaleEv
Line
Count
Source
215
147
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE5scaleEv
Line
Count
Source
215
407
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE5scaleEv
Line
Count
Source
215
28
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE5scaleEv
Line
Count
Source
215
32
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE5scaleEv
Line
Count
Source
215
2.36k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE5scaleEv
Line
Count
Source
215
610k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE5scaleEv
Line
Count
Source
215
614
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE5scaleEv
Line
Count
Source
215
632
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE5scaleEv
Line
Count
Source
215
301k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE5scaleEv
Line
Count
Source
215
145
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE5scaleEv
Line
Count
Source
215
8.46k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE5scaleEv
Line
Count
Source
215
10.4k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE5scaleEv
Line
Count
Source
215
323
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE5scaleEv
Line
Count
Source
215
3.33k
    int scale() const { return _scale; }
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE5scaleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE5scaleEv
Line
Count
Source
215
1.10k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE5scaleEv
Line
Count
Source
215
1.57k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE5scaleEv
Line
Count
Source
215
3.48k
    int scale() const { return _scale; }
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE5scaleEv
Line
Count
Source
215
1.18k
    int scale() const { return _scale; }
216
217
    static void add_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
218
304k
                                      const CppType& value) {
219
304k
        static_cast<void>(range.add_fixed_value(value));
220
304k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
218
79.0k
                                      const CppType& value) {
219
79.0k
        static_cast<void>(range.add_fixed_value(value));
220
79.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
218
182
                                      const CppType& value) {
219
182
        static_cast<void>(range.add_fixed_value(value));
220
182
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
218
44.1k
                                      const CppType& value) {
219
44.1k
        static_cast<void>(range.add_fixed_value(value));
220
44.1k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
218
698
                                      const CppType& value) {
219
698
        static_cast<void>(range.add_fixed_value(value));
220
698
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
218
195
                                      const CppType& value) {
219
195
        static_cast<void>(range.add_fixed_value(value));
220
195
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
218
23
                                      const CppType& value) {
219
23
        static_cast<void>(range.add_fixed_value(value));
220
23
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
218
129
                                      const CppType& value) {
219
129
        static_cast<void>(range.add_fixed_value(value));
220
129
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
218
23
                                      const CppType& value) {
219
23
        static_cast<void>(range.add_fixed_value(value));
220
23
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
218
25
                                      const CppType& value) {
219
25
        static_cast<void>(range.add_fixed_value(value));
220
25
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
855
                                      const CppType& value) {
219
855
        static_cast<void>(range.add_fixed_value(value));
220
855
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
167k
                                      const CppType& value) {
219
167k
        static_cast<void>(range.add_fixed_value(value));
220
167k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
218
343
                                      const CppType& value) {
219
343
        static_cast<void>(range.add_fixed_value(value));
220
343
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
52
                                      const CppType& value) {
219
52
        static_cast<void>(range.add_fixed_value(value));
220
52
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
218
9.20k
                                      const CppType& value) {
219
9.20k
        static_cast<void>(range.add_fixed_value(value));
220
9.20k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
218
69
                                      const CppType& value) {
219
69
        static_cast<void>(range.add_fixed_value(value));
220
69
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
218
402
                                      const CppType& value) {
219
402
        static_cast<void>(range.add_fixed_value(value));
220
402
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
218
248
                                      const CppType& value) {
219
248
        static_cast<void>(range.add_fixed_value(value));
220
248
    }
_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
193
                                      const CppType& value) {
219
193
        static_cast<void>(range.add_fixed_value(value));
220
193
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
218
41
                                      const CppType& value) {
219
41
        static_cast<void>(range.add_fixed_value(value));
220
41
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
218
288
                                      const CppType& value) {
219
288
        static_cast<void>(range.add_fixed_value(value));
220
288
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
218
118
                                      const CppType& value) {
219
118
        static_cast<void>(range.add_fixed_value(value));
220
118
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE21add_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
218
47
                                      const CppType& value) {
219
47
        static_cast<void>(range.add_fixed_value(value));
220
47
    }
221
222
    static void remove_fixed_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
223
3
                                         const CppType& value) {
224
3
        range.remove_fixed_value(value);
225
3
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKa
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKs
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKi
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
223
3
                                         const CppType& value) {
224
3
        range.remove_fixed_value(value);
225
3
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKn
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKf
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKd
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKj
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKo
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE24remove_fixed_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
226
227
    static void empty_function(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
228
2.38k
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE14empty_functionERS2_NS_11SQLFilterOpERKa
Line
Count
Source
228
70
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE14empty_functionERS2_NS_11SQLFilterOpERKs
Line
Count
Source
228
47
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE14empty_functionERS2_NS_11SQLFilterOpERKi
Line
Count
Source
228
657
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE14empty_functionERS2_NS_11SQLFilterOpERKl
Line
Count
Source
228
39
                               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
60
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE14empty_functionERS2_NS_11SQLFilterOpERKd
Line
Count
Source
228
124
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE14empty_functionERS2_NS_11SQLFilterOpERKj
Line
Count
Source
228
6
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE14empty_functionERS2_NS_11SQLFilterOpERKo
Line
Count
Source
228
6
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
81
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
290
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE14empty_functionERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
228
100
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
41
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
228
19
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
Line
Count
Source
228
45
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE14empty_functionERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
228
99
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE14empty_functionERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
228
566
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE14empty_functionERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE14empty_functionERS2_NS_11SQLFilterOpERKh
Line
Count
Source
228
10
                               const CppType& value) {}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE14empty_functionERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
228
47
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
228
10
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE14empty_functionERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
228
11
                               const CppType& value) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE14empty_functionERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
228
58
                               const CppType& value) {}
229
230
    static void add_value_range(ColumnValueRange<primitive_type>& range, SQLFilterOp op,
231
105k
                                const CppType& value) {
232
105k
        static_cast<void>(range.add_range(op, value));
233
105k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_value_rangeERS2_NS_11SQLFilterOpERKa
Line
Count
Source
231
1.84k
                                const CppType& value) {
232
1.84k
        static_cast<void>(range.add_range(op, value));
233
1.84k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_value_rangeERS2_NS_11SQLFilterOpERKs
Line
Count
Source
231
1.41k
                                const CppType& value) {
232
1.41k
        static_cast<void>(range.add_range(op, value));
233
1.41k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_value_rangeERS2_NS_11SQLFilterOpERKi
Line
Count
Source
231
8.40k
                                const CppType& value) {
232
8.40k
        static_cast<void>(range.add_range(op, value));
233
8.40k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_value_rangeERS2_NS_11SQLFilterOpERKl
Line
Count
Source
231
67.6k
                                const CppType& value) {
232
67.6k
        static_cast<void>(range.add_range(op, value));
233
67.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_value_rangeERS2_NS_11SQLFilterOpERKn
Line
Count
Source
231
260
                                const CppType& value) {
232
260
        static_cast<void>(range.add_range(op, value));
233
260
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_value_rangeERS2_NS_11SQLFilterOpERKf
Line
Count
Source
231
50
                                const CppType& value) {
232
50
        static_cast<void>(range.add_range(op, value));
233
50
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_value_rangeERS2_NS_11SQLFilterOpERKd
Line
Count
Source
231
172
                                const CppType& value) {
232
172
        static_cast<void>(range.add_range(op, value));
233
172
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_value_rangeERS2_NS_11SQLFilterOpERKj
Line
Count
Source
231
4
                                const CppType& value) {
232
4
        static_cast<void>(range.add_range(op, value));
233
4
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_value_rangeERS2_NS_11SQLFilterOpERKo
Line
Count
Source
231
4
                                const CppType& value) {
232
4
        static_cast<void>(range.add_range(op, value));
233
4
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
523
                                const CppType& value) {
232
523
        static_cast<void>(range.add_range(op, value));
233
523
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
1.29k
                                const CppType& value) {
232
1.29k
        static_cast<void>(range.add_range(op, value));
233
1.29k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_value_rangeERS2_NS_11SQLFilterOpERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
231
144
                                const CppType& value) {
232
144
        static_cast<void>(range.add_range(op, value));
233
144
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
231
19.5k
                                const CppType& value) {
232
19.5k
        static_cast<void>(range.add_range(op, value));
233
19.5k
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
231
2.93k
                                const CppType& value) {
232
2.93k
        static_cast<void>(range.add_range(op, value));
233
2.93k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_16TimestampTzValueE
Line
Count
Source
231
958
                                const CppType& value) {
232
958
        static_cast<void>(range.add_range(op, value));
233
958
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE15add_value_rangeERS2_NS_11SQLFilterOpERKh
Line
Count
Source
231
2
                                const CppType& value) {
232
2
        static_cast<void>(range.add_range(op, value));
233
2
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIiEE
Line
Count
Source
231
106
                                const CppType& value) {
232
106
        static_cast<void>(range.add_range(op, value));
233
106
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIlEE
Line
Count
Source
231
88
                                const CppType& value) {
232
88
        static_cast<void>(range.add_range(op, value));
233
88
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_12Decimal128V3E
Line
Count
Source
231
96
                                const CppType& value) {
232
96
        static_cast<void>(range.add_range(op, value));
233
96
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_value_rangeERS2_NS_11SQLFilterOpERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
231
75
                                const CppType& value) {
232
75
        static_cast<void>(range.add_range(op, value));
233
75
    }
234
235
    static ColumnValueRange<primitive_type> create_empty_column_value_range(bool is_nullable_col,
236
                                                                            int precision,
237
392k
                                                                            int scale) {
238
392k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
392k
                                                precision, scale);
240
392k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
81.0k
                                                                            int scale) {
238
81.0k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
81.0k
                                                precision, scale);
240
81.0k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.56k
                                                                            int scale) {
238
1.56k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.56k
                                                precision, scale);
240
1.56k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
14.4k
                                                                            int scale) {
238
14.4k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
14.4k
                                                precision, scale);
240
14.4k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
89.7k
                                                                            int scale) {
238
89.7k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
89.7k
                                                precision, scale);
240
89.7k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
447
                                                                            int scale) {
238
447
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
447
                                                precision, scale);
240
447
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
141
                                                                            int scale) {
238
141
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
141
                                                precision, scale);
240
141
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
394
                                                                            int scale) {
238
394
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
394
                                                precision, scale);
240
394
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
28
                                                                            int scale) {
238
28
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
28
                                                precision, scale);
240
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
28
                                                                            int scale) {
238
28
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
28
                                                precision, scale);
240
28
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.07k
                                                                            int scale) {
238
1.07k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.07k
                                                precision, scale);
240
1.07k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
168k
                                                                            int scale) {
238
168k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
168k
                                                precision, scale);
240
168k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
611
                                                                            int scale) {
238
611
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
611
                                                precision, scale);
240
611
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE31create_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_13PrimitiveTypeE25EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
28.6k
                                                                            int scale) {
238
28.6k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
28.6k
                                                precision, scale);
240
28.6k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
57
                                                                            int scale) {
238
57
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
57
                                                precision, scale);
240
57
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
3.45k
                                                                            int scale) {
238
3.45k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
3.45k
                                                precision, scale);
240
3.45k
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
1.47k
                                                                            int scale) {
238
1.47k
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
1.47k
                                                precision, scale);
240
1.47k
    }
_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
196
                                                                            int scale) {
238
196
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
196
                                                precision, scale);
240
196
    }
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE31create_empty_column_value_rangeEbii
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
205
                                                                            int scale) {
238
205
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
205
                                                precision, scale);
240
205
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
352
                                                                            int scale) {
238
352
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
352
                                                precision, scale);
240
352
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
215
                                                                            int scale) {
238
215
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
215
                                                precision, scale);
240
215
    }
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE31create_empty_column_value_rangeEbii
Line
Count
Source
237
157
                                                                            int scale) {
238
157
        return ColumnValueRange<primitive_type>("", TYPE_MAX, TYPE_MIN, is_nullable_col, false,
239
157
                                                precision, scale);
240
157
    }
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
608k
    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.77k
    std::string debug_string() {
310
1.77k
        std::stringstream ss;
311
1.77k
        DCHECK(_begin_scan_keys.size() == _end_scan_keys.size());
312
1.77k
        ss << "ScanKeys:";
313
314
13.9k
        for (int i = 0; i < _begin_scan_keys.size(); ++i) {
315
18.4E
            ss << "ScanKey=" << (_begin_include ? "[" : "(") << _begin_scan_keys[i] << " : "
316
18.4E
               << _end_scan_keys[i] << (_end_include ? "]" : ")");
317
12.1k
        }
318
1.77k
        return ss.str();
319
1.77k
    }
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
276k
    void set_is_convertible(bool is_convertible) { _is_convertible = is_convertible; }
327
328
private:
329
    std::vector<OlapTuple> _begin_scan_keys;
330
    std::vector<OlapTuple> _end_scan_keys;
331
    bool _has_range_value = false;
332
    bool _begin_include = false;
333
    bool _end_include = false;
334
    bool _is_convertible = false;
335
};
336
337
using ColumnValueRangeType = std::variant<
338
        ColumnValueRange<TYPE_TINYINT>, ColumnValueRange<TYPE_SMALLINT>, ColumnValueRange<TYPE_INT>,
339
        ColumnValueRange<TYPE_BIGINT>, ColumnValueRange<TYPE_LARGEINT>,
340
        ColumnValueRange<TYPE_FLOAT>, ColumnValueRange<TYPE_DOUBLE>, ColumnValueRange<TYPE_IPV4>,
341
        ColumnValueRange<TYPE_IPV6>, ColumnValueRange<TYPE_CHAR>, ColumnValueRange<TYPE_VARCHAR>,
342
        ColumnValueRange<TYPE_STRING>, ColumnValueRange<TYPE_DATE>, ColumnValueRange<TYPE_DATEV2>,
343
        ColumnValueRange<TYPE_DATETIME>, ColumnValueRange<TYPE_DATETIMEV2>,
344
        ColumnValueRange<TYPE_TIMESTAMPTZ>, ColumnValueRange<TYPE_DECIMALV2>,
345
        ColumnValueRange<TYPE_BOOLEAN>, ColumnValueRange<TYPE_HLL>,
346
        ColumnValueRange<TYPE_DECIMAL32>, ColumnValueRange<TYPE_DECIMAL64>,
347
        ColumnValueRange<TYPE_DECIMAL128I>, ColumnValueRange<TYPE_DECIMAL256>>;
348
349
template <PrimitiveType primitive_type>
350
const typename ColumnValueRange<primitive_type>::CppType
351
        ColumnValueRange<primitive_type>::TYPE_MIN =
352
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::min();
353
template <PrimitiveType primitive_type>
354
const typename ColumnValueRange<primitive_type>::CppType
355
        ColumnValueRange<primitive_type>::TYPE_MAX =
356
                type_limit<typename ColumnValueRange<primitive_type>::CppType>::max();
357
358
template <PrimitiveType primitive_type>
359
ColumnValueRange<primitive_type>::ColumnValueRange()
360
1.58M
        : _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
1.97M
        : _column_name(std::move(col_name)),
381
1.97M
          _column_type(primitive_type),
382
1.07M
          _low_value(min),
383
1.07M
          _high_value(max),
384
1.97M
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.97M
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.97M
          _is_nullable_col(is_nullable_col),
387
1.97M
          _contain_null(is_nullable_col && contain_null),
388
1.97M
          _precision(precision),
389
1.97M
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKaSA_bbii
Line
Count
Source
380
178k
        : _column_name(std::move(col_name)),
381
178k
          _column_type(primitive_type),
382
178k
          _low_value(min),
383
178k
          _high_value(max),
384
178k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
178k
          _high_op(FILTER_LESS_OR_EQUAL),
386
178k
          _is_nullable_col(is_nullable_col),
387
178k
          _contain_null(is_nullable_col && contain_null),
388
178k
          _precision(precision),
389
178k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKsSA_bbii
Line
Count
Source
380
16.0k
        : _column_name(std::move(col_name)),
381
16.0k
          _column_type(primitive_type),
382
16.0k
          _low_value(min),
383
16.0k
          _high_value(max),
384
16.0k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
16.0k
          _high_op(FILTER_LESS_OR_EQUAL),
386
16.0k
          _is_nullable_col(is_nullable_col),
387
16.0k
          _contain_null(is_nullable_col && contain_null),
388
16.0k
          _precision(precision),
389
16.0k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKiSA_bbii
Line
Count
Source
380
228k
        : _column_name(std::move(col_name)),
381
228k
          _column_type(primitive_type),
382
228k
          _low_value(min),
383
228k
          _high_value(max),
384
228k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
228k
          _high_op(FILTER_LESS_OR_EQUAL),
386
228k
          _is_nullable_col(is_nullable_col),
387
228k
          _contain_null(is_nullable_col && contain_null),
388
228k
          _precision(precision),
389
228k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKlSA_bbii
Line
Count
Source
380
447k
        : _column_name(std::move(col_name)),
381
447k
          _column_type(primitive_type),
382
447k
          _low_value(min),
383
447k
          _high_value(max),
384
447k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
447k
          _high_op(FILTER_LESS_OR_EQUAL),
386
447k
          _is_nullable_col(is_nullable_col),
387
447k
          _contain_null(is_nullable_col && contain_null),
388
447k
          _precision(precision),
389
447k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKnSA_bbii
Line
Count
Source
380
10.5k
        : _column_name(std::move(col_name)),
381
10.5k
          _column_type(primitive_type),
382
10.5k
          _low_value(min),
383
10.5k
          _high_value(max),
384
10.5k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
10.5k
          _high_op(FILTER_LESS_OR_EQUAL),
386
10.5k
          _is_nullable_col(is_nullable_col),
387
10.5k
          _contain_null(is_nullable_col && contain_null),
388
10.5k
          _precision(precision),
389
10.5k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKfSA_bbii
Line
Count
Source
380
7.74k
        : _column_name(std::move(col_name)),
381
7.74k
          _column_type(primitive_type),
382
7.74k
          _low_value(min),
383
7.74k
          _high_value(max),
384
7.74k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
7.74k
          _high_op(FILTER_LESS_OR_EQUAL),
386
7.74k
          _is_nullable_col(is_nullable_col),
387
7.74k
          _contain_null(is_nullable_col && contain_null),
388
7.74k
          _precision(precision),
389
7.74k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKdSA_bbii
Line
Count
Source
380
10.7k
        : _column_name(std::move(col_name)),
381
10.7k
          _column_type(primitive_type),
382
10.7k
          _low_value(min),
383
10.7k
          _high_value(max),
384
10.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
10.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
10.7k
          _is_nullable_col(is_nullable_col),
387
10.7k
          _contain_null(is_nullable_col && contain_null),
388
10.7k
          _precision(precision),
389
10.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKjSA_bbii
Line
Count
Source
380
487
        : _column_name(std::move(col_name)),
381
487
          _column_type(primitive_type),
382
487
          _low_value(min),
383
487
          _high_value(max),
384
487
          _low_op(FILTER_LARGER_OR_EQUAL),
385
487
          _high_op(FILTER_LESS_OR_EQUAL),
386
487
          _is_nullable_col(is_nullable_col),
387
487
          _contain_null(is_nullable_col && contain_null),
388
487
          _precision(precision),
389
487
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKoSA_bbii
Line
Count
Source
380
524
        : _column_name(std::move(col_name)),
381
524
          _column_type(primitive_type),
382
524
          _low_value(min),
383
524
          _high_value(max),
384
524
          _low_op(FILTER_LARGER_OR_EQUAL),
385
524
          _high_op(FILTER_LESS_OR_EQUAL),
386
524
          _is_nullable_col(is_nullable_col),
387
524
          _contain_null(is_nullable_col && contain_null),
388
524
          _precision(precision),
389
524
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
13.4k
        : _column_name(std::move(col_name)),
381
13.4k
          _column_type(primitive_type),
382
13.4k
          _low_value(min),
383
13.4k
          _high_value(max),
384
13.4k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
13.4k
          _high_op(FILTER_LESS_OR_EQUAL),
386
13.4k
          _is_nullable_col(is_nullable_col),
387
13.4k
          _contain_null(is_nullable_col && contain_null),
388
13.4k
          _precision(precision),
389
13.4k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
720k
        : _column_name(std::move(col_name)),
381
720k
          _column_type(primitive_type),
382
720k
          _low_value(min),
383
720k
          _high_value(max),
384
720k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
720k
          _high_op(FILTER_LESS_OR_EQUAL),
386
720k
          _is_nullable_col(is_nullable_col),
387
720k
          _contain_null(is_nullable_col && contain_null),
388
720k
          _precision(precision),
389
720k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS8_SA_bbii
Line
Count
Source
380
77.8k
        : _column_name(std::move(col_name)),
381
77.8k
          _column_type(primitive_type),
382
77.8k
          _low_value(min),
383
77.8k
          _high_value(max),
384
77.8k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
77.8k
          _high_op(FILTER_LESS_OR_EQUAL),
386
77.8k
          _is_nullable_col(is_nullable_col),
387
77.8k
          _contain_null(is_nullable_col && contain_null),
388
77.8k
          _precision(precision),
389
77.8k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
548
        : _column_name(std::move(col_name)),
381
548
          _column_type(primitive_type),
382
548
          _low_value(min),
383
548
          _high_value(max),
384
548
          _low_op(FILTER_LARGER_OR_EQUAL),
385
548
          _high_op(FILTER_LESS_OR_EQUAL),
386
548
          _is_nullable_col(is_nullable_col),
387
548
          _contain_null(is_nullable_col && contain_null),
388
548
          _precision(precision),
389
548
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_15DateV2ValueTypeEEESD_bbii
Line
Count
Source
380
120k
        : _column_name(std::move(col_name)),
381
120k
          _column_type(primitive_type),
382
120k
          _low_value(min),
383
120k
          _high_value(max),
384
120k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
120k
          _high_op(FILTER_LESS_OR_EQUAL),
386
120k
          _is_nullable_col(is_nullable_col),
387
120k
          _contain_null(is_nullable_col && contain_null),
388
120k
          _precision(precision),
389
120k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16VecDateTimeValueESB_bbii
Line
Count
Source
380
577
        : _column_name(std::move(col_name)),
381
577
          _column_type(primitive_type),
382
577
          _low_value(min),
383
577
          _high_value(max),
384
577
          _low_op(FILTER_LARGER_OR_EQUAL),
385
577
          _high_op(FILTER_LESS_OR_EQUAL),
386
577
          _is_nullable_col(is_nullable_col),
387
577
          _contain_null(is_nullable_col && contain_null),
388
577
          _precision(precision),
389
577
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEESD_bbii
Line
Count
Source
380
80.3k
        : _column_name(std::move(col_name)),
381
80.3k
          _column_type(primitive_type),
382
80.3k
          _low_value(min),
383
80.3k
          _high_value(max),
384
80.3k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
80.3k
          _high_op(FILTER_LESS_OR_EQUAL),
386
80.3k
          _is_nullable_col(is_nullable_col),
387
80.3k
          _contain_null(is_nullable_col && contain_null),
388
80.3k
          _precision(precision),
389
80.3k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_16TimestampTzValueESB_bbii
Line
Count
Source
380
12.7k
        : _column_name(std::move(col_name)),
381
12.7k
          _column_type(primitive_type),
382
12.7k
          _low_value(min),
383
12.7k
          _high_value(max),
384
12.7k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
12.7k
          _high_op(FILTER_LESS_OR_EQUAL),
386
12.7k
          _is_nullable_col(is_nullable_col),
387
12.7k
          _contain_null(is_nullable_col && contain_null),
388
12.7k
          _precision(precision),
389
12.7k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_14DecimalV2ValueESB_bbii
Line
Count
Source
380
559
        : _column_name(std::move(col_name)),
381
559
          _column_type(primitive_type),
382
559
          _low_value(min),
383
559
          _high_value(max),
384
559
          _low_op(FILTER_LARGER_OR_EQUAL),
385
559
          _high_op(FILTER_LESS_OR_EQUAL),
386
559
          _is_nullable_col(is_nullable_col),
387
559
          _contain_null(is_nullable_col && contain_null),
388
559
          _precision(precision),
389
559
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKhSA_bbii
Line
Count
Source
380
6.92k
        : _column_name(std::move(col_name)),
381
6.92k
          _column_type(primitive_type),
382
6.92k
          _low_value(min),
383
6.92k
          _high_value(max),
384
6.92k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
6.92k
          _high_op(FILTER_LESS_OR_EQUAL),
386
6.92k
          _is_nullable_col(is_nullable_col),
387
6.92k
          _contain_null(is_nullable_col && contain_null),
388
6.92k
          _precision(precision),
389
6.92k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_9StringRefESB_bbii
Line
Count
Source
380
458
        : _column_name(std::move(col_name)),
381
458
          _column_type(primitive_type),
382
458
          _low_value(min),
383
458
          _high_value(max),
384
458
          _low_op(FILTER_LARGER_OR_EQUAL),
385
458
          _high_op(FILTER_LESS_OR_EQUAL),
386
458
          _is_nullable_col(is_nullable_col),
387
458
          _contain_null(is_nullable_col && contain_null),
388
458
          _precision(precision),
389
458
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIiEESC_bbii
Line
Count
Source
380
8.38k
        : _column_name(std::move(col_name)),
381
8.38k
          _column_type(primitive_type),
382
8.38k
          _low_value(min),
383
8.38k
          _high_value(max),
384
8.38k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
8.38k
          _high_op(FILTER_LESS_OR_EQUAL),
386
8.38k
          _is_nullable_col(is_nullable_col),
387
8.38k
          _contain_null(is_nullable_col && contain_null),
388
8.38k
          _precision(precision),
389
8.38k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIlEESC_bbii
Line
Count
Source
380
23.1k
        : _column_name(std::move(col_name)),
381
23.1k
          _column_type(primitive_type),
382
23.1k
          _low_value(min),
383
23.1k
          _high_value(max),
384
23.1k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
23.1k
          _high_op(FILTER_LESS_OR_EQUAL),
386
23.1k
          _is_nullable_col(is_nullable_col),
387
23.1k
          _contain_null(is_nullable_col && contain_null),
388
23.1k
          _precision(precision),
389
23.1k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_12Decimal128V3ESB_bbii
Line
Count
Source
380
10.4k
        : _column_name(std::move(col_name)),
381
10.4k
          _column_type(primitive_type),
382
10.4k
          _low_value(min),
383
10.4k
          _high_value(max),
384
10.4k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
10.4k
          _high_op(FILTER_LESS_OR_EQUAL),
386
10.4k
          _is_nullable_col(is_nullable_col),
387
10.4k
          _contain_null(is_nullable_col && contain_null),
388
10.4k
          _precision(precision),
389
10.4k
          _scale(scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7DecimalIN4wide7integerILm256EiEEEESF_bbii
Line
Count
Source
380
1.59k
        : _column_name(std::move(col_name)),
381
1.59k
          _column_type(primitive_type),
382
1.59k
          _low_value(min),
383
1.59k
          _high_value(max),
384
1.59k
          _low_op(FILTER_LARGER_OR_EQUAL),
385
1.59k
          _high_op(FILTER_LESS_OR_EQUAL),
386
1.59k
          _is_nullable_col(is_nullable_col),
387
1.59k
          _contain_null(is_nullable_col && contain_null),
388
1.59k
          _precision(precision),
389
1.59k
          _scale(scale) {}
390
391
template <PrimitiveType primitive_type>
392
ColumnValueRange<primitive_type>::ColumnValueRange(std::string col_name, bool is_nullable_col,
393
                                                   int precision, int scale)
394
1.57M
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.57M
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
97.0k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
97.0k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
14.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
14.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
213k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
213k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
356k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
356k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.0k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.0k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
7.53k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
7.53k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.3k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.3k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
12.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
12.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
502
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
502
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
517
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
517
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
91.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
91.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
76.5k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
76.5k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
11.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
11.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
548k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
548k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
77.1k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
77.1k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
456
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
456
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
8.10k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
8.10k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
22.6k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
22.6k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
10.2k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
10.2k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
1.42k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
1.42k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
556
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
556
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
6.66k
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
6.66k
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
456
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
456
                           is_nullable_col, precision, scale) {}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EEC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbii
Line
Count
Source
394
490
        : ColumnValueRange(std::move(col_name), TYPE_MIN, TYPE_MAX, is_nullable_col,
395
490
                           is_nullable_col, precision, scale) {}
396
397
template <PrimitiveType primitive_type>
398
319k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
319k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
319k
    _fixed_values.insert(value);
404
319k
    _contain_null = false;
405
406
319k
    _high_value = TYPE_MIN;
407
319k
    _low_value = TYPE_MAX;
408
409
319k
    return Status::OK();
410
319k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE15add_fixed_valueERKa
Line
Count
Source
398
79.4k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
79.4k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
79.4k
    _fixed_values.insert(value);
404
79.4k
    _contain_null = false;
405
406
79.4k
    _high_value = TYPE_MIN;
407
79.4k
    _low_value = TYPE_MAX;
408
409
79.4k
    return Status::OK();
410
79.4k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE15add_fixed_valueERKs
Line
Count
Source
398
188
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
188
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
188
    _fixed_values.insert(value);
404
188
    _contain_null = false;
405
406
188
    _high_value = TYPE_MIN;
407
188
    _low_value = TYPE_MAX;
408
409
188
    return Status::OK();
410
188
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE15add_fixed_valueERKi
Line
Count
Source
398
44.5k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
44.5k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
44.5k
    _fixed_values.insert(value);
404
44.5k
    _contain_null = false;
405
406
44.5k
    _high_value = TYPE_MIN;
407
44.5k
    _low_value = TYPE_MAX;
408
409
44.5k
    return Status::OK();
410
44.5k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE15add_fixed_valueERKl
Line
Count
Source
398
14.7k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
14.7k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
14.7k
    _fixed_values.insert(value);
404
14.7k
    _contain_null = false;
405
406
14.7k
    _high_value = TYPE_MIN;
407
14.7k
    _low_value = TYPE_MAX;
408
409
14.7k
    return Status::OK();
410
14.7k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE15add_fixed_valueERKn
Line
Count
Source
398
206
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
206
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
206
    _fixed_values.insert(value);
404
206
    _contain_null = false;
405
406
206
    _high_value = TYPE_MIN;
407
206
    _low_value = TYPE_MAX;
408
409
206
    return Status::OK();
410
206
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE15add_fixed_valueERKf
Line
Count
Source
398
22
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
22
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
22
    _fixed_values.insert(value);
404
22
    _contain_null = false;
405
406
22
    _high_value = TYPE_MIN;
407
22
    _low_value = TYPE_MAX;
408
409
22
    return Status::OK();
410
22
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE15add_fixed_valueERKd
Line
Count
Source
398
134
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
134
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
134
    _fixed_values.insert(value);
404
134
    _contain_null = false;
405
406
134
    _high_value = TYPE_MIN;
407
134
    _low_value = TYPE_MAX;
408
409
134
    return Status::OK();
410
134
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE15add_fixed_valueERKj
Line
Count
Source
398
23
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
23
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
23
    _fixed_values.insert(value);
404
23
    _contain_null = false;
405
406
23
    _high_value = TYPE_MIN;
407
23
    _low_value = TYPE_MAX;
408
409
23
    return Status::OK();
410
23
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE15add_fixed_valueERKo
Line
Count
Source
398
25
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
25
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
25
    _fixed_values.insert(value);
404
25
    _contain_null = false;
405
406
25
    _high_value = TYPE_MIN;
407
25
    _low_value = TYPE_MAX;
408
409
25
    return Status::OK();
410
25
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
861
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
861
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
861
    _fixed_values.insert(value);
404
861
    _contain_null = false;
405
406
861
    _high_value = TYPE_MIN;
407
861
    _low_value = TYPE_MAX;
408
409
861
    return Status::OK();
410
861
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
167k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
167k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
167k
    _fixed_values.insert(value);
404
167k
    _contain_null = false;
405
406
167k
    _high_value = TYPE_MIN;
407
167k
    _low_value = TYPE_MAX;
408
409
167k
    return Status::OK();
410
167k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE15add_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
398
355
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
355
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
355
    _fixed_values.insert(value);
404
355
    _contain_null = false;
405
406
355
    _high_value = TYPE_MIN;
407
355
    _low_value = TYPE_MAX;
408
409
355
    return Status::OK();
410
355
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
52
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
52
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
52
    _fixed_values.insert(value);
404
52
    _contain_null = false;
405
406
52
    _high_value = TYPE_MIN;
407
52
    _low_value = TYPE_MAX;
408
409
52
    return Status::OK();
410
52
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE15add_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
398
9.26k
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
9.26k
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
9.26k
    _fixed_values.insert(value);
404
9.26k
    _contain_null = false;
405
406
9.26k
    _high_value = TYPE_MIN;
407
9.26k
    _low_value = TYPE_MAX;
408
409
9.26k
    return Status::OK();
410
9.26k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE15add_fixed_valueERKNS_16VecDateTimeValueE
Line
Count
Source
398
70
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
70
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
70
    _fixed_values.insert(value);
404
70
    _contain_null = false;
405
406
70
    _high_value = TYPE_MIN;
407
70
    _low_value = TYPE_MAX;
408
409
70
    return Status::OK();
410
70
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE15add_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
398
425
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
425
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
425
    _fixed_values.insert(value);
404
425
    _contain_null = false;
405
406
425
    _high_value = TYPE_MIN;
407
425
    _low_value = TYPE_MAX;
408
409
425
    return Status::OK();
410
425
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE15add_fixed_valueERKNS_16TimestampTzValueE
Line
Count
Source
398
344
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
344
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
344
    _fixed_values.insert(value);
404
344
    _contain_null = false;
405
406
344
    _high_value = TYPE_MIN;
407
344
    _low_value = TYPE_MAX;
408
409
344
    return Status::OK();
410
344
}
_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
195
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
195
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
195
    _fixed_values.insert(value);
404
195
    _contain_null = false;
405
406
195
    _high_value = TYPE_MIN;
407
195
    _low_value = TYPE_MAX;
408
409
195
    return Status::OK();
410
195
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE15add_fixed_valueERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE15add_fixed_valueERKNS_7DecimalIiEE
Line
Count
Source
398
42
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
42
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
42
    _fixed_values.insert(value);
404
42
    _contain_null = false;
405
406
42
    _high_value = TYPE_MIN;
407
42
    _low_value = TYPE_MAX;
408
409
42
    return Status::OK();
410
42
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE15add_fixed_valueERKNS_7DecimalIlEE
Line
Count
Source
398
289
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
289
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
289
    _fixed_values.insert(value);
404
289
    _contain_null = false;
405
406
289
    _high_value = TYPE_MIN;
407
289
    _low_value = TYPE_MAX;
408
409
289
    return Status::OK();
410
289
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE15add_fixed_valueERKNS_12Decimal128V3E
Line
Count
Source
398
118
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
118
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
118
    _fixed_values.insert(value);
404
118
    _contain_null = false;
405
406
118
    _high_value = TYPE_MIN;
407
118
    _low_value = TYPE_MAX;
408
409
118
    return Status::OK();
410
118
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE15add_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
Line
Count
Source
398
47
Status ColumnValueRange<primitive_type>::add_fixed_value(const CppType& value) {
399
47
    if (INVALID_TYPE == _column_type) {
400
0
        return Status::InternalError("AddFixedValue failed, Invalid type");
401
0
    }
402
403
47
    _fixed_values.insert(value);
404
47
    _contain_null = false;
405
406
47
    _high_value = TYPE_MIN;
407
47
    _low_value = TYPE_MAX;
408
409
47
    return Status::OK();
410
47
}
411
412
template <PrimitiveType primitive_type>
413
3
void ColumnValueRange<primitive_type>::remove_fixed_value(const CppType& value) {
414
3
    _fixed_values.erase(value);
415
3
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE18remove_fixed_valueERKa
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE18remove_fixed_valueERKs
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE18remove_fixed_valueERKi
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE18remove_fixed_valueERKl
Line
Count
Source
413
3
void ColumnValueRange<primitive_type>::remove_fixed_value(const CppType& value) {
414
3
    _fixed_values.erase(value);
415
3
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE18remove_fixed_valueERKn
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE18remove_fixed_valueERKf
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE18remove_fixed_valueERKd
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE18remove_fixed_valueERKj
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE18remove_fixed_valueERKo
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE18remove_fixed_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE18remove_fixed_valueERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE18remove_fixed_valueERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE18remove_fixed_valueERKNS_16VecDateTimeValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE18remove_fixed_valueERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE18remove_fixed_valueERKNS_16TimestampTzValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE18remove_fixed_valueERKNS_14DecimalV2ValueE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE18remove_fixed_valueERKh
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE18remove_fixed_valueERKNS_9StringRefE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE18remove_fixed_valueERKNS_7DecimalIiEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE18remove_fixed_valueERKNS_7DecimalIlEE
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE18remove_fixed_valueERKNS_12Decimal128V3E
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE18remove_fixed_valueERKNS_7DecimalIN4wide7integerILm256EiEEEE
416
417
template <PrimitiveType primitive_type>
418
5.07M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
5.07M
    return _fixed_values.size() != 0;
420
5.07M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_fixed_value_rangeEv
Line
Count
Source
418
725k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
725k
    return _fixed_values.size() != 0;
420
725k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_fixed_value_rangeEv
Line
Count
Source
418
17.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
17.0k
    return _fixed_values.size() != 0;
420
17.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_fixed_value_rangeEv
Line
Count
Source
418
455k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
455k
    return _fixed_values.size() != 0;
420
455k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_fixed_value_rangeEv
Line
Count
Source
418
796k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
796k
    return _fixed_values.size() != 0;
420
796k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_fixed_value_rangeEv
Line
Count
Source
418
27.7k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
27.7k
    return _fixed_values.size() != 0;
420
27.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_fixed_value_rangeEv
Line
Count
Source
418
7.86k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
7.86k
    return _fixed_values.size() != 0;
420
7.86k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_fixed_value_rangeEv
Line
Count
Source
418
11.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
11.4k
    return _fixed_values.size() != 0;
420
11.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_fixed_value_rangeEv
Line
Count
Source
418
624
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
624
    return _fixed_values.size() != 0;
420
624
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_fixed_value_rangeEv
Line
Count
Source
418
670
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
670
    return _fixed_values.size() != 0;
420
670
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_fixed_value_rangeEv
Line
Count
Source
418
18.1k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
18.1k
    return _fixed_values.size() != 0;
420
18.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_fixed_value_rangeEv
Line
Count
Source
418
2.54M
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
2.54M
    return _fixed_values.size() != 0;
420
2.54M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_fixed_value_rangeEv
Line
Count
Source
418
79.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
79.5k
    return _fixed_values.size() != 0;
420
79.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_fixed_value_rangeEv
Line
Count
Source
418
742
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
742
    return _fixed_values.size() != 0;
420
742
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_fixed_value_rangeEv
Line
Count
Source
418
193k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
193k
    return _fixed_values.size() != 0;
420
193k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_fixed_value_rangeEv
Line
Count
Source
418
950
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
950
    return _fixed_values.size() != 0;
420
950
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_fixed_value_rangeEv
Line
Count
Source
418
92.2k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
92.2k
    return _fixed_values.size() != 0;
420
92.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_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_13PrimitiveTypeE20EE20is_fixed_value_rangeEv
Line
Count
Source
418
1.18k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
1.18k
    return _fixed_values.size() != 0;
420
1.18k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_fixed_value_rangeEv
Line
Count
Source
418
14.1k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
14.1k
    return _fixed_values.size() != 0;
420
14.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_fixed_value_rangeEv
Line
Count
Source
418
456
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
456
    return _fixed_values.size() != 0;
420
456
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_fixed_value_rangeEv
Line
Count
Source
418
10.3k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
10.3k
    return _fixed_values.size() != 0;
420
10.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_fixed_value_rangeEv
Line
Count
Source
418
26.9k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
26.9k
    return _fixed_values.size() != 0;
420
26.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_fixed_value_rangeEv
Line
Count
Source
418
17.4k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
17.4k
    return _fixed_values.size() != 0;
420
17.4k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_fixed_value_rangeEv
Line
Count
Source
418
3.77k
bool ColumnValueRange<primitive_type>::is_fixed_value_range() const {
419
3.77k
    return _fixed_values.size() != 0;
420
3.77k
}
421
422
template <PrimitiveType primitive_type>
423
1.83M
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.83M
    return Compare::greater(_high_value, _low_value);
425
1.83M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_scope_value_rangeEv
Line
Count
Source
423
99.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
99.0k
    return Compare::greater(_high_value, _low_value);
425
99.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_scope_value_rangeEv
Line
Count
Source
423
14.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.5k
    return Compare::greater(_high_value, _low_value);
425
14.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_scope_value_rangeEv
Line
Count
Source
423
275k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
275k
    return Compare::greater(_high_value, _low_value);
425
275k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_scope_value_rangeEv
Line
Count
Source
423
472k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
472k
    return Compare::greater(_high_value, _low_value);
425
472k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_scope_value_rangeEv
Line
Count
Source
423
14.0k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
14.0k
    return Compare::greater(_high_value, _low_value);
425
14.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_scope_value_rangeEv
Line
Count
Source
423
7.57k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
7.57k
    return Compare::greater(_high_value, _low_value);
425
7.57k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_scope_value_rangeEv
Line
Count
Source
423
10.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
10.1k
    return Compare::greater(_high_value, _low_value);
425
10.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE20is_scope_value_rangeEv
Line
Count
Source
423
462
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
462
    return Compare::greater(_high_value, _low_value);
425
462
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_scope_value_rangeEv
Line
Count
Source
423
497
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
497
    return Compare::greater(_high_value, _low_value);
425
497
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_scope_value_rangeEv
Line
Count
Source
423
12.5k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
12.5k
    return Compare::greater(_high_value, _low_value);
425
12.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_scope_value_rangeEv
Line
Count
Source
423
608k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
608k
    return Compare::greater(_high_value, _low_value);
425
608k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_scope_value_rangeEv
Line
Count
Source
423
76.6k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
76.6k
    return Compare::greater(_high_value, _low_value);
425
76.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_scope_value_rangeEv
Line
Count
Source
423
504
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
504
    return Compare::greater(_high_value, _low_value);
425
504
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_scope_value_rangeEv
Line
Count
Source
423
94.2k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
94.2k
    return Compare::greater(_high_value, _low_value);
425
94.2k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_scope_value_rangeEv
Line
Count
Source
423
533
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
533
    return Compare::greater(_high_value, _low_value);
425
533
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_scope_value_rangeEv
Line
Count
Source
423
78.8k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
78.8k
    return Compare::greater(_high_value, _low_value);
425
78.8k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_scope_value_rangeEv
Line
Count
Source
423
15.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
15.1k
    return Compare::greater(_high_value, _low_value);
425
15.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_scope_value_rangeEv
Line
Count
Source
423
711
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
711
    return Compare::greater(_high_value, _low_value);
425
711
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_scope_value_rangeEv
Line
Count
Source
423
8.14k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.14k
    return Compare::greater(_high_value, _low_value);
425
8.14k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_scope_value_rangeEv
Line
Count
Source
423
455
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
455
    return Compare::greater(_high_value, _low_value);
425
455
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_scope_value_rangeEv
Line
Count
Source
423
8.47k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
8.47k
    return Compare::greater(_high_value, _low_value);
425
8.47k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_scope_value_rangeEv
Line
Count
Source
423
23.1k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
23.1k
    return Compare::greater(_high_value, _low_value);
425
23.1k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_scope_value_rangeEv
Line
Count
Source
423
11.7k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
11.7k
    return Compare::greater(_high_value, _low_value);
425
11.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_scope_value_rangeEv
Line
Count
Source
423
1.91k
bool ColumnValueRange<primitive_type>::is_scope_value_range() const {
424
1.91k
    return Compare::greater(_high_value, _low_value);
425
1.91k
}
426
427
template <PrimitiveType primitive_type>
428
2.52M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.52M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.52M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.52M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE20is_empty_value_rangeEv
Line
Count
Source
428
255k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
255k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
255k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
255k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE20is_empty_value_rangeEv
Line
Count
Source
428
14.6k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.6k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.6k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE20is_empty_value_rangeEv
Line
Count
Source
428
287k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
287k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
287k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
287k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE20is_empty_value_rangeEv
Line
Count
Source
428
476k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
476k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
476k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
476k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE20is_empty_value_rangeEv
Line
Count
Source
428
14.5k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
14.5k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
14.5k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
14.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE20is_empty_value_rangeEv
Line
Count
Source
428
7.57k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
7.57k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
7.57k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
7.57k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE20is_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_13PrimitiveTypeE36EE20is_empty_value_rangeEv
Line
Count
Source
428
499
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
499
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
499
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
499
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE20is_empty_value_rangeEv
Line
Count
Source
428
534
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
534
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
534
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
534
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE20is_empty_value_rangeEv
Line
Count
Source
428
13.5k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
13.5k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
13.5k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
13.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE20is_empty_value_rangeEv
Line
Count
Source
428
1.09M
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
1.09M
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
1.09M
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
1.09M
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE20is_empty_value_rangeEv
Line
Count
Source
428
77.3k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
77.3k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
77.3k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
77.3k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE20is_empty_value_rangeEv
Line
Count
Source
428
556
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
556
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
556
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
556
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE20is_empty_value_rangeEv
Line
Count
Source
428
112k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
112k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
112k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
112k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE20is_empty_value_rangeEv
Line
Count
Source
428
627
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
627
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
627
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
627
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE20is_empty_value_rangeEv
Line
Count
Source
428
79.7k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
79.7k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
79.7k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
79.7k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE20is_empty_value_rangeEv
Line
Count
Source
428
15.6k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
15.6k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
15.6k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
15.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE20is_empty_value_rangeEv
Line
Count
Source
428
714
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
714
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
714
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
714
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE20is_empty_value_rangeEv
Line
Count
Source
428
8.54k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.54k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.54k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.54k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE20is_empty_value_rangeEv
Line
Count
Source
428
456
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
456
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
456
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
456
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE20is_empty_value_rangeEv
Line
Count
Source
428
8.63k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
8.63k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
8.63k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
8.63k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE20is_empty_value_rangeEv
Line
Count
Source
428
23.6k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
23.6k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
23.6k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
23.6k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE20is_empty_value_rangeEv
Line
Count
Source
428
11.9k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
11.9k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
11.9k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
11.9k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE20is_empty_value_rangeEv
Line
Count
Source
428
2.00k
bool ColumnValueRange<primitive_type>::is_empty_value_range() const {
429
2.00k
    if (INVALID_TYPE == _column_type) {
430
0
        return true;
431
0
    }
432
433
2.00k
    return (!is_fixed_value_range() && !is_scope_value_range() && !contain_null());
434
2.00k
}
435
436
template <PrimitiveType primitive_type>
437
170k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
170k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
170k
    if (!is_enumeration_type(_column_type)) {
443
19.0k
        return false;
444
19.0k
    }
445
446
151k
    return true;
447
170k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.92k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.92k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.92k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
1.92k
    return true;
447
1.92k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_fixed_value_convertibleEv
Line
Count
Source
437
99
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
99
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
99
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
99
    return true;
447
99
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_fixed_value_convertibleEv
Line
Count
Source
437
62.0k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
62.0k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
62.0k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
62.0k
    return true;
447
62.0k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_fixed_value_convertibleEv
Line
Count
Source
437
80.5k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
80.5k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
80.5k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
80.5k
    return true;
447
80.5k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_fixed_value_convertibleEv
Line
Count
Source
437
3.90k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
3.90k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
3.90k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
3.90k
    return true;
447
3.90k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26is_fixed_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26is_fixed_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
1
    return true;
447
1
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26is_fixed_value_convertibleEv
Line
Count
Source
437
418
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
418
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
419
    if (!is_enumeration_type(_column_type)) {
443
419
        return false;
444
419
    }
445
446
18.4E
    return true;
447
418
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_fixed_value_convertibleEv
Line
Count
Source
437
7.65k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
7.65k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
7.65k
    if (!is_enumeration_type(_column_type)) {
443
7.61k
        return false;
444
7.61k
    }
445
446
37
    return true;
447
7.65k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_fixed_value_convertibleEv
Line
Count
Source
437
6
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
6
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
6
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
6
    return true;
447
6
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.87k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.87k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.87k
    if (!is_enumeration_type(_column_type)) {
443
0
        return false;
444
0
    }
445
446
2.87k
    return true;
447
2.87k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_fixed_value_convertibleEv
Line
Count
Source
437
21
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
21
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
21
    if (!is_enumeration_type(_column_type)) {
443
20
        return false;
444
20
    }
445
446
1
    return true;
447
21
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_fixed_value_convertibleEv
Line
Count
Source
437
2.39k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
2.39k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
2.40k
    if (!is_enumeration_type(_column_type)) {
443
2.40k
        return false;
444
2.40k
    }
445
446
18.4E
    return true;
447
2.39k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_fixed_value_convertibleEv
Line
Count
Source
437
4.07k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
4.07k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
4.07k
    if (!is_enumeration_type(_column_type)) {
443
4.06k
        return false;
444
4.06k
    }
445
446
10
    return true;
447
4.07k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_fixed_value_convertibleEv
Line
Count
Source
437
156
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
156
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
156
    if (!is_enumeration_type(_column_type)) {
443
156
        return false;
444
156
    }
445
446
0
    return true;
447
156
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.50k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.50k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.50k
    if (!is_enumeration_type(_column_type)) {
443
1.49k
        return false;
444
1.49k
    }
445
446
9
    return true;
447
1.50k
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_fixed_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_fixed_value_convertibleEv
Line
Count
Source
437
422
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
422
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
422
    if (!is_enumeration_type(_column_type)) {
443
421
        return false;
444
421
    }
445
446
1
    return true;
447
422
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_fixed_value_convertibleEv
Line
Count
Source
437
553
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
553
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
553
    if (!is_enumeration_type(_column_type)) {
443
545
        return false;
444
545
    }
445
446
8
    return true;
447
553
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_fixed_value_convertibleEv
Line
Count
Source
437
1.51k
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
1.51k
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
1.51k
    if (!is_enumeration_type(_column_type)) {
443
1.51k
        return false;
444
1.51k
    }
445
446
18.4E
    return true;
447
1.51k
}
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_fixed_value_convertibleEv
Line
Count
Source
437
421
bool ColumnValueRange<primitive_type>::is_fixed_value_convertible() const {
438
421
    if (is_fixed_value_range()) {
439
0
        return false;
440
0
    }
441
442
421
    if (!is_enumeration_type(_column_type)) {
443
415
        return false;
444
415
    }
445
446
6
    return true;
447
421
}
448
449
template <PrimitiveType primitive_type>
450
37
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
37
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
37
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
36
    return true;
460
37
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26is_range_value_convertibleEv
Line
Count
Source
450
34
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
34
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
34
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
34
    return true;
460
34
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26is_range_value_convertibleEv
Line
Count
Source
450
2
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
2
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
2
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
0
        return false;
457
0
    }
458
459
2
    return true;
460
2
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE26is_range_value_convertibleEv
_ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE26is_range_value_convertibleEv
Line
Count
Source
450
1
bool ColumnValueRange<primitive_type>::is_range_value_convertible() const {
451
1
    if (!is_fixed_value_range()) {
452
0
        return false;
453
0
    }
454
455
1
    if (TYPE_NULL == _column_type || TYPE_BOOLEAN == _column_type) {
456
1
        return false;
457
1
    }
458
459
0
    return true;
460
1
}
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26is_range_value_convertibleEv
Unexecuted instantiation: _ZNK5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE26is_range_value_convertibleEv
461
462
// The return value indicates whether eos.
463
template <PrimitiveType primitive_type>
464
bool ColumnValueRange<primitive_type>::convert_to_close_range(
465
        std::vector<OlapTuple>& begin_scan_keys, std::vector<OlapTuple>& end_scan_keys,
466
146k
        bool& begin_include, bool& end_include) {
467
146k
    if constexpr (!_is_reject_split_type) {
468
146k
        begin_include = true;
469
146k
        end_include = true;
470
471
146k
        bool is_empty = false;
472
473
146k
        if (!is_begin_include()) {
474
7.23k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
7.23k
            } else {
477
7.23k
                ++_low_value;
478
7.23k
            }
479
7.23k
        }
480
481
146k
        if (!is_end_include()) {
482
719
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
719
            } else {
485
719
                --_high_value;
486
719
            }
487
719
        }
488
489
146k
        if (Compare::less(_high_value, _low_value)) {
490
32
            is_empty = true;
491
32
        }
492
493
146k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
146k
    }
499
146k
    return false;
500
146k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
1.90k
        bool& begin_include, bool& end_include) {
467
1.90k
    if constexpr (!_is_reject_split_type) {
468
1.90k
        begin_include = true;
469
1.90k
        end_include = true;
470
471
1.90k
        bool is_empty = false;
472
473
1.90k
        if (!is_begin_include()) {
474
60
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
60
            } else {
477
60
                ++_low_value;
478
60
            }
479
60
        }
480
481
1.90k
        if (!is_end_include()) {
482
11
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
11
            } else {
485
11
                --_high_value;
486
11
            }
487
11
        }
488
489
1.90k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
1.90k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
1.90k
    }
499
1.90k
    return false;
500
1.90k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
98
        bool& begin_include, bool& end_include) {
467
98
    if constexpr (!_is_reject_split_type) {
468
98
        begin_include = true;
469
98
        end_include = true;
470
471
98
        bool is_empty = false;
472
473
98
        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
98
        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
98
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
98
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
98
    }
499
98
    return false;
500
98
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
61.3k
        bool& begin_include, bool& end_include) {
467
61.3k
    if constexpr (!_is_reject_split_type) {
468
61.3k
        begin_include = true;
469
61.3k
        end_include = true;
470
471
61.3k
        bool is_empty = false;
472
473
61.3k
        if (!is_begin_include()) {
474
506
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
506
            } else {
477
506
                ++_low_value;
478
506
            }
479
506
        }
480
481
61.3k
        if (!is_end_include()) {
482
617
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
617
            } else {
485
617
                --_high_value;
486
617
            }
487
617
        }
488
489
61.3k
        if (Compare::less(_high_value, _low_value)) {
490
32
            is_empty = true;
491
32
        }
492
493
61.3k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
61.3k
    }
499
61.3k
    return false;
500
61.3k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
80.5k
        bool& begin_include, bool& end_include) {
467
80.5k
    if constexpr (!_is_reject_split_type) {
468
80.5k
        begin_include = true;
469
80.5k
        end_include = true;
470
471
80.5k
        bool is_empty = false;
472
473
80.5k
        if (!is_begin_include()) {
474
6.63k
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
6.63k
            } else {
477
6.63k
                ++_low_value;
478
6.63k
            }
479
6.63k
        }
480
481
80.5k
        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
80.5k
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
80.5k
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
80.5k
    }
499
80.5k
    return false;
500
80.5k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
1
        bool& begin_include, bool& end_include) {
467
1
    if constexpr (!_is_reject_split_type) {
468
1
        begin_include = true;
469
1
        end_include = true;
470
471
1
        bool is_empty = false;
472
473
1
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
1
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
1
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
1
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
1
    }
499
1
    return false;
500
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
6
        bool& begin_include, bool& end_include) {
467
6
    if constexpr (!_is_reject_split_type) {
468
6
        begin_include = true;
469
6
        end_include = true;
470
471
6
        bool is_empty = false;
472
473
6
        if (!is_begin_include()) {
474
0
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
0
            } else {
477
0
                ++_low_value;
478
0
            }
479
0
        }
480
481
6
        if (!is_end_include()) {
482
0
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
0
            } else {
485
0
                --_high_value;
486
0
            }
487
0
        }
488
489
6
        if (Compare::less(_high_value, _low_value)) {
490
0
            is_empty = true;
491
0
        }
492
493
6
        if (is_empty && !contain_null()) {
494
0
            begin_scan_keys.clear();
495
0
            end_scan_keys.clear();
496
0
            return true;
497
0
        }
498
6
    }
499
6
    return false;
500
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_close_rangeERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_
Line
Count
Source
466
2.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
29
            if (Compare::equal(_low_value, TYPE_MAX)) {
475
0
                is_empty = true;
476
29
            } else {
477
29
                ++_low_value;
478
29
            }
479
29
        }
480
481
2.87k
        if (!is_end_include()) {
482
82
            if (Compare::equal(_high_value, TYPE_MIN)) {
483
0
                is_empty = true;
484
82
            } else {
485
82
                --_high_value;
486
82
            }
487
82
        }
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
147k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
147k
    if constexpr (!_is_reject_split_type) {
508
147k
        CppType min_value = get_range_min_value();
509
147k
        CppType max_value = get_range_max_value();
510
147k
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
6
            min_value.set_type(TimeType::TIME_DATE);
512
6
            max_value.set_type(TimeType::TIME_DATE);
513
6
        }
514
147k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
147k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
32
            DCHECK(contain_null());
518
32
        }
519
520
147k
        auto no_split = [&]() -> bool {
521
140k
            begin_scan_keys.emplace_back();
522
140k
            begin_scan_keys.back().add_value(
523
140k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
140k
                    contain_null());
525
140k
            end_scan_keys.emplace_back();
526
140k
            end_scan_keys.back().add_value(
527
140k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
140k
                    empty_range_only_null ? true : false);
529
140k
            return true;
530
140k
        };
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
60.4k
        auto no_split = [&]() -> bool {
521
60.4k
            begin_scan_keys.emplace_back();
522
60.4k
            begin_scan_keys.back().add_value(
523
60.4k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
60.4k
                    contain_null());
525
60.4k
            end_scan_keys.emplace_back();
526
60.4k
            end_scan_keys.back().add_value(
527
60.4k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
60.4k
                    empty_range_only_null ? true : false);
529
60.4k
            return true;
530
60.4k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
79.9k
        auto no_split = [&]() -> bool {
521
79.9k
            begin_scan_keys.emplace_back();
522
79.9k
            begin_scan_keys.back().add_value(
523
79.9k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
79.9k
                    contain_null());
525
79.9k
            end_scan_keys.emplace_back();
526
79.9k
            end_scan_keys.back().add_value(
527
79.9k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
79.9k
                    empty_range_only_null ? true : false);
529
79.9k
            return true;
530
79.9k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Line
Count
Source
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlvE_clEv
531
147k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
32
            return no_split();
533
32
        }
534
535
384k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
139k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
139k
                return value;
539
244k
            } else {
540
244k
                return (int128_t)value;
541
244k
            }
542
384k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKaE_clESA_
Line
Count
Source
535
85.9k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
85.9k
            } else {
540
85.9k
                return (int128_t)value;
541
85.9k
            }
542
85.9k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKsE_clESA_
Line
Count
Source
535
4.83k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
4.83k
            } else {
540
4.83k
                return (int128_t)value;
541
4.83k
            }
542
4.83k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKiE_clESA_
Line
Count
Source
535
71.6k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
71.6k
            } else {
540
71.6k
                return (int128_t)value;
541
71.6k
            }
542
71.6k
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKlE_clESA_
Line
Count
Source
535
82.0k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
82.0k
            } else {
540
82.0k
                return (int128_t)value;
541
82.0k
            }
542
82.0k
        };
Unexecuted instantiation: _ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKjE_clESA_
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKoE_clESA_
Line
Count
Source
535
1
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
                return value;
539
1
            } else {
540
1
                return (int128_t)value;
541
1
            }
542
1
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_16VecDateTimeValueEE_clESB_
Line
Count
Source
535
294
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
294
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
294
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
294
        };
_ZZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_iENKUlRKNS_11DateV2ValueINS_15DateV2ValueTypeEEEE_clESD_
Line
Count
Source
535
139k
        auto cast = [](const CppType& value) {
536
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
139k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
139k
                return value;
539
            } else {
540
                return (int128_t)value;
541
            }
542
139k
        };
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
147k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
147k
        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
147k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
141k
            return no_split();
552
141k
        }
553
6.07k
        int step_size = cast_set<int>(step_size_may_overflow);
554
6.07k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6.07k
        if (contain_null()) {
558
2.74k
            begin_scan_keys.emplace_back();
559
2.74k
            begin_scan_keys.back().add_null();
560
2.74k
            end_scan_keys.emplace_back();
561
2.74k
            end_scan_keys.back().add_null();
562
2.74k
        }
563
236k
        while (true) {
564
236k
            begin_scan_keys.emplace_back();
565
236k
            begin_scan_keys.back().add_value(
566
236k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
236k
            if (cast(max_value) - min_value < step_size) {
569
5.01k
                min_value = max_value;
570
231k
            } else {
571
231k
                min_value += step_size;
572
231k
            }
573
574
236k
            end_scan_keys.emplace_back();
575
236k
            end_scan_keys.back().add_value(
576
236k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
236k
            if (Compare::equal(min_value, max_value)) {
579
5.94k
                break;
580
5.94k
            }
581
230k
            ++min_value;
582
230k
            ++real_step_size;
583
230k
            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
230k
        }
592
593
6.07k
        return step_size != 0;
594
6.07k
    }
595
0
    return false;
596
147k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
1.93k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
1.93k
    if constexpr (!_is_reject_split_type) {
508
1.93k
        CppType min_value = get_range_min_value();
509
1.93k
        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.93k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
1.93k
        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.93k
        auto no_split = [&]() -> bool {
521
1.93k
            begin_scan_keys.emplace_back();
522
1.93k
            begin_scan_keys.back().add_value(
523
1.93k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1.93k
                    contain_null());
525
1.93k
            end_scan_keys.emplace_back();
526
1.93k
            end_scan_keys.back().add_value(
527
1.93k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1.93k
                    empty_range_only_null ? true : false);
529
1.93k
            return true;
530
1.93k
        };
531
1.93k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
1.93k
        auto cast = [](const CppType& value) {
536
1.93k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
1.93k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
1.93k
                return value;
539
1.93k
            } else {
540
1.93k
                return (int128_t)value;
541
1.93k
            }
542
1.93k
        };
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.93k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
1.93k
        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.93k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
1.93k
        int step_size = cast_set<int>(step_size_may_overflow);
554
1.93k
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
1.93k
        if (contain_null()) {
558
1.55k
            begin_scan_keys.emplace_back();
559
1.55k
            begin_scan_keys.back().add_null();
560
1.55k
            end_scan_keys.emplace_back();
561
1.55k
            end_scan_keys.back().add_null();
562
1.55k
        }
563
83.8k
        while (true) {
564
83.8k
            begin_scan_keys.emplace_back();
565
83.8k
            begin_scan_keys.back().add_value(
566
83.8k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
83.8k
            if (cast(max_value) - min_value < step_size) {
569
1.93k
                min_value = max_value;
570
81.9k
            } else {
571
81.9k
                min_value += step_size;
572
81.9k
            }
573
574
83.8k
            end_scan_keys.emplace_back();
575
83.8k
            end_scan_keys.back().add_value(
576
83.8k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
83.8k
            if (Compare::equal(min_value, max_value)) {
579
1.97k
                break;
580
1.97k
            }
581
81.8k
            ++min_value;
582
81.8k
            ++real_step_size;
583
81.8k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
81.8k
        }
592
593
1.93k
        return step_size != 0;
594
1.93k
    }
595
0
    return false;
596
1.93k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
99
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
99
    if constexpr (!_is_reject_split_type) {
508
99
        CppType min_value = get_range_min_value();
509
99
        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
99
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
99
        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
99
        auto no_split = [&]() -> bool {
521
99
            begin_scan_keys.emplace_back();
522
99
            begin_scan_keys.back().add_value(
523
99
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
99
                    contain_null());
525
99
            end_scan_keys.emplace_back();
526
99
            end_scan_keys.back().add_value(
527
99
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
99
                    empty_range_only_null ? true : false);
529
99
            return true;
530
99
        };
531
99
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
99
        auto cast = [](const CppType& value) {
536
99
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
99
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
99
                return value;
539
99
            } else {
540
99
                return (int128_t)value;
541
99
            }
542
99
        };
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
99
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
99
        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
99
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
99
        int step_size = cast_set<int>(step_size_may_overflow);
554
99
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
99
        if (contain_null()) {
558
91
            begin_scan_keys.emplace_back();
559
91
            begin_scan_keys.back().add_null();
560
91
            end_scan_keys.emplace_back();
561
91
            end_scan_keys.back().add_null();
562
91
        }
563
4.74k
        while (true) {
564
4.74k
            begin_scan_keys.emplace_back();
565
4.74k
            begin_scan_keys.back().add_value(
566
4.74k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
4.74k
            if (cast(max_value) - min_value < step_size) {
569
99
                min_value = max_value;
570
4.64k
            } else {
571
4.64k
                min_value += step_size;
572
4.64k
            }
573
574
4.74k
            end_scan_keys.emplace_back();
575
4.74k
            end_scan_keys.back().add_value(
576
4.74k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
4.74k
            if (Compare::equal(min_value, max_value)) {
579
99
                break;
580
99
            }
581
4.64k
            ++min_value;
582
4.64k
            ++real_step_size;
583
4.64k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
4.64k
        }
592
593
99
        return step_size != 0;
594
99
    }
595
0
    return false;
596
99
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
61.8k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
61.8k
    if constexpr (!_is_reject_split_type) {
508
61.8k
        CppType min_value = get_range_min_value();
509
61.8k
        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
61.8k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
61.8k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
32
            DCHECK(contain_null());
518
32
        }
519
520
61.8k
        auto no_split = [&]() -> bool {
521
61.8k
            begin_scan_keys.emplace_back();
522
61.8k
            begin_scan_keys.back().add_value(
523
61.8k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
61.8k
                    contain_null());
525
61.8k
            end_scan_keys.emplace_back();
526
61.8k
            end_scan_keys.back().add_value(
527
61.8k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
61.8k
                    empty_range_only_null ? true : false);
529
61.8k
            return true;
530
61.8k
        };
531
61.8k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
32
            return no_split();
533
32
        }
534
535
61.7k
        auto cast = [](const CppType& value) {
536
61.7k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
61.7k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
61.7k
                return value;
539
61.7k
            } else {
540
61.7k
                return (int128_t)value;
541
61.7k
            }
542
61.7k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
61.7k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
61.7k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
61.7k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
60.9k
            return no_split();
552
60.9k
        }
553
826
        int step_size = cast_set<int>(step_size_may_overflow);
554
826
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
826
        if (contain_null()) {
558
0
            begin_scan_keys.emplace_back();
559
0
            begin_scan_keys.back().add_null();
560
0
            end_scan_keys.emplace_back();
561
0
            end_scan_keys.back().add_null();
562
0
        }
563
10.3k
        while (true) {
564
10.1k
            begin_scan_keys.emplace_back();
565
10.1k
            begin_scan_keys.back().add_value(
566
10.1k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
10.1k
            if (cast(max_value) - min_value < step_size) {
569
163
                min_value = max_value;
570
9.95k
            } else {
571
9.95k
                min_value += step_size;
572
9.95k
            }
573
574
10.1k
            end_scan_keys.emplace_back();
575
10.1k
            end_scan_keys.back().add_value(
576
10.1k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
10.1k
            if (Compare::equal(min_value, max_value)) {
579
571
                break;
580
571
            }
581
9.54k
            ++min_value;
582
9.54k
            ++real_step_size;
583
9.54k
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
9.54k
        }
592
593
826
        return step_size != 0;
594
826
    }
595
0
    return false;
596
61.8k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
80.5k
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
80.5k
    if constexpr (!_is_reject_split_type) {
508
80.5k
        CppType min_value = get_range_min_value();
509
80.5k
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
80.5k
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
80.5k
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
80.5k
        auto no_split = [&]() -> bool {
521
80.5k
            begin_scan_keys.emplace_back();
522
80.5k
            begin_scan_keys.back().add_value(
523
80.5k
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
80.5k
                    contain_null());
525
80.5k
            end_scan_keys.emplace_back();
526
80.5k
            end_scan_keys.back().add_value(
527
80.5k
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
80.5k
                    empty_range_only_null ? true : false);
529
80.5k
            return true;
530
80.5k
        };
531
80.5k
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
80.5k
        auto cast = [](const CppType& value) {
536
80.5k
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
80.5k
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
80.5k
                return value;
539
80.5k
            } else {
540
80.5k
                return (int128_t)value;
541
80.5k
            }
542
80.5k
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
80.5k
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
80.5k
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
80.5k
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
80.2k
            return no_split();
552
80.2k
        }
553
325
        int step_size = cast_set<int>(step_size_may_overflow);
554
325
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
325
        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.63k
        while (true) {
564
1.63k
            begin_scan_keys.emplace_back();
565
1.63k
            begin_scan_keys.back().add_value(
566
1.63k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
1.63k
            if (cast(max_value) - min_value < step_size) {
569
3
                min_value = max_value;
570
1.63k
            } else {
571
1.63k
                min_value += step_size;
572
1.63k
            }
573
574
1.63k
            end_scan_keys.emplace_back();
575
1.63k
            end_scan_keys.back().add_value(
576
1.63k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
1.63k
            if (Compare::equal(min_value, max_value)) {
579
392
                break;
580
392
            }
581
1.24k
            ++min_value;
582
1.24k
            ++real_step_size;
583
1.24k
            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.24k
        }
592
593
325
        return step_size != 0;
594
325
    }
595
0
    return false;
596
80.5k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
1
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
1
    if constexpr (!_is_reject_split_type) {
508
1
        CppType min_value = get_range_min_value();
509
1
        CppType max_value = get_range_max_value();
510
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
            min_value.set_type(TimeType::TIME_DATE);
512
            max_value.set_type(TimeType::TIME_DATE);
513
        }
514
1
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
1
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
1
        auto no_split = [&]() -> bool {
521
1
            begin_scan_keys.emplace_back();
522
1
            begin_scan_keys.back().add_value(
523
1
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
1
                    contain_null());
525
1
            end_scan_keys.emplace_back();
526
1
            end_scan_keys.back().add_value(
527
1
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
1
                    empty_range_only_null ? true : false);
529
1
            return true;
530
1
        };
531
1
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
1
        auto cast = [](const CppType& value) {
536
1
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
1
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
1
                return value;
539
1
            } else {
540
1
                return (int128_t)value;
541
1
            }
542
1
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
1
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
1
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
1
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
1
            return no_split();
552
1
        }
553
0
        int step_size = cast_set<int>(step_size_may_overflow);
554
0
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
0
        if (contain_null()) {
558
0
            begin_scan_keys.emplace_back();
559
0
            begin_scan_keys.back().add_null();
560
0
            end_scan_keys.emplace_back();
561
0
            end_scan_keys.back().add_null();
562
0
        }
563
0
        while (true) {
564
0
            begin_scan_keys.emplace_back();
565
0
            begin_scan_keys.back().add_value(
566
0
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
0
            if (cast(max_value) - min_value < step_size) {
569
0
                min_value = max_value;
570
0
            } else {
571
0
                min_value += step_size;
572
0
            }
573
574
0
            end_scan_keys.emplace_back();
575
0
            end_scan_keys.back().add_value(
576
0
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
0
            if (Compare::equal(min_value, max_value)) {
579
0
                break;
580
0
            }
581
0
            ++min_value;
582
0
            ++real_step_size;
583
0
            if (real_step_size > MAX_STEP_SIZE) {
584
0
                throw Exception(Status::InternalError(
585
0
                        "convert_to_avg_range_value meet error. type={}, step_size={}, "
586
0
                        "min_value={}, max_value={}",
587
0
                        int(primitive_type), step_size,
588
0
                        cast_to_string<primitive_type, CppType>(min_value, scale()),
589
0
                        cast_to_string<primitive_type, CppType>(max_value, scale())));
590
0
            }
591
0
        }
592
593
0
        return step_size != 0;
594
0
    }
595
0
    return false;
596
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
6
        bool& begin_include, bool& end_include, int32_t max_scan_key_num) {
507
6
    if constexpr (!_is_reject_split_type) {
508
6
        CppType min_value = get_range_min_value();
509
6
        CppType max_value = get_range_max_value();
510
6
        if constexpr (primitive_type == PrimitiveType::TYPE_DATE) {
511
6
            min_value.set_type(TimeType::TIME_DATE);
512
6
            max_value.set_type(TimeType::TIME_DATE);
513
6
        }
514
6
        auto empty_range_only_null = Compare::greater(min_value, max_value);
515
6
        if (empty_range_only_null) {
516
            // Not contain null will be disposed in `convert_to_close_range`, return eos.
517
0
            DCHECK(contain_null());
518
0
        }
519
520
6
        auto no_split = [&]() -> bool {
521
6
            begin_scan_keys.emplace_back();
522
6
            begin_scan_keys.back().add_value(
523
6
                    cast_to_string<primitive_type, CppType>(get_range_min_value(), scale()),
524
6
                    contain_null());
525
6
            end_scan_keys.emplace_back();
526
6
            end_scan_keys.back().add_value(
527
6
                    cast_to_string<primitive_type, CppType>(get_range_max_value(), scale()),
528
6
                    empty_range_only_null ? true : false);
529
6
            return true;
530
6
        };
531
6
        if (empty_range_only_null || max_scan_key_num == 1) {
532
0
            return no_split();
533
0
        }
534
535
6
        auto cast = [](const CppType& value) {
536
6
            if constexpr (primitive_type == PrimitiveType::TYPE_DATE ||
537
6
                          primitive_type == PrimitiveType::TYPE_DATEV2) {
538
6
                return value;
539
6
            } else {
540
6
                return (int128_t)value;
541
6
            }
542
6
        };
543
544
        // When CppType is date, we can not convert it to integer number and calculate distance.
545
        // In other case, we convert element to int128 to avoit overflow.
546
6
        int128_t step_size_may_overflow = (cast(max_value) - min_value) / max_scan_key_num;
547
548
6
        constexpr size_t MAX_STEP_SIZE = 1 << 20;
549
        // When the step size is too large, the range is easy to not really contain data.
550
6
        if (step_size_may_overflow > MAX_STEP_SIZE) {
551
0
            return no_split();
552
0
        }
553
6
        int step_size = cast_set<int>(step_size_may_overflow);
554
6
        int real_step_size = 0;
555
556
        // Add null key if contain null, must do after no_split check
557
6
        if (contain_null()) {
558
6
            begin_scan_keys.emplace_back();
559
6
            begin_scan_keys.back().add_null();
560
6
            end_scan_keys.emplace_back();
561
6
            end_scan_keys.back().add_null();
562
6
        }
563
288
        while (true) {
564
288
            begin_scan_keys.emplace_back();
565
288
            begin_scan_keys.back().add_value(
566
288
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
288
            if (cast(max_value) - min_value < step_size) {
569
6
                min_value = max_value;
570
282
            } else {
571
282
                min_value += step_size;
572
282
            }
573
574
288
            end_scan_keys.emplace_back();
575
288
            end_scan_keys.back().add_value(
576
288
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
288
            if (Compare::equal(min_value, max_value)) {
579
6
                break;
580
6
            }
581
282
            ++min_value;
582
282
            ++real_step_size;
583
282
            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
282
        }
592
593
6
        return step_size != 0;
594
6
    }
595
0
    return false;
596
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE26convert_to_avg_range_valueERSt6vectorINS_9OlapTupleESaIS4_EES7_RbS8_i
Line
Count
Source
506
2.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.09k
            begin_scan_keys.emplace_back();
559
1.09k
            begin_scan_keys.back().add_null();
560
1.09k
            end_scan_keys.emplace_back();
561
1.09k
            end_scan_keys.back().add_null();
562
1.09k
        }
563
135k
        while (true) {
564
135k
            begin_scan_keys.emplace_back();
565
135k
            begin_scan_keys.back().add_value(
566
135k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
567
568
135k
            if (cast(max_value) - min_value < step_size) {
569
2.80k
                min_value = max_value;
570
133k
            } else {
571
133k
                min_value += step_size;
572
133k
            }
573
574
135k
            end_scan_keys.emplace_back();
575
135k
            end_scan_keys.back().add_value(
576
135k
                    cast_to_string<primitive_type, CppType>(min_value, scale()));
577
578
135k
            if (Compare::equal(min_value, max_value)) {
579
2.90k
                break;
580
2.90k
            }
581
132k
            ++min_value;
582
132k
            ++real_step_size;
583
132k
            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
132k
        }
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
18
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
18
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
18
    if (!_fixed_values.empty()) {
605
18
        _low_value = *_fixed_values.begin();
606
18
        _low_op = FILTER_LARGER_OR_EQUAL;
607
18
        _high_value = *_fixed_values.rbegin();
608
18
        _high_op = FILTER_LESS_OR_EQUAL;
609
18
        _fixed_values.clear();
610
18
    }
611
18
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE22convert_to_range_valueEv
Line
Count
Source
599
17
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
17
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
17
    if (!_fixed_values.empty()) {
605
17
        _low_value = *_fixed_values.begin();
606
17
        _low_op = FILTER_LARGER_OR_EQUAL;
607
17
        _high_value = *_fixed_values.rbegin();
608
17
        _high_op = FILTER_LESS_OR_EQUAL;
609
17
        _fixed_values.clear();
610
17
    }
611
17
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE22convert_to_range_valueEv
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE22convert_to_range_valueEv
Line
Count
Source
599
1
void ColumnValueRange<primitive_type>::convert_to_range_value() {
600
1
    if (!is_range_value_convertible()) {
601
0
        return;
602
0
    }
603
604
1
    if (!_fixed_values.empty()) {
605
1
        _low_value = *_fixed_values.begin();
606
1
        _low_op = FILTER_LARGER_OR_EQUAL;
607
1
        _high_value = *_fixed_values.rbegin();
608
1
        _high_op = FILTER_LESS_OR_EQUAL;
609
1
        _fixed_values.clear();
610
1
    }
611
1
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE22convert_to_range_valueEv
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE22convert_to_range_valueEv
612
613
template <PrimitiveType primitive_type>
614
151k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
151k
    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
151k
    _contain_null = false;
621
622
151k
    if (is_fixed_value_range()) {
623
13.5k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
13.5k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
13.3k
        case FILTER_LARGER_OR_EQUAL: {
632
13.3k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
13.3k
            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
227
        case FILTER_LESS_OR_EQUAL: {
647
227
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
227
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
13.5k
        }
655
656
13.5k
        _high_value = TYPE_MIN;
657
13.5k
        _low_value = TYPE_MAX;
658
137k
    } else {
659
137k
        if (Compare::greater(_high_value, _low_value)) {
660
74.7k
            switch (op) {
661
29.2k
            case FILTER_LARGER: {
662
29.2k
                if (Compare::greater_equal(value, _low_value)) {
663
29.2k
                    _low_value = value;
664
29.2k
                    _low_op = op;
665
29.2k
                }
666
667
29.2k
                break;
668
0
            }
669
670
15.7k
            case FILTER_LARGER_OR_EQUAL: {
671
15.7k
                if (Compare::greater(value, _low_value)) {
672
14.6k
                    _low_value = value;
673
14.6k
                    _low_op = op;
674
14.6k
                }
675
676
15.7k
                break;
677
0
            }
678
679
5.64k
            case FILTER_LESS: {
680
5.64k
                if (Compare::less_equal(value, _high_value)) {
681
5.60k
                    _high_value = value;
682
5.60k
                    _high_op = op;
683
5.60k
                }
684
685
5.64k
                break;
686
0
            }
687
688
24.0k
            case FILTER_LESS_OR_EQUAL: {
689
24.0k
                if (Compare::less(value, _high_value)) {
690
23.0k
                    _high_value = value;
691
23.0k
                    _high_op = op;
692
23.0k
                }
693
694
24.0k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
74.7k
            }
701
74.7k
        }
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
15.0k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
15.0k
            _high_value = TYPE_MIN;
707
15.0k
            _low_value = TYPE_MAX;
708
15.0k
        }
709
137k
    }
710
711
151k
    return Status::OK();
712
151k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE9add_rangeENS_11SQLFilterOpEa
Line
Count
Source
614
2.20k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2.20k
    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.20k
    _contain_null = false;
621
622
2.20k
    if (is_fixed_value_range()) {
623
252
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
252
        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
243
        case FILTER_LARGER_OR_EQUAL: {
632
243
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
243
            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
252
        }
655
656
254
        _high_value = TYPE_MIN;
657
254
        _low_value = TYPE_MAX;
658
1.95k
    } else {
659
1.95k
        if (Compare::greater(_high_value, _low_value)) {
660
1.90k
            switch (op) {
661
339
            case FILTER_LARGER: {
662
339
                if (Compare::greater_equal(value, _low_value)) {
663
338
                    _low_value = value;
664
338
                    _low_op = op;
665
338
                }
666
667
339
                break;
668
0
            }
669
670
560
            case FILTER_LARGER_OR_EQUAL: {
671
560
                if (Compare::greater(value, _low_value)) {
672
396
                    _low_value = value;
673
396
                    _low_op = op;
674
396
                }
675
676
560
                break;
677
0
            }
678
679
285
            case FILTER_LESS: {
680
285
                if (Compare::less_equal(value, _high_value)) {
681
277
                    _high_value = value;
682
277
                    _high_op = op;
683
277
                }
684
685
285
                break;
686
0
            }
687
688
734
            case FILTER_LESS_OR_EQUAL: {
689
734
                if (Compare::less(value, _high_value)) {
690
559
                    _high_value = value;
691
559
                    _high_op = op;
692
559
                }
693
694
734
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.90k
            }
701
1.90k
        }
702
703
1.94k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.94k
            Compare::equal(_high_value, _low_value)) {
705
320
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
320
            _high_value = TYPE_MIN;
707
320
            _low_value = TYPE_MAX;
708
320
        }
709
1.94k
    }
710
711
2.19k
    return Status::OK();
712
2.20k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE9add_rangeENS_11SQLFilterOpEs
Line
Count
Source
614
1.46k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.46k
    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.46k
    _contain_null = false;
621
622
1.46k
    if (is_fixed_value_range()) {
623
56
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
56
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
30
        case FILTER_LARGER_OR_EQUAL: {
632
30
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
30
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
25
        case FILTER_LESS_OR_EQUAL: {
647
25
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
25
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
56
        }
655
656
56
        _high_value = TYPE_MIN;
657
56
        _low_value = TYPE_MAX;
658
1.40k
    } else {
659
1.40k
        if (Compare::greater(_high_value, _low_value)) {
660
1.39k
            switch (op) {
661
1.01k
            case FILTER_LARGER: {
662
1.01k
                if (Compare::greater_equal(value, _low_value)) {
663
999
                    _low_value = value;
664
999
                    _low_op = op;
665
999
                }
666
667
1.01k
                break;
668
0
            }
669
670
226
            case FILTER_LARGER_OR_EQUAL: {
671
226
                if (Compare::greater(value, _low_value)) {
672
201
                    _low_value = value;
673
201
                    _low_op = op;
674
201
                }
675
676
226
                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
141
            case FILTER_LESS_OR_EQUAL: {
689
141
                if (Compare::less(value, _high_value)) {
690
101
                    _high_value = value;
691
101
                    _high_op = op;
692
101
                }
693
694
141
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.39k
            }
701
1.39k
        }
702
703
1.39k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.39k
            Compare::equal(_high_value, _low_value)) {
705
5
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
5
            _high_value = TYPE_MIN;
707
5
            _low_value = TYPE_MAX;
708
5
        }
709
1.39k
    }
710
711
1.45k
    return Status::OK();
712
1.46k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE9add_rangeENS_11SQLFilterOpEi
Line
Count
Source
614
9.91k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
9.91k
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
9.91k
    _contain_null = false;
621
622
9.91k
    if (is_fixed_value_range()) {
623
375
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
375
        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
253
        case FILTER_LARGER_OR_EQUAL: {
632
253
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
253
            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
122
        case FILTER_LESS_OR_EQUAL: {
647
122
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
122
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
375
        }
655
656
376
        _high_value = TYPE_MIN;
657
376
        _low_value = TYPE_MAX;
658
9.53k
    } else {
659
9.53k
        if (Compare::greater(_high_value, _low_value)) {
660
8.88k
            switch (op) {
661
1.83k
            case FILTER_LARGER: {
662
1.83k
                if (Compare::greater_equal(value, _low_value)) {
663
1.81k
                    _low_value = value;
664
1.81k
                    _low_op = op;
665
1.81k
                }
666
667
1.83k
                break;
668
0
            }
669
670
3.07k
            case FILTER_LARGER_OR_EQUAL: {
671
3.07k
                if (Compare::greater(value, _low_value)) {
672
2.60k
                    _low_value = value;
673
2.60k
                    _low_op = op;
674
2.60k
                }
675
676
3.07k
                break;
677
0
            }
678
679
889
            case FILTER_LESS: {
680
889
                if (Compare::less_equal(value, _high_value)) {
681
880
                    _high_value = value;
682
880
                    _high_op = op;
683
880
                }
684
685
889
                break;
686
0
            }
687
688
3.09k
            case FILTER_LESS_OR_EQUAL: {
689
3.09k
                if (Compare::less(value, _high_value)) {
690
2.61k
                    _high_value = value;
691
2.61k
                    _high_op = op;
692
2.61k
                }
693
694
3.09k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
8.88k
            }
701
8.88k
        }
702
703
9.49k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
9.49k
            Compare::equal(_high_value, _low_value)) {
705
382
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
382
            _high_value = TYPE_MIN;
707
382
            _low_value = TYPE_MAX;
708
382
        }
709
9.49k
    }
710
711
9.86k
    return Status::OK();
712
9.91k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE9add_rangeENS_11SQLFilterOpEl
Line
Count
Source
614
110k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
110k
    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
110k
    _contain_null = false;
621
622
110k
    if (is_fixed_value_range()) {
623
12.8k
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
12.8k
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
12.7k
        case FILTER_LARGER_OR_EQUAL: {
632
12.7k
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
12.7k
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
55
        case FILTER_LESS_OR_EQUAL: {
647
55
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
55
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
12.8k
        }
655
656
12.8k
        _high_value = TYPE_MIN;
657
12.8k
        _low_value = TYPE_MAX;
658
97.9k
    } else {
659
97.9k
        if (Compare::greater(_high_value, _low_value)) {
660
35.7k
            switch (op) {
661
11.4k
            case FILTER_LARGER: {
662
11.4k
                if (Compare::greater_equal(value, _low_value)) {
663
11.4k
                    _low_value = value;
664
11.4k
                    _low_op = op;
665
11.4k
                }
666
667
11.4k
                break;
668
0
            }
669
670
5.64k
            case FILTER_LARGER_OR_EQUAL: {
671
5.64k
                if (Compare::greater(value, _low_value)) {
672
5.62k
                    _low_value = value;
673
5.62k
                    _low_op = op;
674
5.62k
                }
675
676
5.64k
                break;
677
0
            }
678
679
35
            case FILTER_LESS: {
680
35
                if (Compare::less_equal(value, _high_value)) {
681
35
                    _high_value = value;
682
35
                    _high_op = op;
683
35
                }
684
685
35
                break;
686
0
            }
687
688
18.6k
            case FILTER_LESS_OR_EQUAL: {
689
18.6k
                if (Compare::less(value, _high_value)) {
690
18.6k
                    _high_value = value;
691
18.6k
                    _high_op = op;
692
18.6k
                }
693
694
18.6k
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
35.7k
            }
701
35.7k
        }
702
703
97.9k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
97.9k
            Compare::equal(_high_value, _low_value)) {
705
14.0k
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
14.0k
            _high_value = TYPE_MIN;
707
14.0k
            _low_value = TYPE_MAX;
708
14.0k
        }
709
97.9k
    }
710
711
110k
    return Status::OK();
712
110k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE9add_rangeENS_11SQLFilterOpEn
Line
Count
Source
614
265
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
265
    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
265
    _contain_null = false;
621
622
265
    if (is_fixed_value_range()) {
623
2
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
2
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
1
        case FILTER_LARGER_OR_EQUAL: {
632
1
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
1
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
1
        case FILTER_LESS_OR_EQUAL: {
647
1
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
1
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
2
        }
655
656
2
        _high_value = TYPE_MIN;
657
2
        _low_value = TYPE_MAX;
658
263
    } else {
659
263
        if (Compare::greater(_high_value, _low_value)) {
660
261
            switch (op) {
661
46
            case FILTER_LARGER: {
662
46
                if (Compare::greater_equal(value, _low_value)) {
663
45
                    _low_value = value;
664
45
                    _low_op = op;
665
45
                }
666
667
46
                break;
668
0
            }
669
670
72
            case FILTER_LARGER_OR_EQUAL: {
671
72
                if (Compare::greater(value, _low_value)) {
672
69
                    _low_value = value;
673
69
                    _low_op = op;
674
69
                }
675
676
72
                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
120
            case FILTER_LESS_OR_EQUAL: {
689
120
                if (Compare::less(value, _high_value)) {
690
114
                    _high_value = value;
691
114
                    _high_op = op;
692
114
                }
693
694
120
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
261
            }
701
261
        }
702
703
259
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
259
            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
259
    }
710
711
261
    return Status::OK();
712
265
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE9add_rangeENS_11SQLFilterOpEf
Line
Count
Source
614
75
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
75
    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
75
    _contain_null = false;
621
622
75
    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
75
    } else {
659
75
        if (Compare::greater(_high_value, _low_value)) {
660
74
            switch (op) {
661
27
            case FILTER_LARGER: {
662
27
                if (Compare::greater_equal(value, _low_value)) {
663
27
                    _low_value = value;
664
27
                    _low_op = op;
665
27
                }
666
667
27
                break;
668
0
            }
669
670
25
            case FILTER_LARGER_OR_EQUAL: {
671
25
                if (Compare::greater(value, _low_value)) {
672
12
                    _low_value = value;
673
12
                    _low_op = op;
674
12
                }
675
676
25
                break;
677
0
            }
678
679
6
            case FILTER_LESS: {
680
6
                if (Compare::less_equal(value, _high_value)) {
681
6
                    _high_value = value;
682
6
                    _high_op = op;
683
6
                }
684
685
6
                break;
686
0
            }
687
688
17
            case FILTER_LESS_OR_EQUAL: {
689
17
                if (Compare::less(value, _high_value)) {
690
6
                    _high_value = value;
691
6
                    _high_op = op;
692
6
                }
693
694
17
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
74
            }
701
74
        }
702
703
72
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
72
            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
72
    }
710
711
72
    return Status::OK();
712
75
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE9add_rangeENS_11SQLFilterOpEd
Line
Count
Source
614
251
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
251
    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
251
    _contain_null = false;
621
622
251
    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
251
    } else {
659
251
        if (Compare::greater(_high_value, _low_value)) {
660
251
            switch (op) {
661
68
            case FILTER_LARGER: {
662
68
                if (Compare::greater_equal(value, _low_value)) {
663
68
                    _low_value = value;
664
68
                    _low_op = op;
665
68
                }
666
667
68
                break;
668
0
            }
669
670
75
            case FILTER_LARGER_OR_EQUAL: {
671
75
                if (Compare::greater(value, _low_value)) {
672
31
                    _low_value = value;
673
31
                    _low_op = op;
674
31
                }
675
676
75
                break;
677
0
            }
678
679
33
            case FILTER_LESS: {
680
33
                if (Compare::less_equal(value, _high_value)) {
681
32
                    _high_value = value;
682
32
                    _high_op = op;
683
32
                }
684
685
33
                break;
686
0
            }
687
688
78
            case FILTER_LESS_OR_EQUAL: {
689
78
                if (Compare::less(value, _high_value)) {
690
35
                    _high_value = value;
691
35
                    _high_op = op;
692
35
                }
693
694
78
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
251
            }
701
251
        }
702
703
251
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
251
            Compare::equal(_high_value, _low_value)) {
705
7
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
7
            _high_value = TYPE_MIN;
707
7
            _low_value = TYPE_MAX;
708
7
        }
709
251
    }
710
711
251
    return Status::OK();
712
251
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE9add_rangeENS_11SQLFilterOpEj
Line
Count
Source
614
10
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
10
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
10
    _contain_null = false;
621
622
10
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
10
    } else {
659
10
        if (Compare::greater(_high_value, _low_value)) {
660
10
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
5
            case FILTER_LARGER_OR_EQUAL: {
671
5
                if (Compare::greater(value, _low_value)) {
672
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
5
                break;
677
0
            }
678
679
2
            case FILTER_LESS: {
680
2
                if (Compare::less_equal(value, _high_value)) {
681
2
                    _high_value = value;
682
2
                    _high_op = op;
683
2
                }
684
685
2
                break;
686
0
            }
687
688
3
            case FILTER_LESS_OR_EQUAL: {
689
3
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
3
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
10
            }
701
10
        }
702
703
10
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
10
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
10
    }
710
711
10
    return Status::OK();
712
10
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE9add_rangeENS_11SQLFilterOpEo
Line
Count
Source
614
6
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
6
    if (INVALID_TYPE == _column_type) {
616
0
        return Status::InternalError("AddRange failed, Invalid type");
617
0
    }
618
619
    // add range means range should not contain null
620
6
    _contain_null = false;
621
622
6
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
6
    } else {
659
6
        if (Compare::greater(_high_value, _low_value)) {
660
6
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
3
            case FILTER_LARGER_OR_EQUAL: {
671
3
                if (Compare::greater(value, _low_value)) {
672
2
                    _low_value = value;
673
2
                    _low_op = op;
674
2
                }
675
676
3
                break;
677
0
            }
678
679
2
            case FILTER_LESS: {
680
2
                if (Compare::less_equal(value, _high_value)) {
681
2
                    _high_value = value;
682
2
                    _high_op = op;
683
2
                }
684
685
2
                break;
686
0
            }
687
688
1
            case FILTER_LESS_OR_EQUAL: {
689
1
                if (Compare::less(value, _high_value)) {
690
0
                    _high_value = value;
691
0
                    _high_op = op;
692
0
                }
693
694
1
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
6
            }
701
6
        }
702
703
6
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
6
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
6
    }
710
711
6
    return Status::OK();
712
6
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
562
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
562
    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
562
    _contain_null = false;
621
622
562
    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
562
    } else {
659
562
        if (Compare::greater(_high_value, _low_value)) {
660
562
            switch (op) {
661
422
            case FILTER_LARGER: {
662
422
                if (Compare::greater_equal(value, _low_value)) {
663
415
                    _low_value = value;
664
415
                    _low_op = op;
665
415
                }
666
667
422
                break;
668
0
            }
669
670
41
            case FILTER_LARGER_OR_EQUAL: {
671
41
                if (Compare::greater(value, _low_value)) {
672
21
                    _low_value = value;
673
21
                    _low_op = op;
674
21
                }
675
676
41
                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
54
            case FILTER_LESS_OR_EQUAL: {
689
54
                if (Compare::less(value, _high_value)) {
690
37
                    _high_value = value;
691
37
                    _high_op = op;
692
37
                }
693
694
54
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
562
            }
701
562
        }
702
703
563
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
563
            Compare::equal(_high_value, _low_value)) {
705
6
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
6
            _high_value = TYPE_MIN;
707
6
            _low_value = TYPE_MAX;
708
6
        }
709
563
    }
710
711
563
    return Status::OK();
712
562
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
1.42k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.42k
    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.42k
    _contain_null = false;
621
622
1.42k
    if (is_fixed_value_range()) {
623
39
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
39
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
33
        case FILTER_LARGER_OR_EQUAL: {
632
33
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
33
            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
6
        case FILTER_LESS_OR_EQUAL: {
647
6
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
6
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
39
        }
655
656
39
        _high_value = TYPE_MIN;
657
39
        _low_value = TYPE_MAX;
658
1.38k
    } else {
659
1.38k
        if (Compare::greater(_high_value, _low_value)) {
660
1.32k
            switch (op) {
661
888
            case FILTER_LARGER: {
662
888
                if (Compare::greater_equal(value, _low_value)) {
663
879
                    _low_value = value;
664
879
                    _low_op = op;
665
879
                }
666
667
888
                break;
668
0
            }
669
670
136
            case FILTER_LARGER_OR_EQUAL: {
671
136
                if (Compare::greater(value, _low_value)) {
672
99
                    _low_value = value;
673
99
                    _low_op = op;
674
99
                }
675
676
136
                break;
677
0
            }
678
679
90
            case FILTER_LESS: {
680
90
                if (Compare::less_equal(value, _high_value)) {
681
90
                    _high_value = value;
682
90
                    _high_op = op;
683
90
                }
684
685
90
                break;
686
0
            }
687
688
211
            case FILTER_LESS_OR_EQUAL: {
689
211
                if (Compare::less(value, _high_value)) {
690
179
                    _high_value = value;
691
179
                    _high_op = op;
692
179
                }
693
694
211
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.32k
            }
701
1.32k
        }
702
703
1.38k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.38k
            Compare::equal(_high_value, _low_value)) {
705
55
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
55
            _high_value = TYPE_MIN;
707
55
            _low_value = TYPE_MAX;
708
55
        }
709
1.38k
    }
710
711
1.42k
    return Status::OK();
712
1.42k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE9add_rangeENS_11SQLFilterOpENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
614
218
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
218
    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
218
    _contain_null = false;
621
622
218
    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
218
    } else {
659
218
        if (Compare::greater(_high_value, _low_value)) {
660
217
            switch (op) {
661
17
            case FILTER_LARGER: {
662
17
                if (Compare::greater_equal(value, _low_value)) {
663
17
                    _low_value = value;
664
17
                    _low_op = op;
665
17
                }
666
667
17
                break;
668
0
            }
669
670
60
            case FILTER_LARGER_OR_EQUAL: {
671
60
                if (Compare::greater(value, _low_value)) {
672
16
                    _low_value = value;
673
16
                    _low_op = op;
674
16
                }
675
676
60
                break;
677
0
            }
678
679
61
            case FILTER_LESS: {
680
62
                if (Compare::less_equal(value, _high_value)) {
681
62
                    _high_value = value;
682
62
                    _high_op = op;
683
62
                }
684
685
61
                break;
686
0
            }
687
688
79
            case FILTER_LESS_OR_EQUAL: {
689
79
                if (Compare::less(value, _high_value)) {
690
42
                    _high_value = value;
691
42
                    _high_op = op;
692
42
                }
693
694
79
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
217
            }
701
217
        }
702
703
220
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
220
            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
220
    }
710
711
220
    return Status::OK();
712
218
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
614
19.6k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
19.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
19.6k
    _contain_null = false;
621
622
19.6k
    if (is_fixed_value_range()) {
623
19
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
19
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
18
        case FILTER_LARGER_OR_EQUAL: {
632
18
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
18
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
1
        case FILTER_LESS_OR_EQUAL: {
647
1
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
1
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
19
        }
655
656
19
        _high_value = TYPE_MIN;
657
19
        _low_value = TYPE_MAX;
658
19.5k
    } else {
659
19.5k
        if (Compare::greater(_high_value, _low_value)) {
660
19.5k
            switch (op) {
661
12.5k
            case FILTER_LARGER: {
662
12.5k
                if (Compare::greater_equal(value, _low_value)) {
663
12.5k
                    _low_value = value;
664
12.5k
                    _low_op = op;
665
12.5k
                }
666
667
12.5k
                break;
668
0
            }
669
670
4.02k
            case FILTER_LARGER_OR_EQUAL: {
671
4.02k
                if (Compare::greater(value, _low_value)) {
672
3.98k
                    _low_value = value;
673
3.98k
                    _low_op = op;
674
3.98k
                }
675
676
4.02k
                break;
677
0
            }
678
679
2.64k
            case FILTER_LESS: {
680
2.64k
                if (Compare::less_equal(value, _high_value)) {
681
2.63k
                    _high_value = value;
682
2.63k
                    _high_op = op;
683
2.63k
                }
684
685
2.64k
                break;
686
0
            }
687
688
321
            case FILTER_LESS_OR_EQUAL: {
689
321
                if (Compare::less(value, _high_value)) {
690
276
                    _high_value = value;
691
276
                    _high_op = op;
692
276
                }
693
694
321
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
19.5k
            }
701
19.5k
        }
702
703
19.5k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
19.5k
            Compare::equal(_high_value, _low_value)) {
705
48
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
48
            _high_value = TYPE_MIN;
707
48
            _low_value = TYPE_MAX;
708
48
        }
709
19.5k
    }
710
711
19.6k
    return Status::OK();
712
19.6k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE9add_rangeENS_11SQLFilterOpENS_16VecDateTimeValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE9add_rangeENS_11SQLFilterOpENS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
614
3.02k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
3.02k
    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.02k
    _contain_null = false;
621
622
3.02k
    if (is_fixed_value_range()) {
623
10
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
10
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
5
        case FILTER_LARGER_OR_EQUAL: {
632
5
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
5
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
5
        case FILTER_LESS_OR_EQUAL: {
647
5
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
5
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
10
        }
655
656
10
        _high_value = TYPE_MIN;
657
10
        _low_value = TYPE_MAX;
658
3.01k
    } else {
659
3.01k
        if (Compare::greater(_high_value, _low_value)) {
660
3.00k
            switch (op) {
661
228
            case FILTER_LARGER: {
662
230
                if (Compare::greater_equal(value, _low_value)) {
663
230
                    _low_value = value;
664
230
                    _low_op = op;
665
230
                }
666
667
228
                break;
668
0
            }
669
670
1.37k
            case FILTER_LARGER_OR_EQUAL: {
671
1.37k
                if (Compare::greater(value, _low_value)) {
672
1.32k
                    _low_value = value;
673
1.32k
                    _low_op = op;
674
1.32k
                }
675
676
1.37k
                break;
677
0
            }
678
679
1.26k
            case FILTER_LESS: {
680
1.26k
                if (Compare::less_equal(value, _high_value)) {
681
1.25k
                    _high_value = value;
682
1.25k
                    _high_op = op;
683
1.25k
                }
684
685
1.26k
                break;
686
0
            }
687
688
146
            case FILTER_LESS_OR_EQUAL: {
689
146
                if (Compare::less(value, _high_value)) {
690
104
                    _high_value = value;
691
104
                    _high_op = op;
692
104
                }
693
694
146
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
3.00k
            }
701
3.00k
        }
702
703
3.00k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
3.00k
            Compare::equal(_high_value, _low_value)) {
705
20
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
20
            _high_value = TYPE_MIN;
707
20
            _low_value = TYPE_MAX;
708
20
        }
709
3.00k
    }
710
711
3.01k
    return Status::OK();
712
3.02k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE9add_rangeENS_11SQLFilterOpENS_16TimestampTzValueE
Line
Count
Source
614
1.08k
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
1.08k
    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.08k
    _contain_null = false;
621
622
1.08k
    if (is_fixed_value_range()) {
623
0
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
0
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
0
        case FILTER_LARGER_OR_EQUAL: {
632
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
0
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
0
        case FILTER_LESS_OR_EQUAL: {
647
0
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
0
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
0
        }
655
656
0
        _high_value = TYPE_MIN;
657
0
        _low_value = TYPE_MAX;
658
1.08k
    } else {
659
1.08k
        if (Compare::greater(_high_value, _low_value)) {
660
1.07k
            switch (op) {
661
258
            case FILTER_LARGER: {
662
258
                if (Compare::greater_equal(value, _low_value)) {
663
253
                    _low_value = value;
664
253
                    _low_op = op;
665
253
                }
666
667
258
                break;
668
0
            }
669
670
327
            case FILTER_LARGER_OR_EQUAL: {
671
327
                if (Compare::greater(value, _low_value)) {
672
165
                    _low_value = value;
673
165
                    _low_op = op;
674
165
                }
675
676
327
                break;
677
0
            }
678
679
172
            case FILTER_LESS: {
680
172
                if (Compare::less_equal(value, _high_value)) {
681
168
                    _high_value = value;
682
168
                    _high_op = op;
683
168
                }
684
685
172
                break;
686
0
            }
687
688
322
            case FILTER_LESS_OR_EQUAL: {
689
322
                if (Compare::less(value, _high_value)) {
690
249
                    _high_value = value;
691
249
                    _high_op = op;
692
249
                }
693
694
322
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1.07k
            }
701
1.07k
        }
702
703
1.07k
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1.07k
            Compare::equal(_high_value, _low_value)) {
705
96
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
96
            _high_value = TYPE_MIN;
707
96
            _low_value = TYPE_MAX;
708
96
        }
709
1.07k
    }
710
711
1.07k
    return Status::OK();
712
1.08k
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE20EE9add_rangeENS_11SQLFilterOpENS_14DecimalV2ValueE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE2EE9add_rangeENS_11SQLFilterOpEh
Line
Count
Source
614
2
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
2
    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
    _contain_null = false;
621
622
2
    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
1
    } else {
659
1
        if (Compare::greater(_high_value, _low_value)) {
660
1
            switch (op) {
661
0
            case FILTER_LARGER: {
662
0
                if (Compare::greater_equal(value, _low_value)) {
663
0
                    _low_value = value;
664
0
                    _low_op = op;
665
0
                }
666
667
0
                break;
668
0
            }
669
670
0
            case FILTER_LARGER_OR_EQUAL: {
671
0
                if (Compare::greater(value, _low_value)) {
672
0
                    _low_value = value;
673
0
                    _low_op = op;
674
0
                }
675
676
0
                break;
677
0
            }
678
679
0
            case FILTER_LESS: {
680
0
                if (Compare::less_equal(value, _high_value)) {
681
0
                    _high_value = value;
682
0
                    _high_op = op;
683
0
                }
684
685
0
                break;
686
0
            }
687
688
1
            case FILTER_LESS_OR_EQUAL: {
689
1
                if (Compare::less(value, _high_value)) {
690
1
                    _high_value = value;
691
1
                    _high_op = op;
692
1
                }
693
694
1
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
1
            }
701
1
        }
702
703
1
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
1
            Compare::equal(_high_value, _low_value)) {
705
1
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
1
            _high_value = TYPE_MIN;
707
1
            _low_value = TYPE_MAX;
708
1
        }
709
1
    }
710
711
2
    return Status::OK();
712
2
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE9add_rangeENS_11SQLFilterOpENS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE9add_rangeENS_11SQLFilterOpENS_7DecimalIiEE
Line
Count
Source
614
152
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
152
    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
152
    _contain_null = false;
621
622
152
    if (is_fixed_value_range()) {
623
3
        std::pair<IteratorType, IteratorType> bound_pair = _fixed_values.equal_range(value);
624
625
3
        switch (op) {
626
0
        case FILTER_LARGER: {
627
0
            _fixed_values.erase(_fixed_values.begin(), bound_pair.second);
628
0
            break;
629
0
        }
630
631
1
        case FILTER_LARGER_OR_EQUAL: {
632
1
            _fixed_values.erase(_fixed_values.begin(), bound_pair.first);
633
1
            break;
634
0
        }
635
636
0
        case FILTER_LESS: {
637
0
            if (bound_pair.first == _fixed_values.find(value)) {
638
0
                _fixed_values.erase(bound_pair.first, _fixed_values.end());
639
0
            } else {
640
0
                _fixed_values.erase(bound_pair.second, _fixed_values.end());
641
0
            }
642
643
0
            break;
644
0
        }
645
646
2
        case FILTER_LESS_OR_EQUAL: {
647
2
            _fixed_values.erase(bound_pair.second, _fixed_values.end());
648
2
            break;
649
0
        }
650
651
0
        default: {
652
0
            return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
653
0
        }
654
3
        }
655
656
3
        _high_value = TYPE_MIN;
657
3
        _low_value = TYPE_MAX;
658
149
    } else {
659
149
        if (Compare::greater(_high_value, _low_value)) {
660
146
            switch (op) {
661
18
            case FILTER_LARGER: {
662
18
                if (Compare::greater_equal(value, _low_value)) {
663
18
                    _low_value = value;
664
18
                    _low_op = op;
665
18
                }
666
667
18
                break;
668
0
            }
669
670
51
            case FILTER_LARGER_OR_EQUAL: {
671
51
                if (Compare::greater(value, _low_value)) {
672
28
                    _low_value = value;
673
28
                    _low_op = op;
674
28
                }
675
676
51
                break;
677
0
            }
678
679
26
            case FILTER_LESS: {
680
26
                if (Compare::less_equal(value, _high_value)) {
681
24
                    _high_value = value;
682
24
                    _high_op = op;
683
24
                }
684
685
26
                break;
686
0
            }
687
688
53
            case FILTER_LESS_OR_EQUAL: {
689
53
                if (Compare::less(value, _high_value)) {
690
29
                    _high_value = value;
691
29
                    _high_op = op;
692
29
                }
693
694
53
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
146
            }
701
146
        }
702
703
147
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
147
            Compare::equal(_high_value, _low_value)) {
705
0
            RETURN_IF_ERROR(add_fixed_value(_high_value));
706
0
            _high_value = TYPE_MIN;
707
0
            _low_value = TYPE_MAX;
708
0
        }
709
147
    }
710
711
150
    return Status::OK();
712
152
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE9add_rangeENS_11SQLFilterOpENS_7DecimalIlEE
Line
Count
Source
614
91
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
91
    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
91
    _contain_null = false;
621
622
91
    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
91
    } else {
659
94
        if (Compare::greater(_high_value, _low_value)) {
660
94
            switch (op) {
661
31
            case FILTER_LARGER: {
662
31
                if (Compare::greater_equal(value, _low_value)) {
663
31
                    _low_value = value;
664
31
                    _low_op = op;
665
31
                }
666
667
31
                break;
668
0
            }
669
670
20
            case FILTER_LARGER_OR_EQUAL: {
671
20
                if (Compare::greater(value, _low_value)) {
672
18
                    _low_value = value;
673
18
                    _low_op = op;
674
18
                }
675
676
20
                break;
677
0
            }
678
679
22
            case FILTER_LESS: {
680
22
                if (Compare::less_equal(value, _high_value)) {
681
22
                    _high_value = value;
682
22
                    _high_op = op;
683
22
                }
684
685
22
                break;
686
0
            }
687
688
20
            case FILTER_LESS_OR_EQUAL: {
689
20
                if (Compare::less(value, _high_value)) {
690
19
                    _high_value = value;
691
19
                    _high_op = op;
692
19
                }
693
694
20
                break;
695
0
            }
696
697
0
            default: {
698
0
                return Status::InternalError("Add Range fail! Unsupported SQLFilterOp.");
699
0
            }
700
94
            }
701
94
        }
702
703
90
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
90
            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
90
    }
710
711
90
    return Status::OK();
712
91
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE9add_rangeENS_11SQLFilterOpENS_12Decimal128V3E
Line
Count
Source
614
96
Status ColumnValueRange<primitive_type>::add_range(SQLFilterOp op, const CppType value) {
615
96
    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
96
    _contain_null = false;
621
622
96
    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
96
    } else {
659
96
        if (Compare::greater(_high_value, _low_value)) {
660
96
            switch (op) {
661
75
            case FILTER_LARGER: {
662
75
                if (Compare::greater_equal(value, _low_value)) {
663
73
                    _low_value = value;
664
73
                    _low_op = op;
665
73
                }
666
667
75
                break;
668
0
            }
669
670
11
            case FILTER_LARGER_OR_EQUAL: {
671
11
                if (Compare::greater(value, _low_value)) {
672
11
                    _low_value = value;
673
11
                    _low_op = op;
674
11
                }
675
676
11
                break;
677
0
            }
678
679
2
            case FILTER_LESS: {
680
2
                if (Compare::less_equal(value, _high_value)) {
681
2
                    _high_value = value;
682
2
                    _high_op = op;
683
2
                }
684
685
2
                break;
686
0
            }
687
688
9
            case FILTER_LESS_OR_EQUAL: {
689
9
                if (Compare::less(value, _high_value)) {
690
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
96
            }
701
96
        }
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
96
}
_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
98
        if (Compare::greater(_high_value, _low_value)) {
660
98
            switch (op) {
661
22
            case FILTER_LARGER: {
662
22
                if (Compare::greater_equal(value, _low_value)) {
663
22
                    _low_value = value;
664
22
                    _low_op = op;
665
22
                }
666
667
22
                break;
668
0
            }
669
670
27
            case FILTER_LARGER_OR_EQUAL: {
671
27
                if (Compare::greater(value, _low_value)) {
672
15
                    _low_value = value;
673
15
                    _low_op = op;
674
15
                }
675
676
27
                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
98
            }
701
98
        }
702
703
97
        if (FILTER_LARGER_OR_EQUAL == _low_op && FILTER_LESS_OR_EQUAL == _high_op &&
704
97
            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
97
    }
710
711
97
    return Status::OK();
712
98
}
713
714
template <PrimitiveType primitive_type>
715
303k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
303k
    switch (_high_op) {
717
13
    case FILTER_LESS: {
718
13
        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
13
        case FILTER_LARGER_OR_EQUAL: {
724
13
            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
13
        }
731
732
0
        break;
733
13
    }
734
735
303k
    case FILTER_LESS_OR_EQUAL: {
736
303k
        switch (_low_op) {
737
51
        case FILTER_LARGER: {
738
51
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
303k
        case FILTER_LARGER_OR_EQUAL: {
742
303k
            return Compare::less_equal(value, _high_value) &&
743
303k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
303k
        }
750
303k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
303k
    }
756
757
0
    return false;
758
303k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE11is_in_rangeERKa
Line
Count
Source
715
78.8k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
78.8k
    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
78.9k
    case FILTER_LESS_OR_EQUAL: {
736
78.9k
        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
78.8k
        case FILTER_LARGER_OR_EQUAL: {
742
78.8k
            return Compare::less_equal(value, _high_value) &&
743
78.8k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
78.9k
        }
750
78.9k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
78.8k
    }
756
757
0
    return false;
758
78.8k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE11is_in_rangeERKs
Line
Count
Source
715
182
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
182
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
181
    case FILTER_LESS_OR_EQUAL: {
736
181
        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
181
        case FILTER_LARGER_OR_EQUAL: {
742
181
            return Compare::less_equal(value, _high_value) &&
743
181
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
181
        }
750
181
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
182
    }
756
757
0
    return false;
758
182
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE11is_in_rangeERKi
Line
Count
Source
715
44.0k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
44.0k
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
44.0k
    case FILTER_LESS_OR_EQUAL: {
736
44.0k
        switch (_low_op) {
737
42
        case FILTER_LARGER: {
738
42
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
44.0k
        case FILTER_LARGER_OR_EQUAL: {
742
44.0k
            return Compare::less_equal(value, _high_value) &&
743
44.0k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
44.0k
        }
750
44.0k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
44.0k
    }
756
757
0
    return false;
758
44.0k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE11is_in_rangeERKl
Line
Count
Source
715
654
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
654
    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
653
    case FILTER_LESS_OR_EQUAL: {
736
653
        switch (_low_op) {
737
2
        case FILTER_LARGER: {
738
2
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
652
        case FILTER_LARGER_OR_EQUAL: {
742
652
            return Compare::less_equal(value, _high_value) &&
743
652
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
653
        }
750
653
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
654
    }
756
757
0
    return false;
758
654
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE11is_in_rangeERKn
Line
Count
Source
715
193
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
193
    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
193
    case FILTER_LESS_OR_EQUAL: {
736
193
        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
193
        case FILTER_LARGER_OR_EQUAL: {
742
193
            return Compare::less_equal(value, _high_value) &&
743
194
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
193
        }
750
193
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
193
    }
756
757
0
    return false;
758
193
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE11is_in_rangeERKf
Line
Count
Source
715
21
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
21
    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
22
    case FILTER_LESS_OR_EQUAL: {
736
22
        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
22
        case FILTER_LARGER_OR_EQUAL: {
742
22
            return Compare::less_equal(value, _high_value) &&
743
22
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
22
        }
750
22
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
21
    }
756
757
0
    return false;
758
21
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE11is_in_rangeERKd
Line
Count
Source
715
125
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
125
    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
125
    case FILTER_LESS_OR_EQUAL: {
736
125
        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
126
        case FILTER_LARGER_OR_EQUAL: {
742
126
            return Compare::less_equal(value, _high_value) &&
743
126
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
125
        }
750
125
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
125
    }
756
757
0
    return false;
758
125
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE11is_in_rangeERKj
Line
Count
Source
715
23
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
23
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
23
    case FILTER_LESS_OR_EQUAL: {
736
23
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
23
        case FILTER_LARGER_OR_EQUAL: {
742
23
            return Compare::less_equal(value, _high_value) &&
743
23
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
23
        }
750
23
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
23
    }
756
757
0
    return false;
758
23
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE11is_in_rangeERKo
Line
Count
Source
715
25
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
25
    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
25
    case FILTER_LESS_OR_EQUAL: {
736
25
        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
25
        case FILTER_LARGER_OR_EQUAL: {
742
25
            return Compare::less_equal(value, _high_value) &&
743
25
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
25
        }
750
25
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
25
    }
756
757
0
    return false;
758
25
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
779
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
779
    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
779
    case FILTER_LESS_OR_EQUAL: {
736
779
        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
778
        case FILTER_LARGER_OR_EQUAL: {
742
778
            return Compare::less_equal(value, _high_value) &&
743
783
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
779
        }
750
779
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
779
    }
756
757
0
    return false;
758
779
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
167k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
167k
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
167k
    case FILTER_LESS_OR_EQUAL: {
736
167k
        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
167k
        case FILTER_LARGER_OR_EQUAL: {
742
167k
            return Compare::less_equal(value, _high_value) &&
743
167k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
167k
        }
750
167k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
167k
    }
756
757
0
    return false;
758
167k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE11is_in_rangeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
Line
Count
Source
715
340
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
340
    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
338
    case FILTER_LESS_OR_EQUAL: {
736
338
        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
339
        case FILTER_LARGER_OR_EQUAL: {
742
339
            return Compare::less_equal(value, _high_value) &&
743
339
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
338
        }
750
338
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
340
    }
756
757
0
    return false;
758
340
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
52
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
52
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
52
    case FILTER_LESS_OR_EQUAL: {
736
52
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
52
        case FILTER_LARGER_OR_EQUAL: {
742
52
            return Compare::less_equal(value, _high_value) &&
743
52
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
52
        }
750
52
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
52
    }
756
757
0
    return false;
758
52
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE11is_in_rangeERKNS_11DateV2ValueINS_15DateV2ValueTypeEEE
Line
Count
Source
715
9.18k
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
9.18k
    switch (_high_op) {
717
4
    case FILTER_LESS: {
718
4
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
4
        case FILTER_LARGER_OR_EQUAL: {
724
4
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
4
        }
731
732
0
        break;
733
4
    }
734
735
9.17k
    case FILTER_LESS_OR_EQUAL: {
736
9.17k
        switch (_low_op) {
737
7
        case FILTER_LARGER: {
738
7
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
9.17k
        case FILTER_LARGER_OR_EQUAL: {
742
9.17k
            return Compare::less_equal(value, _high_value) &&
743
9.17k
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
9.17k
        }
750
9.17k
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
9.18k
    }
756
757
0
    return false;
758
9.18k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE11is_in_rangeERKNS_16VecDateTimeValueE
Line
Count
Source
715
68
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
68
    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
68
    case FILTER_LESS_OR_EQUAL: {
736
68
        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
68
        case FILTER_LARGER_OR_EQUAL: {
742
68
            return Compare::less_equal(value, _high_value) &&
743
69
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
68
        }
750
68
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
68
    }
756
757
0
    return false;
758
68
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE11is_in_rangeERKNS_11DateV2ValueINS_19DateTimeV2ValueTypeEEE
Line
Count
Source
715
401
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
401
    switch (_high_op) {
717
9
    case FILTER_LESS: {
718
9
        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
9
        case FILTER_LARGER_OR_EQUAL: {
724
9
            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
9
        }
731
732
0
        break;
733
9
    }
734
735
393
    case FILTER_LESS_OR_EQUAL: {
736
393
        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
393
        case FILTER_LARGER_OR_EQUAL: {
742
393
            return Compare::less_equal(value, _high_value) &&
743
393
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
393
        }
750
393
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
401
    }
756
757
0
    return false;
758
401
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE11is_in_rangeERKNS_16TimestampTzValueE
Line
Count
Source
715
246
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
246
    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
246
    case FILTER_LESS_OR_EQUAL: {
736
246
        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
246
        case FILTER_LARGER_OR_EQUAL: {
742
246
            return Compare::less_equal(value, _high_value) &&
743
246
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
246
        }
750
246
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
246
    }
756
757
0
    return false;
758
246
}
_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
195
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
195
    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
195
    case FILTER_LESS_OR_EQUAL: {
736
195
        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
195
        case FILTER_LARGER_OR_EQUAL: {
742
195
            return Compare::less_equal(value, _high_value) &&
743
195
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
195
        }
750
195
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
195
    }
756
757
0
    return false;
758
195
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE11is_in_rangeERKNS_9StringRefE
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE11is_in_rangeERKNS_7DecimalIiEE
Line
Count
Source
715
42
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
42
    switch (_high_op) {
717
0
    case FILTER_LESS: {
718
0
        switch (_low_op) {
719
0
        case FILTER_LARGER: {
720
0
            return Compare::less(value, _high_value) && Compare::greater(value, _low_value);
721
0
        }
722
723
0
        case FILTER_LARGER_OR_EQUAL: {
724
0
            return Compare::less(value, _high_value) && Compare::greater_equal(value, _low_value);
725
0
        }
726
727
0
        default: {
728
0
            DCHECK(false);
729
0
        }
730
0
        }
731
732
0
        break;
733
0
    }
734
735
42
    case FILTER_LESS_OR_EQUAL: {
736
42
        switch (_low_op) {
737
0
        case FILTER_LARGER: {
738
0
            return Compare::less_equal(value, _high_value) && Compare::greater(value, _low_value);
739
0
        }
740
741
40
        case FILTER_LARGER_OR_EQUAL: {
742
40
            return Compare::less_equal(value, _high_value) &&
743
40
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
42
        }
750
42
    }
751
752
0
    default: {
753
0
        DCHECK(false);
754
0
    }
755
42
    }
756
757
0
    return false;
758
42
}
_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
278
    case FILTER_LESS_OR_EQUAL: {
736
278
        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
280
        case FILTER_LARGER_OR_EQUAL: {
742
280
            return Compare::less_equal(value, _high_value) &&
743
282
                   Compare::greater_equal(value, _low_value);
744
0
        }
745
746
0
        default: {
747
0
            DCHECK(false);
748
0
        }
749
278
        }
750
278
    }
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
117
        case FILTER_LARGER_OR_EQUAL: {
742
117
            return Compare::less_equal(value, _high_value) &&
743
117
                   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
47
bool ColumnValueRange<primitive_type>::is_in_range(const CppType& value) {
716
47
    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
47
        case FILTER_LARGER_OR_EQUAL: {
742
47
            return Compare::less_equal(value, _high_value) &&
743
47
                   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
47
    }
756
757
0
    return false;
758
47
}
759
760
template <PrimitiveType primitive_type>
761
286k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
286k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
286k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
21.9k
        set_empty_value_range();
770
21.9k
    }
771
772
286k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
286k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
260k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
133
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
133
                             range._fixed_values.begin(), range._fixed_values.end(),
778
133
                             std::inserter(result_values, result_values.begin()));
779
260k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
10
            IteratorType iter = _fixed_values.begin();
781
782
38
            while (iter != _fixed_values.end()) {
783
28
                if (range.is_in_range(*iter)) {
784
28
                    result_values.insert(*iter);
785
28
                }
786
28
                ++iter;
787
28
            }
788
260k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
260k
            IteratorType iter = range._fixed_values.begin();
790
562k
            while (iter != range._fixed_values.end()) {
791
303k
                if (this->is_in_range(*iter)) {
792
303k
                    result_values.insert(*iter);
793
303k
                }
794
301k
                ++iter;
795
301k
            }
796
260k
        }
797
798
263k
        if (!result_values.empty()) {
799
263k
            _fixed_values = std::move(result_values);
800
263k
            _contain_null = false;
801
263k
            _high_value = TYPE_MIN;
802
263k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
260k
    } else {
807
25.7k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
308
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
308
                set_contain_null(true);
811
308
            }
812
25.4k
        } else {
813
25.4k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
25.4k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
25.4k
        }
816
25.7k
    }
817
286k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE3EE12intersectionERS2_
Line
Count
Source
761
79.3k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
79.3k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
79.3k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
12
        set_empty_value_range();
770
12
    }
771
772
79.3k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
79.3k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
77.7k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
1
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
1
                             range._fixed_values.begin(), range._fixed_values.end(),
778
1
                             std::inserter(result_values, result_values.begin()));
779
77.7k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
77.7k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
77.6k
            IteratorType iter = range._fixed_values.begin();
790
155k
            while (iter != range._fixed_values.end()) {
791
78.6k
                if (this->is_in_range(*iter)) {
792
78.6k
                    result_values.insert(*iter);
793
78.6k
                }
794
77.7k
                ++iter;
795
77.7k
            }
796
77.6k
        }
797
798
79.0k
        if (!result_values.empty()) {
799
79.0k
            _fixed_values = std::move(result_values);
800
79.0k
            _contain_null = false;
801
79.0k
            _high_value = TYPE_MIN;
802
79.0k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
77.7k
    } else {
807
1.66k
        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.66k
        } else {
813
1.66k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
1.66k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
1.66k
        }
816
1.66k
    }
817
79.3k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE4EE12intersectionERS2_
Line
Count
Source
761
115
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
115
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
116
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
4
        set_empty_value_range();
770
4
    }
771
772
115
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
115
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
82
        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
82
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
83
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
83
            IteratorType iter = range._fixed_values.begin();
790
265
            while (iter != range._fixed_values.end()) {
791
182
                if (this->is_in_range(*iter)) {
792
181
                    result_values.insert(*iter);
793
181
                }
794
182
                ++iter;
795
182
            }
796
83
        }
797
798
84
        if (!result_values.empty()) {
799
84
            _fixed_values = std::move(result_values);
800
84
            _contain_null = false;
801
84
            _high_value = TYPE_MIN;
802
84
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
82
    } else {
807
33
        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
32
        } else {
813
32
            static_cast<void>(add_range(range._high_op, range._high_value));
814
32
            static_cast<void>(add_range(range._low_op, range._low_value));
815
32
        }
816
33
    }
817
115
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE5EE12intersectionERS2_
Line
Count
Source
761
5.44k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
5.44k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
5.44k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
305
        set_empty_value_range();
770
305
    }
771
772
5.44k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
5.44k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
4.60k
        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
4.56k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
4.57k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
4.57k
            IteratorType iter = range._fixed_values.begin();
790
48.6k
            while (iter != range._fixed_values.end()) {
791
44.0k
                if (this->is_in_range(*iter)) {
792
44.0k
                    result_values.insert(*iter);
793
44.0k
                }
794
44.0k
                ++iter;
795
44.0k
            }
796
4.57k
        }
797
798
4.65k
        if (!result_values.empty()) {
799
4.65k
            _fixed_values = std::move(result_values);
800
4.65k
            _contain_null = false;
801
4.65k
            _high_value = TYPE_MIN;
802
4.65k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
4.60k
    } else {
807
844
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
59
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
59
                set_contain_null(true);
811
59
            }
812
786
        } else {
813
786
            static_cast<void>(add_range(range._high_op, range._high_value));
814
786
            static_cast<void>(add_range(range._low_op, range._low_value));
815
786
        }
816
844
    }
817
5.44k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE6EE12intersectionERS2_
Line
Count
Source
761
22.1k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
22.1k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
22.1k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
21.6k
        set_empty_value_range();
770
21.6k
    }
771
772
22.1k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
22.1k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
519
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
68
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
68
                             range._fixed_values.begin(), range._fixed_values.end(),
778
68
                             std::inserter(result_values, result_values.begin()));
779
451
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
10
            IteratorType iter = _fixed_values.begin();
781
782
38
            while (iter != _fixed_values.end()) {
783
28
                if (range.is_in_range(*iter)) {
784
28
                    result_values.insert(*iter);
785
28
                }
786
28
                ++iter;
787
28
            }
788
441
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
441
            IteratorType iter = range._fixed_values.begin();
790
1.06k
            while (iter != range._fixed_values.end()) {
791
619
                if (this->is_in_range(*iter)) {
792
618
                    result_values.insert(*iter);
793
618
                }
794
619
                ++iter;
795
619
            }
796
441
        }
797
798
521
        if (!result_values.empty()) {
799
521
            _fixed_values = std::move(result_values);
800
521
            _contain_null = false;
801
521
            _high_value = TYPE_MIN;
802
521
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
21.6k
    } else {
807
21.6k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
21.6k
        } else {
813
21.6k
            static_cast<void>(add_range(range._high_op, range._high_value));
814
21.6k
            static_cast<void>(add_range(range._low_op, range._low_value));
815
21.6k
        }
816
21.6k
    }
817
22.1k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE7EE12intersectionERS2_
Line
Count
Source
761
195
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
195
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
195
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
195
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
195
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
177
        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
177
        } 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
177
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
176
            IteratorType iter = range._fixed_values.begin();
790
367
            while (iter != range._fixed_values.end()) {
791
194
                if (this->is_in_range(*iter)) {
792
194
                    result_values.insert(*iter);
793
194
                }
794
191
                ++iter;
795
191
            }
796
176
        }
797
798
180
        if (!result_values.empty()) {
799
180
            _fixed_values = std::move(result_values);
800
180
            _contain_null = false;
801
180
            _high_value = TYPE_MIN;
802
180
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
177
    } else {
807
18
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
11
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
11
                set_contain_null(true);
811
11
            }
812
11
        } else {
813
7
            static_cast<void>(add_range(range._high_op, range._high_value));
814
7
            static_cast<void>(add_range(range._low_op, range._low_value));
815
7
        }
816
18
    }
817
195
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE8EE12intersectionERS2_
Line
Count
Source
761
36
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
36
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
36
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
36
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
36
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
17
        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
17
        } 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
17
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
17
            IteratorType iter = range._fixed_values.begin();
790
38
            while (iter != range._fixed_values.end()) {
791
22
                if (this->is_in_range(*iter)) {
792
22
                    result_values.insert(*iter);
793
22
                }
794
21
                ++iter;
795
21
            }
796
17
        }
797
798
17
        if (!result_values.empty()) {
799
17
            _fixed_values = std::move(result_values);
800
17
            _contain_null = false;
801
17
            _high_value = TYPE_MIN;
802
17
            _low_value = TYPE_MAX;
803
17
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
19
    } else {
807
19
        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
12
        } else {
813
12
            static_cast<void>(add_range(range._high_op, range._high_value));
814
12
            static_cast<void>(add_range(range._low_op, range._low_value));
815
12
        }
816
19
    }
817
36
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE9EE12intersectionERS2_
Line
Count
Source
761
144
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
144
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
144
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
144
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
144
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
87
        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
87
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
88
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
87
            IteratorType iter = range._fixed_values.begin();
790
207
            while (iter != range._fixed_values.end()) {
791
120
                if (this->is_in_range(*iter)) {
792
120
                    result_values.insert(*iter);
793
120
                }
794
120
                ++iter;
795
120
            }
796
87
        }
797
798
92
        if (!result_values.empty()) {
799
92
            _fixed_values = std::move(result_values);
800
92
            _contain_null = false;
801
92
            _high_value = TYPE_MIN;
802
92
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
87
    } else {
807
57
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
13
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
13
                set_contain_null(true);
811
13
            }
812
44
        } else {
813
44
            static_cast<void>(add_range(range._high_op, range._high_value));
814
44
            static_cast<void>(add_range(range._low_op, range._low_value));
815
44
        }
816
57
    }
817
144
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE36EE12intersectionERS2_
Line
Count
Source
761
21
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
21
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
21
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
21
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
21
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
18
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
18
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
18
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
18
            IteratorType iter = range._fixed_values.begin();
790
41
            while (iter != range._fixed_values.end()) {
791
23
                if (this->is_in_range(*iter)) {
792
23
                    result_values.insert(*iter);
793
23
                }
794
23
                ++iter;
795
23
            }
796
18
        }
797
798
18
        if (!result_values.empty()) {
799
18
            _fixed_values = std::move(result_values);
800
18
            _contain_null = false;
801
18
            _high_value = TYPE_MIN;
802
18
            _low_value = TYPE_MAX;
803
18
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
18
    } else {
807
3
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
3
        } else {
813
3
            static_cast<void>(add_range(range._high_op, range._high_value));
814
3
            static_cast<void>(add_range(range._low_op, range._low_value));
815
3
        }
816
3
    }
817
21
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE37EE12intersectionERS2_
Line
Count
Source
761
21
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
21
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
21
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
21
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
21
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
20
        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
20
        } 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
20
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
20
            IteratorType iter = range._fixed_values.begin();
790
45
            while (iter != range._fixed_values.end()) {
791
25
                if (this->is_in_range(*iter)) {
792
25
                    result_values.insert(*iter);
793
25
                }
794
25
                ++iter;
795
25
            }
796
20
        }
797
798
20
        if (!result_values.empty()) {
799
20
            _fixed_values = std::move(result_values);
800
20
            _contain_null = false;
801
20
            _high_value = TYPE_MIN;
802
20
            _low_value = TYPE_MAX;
803
20
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
20
    } 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
21
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE15EE12intersectionERS2_
Line
Count
Source
761
479
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
479
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
479
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
479
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
479
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
452
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
14
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
14
                             range._fixed_values.begin(), range._fixed_values.end(),
778
14
                             std::inserter(result_values, result_values.begin()));
779
438
        } 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
438
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
436
            IteratorType iter = range._fixed_values.begin();
790
1.20k
            while (iter != range._fixed_values.end()) {
791
781
                if (this->is_in_range(*iter)) {
792
781
                    result_values.insert(*iter);
793
781
                }
794
773
                ++iter;
795
773
            }
796
436
        }
797
798
462
        if (!result_values.empty()) {
799
462
            _fixed_values = std::move(result_values);
800
462
            _contain_null = false;
801
462
            _high_value = TYPE_MIN;
802
462
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
452
    } else {
807
27
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
2
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
2
                set_contain_null(true);
811
2
            }
812
25
        } else {
813
25
            static_cast<void>(add_range(range._high_op, range._high_value));
814
25
            static_cast<void>(add_range(range._low_op, range._low_value));
815
25
        }
816
27
    }
817
479
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE10EE12intersectionERS2_
Line
Count
Source
761
167k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
167k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
167k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
27
        set_empty_value_range();
770
27
    }
771
772
167k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
167k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
166k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
3
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
3
                             range._fixed_values.begin(), range._fixed_values.end(),
778
3
                             std::inserter(result_values, result_values.begin()));
779
166k
        } 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
166k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
166k
            IteratorType iter = range._fixed_values.begin();
790
333k
            while (iter != range._fixed_values.end()) {
791
167k
                if (this->is_in_range(*iter)) {
792
167k
                    result_values.insert(*iter);
793
167k
                }
794
167k
                ++iter;
795
167k
            }
796
166k
        }
797
798
167k
        if (!result_values.empty()) {
799
167k
            _fixed_values = std::move(result_values);
800
167k
            _contain_null = false;
801
167k
            _high_value = TYPE_MIN;
802
167k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
166k
    } else {
807
1.12k
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
131
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
131
                set_contain_null(true);
811
131
            }
812
994
        } else {
813
994
            static_cast<void>(add_range(range._high_op, range._high_value));
814
994
            static_cast<void>(add_range(range._low_op, range._low_value));
815
994
        }
816
1.12k
    }
817
167k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE23EE12intersectionERS2_
Line
Count
Source
761
372
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
372
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
372
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
372
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
372
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
298
        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
298
        } 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
298
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
296
            IteratorType iter = range._fixed_values.begin();
790
634
            while (iter != range._fixed_values.end()) {
791
338
                if (this->is_in_range(*iter)) {
792
337
                    result_values.insert(*iter);
793
337
                }
794
338
                ++iter;
795
338
            }
796
296
        }
797
798
306
        if (!result_values.empty()) {
799
306
            _fixed_values = std::move(result_values);
800
306
            _contain_null = false;
801
306
            _high_value = TYPE_MIN;
802
306
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
298
    } else {
807
74
        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
41
        } else {
813
41
            static_cast<void>(add_range(range._high_op, range._high_value));
814
41
            static_cast<void>(add_range(range._low_op, range._low_value));
815
41
        }
816
74
    }
817
372
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE11EE12intersectionERS2_
Line
Count
Source
761
25
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
25
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
25
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
25
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
25
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
25
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
25
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
25
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
25
            IteratorType iter = range._fixed_values.begin();
790
77
            while (iter != range._fixed_values.end()) {
791
52
                if (this->is_in_range(*iter)) {
792
52
                    result_values.insert(*iter);
793
52
                }
794
52
                ++iter;
795
52
            }
796
25
        }
797
798
25
        if (!result_values.empty()) {
799
25
            _fixed_values = std::move(result_values);
800
25
            _contain_null = false;
801
25
            _high_value = TYPE_MIN;
802
25
            _low_value = TYPE_MAX;
803
25
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
25
    } 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
25
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE25EE12intersectionERS2_
Line
Count
Source
761
9.17k
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
9.17k
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
9.17k
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
9
        set_empty_value_range();
770
9
    }
771
772
9.17k
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
9.17k
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
9.06k
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
6
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
6
                             range._fixed_values.begin(), range._fixed_values.end(),
778
6
                             std::inserter(result_values, result_values.begin()));
779
9.05k
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
9.05k
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
9.05k
            IteratorType iter = range._fixed_values.begin();
790
18.2k
            while (iter != range._fixed_values.end()) {
791
9.18k
                if (this->is_in_range(*iter)) {
792
9.18k
                    result_values.insert(*iter);
793
9.18k
                }
794
9.15k
                ++iter;
795
9.15k
            }
796
9.05k
        }
797
798
9.10k
        if (!result_values.empty()) {
799
9.10k
            _fixed_values = std::move(result_values);
800
9.10k
            _contain_null = false;
801
9.10k
            _high_value = TYPE_MIN;
802
9.10k
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
9.06k
    } else {
807
113
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
31
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
31
                set_contain_null(true);
811
31
            }
812
84
        } else {
813
84
            static_cast<void>(add_range(range._high_op, range._high_value));
814
84
            static_cast<void>(add_range(range._low_op, range._low_value));
815
84
        }
816
113
    }
817
9.17k
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE12EE12intersectionERS2_
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
38
        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
38
        } 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
104
            while (iter != range._fixed_values.end()) {
791
69
                if (this->is_in_range(*iter)) {
792
69
                    result_values.insert(*iter);
793
69
                }
794
65
                ++iter;
795
65
            }
796
39
        }
797
798
41
        if (!result_values.empty()) {
799
41
            _fixed_values = std::move(result_values);
800
41
            _contain_null = false;
801
41
            _high_value = TYPE_MIN;
802
41
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
38
    } else {
807
2
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
2
        } else {
813
2
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2
        }
816
2
    }
817
40
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE26EE12intersectionERS2_
Line
Count
Source
761
431
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
431
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
431
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
431
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
431
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
371
        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
371
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
372
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
372
            IteratorType iter = range._fixed_values.begin();
790
763
            while (iter != range._fixed_values.end()) {
791
401
                if (this->is_in_range(*iter)) {
792
401
                    result_values.insert(*iter);
793
401
                }
794
391
                ++iter;
795
391
            }
796
372
        }
797
798
388
        if (!result_values.empty()) {
799
388
            _fixed_values = std::move(result_values);
800
388
            _contain_null = false;
801
388
            _high_value = TYPE_MIN;
802
388
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
371
    } else {
807
60
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
5
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
5
                set_contain_null(true);
811
5
            }
812
55
        } else {
813
55
            static_cast<void>(add_range(range._high_op, range._high_value));
814
55
            static_cast<void>(add_range(range._low_op, range._low_value));
815
55
        }
816
60
    }
817
431
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE42EE12intersectionERS2_
Line
Count
Source
761
186
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
186
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
186
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
186
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
186
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
105
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
105
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
105
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
105
            IteratorType iter = range._fixed_values.begin();
790
352
            while (iter != range._fixed_values.end()) {
791
247
                if (this->is_in_range(*iter)) {
792
247
                    result_values.insert(*iter);
793
247
                }
794
247
                ++iter;
795
247
            }
796
105
        }
797
798
105
        if (!result_values.empty()) {
799
105
            _fixed_values = std::move(result_values);
800
105
            _contain_null = false;
801
105
            _high_value = TYPE_MIN;
802
105
            _low_value = TYPE_MAX;
803
105
        } else {
804
0
            set_empty_value_range();
805
0
        }
806
105
    } else {
807
81
        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
72
        } else {
813
72
            static_cast<void>(add_range(range._high_op, range._high_value));
814
72
            static_cast<void>(add_range(range._low_op, range._low_value));
815
72
        }
816
81
    }
817
186
}
_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
193
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
193
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
193
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
193
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
193
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
186
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
1
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
1
                             range._fixed_values.begin(), range._fixed_values.end(),
778
1
                             std::inserter(result_values, result_values.begin()));
779
185
        } 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
185
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
185
            IteratorType iter = range._fixed_values.begin();
790
376
            while (iter != range._fixed_values.end()) {
791
194
                if (this->is_in_range(*iter)) {
792
194
                    result_values.insert(*iter);
793
194
                }
794
191
                ++iter;
795
191
            }
796
185
        }
797
798
188
        if (!result_values.empty()) {
799
188
            _fixed_values = std::move(result_values);
800
188
            _contain_null = false;
801
188
            _high_value = TYPE_MIN;
802
188
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
186
    } else {
807
7
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
3
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
3
                set_contain_null(true);
811
3
            }
812
4
        } else {
813
4
            static_cast<void>(add_range(range._high_op, range._high_value));
814
4
            static_cast<void>(add_range(range._low_op, range._low_value));
815
4
        }
816
7
    }
817
193
}
Unexecuted instantiation: _ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE19EE12intersectionERS2_
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE28EE12intersectionERS2_
Line
Count
Source
761
60
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
60
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
60
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
60
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
60
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
33
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
33
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
33
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
32
            IteratorType iter = range._fixed_values.begin();
790
71
            while (iter != range._fixed_values.end()) {
791
40
                if (this->is_in_range(*iter)) {
792
40
                    result_values.insert(*iter);
793
40
                }
794
39
                ++iter;
795
39
            }
796
32
        }
797
798
34
        if (!result_values.empty()) {
799
34
            _fixed_values = std::move(result_values);
800
34
            _contain_null = false;
801
34
            _high_value = TYPE_MIN;
802
34
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
33
    } else {
807
27
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
27
        } else {
813
27
            static_cast<void>(add_range(range._high_op, range._high_value));
814
27
            static_cast<void>(add_range(range._low_op, range._low_value));
815
27
        }
816
27
    }
817
60
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE29EE12intersectionERS2_
Line
Count
Source
761
254
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
254
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
254
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
254
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
254
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
246
        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
246
        } 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
246
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
245
            IteratorType iter = range._fixed_values.begin();
790
524
            while (iter != range._fixed_values.end()) {
791
280
                if (this->is_in_range(*iter)) {
792
280
                    result_values.insert(*iter);
793
280
                }
794
279
                ++iter;
795
279
            }
796
245
        }
797
798
252
        if (!result_values.empty()) {
799
252
            _fixed_values = std::move(result_values);
800
252
            _contain_null = false;
801
252
            _high_value = TYPE_MIN;
802
252
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
246
    } else {
807
8
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
2
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
2
                set_contain_null(true);
811
2
            }
812
6
        } else {
813
6
            static_cast<void>(add_range(range._high_op, range._high_value));
814
6
            static_cast<void>(add_range(range._low_op, range._low_value));
815
6
        }
816
8
    }
817
254
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE30EE12intersectionERS2_
Line
Count
Source
761
112
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
112
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
112
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
112
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
112
    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
109
            IteratorType iter = range._fixed_values.begin();
790
225
            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
109
        }
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
2
        if (contain_null() && range.contain_null()) {
808
            // if both is_whole_range to keep the same, else set_contain_null
809
0
            if (!is_whole_value_range() || !range.is_whole_value_range()) {
810
0
                set_contain_null(true);
811
0
            }
812
2
        } else {
813
2
            static_cast<void>(add_range(range._high_op, range._high_value));
814
2
            static_cast<void>(add_range(range._low_op, range._low_value));
815
2
        }
816
2
    }
817
112
}
_ZN5doris16ColumnValueRangeILNS_13PrimitiveTypeE35EE12intersectionERS2_
Line
Count
Source
761
45
void ColumnValueRange<primitive_type>::intersection(ColumnValueRange<primitive_type>& range) {
762
    // 1. clear if column type not match
763
45
    if (_column_type != range._column_type) {
764
0
        set_empty_value_range();
765
0
    }
766
767
    // 2. clear if any range is empty
768
45
    if (is_empty_value_range() || range.is_empty_value_range()) {
769
0
        set_empty_value_range();
770
0
    }
771
772
45
    SetType result_values;
773
    // 3. fixed_value intersection, fixed value range do not contain null
774
45
    if (is_fixed_value_range() || range.is_fixed_value_range()) {
775
33
        if (is_fixed_value_range() && range.is_fixed_value_range()) {
776
0
            set_intersection(_fixed_values.begin(), _fixed_values.end(),
777
0
                             range._fixed_values.begin(), range._fixed_values.end(),
778
0
                             std::inserter(result_values, result_values.begin()));
779
33
        } else if (is_fixed_value_range() && !range.is_fixed_value_range()) {
780
0
            IteratorType iter = _fixed_values.begin();
781
782
0
            while (iter != _fixed_values.end()) {
783
0
                if (range.is_in_range(*iter)) {
784
0
                    result_values.insert(*iter);
785
0
                }
786
0
                ++iter;
787
0
            }
788
34
        } else if (!is_fixed_value_range() && range.is_fixed_value_range()) {
789
34
            IteratorType iter = range._fixed_values.begin();
790
82
            while (iter != range._fixed_values.end()) {
791
48
                if (this->is_in_range(*iter)) {
792
48
                    result_values.insert(*iter);
793
48
                }
794
48
                ++iter;
795
48
            }
796
34
        }
797
798
34
        if (!result_values.empty()) {
799
34
            _fixed_values = std::move(result_values);
800
34
            _contain_null = false;
801
34
            _high_value = TYPE_MIN;
802
34
            _low_value = TYPE_MAX;
803
18.4E
        } else {
804
18.4E
            set_empty_value_range();
805
18.4E
        }
806
33
    } else {
807
12
        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
11
        } 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
12
    }
817
45
}
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
389k
                                     bool* should_break) {
823
389k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
389k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
389k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
389k
    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
389k
    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
389k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
389k
    if (range.is_fixed_value_range()) {
842
164k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
19
            if (range.is_range_value_convertible()) {
844
18
                range.convert_to_range_value();
845
18
                *exact_value = false;
846
18
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
19
        }
851
225k
    } else {
852
225k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
225k
            !range.is_reject_split_type()) {
854
146k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
146k
                                                 _end_include);
856
857
146k
            if (!(*eos) &&
858
147k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
147k
                                                 _end_include, max_scan_key_num)) {
860
146k
                _has_range_value = true;
861
146k
            }
862
146k
            return Status::OK();
863
146k
        }
864
225k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
243k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
163k
        if (_begin_scan_keys.empty()) {
870
57.0k
            auto fixed_value_set = range.get_fixed_value_set();
871
57.0k
            ConstIterator iter = fixed_value_set.begin();
872
873
115k
            for (; iter != fixed_value_set.end(); ++iter) {
874
58.4k
                _begin_scan_keys.emplace_back();
875
58.4k
                _begin_scan_keys.back().add_value(
876
58.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
58.4k
                _end_scan_keys.emplace_back();
878
58.4k
                _end_scan_keys.back().add_value(
879
58.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
58.4k
            }
881
882
57.0k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
57.0k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
106k
        else {
890
106k
            auto fixed_value_set = range.get_fixed_value_set();
891
106k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
213k
            for (int i = 0; i < original_key_range_size; ++i) {
894
106k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
106k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
106k
                ConstIterator iter = fixed_value_set.begin();
898
899
213k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
106k
                    if (iter == fixed_value_set.begin()) {
902
106k
                        _begin_scan_keys[i].add_value(
903
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
106k
                        _end_scan_keys[i].add_value(
905
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
106k
                    } // append follow ScanKey
907
415
                    else {
908
415
                        _begin_scan_keys.push_back(start_base_key_range);
909
415
                        _begin_scan_keys.back().add_value(
910
415
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
415
                        _end_scan_keys.push_back(end_base_key_range);
912
415
                        _end_scan_keys.back().add_value(
913
415
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
415
                    }
915
106k
                }
916
917
106k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
106k
            }
924
106k
        }
925
926
163k
        _begin_include = true;
927
163k
        _end_include = true;
928
163k
    } // Extend ScanKey with range value
929
79.4k
    else {
930
79.4k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
79.4k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
16
            CHECK(range.contain_null());
935
16
            if (_begin_scan_keys.empty()) {
936
16
                _begin_scan_keys.emplace_back();
937
16
                _begin_scan_keys.back().add_null();
938
16
                _end_scan_keys.emplace_back();
939
16
                _end_scan_keys.back().add_null();
940
16
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
79.4k
        } else if (_begin_scan_keys.empty()) {
947
23.2k
            _begin_scan_keys.emplace_back();
948
23.2k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
23.2k
                                                      range.get_range_min_value(), range.scale()),
950
23.2k
                                              range.contain_null());
951
23.2k
            _end_scan_keys.emplace_back();
952
23.2k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
23.2k
                    range.get_range_max_value(), range.scale()));
954
56.1k
        } else {
955
114k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
58.5k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
58.5k
                                                      range.get_range_min_value(), range.scale()),
958
58.5k
                                              range.contain_null());
959
58.5k
            }
960
961
114k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
58.5k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
58.5k
                        range.get_range_max_value(), range.scale()));
964
58.5k
            }
965
56.1k
        }
966
79.4k
        _begin_include = range.is_begin_include();
967
79.4k
        _end_include = range.is_end_include();
968
79.4k
    }
969
970
243k
    return Status::OK();
971
389k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE3EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.96k
                                     bool* should_break) {
823
1.96k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.96k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.96k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.96k
    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.96k
    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.96k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.96k
    if (range.is_fixed_value_range()) {
842
11
        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.95k
    } else {
852
1.95k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.95k
            !range.is_reject_split_type()) {
854
1.90k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
1.90k
                                                 _end_include);
856
857
1.90k
            if (!(*eos) &&
858
1.92k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
1.95k
                                                 _end_include, max_scan_key_num)) {
860
1.95k
                _has_range_value = true;
861
1.95k
            }
862
1.90k
            return Status::OK();
863
1.90k
        }
864
1.95k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
56
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
11
        if (_begin_scan_keys.empty()) {
870
11
            auto fixed_value_set = range.get_fixed_value_set();
871
11
            ConstIterator iter = fixed_value_set.begin();
872
873
24
            for (; iter != fixed_value_set.end(); ++iter) {
874
13
                _begin_scan_keys.emplace_back();
875
13
                _begin_scan_keys.back().add_value(
876
13
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
13
                _end_scan_keys.emplace_back();
878
13
                _end_scan_keys.back().add_value(
879
13
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
13
            }
881
882
11
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
11
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
11
        _begin_include = true;
927
11
        _end_include = true;
928
11
    } // Extend ScanKey with range value
929
45
    else {
930
45
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
45
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
45
        } else if (_begin_scan_keys.empty()) {
947
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
43
        } else {
955
81
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
38
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
38
                                                      range.get_range_min_value(), range.scale()),
958
38
                                              range.contain_null());
959
38
            }
960
961
81
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
38
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
38
                        range.get_range_max_value(), range.scale()));
964
38
            }
965
43
        }
966
45
        _begin_include = range.is_begin_include();
967
45
        _end_include = range.is_end_include();
968
45
    }
969
970
56
    return Status::OK();
971
1.96k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE4EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
158
                                     bool* should_break) {
823
158
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
158
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
158
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
158
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
158
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
158
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
158
    if (range.is_fixed_value_range()) {
842
3
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
155
    } else {
852
155
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
155
            !range.is_reject_split_type()) {
854
98
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
98
                                                 _end_include);
856
857
98
            if (!(*eos) &&
858
98
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
99
                                                 _end_include, max_scan_key_num)) {
860
99
                _has_range_value = true;
861
99
            }
862
98
            return Status::OK();
863
98
        }
864
155
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
60
    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
57
    else {
930
57
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
57
        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
57
        } 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
57
        } else {
955
379
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
322
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
322
                                                      range.get_range_min_value(), range.scale()),
958
322
                                              range.contain_null());
959
322
            }
960
961
385
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
328
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
328
                        range.get_range_max_value(), range.scale()));
964
328
            }
965
57
        }
966
57
        _begin_include = range.is_begin_include();
967
57
        _end_include = range.is_end_include();
968
57
    }
969
970
60
    return Status::OK();
971
158
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE5EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
64.3k
                                     bool* should_break) {
823
64.3k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
64.3k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
64.3k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
64.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
64.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
64.3k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
64.3k
    if (range.is_fixed_value_range()) {
842
2.47k
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
17
            if (range.is_range_value_convertible()) {
844
17
                range.convert_to_range_value();
845
17
                *exact_value = false;
846
17
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
17
        }
851
61.8k
    } else {
852
62.1k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
61.8k
            !range.is_reject_split_type()) {
854
61.3k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
61.3k
                                                 _end_include);
856
857
61.3k
            if (!(*eos) &&
858
61.8k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
61.8k
                                                 _end_include, max_scan_key_num)) {
860
61.7k
                _has_range_value = true;
861
61.7k
            }
862
61.3k
            return Status::OK();
863
61.3k
        }
864
61.8k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3.00k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
2.45k
        if (_begin_scan_keys.empty()) {
870
2.31k
            auto fixed_value_set = range.get_fixed_value_set();
871
2.31k
            ConstIterator iter = fixed_value_set.begin();
872
873
5.29k
            for (; iter != fixed_value_set.end(); ++iter) {
874
2.98k
                _begin_scan_keys.emplace_back();
875
2.98k
                _begin_scan_keys.back().add_value(
876
2.98k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
2.98k
                _end_scan_keys.emplace_back();
878
2.98k
                _end_scan_keys.back().add_value(
879
2.98k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
2.98k
            }
881
882
2.31k
            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.31k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
143
        else {
890
143
            auto fixed_value_set = range.get_fixed_value_set();
891
143
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
302
            for (int i = 0; i < original_key_range_size; ++i) {
894
159
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
159
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
159
                ConstIterator iter = fixed_value_set.begin();
898
899
318
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
159
                    if (iter == fixed_value_set.begin()) {
902
158
                        _begin_scan_keys[i].add_value(
903
158
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
158
                        _end_scan_keys[i].add_value(
905
158
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
158
                    } // append follow ScanKey
907
1
                    else {
908
1
                        _begin_scan_keys.push_back(start_base_key_range);
909
1
                        _begin_scan_keys.back().add_value(
910
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
1
                        _end_scan_keys.push_back(end_base_key_range);
912
1
                        _end_scan_keys.back().add_value(
913
1
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
1
                    }
915
159
                }
916
917
159
                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
159
            }
924
143
        }
925
926
2.45k
        _begin_include = true;
927
2.45k
        _end_include = true;
928
2.45k
    } // Extend ScanKey with range value
929
553
    else {
930
553
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
553
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
553
        } else if (_begin_scan_keys.empty()) {
947
115
            _begin_scan_keys.emplace_back();
948
115
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
115
                                                      range.get_range_min_value(), range.scale()),
950
115
                                              range.contain_null());
951
115
            _end_scan_keys.emplace_back();
952
115
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
115
                    range.get_range_max_value(), range.scale()));
954
438
        } else {
955
2.68k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
2.25k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
2.25k
                                                      range.get_range_min_value(), range.scale()),
958
2.25k
                                              range.contain_null());
959
2.25k
            }
960
961
2.68k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
2.24k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
2.24k
                        range.get_range_max_value(), range.scale()));
964
2.24k
            }
965
438
        }
966
553
        _begin_include = range.is_begin_include();
967
553
        _end_include = range.is_end_include();
968
553
    }
969
970
3.00k
    return Status::OK();
971
64.3k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE6EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
81.7k
                                     bool* should_break) {
823
81.7k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
81.7k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
81.7k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
81.7k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
81.7k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
81.7k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
81.7k
    if (range.is_fixed_value_range()) {
842
861
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
80.8k
    } else {
852
80.8k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
80.8k
            !range.is_reject_split_type()) {
854
80.4k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
80.4k
                                                 _end_include);
856
857
80.4k
            if (!(*eos) &&
858
80.5k
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
80.5k
                                                 _end_include, max_scan_key_num)) {
860
80.1k
                _has_range_value = true;
861
80.1k
            }
862
80.4k
            return Status::OK();
863
80.4k
        }
864
80.8k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.27k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
859
        if (_begin_scan_keys.empty()) {
870
859
            auto fixed_value_set = range.get_fixed_value_set();
871
859
            ConstIterator iter = fixed_value_set.begin();
872
873
1.79k
            for (; iter != fixed_value_set.end(); ++iter) {
874
933
                _begin_scan_keys.emplace_back();
875
933
                _begin_scan_keys.back().add_value(
876
933
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
933
                _end_scan_keys.emplace_back();
878
933
                _end_scan_keys.back().add_value(
879
933
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
933
            }
881
882
859
            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
859
        } // 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
859
        _begin_include = true;
927
859
        _end_include = true;
928
859
    } // Extend ScanKey with range value
929
415
    else {
930
415
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
415
        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
415
        } else if (_begin_scan_keys.empty()) {
947
23
            _begin_scan_keys.emplace_back();
948
23
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
23
                                                      range.get_range_min_value(), range.scale()),
950
23
                                              range.contain_null());
951
23
            _end_scan_keys.emplace_back();
952
23
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
23
                    range.get_range_max_value(), range.scale()));
954
392
        } else {
955
1.11k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
722
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
722
                                                      range.get_range_min_value(), range.scale()),
958
722
                                              range.contain_null());
959
722
            }
960
961
1.11k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
724
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
724
                        range.get_range_max_value(), range.scale()));
964
724
            }
965
392
        }
966
415
        _begin_include = range.is_begin_include();
967
415
        _end_include = range.is_end_include();
968
415
    }
969
970
1.27k
    return Status::OK();
971
81.7k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE7EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.09k
                                     bool* should_break) {
823
4.09k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.09k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.09k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.09k
    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.09k
    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.09k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.09k
    if (range.is_fixed_value_range()) {
842
140
        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.95k
    } else {
852
3.95k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
3.95k
            !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.95k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.09k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
140
        if (_begin_scan_keys.empty()) {
870
140
            auto fixed_value_set = range.get_fixed_value_set();
871
140
            ConstIterator iter = fixed_value_set.begin();
872
873
295
            for (; iter != fixed_value_set.end(); ++iter) {
874
155
                _begin_scan_keys.emplace_back();
875
155
                _begin_scan_keys.back().add_value(
876
155
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
155
                _end_scan_keys.emplace_back();
878
155
                _end_scan_keys.back().add_value(
879
155
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
155
            }
881
882
140
            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
140
        } // 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
140
        _begin_include = true;
927
140
        _end_include = true;
928
140
    } // Extend ScanKey with range value
929
3.95k
    else {
930
3.95k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
3.95k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
1
            CHECK(range.contain_null());
935
1
            if (_begin_scan_keys.empty()) {
936
1
                _begin_scan_keys.emplace_back();
937
1
                _begin_scan_keys.back().add_null();
938
1
                _end_scan_keys.emplace_back();
939
1
                _end_scan_keys.back().add_null();
940
1
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
3.95k
        } else if (_begin_scan_keys.empty()) {
947
3.92k
            _begin_scan_keys.emplace_back();
948
3.92k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
3.92k
                                                      range.get_range_min_value(), range.scale()),
950
3.92k
                                              range.contain_null());
951
3.92k
            _end_scan_keys.emplace_back();
952
3.92k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
3.92k
                    range.get_range_max_value(), range.scale()));
954
3.92k
        } else {
955
104
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
76
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
76
                                                      range.get_range_min_value(), range.scale()),
958
76
                                              range.contain_null());
959
76
            }
960
961
104
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
76
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
76
                        range.get_range_max_value(), range.scale()));
964
76
            }
965
28
        }
966
3.95k
        _begin_include = range.is_begin_include();
967
3.95k
        _end_include = range.is_end_include();
968
3.95k
    }
969
970
4.09k
    return Status::OK();
971
4.09k
}
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
456
                                     bool* should_break) {
823
456
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
456
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
456
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
456
    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
456
    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
456
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
456
    if (range.is_fixed_value_range()) {
842
27
        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
429
    } else {
852
429
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
429
            !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
429
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
456
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
26
        if (_begin_scan_keys.empty()) {
870
25
            auto fixed_value_set = range.get_fixed_value_set();
871
25
            ConstIterator iter = fixed_value_set.begin();
872
873
86
            for (; iter != fixed_value_set.end(); ++iter) {
874
61
                _begin_scan_keys.emplace_back();
875
61
                _begin_scan_keys.back().add_value(
876
61
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
61
                _end_scan_keys.emplace_back();
878
61
                _end_scan_keys.back().add_value(
879
61
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
61
            }
881
882
25
            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
25
        } // 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
26
        _begin_include = true;
927
26
        _end_include = true;
928
26
    } // Extend ScanKey with range value
929
430
    else {
930
430
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
430
        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
429
        } else if (_begin_scan_keys.empty()) {
947
418
            _begin_scan_keys.emplace_back();
948
418
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
418
                                                      range.get_range_min_value(), range.scale()),
950
418
                                              range.contain_null());
951
418
            _end_scan_keys.emplace_back();
952
418
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
418
                    range.get_range_max_value(), range.scale()));
954
418
        } else {
955
171
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
160
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
160
                                                      range.get_range_min_value(), range.scale()),
958
160
                                              range.contain_null());
959
160
            }
960
961
169
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
158
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
158
                        range.get_range_max_value(), range.scale()));
964
158
            }
965
11
        }
966
430
        _begin_include = range.is_begin_include();
967
430
        _end_include = range.is_end_include();
968
430
    }
969
970
456
    return Status::OK();
971
456
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE10EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
222k
                                     bool* should_break) {
823
222k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
222k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
222k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
222k
    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
222k
    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
222k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
222k
    if (range.is_fixed_value_range()) {
842
159k
        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
159k
    } else {
852
62.3k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
62.3k
            !range.is_reject_split_type()) {
854
0
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
0
                                                 _end_include);
856
857
0
            if (!(*eos) &&
858
0
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
0
                                                 _end_include, max_scan_key_num)) {
860
0
                _has_range_value = true;
861
0
            }
862
0
            return Status::OK();
863
0
        }
864
62.3k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
222k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
159k
        if (_begin_scan_keys.empty()) {
870
53.0k
            auto fixed_value_set = range.get_fixed_value_set();
871
53.0k
            ConstIterator iter = fixed_value_set.begin();
872
873
106k
            for (; iter != fixed_value_set.end(); ++iter) {
874
53.4k
                _begin_scan_keys.emplace_back();
875
53.4k
                _begin_scan_keys.back().add_value(
876
53.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
53.4k
                _end_scan_keys.emplace_back();
878
53.4k
                _end_scan_keys.back().add_value(
879
53.4k
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
53.4k
            }
881
882
53.0k
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
53.0k
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
106k
        else {
890
106k
            auto fixed_value_set = range.get_fixed_value_set();
891
106k
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
213k
            for (int i = 0; i < original_key_range_size; ++i) {
894
106k
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
106k
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
106k
                ConstIterator iter = fixed_value_set.begin();
898
899
213k
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
106k
                    if (iter == fixed_value_set.begin()) {
902
106k
                        _begin_scan_keys[i].add_value(
903
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
106k
                        _end_scan_keys[i].add_value(
905
106k
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
106k
                    } // append follow ScanKey
907
414
                    else {
908
414
                        _begin_scan_keys.push_back(start_base_key_range);
909
414
                        _begin_scan_keys.back().add_value(
910
414
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
414
                        _end_scan_keys.push_back(end_base_key_range);
912
414
                        _end_scan_keys.back().add_value(
913
414
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
414
                    }
915
106k
                }
916
917
106k
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
106k
            }
924
106k
        }
925
926
159k
        _begin_include = true;
927
159k
        _end_include = true;
928
159k
    } // Extend ScanKey with range value
929
62.6k
    else {
930
62.6k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
62.6k
        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
62.6k
        } else if (_begin_scan_keys.empty()) {
947
7.69k
            _begin_scan_keys.emplace_back();
948
7.69k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
7.69k
                                                      range.get_range_min_value(), range.scale()),
950
7.69k
                                              range.contain_null());
951
7.69k
            _end_scan_keys.emplace_back();
952
7.69k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
7.69k
                    range.get_range_max_value(), range.scale()));
954
54.9k
        } else {
955
109k
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
54.6k
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
54.6k
                                                      range.get_range_min_value(), range.scale()),
958
54.6k
                                              range.contain_null());
959
54.6k
            }
960
961
109k
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
54.6k
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
54.6k
                        range.get_range_max_value(), range.scale()));
964
54.6k
            }
965
54.9k
        }
966
62.6k
        _begin_include = range.is_begin_include();
967
62.6k
        _end_include = range.is_end_include();
968
62.6k
    }
969
970
222k
    return Status::OK();
971
222k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE23EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE11EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
9
                                     bool* should_break) {
823
9
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
9
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
9
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
9
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
9
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
9
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
9
    if (range.is_fixed_value_range()) {
842
3
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
6
    } else {
852
6
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
6
            !range.is_reject_split_type()) {
854
6
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
6
                                                 _end_include);
856
857
6
            if (!(*eos) &&
858
6
                range.convert_to_avg_range_value(_begin_scan_keys, _end_scan_keys, _begin_include,
859
6
                                                 _end_include, max_scan_key_num)) {
860
6
                _has_range_value = true;
861
6
            }
862
6
            return Status::OK();
863
6
        }
864
6
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
3
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
3
        if (_begin_scan_keys.empty()) {
870
3
            auto fixed_value_set = range.get_fixed_value_set();
871
3
            ConstIterator iter = fixed_value_set.begin();
872
873
10
            for (; iter != fixed_value_set.end(); ++iter) {
874
7
                _begin_scan_keys.emplace_back();
875
7
                _begin_scan_keys.back().add_value(
876
7
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
7
                _end_scan_keys.emplace_back();
878
7
                _end_scan_keys.back().add_value(
879
7
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
7
            }
881
882
3
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
3
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
3
        _begin_include = true;
927
3
        _end_include = true;
928
3
    } // Extend ScanKey with range value
929
0
    else {
930
0
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
0
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
0
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
0
        } else {
955
0
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
0
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
0
                                                      range.get_range_min_value(), range.scale()),
958
0
                                              range.contain_null());
959
0
            }
960
961
0
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
0
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
0
                        range.get_range_max_value(), range.scale()));
964
0
            }
965
0
        }
966
0
        _begin_include = range.is_begin_include();
967
0
        _end_include = range.is_end_include();
968
0
    }
969
970
3
    return Status::OK();
971
9
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE25EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
3.28k
                                     bool* should_break) {
823
3.28k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
3.28k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
3.28k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
3.28k
    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.28k
    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.28k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
3.28k
    if (range.is_fixed_value_range()) {
842
322
        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.96k
    } else {
852
2.96k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.96k
            !range.is_reject_split_type()) {
854
2.88k
            *eos |= range.convert_to_close_range(_begin_scan_keys, _end_scan_keys, _begin_include,
855
2.88k
                                                 _end_include);
856
857
2.88k
            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.81k
                _has_range_value = true;
861
2.81k
            }
862
2.88k
            return Status::OK();
863
2.88k
        }
864
2.96k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
407
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
322
        if (_begin_scan_keys.empty()) {
870
320
            auto fixed_value_set = range.get_fixed_value_set();
871
320
            ConstIterator iter = fixed_value_set.begin();
872
873
691
            for (; iter != fixed_value_set.end(); ++iter) {
874
371
                _begin_scan_keys.emplace_back();
875
371
                _begin_scan_keys.back().add_value(
876
371
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
371
                _end_scan_keys.emplace_back();
878
371
                _end_scan_keys.back().add_value(
879
371
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
371
            }
881
882
320
            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
320
        } // 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
322
        _begin_include = true;
927
322
        _end_include = true;
928
322
    } // Extend ScanKey with range value
929
85
    else {
930
85
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
85
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
0
            CHECK(range.contain_null());
935
0
            if (_begin_scan_keys.empty()) {
936
0
                _begin_scan_keys.emplace_back();
937
0
                _begin_scan_keys.back().add_null();
938
0
                _end_scan_keys.emplace_back();
939
0
                _end_scan_keys.back().add_null();
940
0
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
85
        } else if (_begin_scan_keys.empty()) {
947
0
            _begin_scan_keys.emplace_back();
948
0
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
0
                                                      range.get_range_min_value(), range.scale()),
950
0
                                              range.contain_null());
951
0
            _end_scan_keys.emplace_back();
952
0
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
0
                    range.get_range_max_value(), range.scale()));
954
85
        } else {
955
181
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
96
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
96
                                                      range.get_range_min_value(), range.scale()),
958
96
                                              range.contain_null());
959
96
            }
960
961
181
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
96
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
96
                        range.get_range_max_value(), range.scale()));
964
96
            }
965
85
        }
966
85
        _begin_include = range.is_begin_include();
967
85
        _end_include = range.is_end_include();
968
85
    }
969
970
407
    return Status::OK();
971
3.28k
}
_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
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
30
    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
21
    } else {
852
21
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
21
            !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
21
    }
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
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
21
    else {
930
21
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
21
        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
21
        } else if (_begin_scan_keys.empty()) {
947
21
            _begin_scan_keys.emplace_back();
948
21
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
21
                                                      range.get_range_min_value(), range.scale()),
950
21
                                              range.contain_null());
951
21
            _end_scan_keys.emplace_back();
952
21
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
21
                    range.get_range_max_value(), range.scale()));
954
21
        } 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
21
        _begin_include = range.is_begin_include();
967
21
        _end_include = range.is_end_include();
968
21
    }
969
970
30
    return Status::OK();
971
30
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE26EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
2.46k
                                     bool* should_break) {
823
2.46k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
2.46k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
2.46k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
2.46k
    if (range.is_empty_value_range()) {
829
0
        _begin_scan_keys.clear();
830
0
        _end_scan_keys.clear();
831
0
        return Status::OK();
832
0
    }
833
834
    // 2. stop extend ScanKey when it's already extend a range value
835
2.46k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
2.46k
    if (range.is_fixed_value_range()) {
842
68
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
2.39k
    } else {
852
2.39k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
2.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
2.39k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
2.46k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
68
        if (_begin_scan_keys.empty()) {
870
65
            auto fixed_value_set = range.get_fixed_value_set();
871
65
            ConstIterator iter = fixed_value_set.begin();
872
873
132
            for (; iter != fixed_value_set.end(); ++iter) {
874
67
                _begin_scan_keys.emplace_back();
875
67
                _begin_scan_keys.back().add_value(
876
67
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
67
                _end_scan_keys.emplace_back();
878
67
                _end_scan_keys.back().add_value(
879
67
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
67
            }
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
3
        else {
890
3
            auto fixed_value_set = range.get_fixed_value_set();
891
3
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
7
            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
3
        }
925
926
68
        _begin_include = true;
927
68
        _end_include = true;
928
68
    } // Extend ScanKey with range value
929
2.39k
    else {
930
2.39k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
2.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
2.40k
        } else if (_begin_scan_keys.empty()) {
947
2.40k
            _begin_scan_keys.emplace_back();
948
2.40k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
2.40k
                                                      range.get_range_min_value(), range.scale()),
950
2.40k
                                              range.contain_null());
951
2.40k
            _end_scan_keys.emplace_back();
952
2.40k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
2.40k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
2
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
2
                                                      range.get_range_min_value(), range.scale()),
958
2
                                              range.contain_null());
959
2
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
2
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
2
                        range.get_range_max_value(), range.scale()));
964
2
            }
965
18.4E
        }
966
2.39k
        _begin_include = range.is_begin_include();
967
2.39k
        _end_include = range.is_end_include();
968
2.39k
    }
969
970
2.46k
    return Status::OK();
971
2.46k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE42EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
4.27k
                                     bool* should_break) {
823
4.27k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
4.27k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
4.27k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
4.27k
    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.27k
    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.27k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
4.27k
    if (range.is_fixed_value_range()) {
842
191
        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.08k
    } else {
852
4.08k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
4.08k
            !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.08k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
4.27k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
189
        if (_begin_scan_keys.empty()) {
870
189
            auto fixed_value_set = range.get_fixed_value_set();
871
189
            ConstIterator iter = fixed_value_set.begin();
872
873
520
            for (; iter != fixed_value_set.end(); ++iter) {
874
331
                _begin_scan_keys.emplace_back();
875
331
                _begin_scan_keys.back().add_value(
876
331
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
331
                _end_scan_keys.emplace_back();
878
331
                _end_scan_keys.back().add_value(
879
331
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
331
            }
881
882
189
            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
189
        } // 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
189
        _begin_include = true;
927
189
        _end_include = true;
928
189
    } // Extend ScanKey with range value
929
4.08k
    else {
930
4.08k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
4.08k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
9
            CHECK(range.contain_null());
935
9
            if (_begin_scan_keys.empty()) {
936
9
                _begin_scan_keys.emplace_back();
937
9
                _begin_scan_keys.back().add_null();
938
9
                _end_scan_keys.emplace_back();
939
9
                _end_scan_keys.back().add_null();
940
9
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
4.09k
        } else if (_begin_scan_keys.empty()) {
947
4.09k
            _begin_scan_keys.emplace_back();
948
4.09k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
4.09k
                                                      range.get_range_min_value(), range.scale()),
950
4.09k
                                              range.contain_null());
951
4.09k
            _end_scan_keys.emplace_back();
952
4.09k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
4.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
4.08k
        _begin_include = range.is_begin_include();
967
4.08k
        _end_include = range.is_end_include();
968
4.08k
    }
969
970
4.27k
    return Status::OK();
971
4.27k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE20EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
156
                                     bool* should_break) {
823
156
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
156
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
156
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
156
    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
156
    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
156
    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
155
    } else {
852
157
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
155
            !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
155
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
156
    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
155
    else {
930
155
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
155
        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
155
        } else if (_begin_scan_keys.empty()) {
947
154
            _begin_scan_keys.emplace_back();
948
154
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
154
                                                      range.get_range_min_value(), range.scale()),
950
154
                                              range.contain_null());
951
154
            _end_scan_keys.emplace_back();
952
154
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
154
                    range.get_range_max_value(), range.scale()));
954
154
        } 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
155
        _begin_include = range.is_begin_include();
967
155
        _end_include = range.is_end_include();
968
155
    }
969
970
156
    return Status::OK();
971
156
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE2EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.49k
                                     bool* should_break) {
823
1.49k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.49k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.49k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.49k
    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.49k
    if (_has_range_value) {
836
0
        return Status::OK();
837
0
    }
838
839
    //if a column doesn't have any predicate, we will try converting the range to fixed values
840
18.4E
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.49k
    if (range.is_fixed_value_range()) {
842
8
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
1
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
1
            } else {
847
1
                *should_break = true;
848
1
                return Status::OK();
849
1
            }
850
1
        }
851
1.49k
    } else {
852
1.50k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.49k
            !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.49k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.49k
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
7
        if (_begin_scan_keys.empty()) {
870
7
            auto fixed_value_set = range.get_fixed_value_set();
871
7
            ConstIterator iter = fixed_value_set.begin();
872
873
19
            for (; iter != fixed_value_set.end(); ++iter) {
874
12
                _begin_scan_keys.emplace_back();
875
12
                _begin_scan_keys.back().add_value(
876
12
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
12
                _end_scan_keys.emplace_back();
878
12
                _end_scan_keys.back().add_value(
879
12
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
12
            }
881
882
7
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
7
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
7
        _begin_include = true;
927
7
        _end_include = true;
928
7
    } // Extend ScanKey with range value
929
1.49k
    else {
930
1.49k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.49k
        if (Compare::less(range.get_range_max_value(), range.get_range_min_value())) {
934
3
            CHECK(range.contain_null());
935
3
            if (_begin_scan_keys.empty()) {
936
3
                _begin_scan_keys.emplace_back();
937
3
                _begin_scan_keys.back().add_null();
938
3
                _end_scan_keys.emplace_back();
939
3
                _end_scan_keys.back().add_null();
940
3
            } else {
941
0
                for (int i = 0; i < _begin_scan_keys.size(); ++i) {
942
0
                    _begin_scan_keys[i].add_null();
943
0
                    _end_scan_keys[i].add_null();
944
0
                }
945
0
            }
946
1.49k
        } else if (_begin_scan_keys.empty()) {
947
1.49k
            _begin_scan_keys.emplace_back();
948
1.49k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.49k
                                                      range.get_range_min_value(), range.scale()),
950
1.49k
                                              range.contain_null());
951
1.49k
            _end_scan_keys.emplace_back();
952
1.49k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.49k
                    range.get_range_max_value(), range.scale()));
954
18.4E
        } else {
955
18.4E
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
30
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
30
                                                      range.get_range_min_value(), range.scale()),
958
30
                                              range.contain_null());
959
30
            }
960
961
18.4E
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
30
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
30
                        range.get_range_max_value(), range.scale()));
964
30
            }
965
18.4E
        }
966
1.49k
        _begin_include = range.is_begin_include();
967
1.49k
        _end_include = range.is_end_include();
968
1.49k
    }
969
970
1.49k
    return Status::OK();
971
1.49k
}
Unexecuted instantiation: _ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE19EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE28EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
439
                                     bool* should_break) {
823
439
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
439
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
439
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
439
    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
439
    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
439
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
439
    if (range.is_fixed_value_range()) {
842
19
        if (range.get_fixed_value_size() > max_scan_key_num / scan_keys_size) {
843
0
            if (range.is_range_value_convertible()) {
844
0
                range.convert_to_range_value();
845
0
                *exact_value = false;
846
0
            } else {
847
0
                *should_break = true;
848
0
                return Status::OK();
849
0
            }
850
0
        }
851
420
    } else {
852
422
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
420
            !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
420
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
439
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
19
        if (_begin_scan_keys.empty()) {
870
17
            auto fixed_value_set = range.get_fixed_value_set();
871
17
            ConstIterator iter = fixed_value_set.begin();
872
873
41
            for (; iter != fixed_value_set.end(); ++iter) {
874
24
                _begin_scan_keys.emplace_back();
875
24
                _begin_scan_keys.back().add_value(
876
24
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
24
                _end_scan_keys.emplace_back();
878
24
                _end_scan_keys.back().add_value(
879
24
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
24
            }
881
882
17
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
17
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
2
        else {
890
2
            auto fixed_value_set = range.get_fixed_value_set();
891
2
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
4
            for (int i = 0; i < original_key_range_size; ++i) {
894
2
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
2
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
2
                ConstIterator iter = fixed_value_set.begin();
898
899
4
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
2
                    if (iter == fixed_value_set.begin()) {
902
2
                        _begin_scan_keys[i].add_value(
903
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
2
                        _end_scan_keys[i].add_value(
905
2
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
2
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
2
                }
916
917
2
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
2
            }
924
2
        }
925
926
19
        _begin_include = true;
927
19
        _end_include = true;
928
19
    } // Extend ScanKey with range value
929
420
    else {
930
420
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
420
        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
422
        } else if (_begin_scan_keys.empty()) {
947
422
            _begin_scan_keys.emplace_back();
948
422
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
422
                                                      range.get_range_min_value(), range.scale()),
950
422
                                              range.contain_null());
951
422
            _end_scan_keys.emplace_back();
952
422
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
422
                    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
420
        _begin_include = range.is_begin_include();
967
420
        _end_include = range.is_end_include();
968
420
    }
969
970
439
    return Status::OK();
971
439
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE29EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
585
                                     bool* should_break) {
823
585
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
585
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
585
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
585
    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
585
    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
585
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
585
    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
565
    } else {
852
565
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
565
            !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
565
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
585
    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
565
    else {
930
565
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
565
        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
565
        } else if (_begin_scan_keys.empty()) {
947
551
            _begin_scan_keys.emplace_back();
948
551
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
551
                                                      range.get_range_min_value(), range.scale()),
950
551
                                              range.contain_null());
951
551
            _end_scan_keys.emplace_back();
952
551
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
551
                    range.get_range_max_value(), range.scale()));
954
551
        } else {
955
43
            for (int i = 0; i < _begin_scan_keys.size(); ++i) {
956
29
                _begin_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
957
29
                                                      range.get_range_min_value(), range.scale()),
958
29
                                              range.contain_null());
959
29
            }
960
961
43
            for (int i = 0; i < _end_scan_keys.size(); ++i) {
962
29
                _end_scan_keys[i].add_value(cast_to_string<primitive_type, CppType>(
963
29
                        range.get_range_max_value(), range.scale()));
964
29
            }
965
14
        }
966
565
        _begin_include = range.is_begin_include();
967
565
        _end_include = range.is_end_include();
968
565
    }
969
970
585
    return Status::OK();
971
585
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE30EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
1.61k
                                     bool* should_break) {
823
1.61k
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
1.61k
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
1.61k
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
1.61k
    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.61k
    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.61k
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
1.61k
    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.61k
    } else {
852
1.61k
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
1.61k
            !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.61k
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
1.61k
    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.61k
    else {
930
1.61k
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
1.61k
        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.61k
        } else if (_begin_scan_keys.empty()) {
947
1.50k
            _begin_scan_keys.emplace_back();
948
1.50k
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
1.50k
                                                      range.get_range_min_value(), range.scale()),
950
1.50k
                                              range.contain_null());
951
1.50k
            _end_scan_keys.emplace_back();
952
1.50k
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
1.50k
                    range.get_range_max_value(), range.scale()));
954
1.50k
        } 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.61k
        _begin_include = range.is_begin_include();
967
1.61k
        _end_include = range.is_end_include();
968
1.61k
    }
969
970
1.61k
    return Status::OK();
971
1.61k
}
_ZN5doris12OlapScanKeys15extend_scan_keyILNS_13PrimitiveTypeE35EEENS_6StatusERNS_16ColumnValueRangeIXT_EEEiPbS7_S7_
Line
Count
Source
822
495
                                     bool* should_break) {
823
495
    using CppType = std::conditional_t<primitive_type == TYPE_HLL, StringRef,
824
495
                                       typename PrimitiveTypeTraits<primitive_type>::CppType>;
825
495
    using ConstIterator = typename ColumnValueRange<primitive_type>::SetType::const_iterator;
826
827
    // 1. clear ScanKey if some column range is empty
828
495
    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
495
    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
495
    auto scan_keys_size = _begin_scan_keys.empty() ? 1 : _begin_scan_keys.size();
841
495
    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
477
    } else {
852
477
        if (_begin_scan_keys.empty() && range.is_fixed_value_convertible() && _is_convertible &&
853
477
            !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
477
    }
865
866
    // 3.1 extend ScanKey with FixedValueRange
867
495
    if (range.is_fixed_value_range()) {
868
        // 3.1.1 construct num of fixed value ScanKey (begin_key == end_key)
869
18
        if (_begin_scan_keys.empty()) {
870
18
            auto fixed_value_set = range.get_fixed_value_set();
871
18
            ConstIterator iter = fixed_value_set.begin();
872
873
48
            for (; iter != fixed_value_set.end(); ++iter) {
874
30
                _begin_scan_keys.emplace_back();
875
30
                _begin_scan_keys.back().add_value(
876
30
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
877
30
                _end_scan_keys.emplace_back();
878
30
                _end_scan_keys.back().add_value(
879
30
                        cast_to_string<primitive_type, CppType>(*iter, range.scale()));
880
30
            }
881
882
18
            if (range.contain_null()) {
883
0
                _begin_scan_keys.emplace_back();
884
0
                _begin_scan_keys.back().add_null();
885
0
                _end_scan_keys.emplace_back();
886
0
                _end_scan_keys.back().add_null();
887
0
            }
888
18
        } // 3.1.2 produces the Cartesian product of ScanKey and fixed_value
889
0
        else {
890
0
            auto fixed_value_set = range.get_fixed_value_set();
891
0
            size_t original_key_range_size = _begin_scan_keys.size();
892
893
0
            for (int i = 0; i < original_key_range_size; ++i) {
894
0
                OlapTuple start_base_key_range = _begin_scan_keys[i];
895
0
                OlapTuple end_base_key_range = _end_scan_keys[i];
896
897
0
                ConstIterator iter = fixed_value_set.begin();
898
899
0
                for (; iter != fixed_value_set.end(); ++iter) {
900
                    // alter the first ScanKey in original place
901
0
                    if (iter == fixed_value_set.begin()) {
902
0
                        _begin_scan_keys[i].add_value(
903
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
904
0
                        _end_scan_keys[i].add_value(
905
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
906
0
                    } // append follow ScanKey
907
0
                    else {
908
0
                        _begin_scan_keys.push_back(start_base_key_range);
909
0
                        _begin_scan_keys.back().add_value(
910
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
911
0
                        _end_scan_keys.push_back(end_base_key_range);
912
0
                        _end_scan_keys.back().add_value(
913
0
                                cast_to_string<primitive_type, CppType>(*iter, range.scale()));
914
0
                    }
915
0
                }
916
917
0
                if (range.contain_null()) {
918
0
                    _begin_scan_keys.push_back(start_base_key_range);
919
0
                    _begin_scan_keys.back().add_null();
920
0
                    _end_scan_keys.push_back(end_base_key_range);
921
0
                    _end_scan_keys.back().add_null();
922
0
                }
923
0
            }
924
0
        }
925
926
18
        _begin_include = true;
927
18
        _end_include = true;
928
18
    } // Extend ScanKey with range value
929
477
    else {
930
477
        _has_range_value = true;
931
932
        /// if max < min, this range should only contains a null value.
933
477
        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
476
        } else if (_begin_scan_keys.empty()) {
947
416
            _begin_scan_keys.emplace_back();
948
416
            _begin_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
949
416
                                                      range.get_range_min_value(), range.scale()),
950
416
                                              range.contain_null());
951
416
            _end_scan_keys.emplace_back();
952
416
            _end_scan_keys.back().add_value(cast_to_string<primitive_type, CppType>(
953
416
                    range.get_range_max_value(), range.scale()));
954
416
        } else {
955
120
            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
120
            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
60
        }
966
477
        _begin_include = range.is_begin_include();
967
477
        _end_include = range.is_end_include();
968
477
    }
969
970
495
    return Status::OK();
971
495
}
972
973
#include "common/compile_check_end.h"
974
} // namespace doris