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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

#include "common/exception/binder.h"
#include "common/type_utils.h"
#include "function/list/vector_list_functions.h"
#include "function/scalar_function.h"
#include <format>

using namespace lbug::common;

namespace lbug {
namespace function {

template<typename OPERATION>
static std::unique_ptr<FunctionBindData> bindFuncListAggr(const ScalarBindFuncInput& input) {
    auto scalarFunction = input.definition->ptrCast<ScalarFunction>();
    const auto& resultType = ListType::getChildType(input.arguments[0]->dataType);
    TypeUtils::visit(
        resultType,
        [&scalarFunction]<NumericTypes T>(T) {
            scalarFunction->execFunc =
                ScalarFunction::UnaryExecNestedTypeFunction<list_entry_t, T, OPERATION>;
        },
        [&input, &resultType](auto) {
            throw BinderException(std::format("Unsupported inner data type for {}: {}",
                input.definition->name, LogicalTypeUtils::toString(resultType.getLogicalTypeID())));
        });
    return FunctionBindData::getSimpleBindData(input.arguments, resultType);
}

template<typename OPERATION>
static std::unique_ptr<FunctionBindData> bindFuncListMinMax(const ScalarBindFuncInput& input) {
    auto scalarFunction = input.definition->ptrCast<ScalarFunction>();
    const auto& argType = input.arguments[0]->dataType;
    if (argType.getPhysicalType() != PhysicalTypeID::LIST &&
        argType.getPhysicalType() != PhysicalTypeID::ARRAY) {
        if (argType.getLogicalTypeID() != LogicalTypeID::ANY) {
            throw BinderException(std::format("Unsupported inner data type for {}: {}",
                input.definition->name, LogicalTypeUtils::toString(argType.getLogicalTypeID())));
        }
        scalarFunction->execFunc =
            ScalarFunction::UnaryExecNestedTypeFunction<list_entry_t, int64_t, OPERATION>;
        std::vector<LogicalType> types;
        types.push_back(LogicalType::LIST(LogicalType::INT64()));
        return std::make_unique<FunctionBindData>(std::move(types), LogicalType::INT64());
    }
    const auto& resultType = ListType::getChildType(argType);
    if (resultType.getLogicalTypeID() == LogicalTypeID::ANY) {
        throw BinderException(std::format("Unsupported inner data type for {}: {}",
            input.definition->name, LogicalTypeUtils::toString(resultType.getLogicalTypeID())));
    }
    TypeUtils::visit(
        resultType.getPhysicalType(),
        [&scalarFunction]<ComparableTypes T>(T) {
            scalarFunction->execFunc =
                ScalarFunction::UnaryExecNestedTypeFunction<list_entry_t, T, OPERATION>;
        },
        [&input, &resultType](auto) {
            throw BinderException(std::format("Unsupported inner data type for {}: {}",
                input.definition->name, LogicalTypeUtils::toString(resultType.getLogicalTypeID())));
        });
    return FunctionBindData::getSimpleBindData(input.arguments, resultType);
}

struct ListSum {
    template<typename T>
    static void operation(common::list_entry_t& input, T& result, common::ValueVector& inputVector,
        common::ValueVector& /*resultVector*/) {
        auto inputDataVector = common::ListVector::getDataVector(&inputVector);
        result = 0;
        for (auto i = 0u; i < input.size; i++) {
            if (inputDataVector->isNull(input.offset + i)) {
                continue;
            }
            result += inputDataVector->getValue<T>(input.offset + i);
        }
    }
};

function_set ListSumFunction::getFunctionSet() {
    function_set result;
    auto function = std::make_unique<ScalarFunction>(name,
        std::vector<LogicalTypeID>{LogicalTypeID::LIST}, LogicalTypeID::INT64);
    function->bindFunc = bindFuncListAggr<ListSum>;
    result.push_back(std::move(function));
    return result;
}

struct ListProduct {
    template<typename T>
    static void operation(common::list_entry_t& input, T& result, common::ValueVector& inputVector,
        common::ValueVector& /*resultVector*/) {
        auto inputDataVector = common::ListVector::getDataVector(&inputVector);
        result = 1;
        for (auto i = 0u; i < input.size; i++) {
            if (inputDataVector->isNull(input.offset + i)) {
                continue;
            }
            result *= inputDataVector->getValue<T>(input.offset + i);
        }
    }
};

function_set ListProductFunction::getFunctionSet() {
    function_set result;
    auto function = std::make_unique<ScalarFunction>(name,
        std::vector<LogicalTypeID>{LogicalTypeID::LIST}, LogicalTypeID::INT64);
    function->bindFunc = bindFuncListAggr<ListProduct>;
    result.push_back(std::move(function));
    return result;
}

template<bool IS_MIN>
struct ListMinMax {
    template<typename T>
    static void operation(common::list_entry_t& input, T& result, common::ValueVector& inputVector,
        common::ValueVector& resultVector) {
        auto inputDataVector = common::ListVector::getDataVector(&inputVector);
        auto numBytesPerValue = inputDataVector->getNumBytesPerValue();
        auto inputValues = common::ListVector::getListValues(&inputVector, input);
        bool found = false;
        uint8_t* foundPtr = nullptr;
        T best{};
        for (auto i = 0u; i < input.size; i++) {
            if (!inputDataVector->isNull(input.offset + i)) {
                auto val = inputDataVector->getValue<T>(input.offset + i);
                if (!found || (IS_MIN ? val < best : val > best)) {
                    best = val;
                    found = true;
                    foundPtr = inputValues;
                }
            }
            inputValues += numBytesPerValue;
        }
        if (!found) {
            auto resultPos =
                static_cast<sel_t>((reinterpret_cast<uint8_t*>(&result) - resultVector.getData()) /
                                   resultVector.getNumBytesPerValue());
            resultVector.setNull(resultPos, true);
            return;
        }
        resultVector.copyFromVectorData(reinterpret_cast<uint8_t*>(&result), inputDataVector,
            foundPtr);
    }
};

using ListMin = ListMinMax<true>;
using ListMax = ListMinMax<false>;

function_set ListMinFunction::getFunctionSet() {
    function_set result;
    auto function = std::make_unique<ScalarFunction>(name,
        std::vector<LogicalTypeID>{LogicalTypeID::LIST}, LogicalTypeID::ANY);
    function->bindFunc = bindFuncListMinMax<ListMin>;
    result.push_back(std::move(function));
    return result;
}

function_set ListMaxFunction::getFunctionSet() {
    function_set result;
    auto function = std::make_unique<ScalarFunction>(name,
        std::vector<LogicalTypeID>{LogicalTypeID::LIST}, LogicalTypeID::ANY);
    function->bindFunc = bindFuncListMinMax<ListMax>;
    result.push_back(std::move(function));
    return result;
}

} // namespace function
} // namespace lbug