lbug 0.18.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

#include "main/prepared_statement.h"

#include "binder/expression/expression.h" // IWYU pragma: keep
#include "common/exception/binder.h"
#include "common/types/value/value.h"
#include "planner/operator/logical_plan.h" // IWYU pragma: keep
#include <format>

using namespace lbug::common;

namespace lbug {
namespace main {

CachedPreparedStatement::CachedPreparedStatement() = default;
CachedPreparedStatement::~CachedPreparedStatement() = default;

std::vector<std::string> CachedPreparedStatement::getColumnNames() const {
    if (!columnNames.empty()) {
        return columnNames;
    }
    std::vector<std::string> names;
    for (auto& column : columns) {
        names.push_back(column->toString());
    }
    return names;
}

std::vector<LogicalType> CachedPreparedStatement::getColumnTypes() const {
    std::vector<LogicalType> types;
    for (auto& column : columns) {
        types.push_back(column->getDataType().copy());
    }
    return types;
}

bool PreparedStatement::isSuccess() const {
    return success;
}

std::string PreparedStatement::getErrorMessage() const {
    return errMsg;
}

bool PreparedStatement::isReadOnly() const {
    return readOnly;
}

StatementType PreparedStatement::getStatementType() const {
    return preparedSummary.statementType;
}

bool PreparedStatement::canReuseCachedPlanWith(
    const std::unordered_map<std::string, std::unique_ptr<Value>>& inputParams) const {
    if (!unknownParameters.empty()) {
        return false;
    }
    for (auto& [key, value] : inputParams) {
        if (!parameterMap.contains(key)) {
            return false;
        }
        if (parameterMap.at(key)->getDataType() != value->getDataType()) {
            return false;
        }
    }
    return true;
}

static void validateParam(const std::string& paramName, Value* newVal, Value* oldVal) {
    if (newVal->getDataType().getLogicalTypeID() == LogicalTypeID::POINTER &&
        newVal->getValue<uint8_t*>() != oldVal->getValue<uint8_t*>()) {
        throw BinderException(std::format(
            "When preparing the current statement the dataframe passed into parameter "
            "'{}' was different from the one provided during prepare. Dataframes parameters "
            "are only used during prepare; please make sure that they are either not passed into "
            "execute or they match the one passed during prepare.",
            paramName));
    }
}

std::unordered_set<std::string> PreparedStatement::getKnownParameters() {
    std::unordered_set<std::string> result;
    for (auto& [k, _] : parameterMap) {
        result.insert(k);
    }
    return result;
}

void PreparedStatement::updateParameter(const std::string& name, Value* value) {
    DASSERT(parameterMap.contains(name));
    validateParam(name, value, parameterMap.at(name).get());
    *parameterMap.at(name) = std::move(*value);
}

void PreparedStatement::addParameter(const std::string& name, Value* value) {
    parameterMap.insert({name, std::make_shared<Value>(*value)});
}

void PreparedStatement::setParameter(const std::string& name, Value value) {
    if (!parameterMap.contains(name)) {
        throw BinderException(std::format("Parameter {} not found.", name));
    }
    auto& oldValue = parameterMap.at(name);
    if (oldValue->getDataType() != value.getDataType()) {
        throw BinderException(std::format("Cannot update parameter {} with type {}. Expected {}.",
            name, value.getDataType().toString(), oldValue->getDataType().toString()));
    }
    validateParam(name, &value, oldValue.get());
    *oldValue = std::move(value);
}

PreparedStatement::~PreparedStatement() = default;

std::unique_ptr<PreparedStatement> PreparedStatement::getPreparedStatementWithError(
    const std::string& errorMessage) {
    auto preparedStatement = std::make_unique<PreparedStatement>();
    preparedStatement->success = false;
    preparedStatement->errMsg = errorMessage;
    return preparedStatement;
}

} // namespace main
} // namespace lbug