eloqstore-sys 1.1.1

Low-level Rust FFI bindings for EloqStore
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

#include "tasks/read_task.h"

#include <string>
#include <utility>

#include "error.h"
#include "storage/mem_index_page.h"
#include "storage/page_mapper.h"
#include "storage/shard.h"

namespace eloqstore
{

KvError ReadTask::Read(const TableIdent &tbl_id,
                       std::string_view search_key,
                       std::string &value,
                       uint64_t &timestamp,
                       uint64_t &expire_ts)
{
    auto [root_handle, err] = shard->IndexManager()->FindRoot(tbl_id);
    CHECK_KV_ERR(err);
    RootMeta *meta = root_handle.Get();
    if (meta->root_id_ == MaxPageId)
    {
        return KvError::NotFound;
    }
    auto mapping = meta->mapper_->GetMappingSnapshot();

    PageId page_id;
    err = shard->IndexManager()->SeekIndex(
        mapping.Get(), meta->root_id_, search_key, page_id);
    CHECK_KV_ERR(err);
    FilePageId file_page = mapping->ToFilePage(page_id);
    auto [page, err_load] = LoadDataPage(tbl_id, page_id, file_page);
    CHECK_KV_ERR(err_load);

    DataPageIter iter{&page, Options()};
    bool found = iter.Seek(search_key);
    if (!found || Comp()->Compare(iter.Key(), search_key) != 0)
    {
        return KvError::NotFound;
    }

    std::string value_storage;
    auto [val_view, fetch_err] = ResolveValue(
        tbl_id, mapping.Get(), iter, value_storage, meta->compression_.get());
    CHECK_KV_ERR(fetch_err);
    value = value_storage.empty() ? val_view : std::move(value_storage);
    timestamp = iter.Timestamp();
    expire_ts = iter.ExpireTs();
    return KvError::NoError;
}

KvError ReadTask::Floor(const TableIdent &tbl_id,
                        std::string_view search_key,
                        std::string &floor_key,
                        std::string &value,
                        uint64_t &timestamp,
                        uint64_t &expire_ts)
{
    auto [root_handle, err] = shard->IndexManager()->FindRoot(tbl_id);
    CHECK_KV_ERR(err);
    RootMeta *meta = root_handle.Get();
    if (meta->root_id_ == MaxPageId)
    {
        return KvError::NotFound;
    }
    auto mapping = meta->mapper_->GetMappingSnapshot();

    PageId page_id;
    err = shard->IndexManager()->SeekIndex(
        mapping.Get(), meta->root_id_, search_key, page_id);
    CHECK_KV_ERR(err);
    FilePageId file_page = mapping->ToFilePage(page_id);
    auto [page, err_load] = LoadDataPage(tbl_id, page_id, file_page);
    CHECK_KV_ERR(err_load);

    DataPageIter iter{&page, Options()};
    if (!iter.SeekFloor(search_key))
    {
        PageId page_id = page.PrevPageId();
        if (page_id == MaxPageId)
        {
            return KvError::NotFound;
        }
        FilePageId file_page = mapping->ToFilePage(page_id);
        auto [prev_page, err] = LoadDataPage(tbl_id, page_id, file_page);
        CHECK_KV_ERR(err);
        page = std::move(prev_page);
        iter.Reset(&page, Options()->data_page_size);
        bool found = iter.SeekFloor(search_key);
        CHECK(found);
    }
    floor_key = iter.Key();
    std::string value_storage;
    auto [val_view, fetch_err] = ResolveValue(
        tbl_id, mapping.Get(), iter, value_storage, meta->compression_.get());
    CHECK_KV_ERR(fetch_err);
    value = value_storage.empty() ? val_view : std::move(value_storage);
    timestamp = iter.Timestamp();
    expire_ts = iter.ExpireTs();
    return KvError::NoError;
}
}  // namespace eloqstore