lbug 0.16.0

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

#include "storage/stats/table_stats.h"

#include "common/serializer/deserializer.h"
#include "common/serializer/serializer.h"

namespace lbug {
namespace storage {

TableStats::TableStats(std::span<const common::LogicalType> dataTypes) : cardinality{0} {
    for (const auto& dataType : dataTypes) {
        columnStats.emplace_back(dataType);
    }
}

TableStats::TableStats(const TableStats& other) : cardinality{other.cardinality} {
    columnStats.reserve(other.columnStats.size());
    for (auto i = 0u; i < other.columnStats.size(); ++i) {
        columnStats.emplace_back(other.columnStats[i].copy());
    }
}

void TableStats::update(const std::vector<common::ValueVector*>& vectors, size_t numColumns) {
    std::vector<common::column_id_t> dummyColumnIDs;
    for (auto i = 0u; i < vectors.size(); ++i) {
        dummyColumnIDs.push_back(i);
    }
    update(dummyColumnIDs, vectors, numColumns);
}

void TableStats::update(const std::vector<common::column_id_t>& columnIDs,
    const std::vector<common::ValueVector*>& vectors, size_t numColumns) {
    DASSERT(columnIDs.size() == vectors.size());
    size_t numColumnsToUpdate = std::min(numColumns, vectors.size());

    for (auto i = 0u; i < numColumnsToUpdate; ++i) {
        auto columnID = columnIDs[i];
        DASSERT(columnID < columnStats.size());
        columnStats[columnID].update(vectors[i]);
    }
    const auto numValues = vectors[0]->state->getSelVector().getSelSize();
    for (auto i = 1u; i < numColumnsToUpdate; ++i) {
        DASSERT(vectors[i]->state->getSelVector().getSelSize() == numValues);
    }
    incrementCardinality(numValues);
}

void TableStats::serialize(common::Serializer& serializer) const {
    serializer.writeDebuggingInfo("cardinality");
    serializer.write(cardinality);
    serializer.writeDebuggingInfo("column_stats");
    serializer.serializeVector(columnStats);
}

TableStats TableStats::deserialize(common::Deserializer& deserializer) {
    std::string info;
    deserializer.validateDebuggingInfo(info, "cardinality");
    deserializer.deserializeValue<common::cardinality_t>(cardinality);
    deserializer.validateDebuggingInfo(info, "column_stats");
    deserializer.deserializeVector(columnStats);
    return *this;
}

} // namespace storage
} // namespace lbug