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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#pragma once
#include <vespa/searchcore/proton/documentmetastore/i_document_meta_store.h>
#include <vespa/searchcore/proton/documentmetastore/operation_listener.h>
#include <vespa/searchlib/queryeval/blueprint.h>
namespace proton::test {
struct DocumentMetaStoreObserver : public IDocumentMetaStore
{
IDocumentMetaStore &_store;
uint32_t _removes_complete_cnt;
std::vector<DocId> _removes_complete_lids;
DocId _compactLidSpaceLidLimit;
uint32_t _holdUnblockShrinkLidSpaceCnt;
DocumentMetaStoreObserver(IDocumentMetaStore &store) noexcept
: _store(store),
_removes_complete_cnt(0),
_removes_complete_lids(0),
_compactLidSpaceLidLimit(0),
_holdUnblockShrinkLidSpaceCnt(0)
{}
/**
* Implements search::IDocumentMetaStore
**/
bool getGid(DocId lid, GlobalId &gid) const override {
return _store.getGid(lid, gid);
}
bool getGidEvenIfMoved(DocId lid, GlobalId &gid) const override {
return _store.getGidEvenIfMoved(lid, gid);
}
bool getLid(const GlobalId &gid, DocId &lid) const override {
return _store.getLid(gid, lid);
}
search::DocumentMetaData getMetaData(const GlobalId &gid) const override {
return _store.getMetaData(gid);
}
void getMetaData(const BucketId &bucketId, search::DocumentMetaData::Vector &result) const override {
_store.getMetaData(bucketId, result);
}
search::LidUsageStats getLidUsageStats() const override {
return _store.getLidUsageStats();
}
search::queryeval::Blueprint::UP createWhiteListBlueprint() const override {
return _store.createWhiteListBlueprint();
}
uint64_t getCurrentGeneration() const override {
return _store.getCurrentGeneration();
}
const search::BitVector & getValidLids() const override {
return _store.getValidLids();
}
/**
* Implements documentmetastore::IStore.
*/
Result inspectExisting(const GlobalId &gid, uint64_t prepare_serial_num) override {
return _store.inspectExisting(gid, prepare_serial_num);
}
Result inspect(const GlobalId &gid, uint64_t prepare_serial_num) override {
return _store.inspect(gid, prepare_serial_num);
}
Result put(const GlobalId &gid, const BucketId &bucketId, Timestamp timestamp,
uint32_t docSize, DocId lid, uint64_t prepare_serial_num) override
{
return _store.put(gid, bucketId, timestamp, docSize, lid, prepare_serial_num);
}
bool updateMetaData(DocId lid, const BucketId &bucketId, Timestamp timestamp) override {
return _store.updateMetaData(lid, bucketId, timestamp);
}
bool remove(DocId lid, uint64_t prepare_serial_num) override {
return _store.remove(lid, prepare_serial_num);
}
void removes_complete(const std::vector<DocId>& lids) override {
++_removes_complete_cnt;
_removes_complete_lids.insert(_removes_complete_lids.end(), lids.cbegin(), lids.cend());
_store.removes_complete(lids);
}
void move(DocId fromLid, DocId toLid, uint64_t prepare_serial_num) override {
_store.move(fromLid, toLid, prepare_serial_num);
}
bool validLid(DocId lid) const override {
return _store.validLid(lid);
}
void removeBatch(const std::vector<DocId> &lidsToRemove, const DocId docIdLimit) override {
_store.removeBatch(lidsToRemove, docIdLimit);
}
const RawDocumentMetaData &getRawMetaData(DocId lid) const override {
return _store.getRawMetaData(lid);
}
/**
* Implements documentmetastore::IBucketHandler.
*/
bucketdb::BucketDBOwner &getBucketDB() const override {
return _store.getBucketDB();
}
bucketdb::BucketDeltaPair
handleSplit(const bucketdb::SplitBucketSession &session) override {
return _store.handleSplit(session);
}
bucketdb::BucketDeltaPair
handleJoin(const bucketdb::JoinBucketsSession &session) override {
return _store.handleJoin(session);
}
void updateActiveLids(const BucketId &bucketId, bool active) override {
_store.updateActiveLids(bucketId, active);
}
void setBucketState(const BucketId &bucketId, bool active) override {
_store.setBucketState(bucketId, active);
}
void populateActiveBuckets(document::BucketId::List buckets) override {
_store.populateActiveBuckets(std::move(buckets));
}
/**
* Implements proton::IDocumentMetaStore
*/
void constructFreeList() override {
_store.constructFreeList();
}
Iterator begin() const override {
return _store.begin();
}
Iterator lowerBound(const BucketId &bucketId) const override {
return _store.lowerBound(bucketId);
}
Iterator upperBound(const BucketId &bucketId) const override {
return _store.upperBound(bucketId);
}
Iterator lowerBound(const GlobalId &gid) const override {
return _store.lowerBound(gid);
}
Iterator upperBound(const GlobalId &gid) const override {
return _store.upperBound(gid);
}
void getLids(const BucketId &bucketId, std::vector<DocId> &lids) override {
_store.getLids(bucketId, lids);
}
DocId getNumUsedLids() const override {
return _store.getNumUsedLids();
}
DocId getNumActiveLids() const override {
return _store.getNumActiveLids();
}
bool getFreeListActive() const override {
return _store.getFreeListActive();
}
void compactLidSpace(DocId wantedLidLimit) override {
_compactLidSpaceLidLimit = wantedLidLimit;
_store.compactLidSpace(wantedLidLimit);
}
void holdUnblockShrinkLidSpace() override {
++_holdUnblockShrinkLidSpaceCnt;
_store.holdUnblockShrinkLidSpace();
}
void commit(const CommitParam & param) override {
_store.commit(param);
}
DocId getCommittedDocIdLimit() const override {
return _store.getCommittedDocIdLimit();
}
void reclaim_unused_memory() override {
_store.reclaim_unused_memory();
}
bool canShrinkLidSpace() const override {
return _store.canShrinkLidSpace();
}
search::SerialNum getLastSerialNum() const override {
return _store.getLastSerialNum();
}
void foreach(const search::IGidToLidMapperVisitor &visitor) const override {
_store.foreach(visitor);
}
void set_operation_listener(documentmetastore::OperationListener::SP op_listener) override {
_store.set_operation_listener(std::move(op_listener));
}
};
}
|
