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

#pragma once

#include <array>
#include <optional>
#include <string>
#include <vector>

#include "common/enums/rel_direction.h"
#include "common/enums/table_type.h"
#include "common/types/types.h"
#include "storage/stats/table_stats.h"

namespace lbug {
namespace catalog {
class Catalog;
class TableCatalogEntry;
} // namespace catalog
namespace transaction {
class Transaction;
} // namespace transaction

namespace storage {
class StorageManager;

enum class PlannerStatsMode : uint8_t { SCHEMA_ONLY, ANALYZE };

struct PlannerIndexStats {
    std::string indexType;
    std::vector<common::column_id_t> columnIDs;
    bool isPrimary = false;
};

struct PlannerRelDirectionStats {
    common::cardinality_t numRows = 0;
    common::cardinality_t numActiveBoundNodes = 0;
    common::cardinality_t maxDegree = 0;
    double avgDegree = 0;
    bool boundKeysUnique = false;
};

struct PlannerTableStats {
    common::table_id_t tableID = common::INVALID_TABLE_ID;
    common::TableType tableType = common::TableType::NODE;
    uint64_t tableChangeEpoch = 0;
    std::optional<TableStats> storageStats;
    std::array<std::optional<PlannerRelDirectionStats>, common::NUM_REL_DIRECTIONS>
        relDirectionStats;
    std::vector<PlannerIndexStats> indexStats;

    PlannerTableStats copy() const {
        auto result = PlannerTableStats{};
        result.tableID = tableID;
        result.tableType = tableType;
        result.tableChangeEpoch = tableChangeEpoch;
        if (storageStats.has_value()) {
            result.storageStats = storageStats->copy();
        }
        result.relDirectionStats = relDirectionStats;
        result.indexStats = indexStats;
        return result;
    }
};

PlannerTableStats buildPlannerTableStats(StorageManager& storageManager,
    const catalog::Catalog& catalog, const transaction::Transaction* transaction,
    const catalog::TableCatalogEntry& tableEntry,
    common::table_id_t physicalTableID = common::INVALID_TABLE_ID,
    PlannerStatsMode mode = PlannerStatsMode::ANALYZE);

std::vector<common::table_id_t> analyzePlannerStats(StorageManager& storageManager,
    const catalog::Catalog& catalog, const transaction::Transaction* transaction,
    const std::optional<std::string>& tableName);

} // namespace storage
} // namespace lbug