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
188
189
|
// biggie_sorted_impl.h
/**
* Copyright (C) 2018 MongoDB Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the GNU Affero General Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#pragma once
#include "mongo/db/storage/biggie/store.h"
#include "mongo/db/storage/key_string.h"
#include "mongo/db/storage/sorted_data_interface.h"
namespace mongo {
namespace biggie {
class SortedDataBuilderInterface : public ::mongo::SortedDataBuilderInterface {
public:
SortedDataBuilderInterface(OperationContext* opCtx,
bool dupsAllowed,
Ordering order,
const std::string& prefix,
const std::string& identEnd,
const std::string& collectionNamespace,
const std::string& indexName,
const BSONObj& keyPattern);
SpecialFormatInserted commit(bool mayInterrupt) override;
virtual StatusWith<SpecialFormatInserted> addKey(const BSONObj& key, const RecordId& loc);
private:
OperationContext* _opCtx;
bool _dupsAllowed;
// Order of the keys.
Ordering _order;
// Prefix and identEnd for the ident.
std::string _prefix;
std::string _identEnd;
// Index metadata.
const std::string _collectionNamespace;
const std::string _indexName;
const BSONObj _keyPattern;
// Whether or not we've already added something before.
bool _hasLast;
// This is the KeyString of the last key added.
std::string _lastKeyToString;
// This is the last recordId added.
int64_t _lastRID;
};
class SortedDataInterface : public ::mongo::SortedDataInterface {
public:
// Truncate is not required at the time of writing but will be when the truncate command is
// created
Status truncate(OperationContext* opCtx);
SortedDataInterface(const Ordering& ordering, bool isUnique, StringData ident);
virtual SortedDataBuilderInterface* getBulkBuilder(OperationContext* opCtx,
bool dupsAllowed) override;
virtual StatusWith<SpecialFormatInserted> insert(OperationContext* opCtx,
const BSONObj& key,
const RecordId& loc,
bool dupsAllowed) override;
virtual void unindex(OperationContext* opCtx,
const BSONObj& key,
const RecordId& loc,
bool dupsAllowed) override;
virtual Status dupKeyCheck(OperationContext* opCtx,
const BSONObj& key,
const RecordId& loc) override;
virtual void fullValidate(OperationContext* opCtx,
long long* numKeysOut,
ValidateResults* fullResults) const override;
virtual bool appendCustomStats(OperationContext* opCtx,
BSONObjBuilder* output,
double scale) const override;
virtual long long getSpaceUsedBytes(OperationContext* opCtx) const override;
virtual bool isEmpty(OperationContext* opCtx) override;
virtual std::unique_ptr<mongo::SortedDataInterface::Cursor> newCursor(
OperationContext* opCtx, bool isForward = true) const override;
virtual Status initAsEmpty(OperationContext* opCtx) override;
/*
* This is the cursor class required by the sorted data interface.
*/
class Cursor final : public ::mongo::SortedDataInterface::Cursor {
public:
// All the following public functions just implement the interface.
Cursor(OperationContext* opCtx,
bool isForward,
// This is the ident.
std::string _prefix,
// This is a string immediately after the ident and before other idents.
std::string _identEnd,
StringStore* workingCopy,
Ordering order,
bool isUnique,
std::string prefixBSON,
std::string KSForIdentEnd);
virtual void setEndPosition(const BSONObj& key, bool inclusive) override;
virtual boost::optional<IndexKeyEntry> next(RequestedInfo parts = kKeyAndLoc) override;
virtual boost::optional<IndexKeyEntry> seek(const BSONObj& key,
bool inclusive,
RequestedInfo parts = kKeyAndLoc) override;
virtual boost::optional<IndexKeyEntry> seek(const IndexSeekPoint& seekPoint,
RequestedInfo parts = kKeyAndLoc) override;
virtual void save() override;
virtual void restore() override;
virtual void detachFromOperationContext() override;
virtual void reattachToOperationContext(OperationContext* opCtx) override;
private:
// This is a helper function to check if the cursor was explicitly set by the user or not.
bool endPosSet();
// This is a helper function to check if the cursor is valid or not.
bool checkCursorValid();
// This is a helper function for seek.
boost::optional<IndexKeyEntry> seekAfterProcessing(BSONObj finalKey, bool inclusive);
OperationContext* _opCtx;
// This is the "working copy" of the master "branch" in the git analogy.
StringStore* _workingCopy;
// These store the end positions.
boost::optional<StringStore::const_iterator> _endPos;
boost::optional<StringStore::const_reverse_iterator> _endPosReverse;
// This means if the cursor is a forward or reverse cursor.
bool _forward;
// This means whether the cursor has reached the last EOF (with regard to this index).
bool _atEOF;
// This means whether or not the last move was restore.
bool _lastMoveWasRestore;
// This is the keystring for the saved location.
std::string _saveKey;
// These are the same as before.
std::string _prefix;
std::string _identEnd;
// These two store the const_iterator, which is the data structure for cursors. The one we
// use depends on _forward.
StringStore::const_iterator _forwardIt;
StringStore::const_reverse_iterator _reverseIt;
// This is the ordering for the key's values for multi-field keys.
Ordering _order;
// This stores whether or not the end position is inclusive for restore.
bool _endPosIncl;
// This stores the key for the end position.
boost::optional<BSONObj> _endPosKey;
// This stores whether or not the index is unique.
bool _isUnique;
// The next two are the same as above.
std::string _KSForIdentStart;
std::string _KSForIdentEnd;
};
private:
const Ordering _order;
// These two are the same as before.
std::string _prefix;
std::string _identEnd;
// Index metadata.
const std::string _collectionNamespace;
const std::string _indexName;
const BSONObj _keyPattern;
// These are the keystring representations of the _prefix and the _identEnd.
std::string _KSForIdentStart;
std::string _KSForIdentEnd;
// This stores whether or not the end position is inclusive.
bool _isUnique;
};
} // namespace biggie
} // namespace mongo
|
