]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright (c) 2011 The LevelDB Authors. All rights reserved. |
2 | // Use of this source code is governed by a BSD-style license that can be | |
3 | // found in the LICENSE file. See the AUTHORS file for names of contributors. | |
4 | ||
5 | #pragma once | |
6 | #include <map> | |
11fdf7f2 | 7 | #include <memory> |
7c673cae FG |
8 | #include <string> |
9 | #include "rocksdb/db.h" | |
10 | ||
11 | #ifdef _WIN32 | |
12 | // Windows API macro interference | |
13 | #undef DeleteFile | |
14 | #endif | |
15 | ||
7c673cae FG |
16 | namespace rocksdb { |
17 | ||
18 | // This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d | |
19 | class StackableDB : public DB { | |
20 | public: | |
11fdf7f2 | 21 | // StackableDB take sole ownership of the underlying db. |
7c673cae FG |
22 | explicit StackableDB(DB* db) : db_(db) {} |
23 | ||
11fdf7f2 TL |
24 | // StackableDB take shared ownership of the underlying db. |
25 | explicit StackableDB(std::shared_ptr<DB> db) | |
26 | : db_(db.get()), shared_db_ptr_(db) {} | |
27 | ||
7c673cae | 28 | ~StackableDB() { |
11fdf7f2 TL |
29 | if (shared_db_ptr_ == nullptr) { |
30 | delete db_; | |
31 | } else { | |
32 | assert(shared_db_ptr_.get() == db_); | |
33 | } | |
34 | db_ = nullptr; | |
7c673cae FG |
35 | } |
36 | ||
11fdf7f2 TL |
37 | virtual Status Close() override { return db_->Close(); } |
38 | ||
494da23a | 39 | virtual DB* GetBaseDB() { return db_; } |
7c673cae FG |
40 | |
41 | virtual DB* GetRootDB() override { return db_->GetRootDB(); } | |
42 | ||
43 | virtual Status CreateColumnFamily(const ColumnFamilyOptions& options, | |
44 | const std::string& column_family_name, | |
45 | ColumnFamilyHandle** handle) override { | |
46 | return db_->CreateColumnFamily(options, column_family_name, handle); | |
47 | } | |
48 | ||
11fdf7f2 TL |
49 | virtual Status CreateColumnFamilies( |
50 | const ColumnFamilyOptions& options, | |
51 | const std::vector<std::string>& column_family_names, | |
52 | std::vector<ColumnFamilyHandle*>* handles) override { | |
53 | return db_->CreateColumnFamilies(options, column_family_names, handles); | |
54 | } | |
55 | ||
56 | virtual Status CreateColumnFamilies( | |
57 | const std::vector<ColumnFamilyDescriptor>& column_families, | |
58 | std::vector<ColumnFamilyHandle*>* handles) override { | |
59 | return db_->CreateColumnFamilies(column_families, handles); | |
60 | } | |
61 | ||
7c673cae FG |
62 | virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override { |
63 | return db_->DropColumnFamily(column_family); | |
64 | } | |
65 | ||
11fdf7f2 TL |
66 | virtual Status DropColumnFamilies( |
67 | const std::vector<ColumnFamilyHandle*>& column_families) override { | |
68 | return db_->DropColumnFamilies(column_families); | |
69 | } | |
70 | ||
7c673cae FG |
71 | virtual Status DestroyColumnFamilyHandle( |
72 | ColumnFamilyHandle* column_family) override { | |
73 | return db_->DestroyColumnFamilyHandle(column_family); | |
74 | } | |
75 | ||
76 | using DB::Put; | |
77 | virtual Status Put(const WriteOptions& options, | |
78 | ColumnFamilyHandle* column_family, const Slice& key, | |
79 | const Slice& val) override { | |
80 | return db_->Put(options, column_family, key, val); | |
81 | } | |
82 | ||
83 | using DB::Get; | |
84 | virtual Status Get(const ReadOptions& options, | |
85 | ColumnFamilyHandle* column_family, const Slice& key, | |
86 | PinnableSlice* value) override { | |
87 | return db_->Get(options, column_family, key, value); | |
88 | } | |
89 | ||
90 | using DB::MultiGet; | |
91 | virtual std::vector<Status> MultiGet( | |
92 | const ReadOptions& options, | |
93 | const std::vector<ColumnFamilyHandle*>& column_family, | |
94 | const std::vector<Slice>& keys, | |
95 | std::vector<std::string>* values) override { | |
96 | return db_->MultiGet(options, column_family, keys, values); | |
97 | } | |
98 | ||
99 | using DB::IngestExternalFile; | |
100 | virtual Status IngestExternalFile( | |
101 | ColumnFamilyHandle* column_family, | |
102 | const std::vector<std::string>& external_files, | |
103 | const IngestExternalFileOptions& options) override { | |
104 | return db_->IngestExternalFile(column_family, external_files, options); | |
105 | } | |
106 | ||
494da23a TL |
107 | using DB::IngestExternalFiles; |
108 | virtual Status IngestExternalFiles( | |
109 | const std::vector<IngestExternalFileArg>& args) override { | |
110 | return db_->IngestExternalFiles(args); | |
111 | } | |
112 | ||
11fdf7f2 TL |
113 | virtual Status VerifyChecksum() override { return db_->VerifyChecksum(); } |
114 | ||
7c673cae FG |
115 | using DB::KeyMayExist; |
116 | virtual bool KeyMayExist(const ReadOptions& options, | |
117 | ColumnFamilyHandle* column_family, const Slice& key, | |
118 | std::string* value, | |
119 | bool* value_found = nullptr) override { | |
120 | return db_->KeyMayExist(options, column_family, key, value, value_found); | |
121 | } | |
122 | ||
123 | using DB::Delete; | |
124 | virtual Status Delete(const WriteOptions& wopts, | |
125 | ColumnFamilyHandle* column_family, | |
126 | const Slice& key) override { | |
127 | return db_->Delete(wopts, column_family, key); | |
128 | } | |
129 | ||
130 | using DB::SingleDelete; | |
131 | virtual Status SingleDelete(const WriteOptions& wopts, | |
132 | ColumnFamilyHandle* column_family, | |
133 | const Slice& key) override { | |
134 | return db_->SingleDelete(wopts, column_family, key); | |
135 | } | |
136 | ||
137 | using DB::Merge; | |
138 | virtual Status Merge(const WriteOptions& options, | |
139 | ColumnFamilyHandle* column_family, const Slice& key, | |
140 | const Slice& value) override { | |
141 | return db_->Merge(options, column_family, key, value); | |
142 | } | |
143 | ||
494da23a TL |
144 | virtual Status Write(const WriteOptions& opts, WriteBatch* updates) override { |
145 | return db_->Write(opts, updates); | |
7c673cae FG |
146 | } |
147 | ||
148 | using DB::NewIterator; | |
149 | virtual Iterator* NewIterator(const ReadOptions& opts, | |
150 | ColumnFamilyHandle* column_family) override { | |
151 | return db_->NewIterator(opts, column_family); | |
152 | } | |
153 | ||
154 | virtual Status NewIterators( | |
155 | const ReadOptions& options, | |
156 | const std::vector<ColumnFamilyHandle*>& column_families, | |
157 | std::vector<Iterator*>* iterators) override { | |
158 | return db_->NewIterators(options, column_families, iterators); | |
159 | } | |
160 | ||
494da23a | 161 | virtual const Snapshot* GetSnapshot() override { return db_->GetSnapshot(); } |
7c673cae FG |
162 | |
163 | virtual void ReleaseSnapshot(const Snapshot* snapshot) override { | |
164 | return db_->ReleaseSnapshot(snapshot); | |
165 | } | |
166 | ||
167 | using DB::GetMapProperty; | |
168 | using DB::GetProperty; | |
169 | virtual bool GetProperty(ColumnFamilyHandle* column_family, | |
170 | const Slice& property, std::string* value) override { | |
171 | return db_->GetProperty(column_family, property, value); | |
172 | } | |
11fdf7f2 TL |
173 | virtual bool GetMapProperty( |
174 | ColumnFamilyHandle* column_family, const Slice& property, | |
175 | std::map<std::string, std::string>* value) override { | |
7c673cae FG |
176 | return db_->GetMapProperty(column_family, property, value); |
177 | } | |
178 | ||
179 | using DB::GetIntProperty; | |
180 | virtual bool GetIntProperty(ColumnFamilyHandle* column_family, | |
181 | const Slice& property, uint64_t* value) override { | |
182 | return db_->GetIntProperty(column_family, property, value); | |
183 | } | |
184 | ||
185 | using DB::GetAggregatedIntProperty; | |
186 | virtual bool GetAggregatedIntProperty(const Slice& property, | |
187 | uint64_t* value) override { | |
188 | return db_->GetAggregatedIntProperty(property, value); | |
189 | } | |
190 | ||
191 | using DB::GetApproximateSizes; | |
494da23a TL |
192 | virtual void GetApproximateSizes( |
193 | ColumnFamilyHandle* column_family, const Range* r, int n, uint64_t* sizes, | |
194 | uint8_t include_flags = INCLUDE_FILES) override { | |
195 | return db_->GetApproximateSizes(column_family, r, n, sizes, include_flags); | |
7c673cae FG |
196 | } |
197 | ||
198 | using DB::GetApproximateMemTableStats; | |
199 | virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family, | |
200 | const Range& range, | |
201 | uint64_t* const count, | |
202 | uint64_t* const size) override { | |
203 | return db_->GetApproximateMemTableStats(column_family, range, count, size); | |
204 | } | |
205 | ||
206 | using DB::CompactRange; | |
207 | virtual Status CompactRange(const CompactRangeOptions& options, | |
208 | ColumnFamilyHandle* column_family, | |
209 | const Slice* begin, const Slice* end) override { | |
210 | return db_->CompactRange(options, column_family, begin, end); | |
211 | } | |
212 | ||
213 | using DB::CompactFiles; | |
214 | virtual Status CompactFiles( | |
215 | const CompactionOptions& compact_options, | |
216 | ColumnFamilyHandle* column_family, | |
494da23a TL |
217 | const std::vector<std::string>& input_file_names, const int output_level, |
218 | const int output_path_id = -1, | |
219 | std::vector<std::string>* const output_file_names = nullptr, | |
220 | CompactionJobInfo* compaction_job_info = nullptr) override { | |
221 | return db_->CompactFiles(compact_options, column_family, input_file_names, | |
222 | output_level, output_path_id, output_file_names, | |
223 | compaction_job_info); | |
7c673cae FG |
224 | } |
225 | ||
226 | virtual Status PauseBackgroundWork() override { | |
227 | return db_->PauseBackgroundWork(); | |
228 | } | |
229 | virtual Status ContinueBackgroundWork() override { | |
230 | return db_->ContinueBackgroundWork(); | |
231 | } | |
232 | ||
233 | virtual Status EnableAutoCompaction( | |
234 | const std::vector<ColumnFamilyHandle*>& column_family_handles) override { | |
235 | return db_->EnableAutoCompaction(column_family_handles); | |
236 | } | |
237 | ||
238 | using DB::NumberLevels; | |
239 | virtual int NumberLevels(ColumnFamilyHandle* column_family) override { | |
240 | return db_->NumberLevels(column_family); | |
241 | } | |
242 | ||
243 | using DB::MaxMemCompactionLevel; | |
494da23a TL |
244 | virtual int MaxMemCompactionLevel( |
245 | ColumnFamilyHandle* column_family) override { | |
7c673cae FG |
246 | return db_->MaxMemCompactionLevel(column_family); |
247 | } | |
248 | ||
249 | using DB::Level0StopWriteTrigger; | |
494da23a TL |
250 | virtual int Level0StopWriteTrigger( |
251 | ColumnFamilyHandle* column_family) override { | |
7c673cae FG |
252 | return db_->Level0StopWriteTrigger(column_family); |
253 | } | |
254 | ||
494da23a | 255 | virtual const std::string& GetName() const override { return db_->GetName(); } |
7c673cae | 256 | |
494da23a | 257 | virtual Env* GetEnv() const override { return db_->GetEnv(); } |
7c673cae FG |
258 | |
259 | using DB::GetOptions; | |
260 | virtual Options GetOptions(ColumnFamilyHandle* column_family) const override { | |
261 | return db_->GetOptions(column_family); | |
262 | } | |
263 | ||
264 | using DB::GetDBOptions; | |
265 | virtual DBOptions GetDBOptions() const override { | |
266 | return db_->GetDBOptions(); | |
267 | } | |
268 | ||
269 | using DB::Flush; | |
270 | virtual Status Flush(const FlushOptions& fopts, | |
271 | ColumnFamilyHandle* column_family) override { | |
272 | return db_->Flush(fopts, column_family); | |
273 | } | |
494da23a TL |
274 | virtual Status Flush( |
275 | const FlushOptions& fopts, | |
276 | const std::vector<ColumnFamilyHandle*>& column_families) override { | |
277 | return db_->Flush(fopts, column_families); | |
7c673cae FG |
278 | } |
279 | ||
494da23a TL |
280 | virtual Status SyncWAL() override { return db_->SyncWAL(); } |
281 | ||
11fdf7f2 TL |
282 | virtual Status FlushWAL(bool sync) override { return db_->FlushWAL(sync); } |
283 | ||
494da23a TL |
284 | virtual Status LockWAL() override { return db_->LockWAL(); } |
285 | ||
286 | virtual Status UnlockWAL() override { return db_->UnlockWAL(); } | |
287 | ||
7c673cae FG |
288 | #ifndef ROCKSDB_LITE |
289 | ||
290 | virtual Status DisableFileDeletions() override { | |
291 | return db_->DisableFileDeletions(); | |
292 | } | |
293 | ||
294 | virtual Status EnableFileDeletions(bool force) override { | |
295 | return db_->EnableFileDeletions(force); | |
296 | } | |
297 | ||
298 | virtual void GetLiveFilesMetaData( | |
299 | std::vector<LiveFileMetaData>* metadata) override { | |
300 | db_->GetLiveFilesMetaData(metadata); | |
301 | } | |
302 | ||
494da23a TL |
303 | virtual void GetColumnFamilyMetaData(ColumnFamilyHandle* column_family, |
304 | ColumnFamilyMetaData* cf_meta) override { | |
7c673cae FG |
305 | db_->GetColumnFamilyMetaData(column_family, cf_meta); |
306 | } | |
307 | ||
308 | #endif // ROCKSDB_LITE | |
309 | ||
310 | virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs, | |
311 | bool flush_memtable = true) override { | |
494da23a | 312 | return db_->GetLiveFiles(vec, mfs, flush_memtable); |
7c673cae FG |
313 | } |
314 | ||
315 | virtual SequenceNumber GetLatestSequenceNumber() const override { | |
316 | return db_->GetLatestSequenceNumber(); | |
317 | } | |
318 | ||
494da23a TL |
319 | virtual bool SetPreserveDeletesSequenceNumber( |
320 | SequenceNumber seqnum) override { | |
11fdf7f2 TL |
321 | return db_->SetPreserveDeletesSequenceNumber(seqnum); |
322 | } | |
323 | ||
7c673cae FG |
324 | virtual Status GetSortedWalFiles(VectorLogPtr& files) override { |
325 | return db_->GetSortedWalFiles(files); | |
326 | } | |
327 | ||
328 | virtual Status DeleteFile(std::string name) override { | |
329 | return db_->DeleteFile(name); | |
330 | } | |
331 | ||
332 | virtual Status GetDbIdentity(std::string& identity) const override { | |
333 | return db_->GetDbIdentity(identity); | |
334 | } | |
335 | ||
336 | using DB::SetOptions; | |
337 | virtual Status SetOptions(ColumnFamilyHandle* column_family_handle, | |
338 | const std::unordered_map<std::string, std::string>& | |
339 | new_options) override { | |
340 | return db_->SetOptions(column_family_handle, new_options); | |
341 | } | |
342 | ||
343 | virtual Status SetDBOptions( | |
344 | const std::unordered_map<std::string, std::string>& new_options) | |
345 | override { | |
346 | return db_->SetDBOptions(new_options); | |
347 | } | |
348 | ||
349 | using DB::ResetStats; | |
350 | virtual Status ResetStats() override { return db_->ResetStats(); } | |
351 | ||
352 | using DB::GetPropertiesOfAllTables; | |
353 | virtual Status GetPropertiesOfAllTables( | |
354 | ColumnFamilyHandle* column_family, | |
355 | TablePropertiesCollection* props) override { | |
356 | return db_->GetPropertiesOfAllTables(column_family, props); | |
357 | } | |
358 | ||
359 | using DB::GetPropertiesOfTablesInRange; | |
360 | virtual Status GetPropertiesOfTablesInRange( | |
361 | ColumnFamilyHandle* column_family, const Range* range, std::size_t n, | |
362 | TablePropertiesCollection* props) override { | |
363 | return db_->GetPropertiesOfTablesInRange(column_family, range, n, props); | |
364 | } | |
365 | ||
366 | virtual Status GetUpdatesSince( | |
494da23a | 367 | SequenceNumber seq_number, std::unique_ptr<TransactionLogIterator>* iter, |
7c673cae FG |
368 | const TransactionLogIterator::ReadOptions& read_options) override { |
369 | return db_->GetUpdatesSince(seq_number, iter, read_options); | |
370 | } | |
371 | ||
11fdf7f2 TL |
372 | virtual Status SuggestCompactRange(ColumnFamilyHandle* column_family, |
373 | const Slice* begin, | |
374 | const Slice* end) override { | |
375 | return db_->SuggestCompactRange(column_family, begin, end); | |
376 | } | |
377 | ||
378 | virtual Status PromoteL0(ColumnFamilyHandle* column_family, | |
379 | int target_level) override { | |
380 | return db_->PromoteL0(column_family, target_level); | |
381 | } | |
382 | ||
7c673cae FG |
383 | virtual ColumnFamilyHandle* DefaultColumnFamily() const override { |
384 | return db_->DefaultColumnFamily(); | |
385 | } | |
386 | ||
387 | protected: | |
388 | DB* db_; | |
11fdf7f2 | 389 | std::shared_ptr<DB> shared_db_ptr_; |
7c673cae FG |
390 | }; |
391 | ||
494da23a | 392 | } // namespace rocksdb |