lbug 0.22.0

An in-process property graph database management system built for query speed and scalability
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#include "storage/predicate/constant_predicate.h"

#include "common/type_utils.h"
#include "common/vector/value_vector.h"
#include "function/comparison/comparison_functions.h"
#include "storage/compression/compression.h"
#include "storage/predicate/filter_selection.h"
#include "storage/table/column_chunk_stats.h"
#include <format>

using namespace lbug::common;
using namespace lbug::function;

namespace lbug {
namespace storage {

template<typename T>
bool inRange(T min, T max, T val) {
    auto a = GreaterThanEquals::operation<T>(val, min);
    auto b = LessThanEquals::operation<T>(val, max);
    return a && b;
}

template<typename T>
ZoneMapCheckResult checkZoneMapSwitch(const MergedColumnChunkStats& mergedStats,
    ExpressionType expressionType, const Value& value) {
    // If the chunk is casted from a non-storage value type
    // The stats will be empty, skip the zone map check in this case
    if (mergedStats.stats.min.has_value() && mergedStats.stats.max.has_value()) {
        auto max = mergedStats.stats.max->get<T>();
        auto min = mergedStats.stats.min->get<T>();
        auto constant = value.getValue<T>();
        switch (expressionType) {
        case ExpressionType::EQUALS: {
            if (!inRange<T>(min, max, constant)) {
                return ZoneMapCheckResult::SKIP_SCAN;
            }
        } break;
        case ExpressionType::NOT_EQUALS: {
            if (Equals::operation<T>(constant, min) && Equals::operation<T>(constant, max)) {
                return ZoneMapCheckResult::SKIP_SCAN;
            }
        } break;
        case ExpressionType::GREATER_THAN: {
            if (GreaterThanEquals::operation<T>(constant, max)) {
                return ZoneMapCheckResult::SKIP_SCAN;
            }
        } break;
        case ExpressionType::GREATER_THAN_EQUALS: {
            if (GreaterThan::operation<T>(constant, max)) {
                return ZoneMapCheckResult::SKIP_SCAN;
            }
        } break;
        case ExpressionType::LESS_THAN: {
            if (LessThanEquals::operation<T>(constant, min)) {
                return ZoneMapCheckResult::SKIP_SCAN;
            }
        } break;
        case ExpressionType::LESS_THAN_EQUALS: {
            if (LessThan::operation<T>(constant, min)) {
                return ZoneMapCheckResult::SKIP_SCAN;
            }
        } break;
        default:
            UNREACHABLE_CODE;
        }
    }
    return ZoneMapCheckResult::ALWAYS_SCAN;
}

ZoneMapCheckResult ColumnConstantPredicate::checkZoneMap(
    const MergedColumnChunkStats& stats) const {
    auto physicalType = value.getDataType().getPhysicalType();
    return TypeUtils::visit(
        physicalType,
        [&]<StorageValueType T>(T) { return checkZoneMapSwitch<T>(stats, expressionType, value); },
        [&](auto) { return ZoneMapCheckResult::ALWAYS_SCAN; });
}

template<typename T, typename Op>
static void filterValues(const ValueVector& vector, SelectionVector& sel, T constant) {
    const auto* values = reinterpret_cast<const T*>(vector.getData());
    if (vector.hasNoNullsGuarantee()) {
        filterSelection(sel, [&](sel_t pos) { return Op::operation(values[pos], constant); });
        return;
    }
    filterSelection(sel,
        [&](sel_t pos) { return !vector.isNull(pos) && Op::operation(values[pos], constant); });
}

void ColumnConstantPredicate::filter(const ValueVector& vector, SelectionVector& sel) const {
    // A predicate on CAST(column) carries the cast's type; its raw values are not comparable.
    if (vector.dataType != value.getDataType()) {
        return;
    }
    TypeUtils::visit(
        vector.dataType.getPhysicalType(),
        [&]<StorageValueType T>(T) {
            const auto constant = value.getValue<T>();
            switch (expressionType) {
            case ExpressionType::EQUALS:
                return filterValues<T, Equals>(vector, sel, constant);
            case ExpressionType::NOT_EQUALS:
                return filterValues<T, NotEquals>(vector, sel, constant);
            case ExpressionType::GREATER_THAN:
                return filterValues<T, GreaterThan>(vector, sel, constant);
            case ExpressionType::GREATER_THAN_EQUALS:
                return filterValues<T, GreaterThanEquals>(vector, sel, constant);
            case ExpressionType::LESS_THAN:
                return filterValues<T, LessThan>(vector, sel, constant);
            case ExpressionType::LESS_THAN_EQUALS:
                return filterValues<T, LessThanEquals>(vector, sel, constant);
            default:
                UNREACHABLE_CODE;
            }
        },
        [](auto) {});
}

std::string ColumnConstantPredicate::toString() {
    std::string valStr;
    if (value.getDataType().getPhysicalType() == PhysicalTypeID::STRING ||
        value.getDataType().getPhysicalType() == PhysicalTypeID::JSON ||
        value.getDataType().getPhysicalType() == PhysicalTypeID::LIST ||
        value.getDataType().getPhysicalType() == PhysicalTypeID::ARRAY ||
        value.getDataType().getPhysicalType() == PhysicalTypeID::STRUCT ||
        value.getDataType().getLogicalTypeID() == LogicalTypeID::UUID ||
        value.getDataType().getLogicalTypeID() == LogicalTypeID::TIMESTAMP ||
        value.getDataType().getLogicalTypeID() == LogicalTypeID::DATE ||
        value.getDataType().getLogicalTypeID() == LogicalTypeID::INTERVAL) {
        valStr = std::format("'{}'", value.toString());
    } else {
        valStr = value.toString();
    }
    return std::format("{} {}", ColumnPredicate::toString(), valStr);
}

} // namespace storage
} // namespace lbug