lbug 0.16.1

An in-process property graph database management system built for query speed and scalability
Documentation 
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

#include "storage/storage_utils.h"

#include <filesystem>
#if defined(_WIN32) || defined(__EMSCRIPTEN__)
#include <cctype>
#include <string_view>
#endif

#include "common/null_buffer.h"
#include "common/types/list_t.h"
#include "common/types/string_t.h"
#include "common/types/types.h"
#include "main/client_context.h"
#include "main/db_config.h"
#include "main/settings.h"
#include <format>

using namespace lbug::common;

namespace lbug {
namespace storage {

namespace {

#if defined(_WIN32) || defined(__EMSCRIPTEN__)
static bool isWindowsDrivePath(std::string_view path) {
    return path.length() >= 2 && std::isalpha(static_cast<unsigned char>(path[0])) &&
           path[1] == ':';
}

static bool isWindowsUNCPath(std::string_view path) {
    return path.length() >= 2 &&
           ((path[0] == '\\' && path[1] == '\\') || (path[0] == '/' && path[1] == '/'));
}
#endif

} // namespace

std::string StorageUtils::getColumnName(const std::string& propertyName, ColumnType type,
    const std::string& prefix) {
    switch (type) {
    case ColumnType::DATA: {
        return std::format("{}_data", propertyName);
    }
    case ColumnType::NULL_MASK: {
        return std::format("{}_null", propertyName);
    }
    case ColumnType::INDEX: {
        return std::format("{}_index", propertyName);
    }
    case ColumnType::OFFSET: {
        return std::format("{}_offset", propertyName);
    }
    case ColumnType::CSR_OFFSET: {
        return std::format("{}_csr_offset", prefix);
    }
    case ColumnType::CSR_LENGTH: {
        return std::format("{}_csr_length", prefix);
    }
    case ColumnType::STRUCT_CHILD: {
        return std::format("{}_{}_child", propertyName, prefix);
    }
    default: {
        if (prefix.empty()) {
            return propertyName;
        }
        return std::format("{}_{}", prefix, propertyName);
    }
    }
}

std::string StorageUtils::expandPath(const main::ClientContext* context, const std::string& path) {
    if (main::DBConfig::isDBPathInMemory(path)) {
        return path;
    }
    auto fullPath = path;
    // Handle '~' for home directory expansion
    if (path.starts_with('~')) {
        fullPath =
            context->getCurrentSetting(main::HomeDirectorySetting::name).getValue<std::string>() +
            fullPath.substr(1);
    }
#ifdef __EMSCRIPTEN__
    if (isWindowsDrivePath(fullPath) || isWindowsUNCPath(fullPath)) {
        for (auto& ch : fullPath) {
            if (ch == '\\') {
                ch = '/';
            }
        }
    }
#endif
    // Normalize the path to resolve '.' and '..'. Avoid std::filesystem::absolute
    // when the input already names a Windows drive/UNC path because absolute may
    // consult current_path(), which can fail if the process cwd has been deleted.
    std::filesystem::path normalizedPath;
    std::filesystem::path filePath{fullPath};
    auto shouldAvoidAbsolute = filePath.is_absolute();
#if defined(_WIN32) || defined(__EMSCRIPTEN__)
    shouldAvoidAbsolute =
        shouldAvoidAbsolute || isWindowsDrivePath(fullPath) || isWindowsUNCPath(fullPath);
#endif
    if (shouldAvoidAbsolute) {
        normalizedPath = filePath.lexically_normal();
    } else {
        normalizedPath = std::filesystem::absolute(filePath).lexically_normal();
    }
    return normalizedPath.string();
}

uint32_t StorageUtils::getDataTypeSize(const LogicalType& type) {
    switch (type.getPhysicalType()) {
    case PhysicalTypeID::STRING:
    case PhysicalTypeID::JSON: {
        return sizeof(string_t);
    }
    case PhysicalTypeID::ARRAY:
    case PhysicalTypeID::LIST: {
        return sizeof(list_t);
    }
    case PhysicalTypeID::STRUCT: {
        uint32_t size = 0;
        const auto fieldsTypes = StructType::getFieldTypes(type);
        for (const auto& fieldType : fieldsTypes) {
            size += getDataTypeSize(*fieldType);
        }
        size += NullBuffer::getNumBytesForNullValues(fieldsTypes.size());
        return size;
    }
    default: {
        return PhysicalTypeUtils::getFixedTypeSize(type.getPhysicalType());
    }
    }
}

} // namespace storage
} // namespace lbug